semi合集-English.pdf - 第1850页

SEMI E42-0704 © SEMI 1995, 2004 119 minimum = 100 seconds maximum = 300 seconds; or TIME BakeTime • (200,100,300,”s”) /* default,min,max,units */ that define the process parameter “BakeTime”, its initial value and restri…

100%1 / 7923
SEMI E42-0704 © SEMI 1995, 2004 118
programs for vision systems), but this restriction may
be removed when the technology advances.
Editing on the equipment may still be desirable,
particularly in a Development Fab. When the equipment
permits a recipe to be changed, the equipment must
provide reporting mechanisms that inform the host of
changes and allow the host’s change control system to
operate.
R1-3.4 Recipe Sharing — A Fab may have several
installation of the same type of equipment (equipment
with the same functionality and the same recipe
language). Therefore, where possible, the same recipe
should be able to be shared between different
equipment of this same type.
R1-3.5 Protection and Process Control — The primary
goal of process control is to ensure that the final result
of the manufacturing process does not change over
time. This may be accomplished by both feedback and
feedforward methods. These methods modify the
settings used in the process. This requires two
capabilities that seem to be in conflict:
• The definition of the process settings (the recipe)
should not change.
• The process settings should change to counter the
drift inherent in real processes.
The first capability is particularly important in a
Production Fab. Most Fab policies prohibit processes
from changing after they have been approved for
production. This is easy to build into a change control
system on the host. However, if the equipment allows
local editing, then it must also enforce this policy.
Wholesale changes in a recipe are never necessary for
the second purpose. Usually only a few parameter
values are modified in small increments to effect
control of the process. A well-defined process specifies
the parameters that vary and their range of variation.
For any given recipe, it must be possible for the host to
specify different values of such parameters for each
piece of equipment so that the recipe may be “tuned”
for that equipment to produce uniform results. In
addition, the process control agent, on the equipment or
the host, may need the ability to calculate the parameter
value changes for each run and to inform the equipment
of the new values. Mechanisms are provided to support
such interactions.
R1-3.6 Recipe Selection — Typical operation of
equipment requires an operator or the host to initially
select the recipe to be run. Recipe selection may be
specified implicitly within the definition of a higher
order “process job”. In either case, the specification of a
recipe is accomplished by referring to its recipe
identifier (i.e., the identifier used by the change control
system) and, where needed to resolve ambiguity, its
location. Once selected, a recipe is initiated by an
appropriate start command, which may be explicitly
given by the operator or host or implicitly given by the
equipment when executing a higher order process job.
Repeated runs of the same recipe may be accomplished
via subsequent start commands without the necessity of
formal recipe re-selection.
R1-4 Example of a Factory Implementation of Approval Levels
A factory might implement different levels of approval by regulating the following levels of recipe approval on the
equipment:
Approval Level
FACTORY POLICY
Level 0 “Unapproved”
Level 1 “In Test”
Level 2 “Non-Production”
Level 3 “Ready for Release”
Level 4 “Released for Production”
with
RecipeReadOnlyLevel = 2 Level 2 = read-only
R1-5 Examples of Variable Parameters
The recipe body may have statements that allow parameters to be changed within fixed limits. For example, recipe
BAKE;2.3 may contain statements such as:
Parameter BakeTime of TIME default = 200 seconds
SEMI E42-0704 © SEMI 1995, 2004 119
minimum = 100 seconds
maximum = 300 seconds;
or
TIME BakeTime • (200,100,300,”s”) /* default,min,max,units */
that define the process parameter “BakeTime”, its initial value and restrictions. The BAKE;2.3 recipe may use the
BakeTime parameter in further internal statements to determine the length of time a wafer is processed, such as:
wait for TIME BakeTime;
This parameter may then be set by a parent recipe as in Example (1) below or from the EqpSpec_PARAM attribute
(see 5.3.1.4) or with a “Select Recipe” command from the host or operator.
For example, a recipe “BAKE;2.3” may define a variable “BakeTime”, while a recipe “RAMP;1,0” may define a
variable “RampSetPoint”. A parent recipe “XYZ” might contain external references in the text of the source form
such as:
(1) RUN RAMP;1 // use default for RampSetPoint
RUN BAKE;2.3 with BakeTime=10 // bake for 10 seconds
or
(2) set RampSetPoint to 500; /* ramp up to 500 degC */
do RAMP(RampSetPoint);
set Baketime to 120; /* 120 sec (2 min.) bake */
do BAKE;2.3(BakeTime);
or
(3) RAMP(RampSetPoint:=500)
BAKE;2.3(BakeTime:=Time_A) /* 1st bake time may vary */
RAMP(RampSetPoint:=650)
BAKE;2.3(BakeTime:=Time_B) /* 2nd bake time may vary*/
RAMP(RampSetPoint:=800)
BAKE;2.3(BakeTime:=Time_B+50) /* 2nd bake plus 50 sec */
where “Time_A” and “Time_B” were both formally defined within XYZ.
In example (1), no initial value is specified for RampSetPoint. In this case, when the main recipe is selected, the
initial value specified either in EqpSpec_LinkParam
or in Gen_LinkParam (that is the same as the definition in
RAMP;2.3) is used. However, in this example, the parameter BakeTime is assigned a value by the parent recipe,
and this supersedes any value from a recipe attribute or a “Select Recipe” command from the host or operator. In
the example given, BakeTime is assigned a value outside of the declared domain. This should create an error when
the recipe is verified.
Examples (2) and (3) illustrate how subrecipes RAMP and BAKE may be referenced multiple times by a parent
recipe, and the parent may provide different values with each reference (Example 2) or may define new parameters
to use with different references (Example 3).
In the above examples, PARAMETERS (set when each individual recipe is verified) and Gen_LinkParam (set when
XYZ is linked) will contain parameter definitions as follows:
Recipe
PARAMETERS n_LinkParam
XYZ;0.8 Time_A Time_A
Time_B Time_B
RampSetPoint
BakeTime
RAMP;1.0 RampSetPoint undefined for unlinked recipe
SEMI E42-0704 © SEMI 1995, 2004 120
BAKE;2.3 BakeTime undefined for unlinked recipe
R1-6 Applications of Object Services
Object Services are defined in SEMI E39 (Object Services Standard (OSS): Concepts, Behavior, and Services). This
section provides a description of how these services may be applied for RMS.
R1-6.1 Scope — Scope may be used to specify the namespace of interest. It may also be used to specify a
namespace or recipe execution resource belonging to a component agent of the service provider. For example, scope
allows a factory host to ask a cluster tool for the attributes of a cluster module.
Scope may be used to point to one of several namespaces supported by an agent.
R1-6.2 Filter — A filter may be used when asking a namespace for a list of recipe identifiers to limit the number of
identifiers returned. For example, the service user may ask a namespace for a list of recipe identifiers that were
edited by “Tom” (Attribute name = “EditedBy”, Attribute value = “Tom”, Attribute Relation = “is equal to”) and
that are linked (Attribute name = “Linked”, Attribute value = “TRUE”, Attribute Relation = “is equal to”).
R1-6.3 Complex Attributes — Object Services do not provide a way to change individual elements in an attribute
with a structure or list form. To add, delete, or modify items in a list or structure, it is necessary to first get the
current attribute value for the object of interest using the GetAttr service, to make the desired changes externally to
the value, and then to write the new value using the SetAttr service.
R1-7 Examples of RMS Application
Figure R1-2 illustrates possible interactions between a namespace and namespace manager implemented on a
factory system, a diskless equipment with a recipe executor, and an operator.
Figure R1-2
Example of RMS Applications