The Parameterized Micromechanical Element (PME) library is a set of generators that allow the user to create micromechanical elements in a quick and easy manner. It also provides a framework for writing cell generators. It enables generators to be relatively process independent and allows limited cell hierarchy. Designs can be generated in Caltech Intermediate Form (CIF), GDS II, or PostScript output formats. Technology dependent design rules are read in from an environment specified technology file. The library provides various geometric primitives and a library of available generators. This chapter discusses the library framework and its usage. Details about the generators themselves are described in subsequent chapters.
The PME library provides various geometry primitives for use in the creation of generators. Rectangle, circle, sector, and polygon primitives are available. Primitives on structural layers can be generated with etch holes if they are parts of structures that will be released from the substrate. These primitives will generate the appropriate layout depending on the output format selected. Currently, these primitives are not directly accessible to the user and are only used within the library of generators.
The generators available in the PME library assume a two layer surface micromachined process. The process is assumed to have two structural layers, two sacrificial layers, and two electrical connect layers. Process specific mask levels and layer names are specified through a process file and are compiled into the library. Technology specific design rules are specified through a separate technology file that is accessed at execution time. The technology design rule file to use can be specified by the user through the environment variable PMETECH. The generators have been written to conform to the technology specific design rules specified via the PMETECH file. However, a design rule checker is not a part of the library and all layouts generated should be checked using an external design rule checker.
The library allows a limited cell hierarchy in both the generators and the output layout. The layout generated for any cell is not stored in program memory but is written out in the sequence generated. Hence any leaf cells used inside the top level cell, must be defined before being called. The same applies to instances within generators too, allowing a generator to be called inside another generator.
The CaMEL PME library can generate layout in CIF, GDS II, and PostScript output formats from the same PME input file. The programs cifpme, gdspme, and pspme generate the CIF, GDS, and PostScript outputs, respectively, from the PME input file.
The PME input is specified in an ascii text file and defines cells and places instances of defined cells at desired locations within the top level cell MAINCELL. The syntax used is similar to C language syntax. The input file should declare PME objects, call desired generators with appropriate parameter lists and assign them to PME objects, and place instances of these objects within MAINCELL. PME objects are declared first using the statement:
PME cell1, cell2, etc.;
Cells are defined using generators in the library:
pme_object = generator(parameter_list, cell_name); cell1 = gen_name1(p1val, p2val, ... , cellname1); cell2 = gen_name2(p1val, p2val, ... , cellname2);
Finally, instances are placed at desired locations in the MAINCELL:
instance(pme_object_name, reflection, rotation, origin_x, origin_y);
Reflection and rotation are performed about the instantiated cell's local coordinate system. Reflection is performed first, rotation is performed second, and the cell is finally translated to place the local origin of the cell instance at the specified location within the MAINCELL. Rotation is specified by passing the desired angular rotation value in degrees. All geometrical length parameters for the generators and locations of instances are specified in microns. Permitted values for reflection are:
'*': no reflection 'x': changes sign of x values; i.e., reflects about y-axis 'y': changes sign of y values; i.e., reflects about x-axis
After the PME input file has been created, layout can be generated in the desired format using one of the three layout generation programs: cifpme, gdspme, or pspme. To generate layout in CIF format run
cifpme pme_input_file > output_file.cif
Similarly, to generate GDS or PostScript versions of the layout use,
gdspme pme_input_file > output_file.gds pspme pme_input_file > output_file.ps
The top level cell in the layout generated will be named MAINCELL. The CIF or GDS layout can then be read into the mask layout editor of choice and modified or assembled with other designs.
A variety of active, passive, and test MEMS structures have been parameterized. In most cases the geometric parameters have been determined by their importance in the overall design of the element. In some cases, physical quantities such as residual strain are also used. The elements in the library are designed to work closely with each other. One or more active elements would typically be used along with one or more passive elements to form a micromechanical system. For instance, a rotary side drive actuator could be combined with a journal bearing to create a rotary variable capacitance motor. Most generators have two versions: one using structural layer 1, and the other using structural layer 2 and are identified by the use of 1 or 2 at the end of the name of the generator. Details about the generators are listed in subsequent chapters of this manual.
The following active elements are currently available in the CaMEL PME library:
The following passive elements are currently available in the CaMEL PME library:
The following test/measurement elements are currently available and are intended to measure mechanical or electrical characteristics of the process:
The following subsections show sample input files and layouts generated by the PME library for the MUMPS-5 process and design rules. The examples illustrate how elements of the library are used in conjunction with each other to generate typical MEMS device.
The following PME input file illustrates the use of reflections and rotations of instances inside the MAINCELL. A rotary comb drive is generated with an angular comb length of 60 degrees, rotor inner radius of 50�m, stator inner radius of 60�m, stator outer radius of 150�m, rotor spoke width of 12�m, stator spoke width of 15�m, finger width of 5�m, air gap of 5�m, and a stator-rotor angular overlap of 30 deg. The comb drive is generated in a cell named rcombcell1.
/* Declare PME objects */ PME p1; /* Call rotary comb generator rcombu */ p1 = rcombu1(60.0,50.0,60.0,150.0,12.0,15.0,5.0,5.0,30.0,rcombcell1); /* Place instances within MAINCELL */ /* 1 - rotate cell by 45 deg */ instance(p1,'*',45.0,-300.0,200.0); /* 2 - reflect about y-axis */ instance(p1,'x',0.0,0.0,200.0); /* 3 - reflect about y-axis & rotate cell by 45 deg */ instance(p1,'x',45.0,300.0,200.0); /* 4 - original cell - no reflection or rotation */ instance(p1,'*',0.0,0.0,0.0); /* 5 - rotate cell by -45 degrees */ instance(p1,'*',-45.0,-300.0,-100.0); /* 6 - reflect cell about x-axis */ instance(p1,'y',0.0,0.0,-100.0); /* 7 - reflect cell about x-axis and rotate by -45 degrees */ instance(p1,'y',-45.0,300.0,-100.0);
Figre 3. Layout of MAINCELL generated by instances example. Cross hairs have been used to show the origin and orientation of the instantiated cell.
A rotary side drive motor on the first structural layer is created using the active element rsdm1 and the passive element bearing1. The rotary side drive is generated with inner ring radius of 21�m, inner rotor tooth radius of 27�m, outer rotor tooth radius of 51�m, stator inner radius of 53�m, stator outer radius of 80�m, rotor pole angle of 18 deg, rotor gap angle of 27 deg, stator pole angle of 18 deg, and stator gap angle of 12 deg. The rotor is aligned with the first stator pole and the cell is named rsdma. The bearing is created with a cap radius of 14�m, journal rotor inner radius of 10�m, and journal rotor outer radius of 27�m.
/* Rotary Side Drive Example */ /* Declare PME Objects */ PME p1, p2; /* Create rotary side drive active element */ p1 = rsdm1(21.0,27.0,51.0,53.0,80.0,18.0,27.0,18.0,12.0,0.0,rsdma); /* Create central journal bearing */ p2 = bearing1(14.0,10.0,27.0,jnla); /* Create motor using instances of cells generated inside MAINCELL */ instance(p1,'*',0.0,0.0,0.0); instance(p2,'*',0.0,0.0,0.0);
Figure 4. Layout of rotary side drive motor generated by the PME input file shown above. Both cells rsdma and jnla are located at the origin of the MAINCELL in this case. The radii of the rotor ring and journal have been chosen to overlap and provide mechanical interconnection of the bearing and rotor ring.
A set of guckel ring test structures to measure residual tensile stress in the first structural layer is generated using the grings1 test/measurement element. Guckel rings are generated to measure strains from 0.05% to 0.25% in steps of 0.025% using a ring width of 20�m and a beam width of 10�m. The film thickness is specified as 2�m and Poisson's ratio for the film is 0.23. A mechanical model of the ring structure incorporated within the generator is used to calculate the ring radii required for the given critical strain values and generate the layout accordingly in a cell named rings1.
/* Guckel Rings Example */ PME p1; /* generate rings for critical strains from 0.05% to 0.25% in steps of 0.025% with a ring width of 20 and beam width of 10, for a film thickness of 2 and Poisson's ratio of 0.23. */ p1 = grings1(0.0005,0.0025,0.00025,20.0,10.0,40.0,2.0,0.23,rings1); /* place instance in MAINCELL */ instance(p1,'*',0.0,0.0,0.0);
Figure 5. Guckel ring test structures on the first structural layer generated by the PME input file shown above.
The following example shows a linear comb resonator on the first structural layer created using the lcomb1 linear comb drive and lfbs1 linear folded beam suspension. The fingers in the comb are 4�m wide with an air gap of 3 �m and the beams in the suspension are 150 �m long and 4�m wide.
/* Linear Comb Resonator with Folded Beam Suspension */ PME p1,p2; /* Create comb drive and folded beam suspension */ p1 = lcomb1(98.0,12.0,14.0,60.0,4.0,3.0,30.0,lcomb); p2 = lfbs1(150.0,4.0,50.0,12.0,30.0,25.0,12.0,98.0,lfbs1); /* Instantiate cells to create linear resonator */ instance(p1,'*',0.0,0.0,75.0); instance(p1,'y',0.0,0.0,-75.0); instance(p2,'*',0.0,0.0,0.0);
Figure 6. MAINCELL layout generated by the linear comb resonator example PME input file.