JP2013152730A - Plasma processing system component analysis software and method and system for creating the same - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a method for creating plasma processing system component analysis software.SOLUTION: Component specifications are defined. Each of the components implements at least one of a user-interface function, a logic operation function, an input function, and an output function for analyzing a plasma processing system component. A plurality of components are selected from a component panel of a visual integrated design editor architecture (VIDEA), thereby causing the plurality of components to be disposed in a layout format in the VIDEA. Properties of each of the plurality of components are specified by performing at least one of selecting from predefined properties and defining parameters for the properties. The plurality of components are saved in a mark-up language configured to be executable by a browser.

Description

  The present invention relates to plasma processing system component analysis software and methods and systems for producing the plasma processing system component analysis software.

  Advances in plasma processing have been brought about by the growth of the semiconductor industry. As plasma processing continues to evolve, there is an increasing need for customized software applications to collect and analyze data collected by plasma processing systems. As discussed herein, a customized software application refers to a software application that may be created to meet the specific needs of individuals, groups, departments, companies, etc.

  Customized software applications may be created for a variety of reasons. For example, customized software applications may be created to simplify the task of collecting and / or extracting information from the plasma processing system. Customized software applications may also be created to provide procedural guidelines such as ATAC inspection plans. In a further example, a customized software application may be created to automate repetitive tasks.

  Regardless of why you need a customized software application, creating a customized software application is a tedious and complex task that typically requires programming skills and knowledge that non-programmers do not have. May be. Furthermore, the task of maintaining and updating customized software applications may also require programming skills and knowledge. Because of this, creating, maintaining, and updating customized software applications in a plasma processing environment can be expensive and time consuming.

  The method for creating a customized software application may include having a software programmer use a text editor for writing software code. Once the software code is created, it may be compiled before the executable file is generated. This method can be a time consuming process that may require a software programmer to write code for both application design and application functionality. As an example, a simple format for collecting data about students can be used by software programmers to write code to design the physical format of the format and then control the function and behavior of that format. You may need to write code.

A further method for generating customized software applications in a plasma processing environment may be based on an integrated development environment (IDE). IDE, also known as a design editor, refers to software that may be used to develop other software applications. IDE helps, but not limited to, build components for creating graphical user interfaces (GUIs), text code editors for creating and editing code, and graphical user interfaces (GUIs), debuggers, and compilers. Tools may be included. Examples of IDE include, but are not limited to, Microsoft (R) Visual Studio, Borland (R) Delphi, and National Instrument (TM) LabVIEW. IDE can simplify the task of creating program code for software applications. One example is that instead of writing code for the GUI and code for the functionality of the software application, the IDE has components that the programmer may use to simplify the task of creating the GUI. May be. However, even with IDE, software application producers must still have the skills and knowledge to write code that defines the functionality of the GUI.

  To help explain, FIG. 1 shows a simple development cycle for developing a customized software application in a plasma processing environment. In an initial step 102, the need for a customized software application may be confirmed. For example, consider a situation where an inspector may need a software application to produce an inspection plan. In the next step 104, the programmer uses IDE (eg, Microsoft® Visual Studio, Borland® Delphi, and National Instrument ™ LabVIEW) to initiate the process of creating the software application. May be.

  In the next step 106, the programmer may design a GUI for the software application. In one example, to create a GUI for a format, a programmer adds components (such as text boxes, list boxes, check boxes, etc.) to the IDE to create a layout for the format. May be.

  In the next step 108, the programmer may write code for the software application. The code may include, but is not limited to, code for defining a load specification, defining a sequence of functions, defining logical criteria, identifying a table, and handling data entries.

  In the next step 110, the programmer may compile the code to identify potential bugs and to generate an executable file.

  In the next step 112, the method may determine whether the code contains a bug. Since the code is written by a programmer, the code can introduce human error (eg, bugs). In one example, if the programmer has created a form for collecting data, the programmer must know the names of the tables and table fields that will store the data collected by the form. When writing table information in the code, the programmer may misspell the table field, leading to a potential bug in the code.

  If the code contains a bug, in the next step 114, the method may provide a warning. By receiving this warning, the programmer must debug the code and perform corrections before returning to the next step 110 for recompiling the code. Steps 110-114 may be repeated until all bugs have been identified.

  If no further bugs are identified, in the next step 116 an executable file may be generated.

  In a next step 118, the customized software application may be distributed to end users. In one example, the customized software application may be deployed once the programmer has completed creating a software application for the inspector.

  IDE methods of creating customized software applications may require skills and knowledge that non-programmers do not have. In addition, changes to customized software applications may require code changes and may require code to be recompiled. In one example, the programmer may not understand the end user's requirements, so creating a software application may require changes to that software application. In order to implement the changes, new code must be written and the code must be recompiled.

  The present invention, in one embodiment, relates to a method for generating plasma processing system component analysis software. The method includes defining component specifications for a plurality of components. Each of the plurality of components performs at least one of a user interface function, a logic operation function, an input function, and an output function to analyze the plasma processing system component. Defining includes selecting a plurality of components from a component panel of a visual integrated design editor architecture (VIDEO), thereby placing the plurality of components in a layout format in VIDEO. Defining further includes specifying each property of the plurality of components by performing at least one of selecting from predefined properties and defining parameters for the property. . The method further includes saving the plurality of components in a markup language configured to be executable by the browser without requiring pre-compilation after the definition.

  In a further embodiment, the invention relates to a product comprising the program storage medium having computer readable code contained within the program storage medium. The computer readable code is configured to generate plasma processing system component analysis software. The product includes computer readable code to help a user define component specifications for a plurality of components. Each of the plurality of components performs at least one of a user interface function, a logic operation function, an input function, and an output function to analyze the plasma processing system component. Computer readable code to help define the component specification selects multiple components from the Visual Integrated Design Editor Architecture (VIDEO) component panel, thereby placing the multiple components within the layout format in VIDEO Computer readable code for Computer readable code for assisting in defining the component specification is provided for the plurality of components by performing at least one of selecting from predefined properties and defining parameters for the properties. Further included is computer readable code for specifying each property. The product further includes computer readable code for saving the plurality of components in a markup language configured to be executable by the browser after definition without requiring pre-compilation.

  In yet a further embodiment, the present invention relates to an arrangement for generating plasma processing system component analysis software. This construct includes a plurality of components. Each of the plurality of components performs at least one of a user interface function, a logical operation function, an input function, and an output function to define a component specification. Multiple components are selectable from the Visual Integrated Design Editor Architecture (VIDEO) component panel, whereby multiple components are placed in a layout format in VIDEO after being selected. Each property of the plurality of components is configurable by performing at least one of selecting from predefined properties and defining parameters for the property. This construct further includes a runtime loader. The runtime loader is configured to execute a plurality of components stored in a markup language configured to be executable by the runtime loader without requiring pre-compilation.

  The above summary of the invention is only one of many embodiments of the invention disclosed herein and is intended to limit the scope of the invention as set forth in the appended claims. Not what you want. These and other features of the present invention will be described in more detail in the following detailed description with reference to the accompanying drawings.

  The present invention is illustrated by way of non-limiting examples in the accompanying drawings, in which like numerals indicate like components.

FIG. 3 illustrates a simple development cycle for a customized software application. FIG. 6 illustrates a simple development cycle for a customized software application using VIDEO in one embodiment of the present invention. FIG. 4 is a diagram illustrating an example of a VIDEO user interface according to an embodiment of the present invention. FIG. 3 is a diagram illustrating an example of a VIDEO user interface including components in an editor according to an embodiment of the present invention. FIG. 4 illustrates an example of how components are defined in a VIDEO environment in one embodiment of the invention. In an embodiment of the present invention, it is a diagram showing an example of an XML file. FIG. 3 is a diagram illustrating an example of a customized software application being executed in an embodiment of the present invention. 1 is a block diagram illustrating an overall VIDEO environment in one embodiment of the present invention. FIG.

  The present invention will now be described in more detail in connection with some embodiments of the invention shown in the accompanying drawings. In the following description, numerous specific details are set forth in order to provide a thorough understanding of the present invention. However, it will be apparent to one skilled in the art that the present invention may be practiced without some or all of these specific details. In some instances, well known process steps and / or structures have not been described in detail so as not to unnecessarily obscure the present invention.

  Various embodiments including methods and techniques are described below. It should be noted that the present invention may encompass a product including a computer readable medium having stored thereon computer readable instructions for carrying out an embodiment of the technology according to the present invention. Computer-readable media includes, for example, semiconductor computer-readable media, magnetic computer-readable media, magneto-optical computer-readable media, optical computer-readable media, or other forms of computer-readable media for storing computer-readable code. But you can. Furthermore, the present invention may include equipment for carrying out embodiments of the present invention. Such equipment may include dedicated circuitry and / or programmable circuitry for performing tasks associated with embodiments of the present invention. Examples of such devices may include general purpose computers and / or special purpose computer devices, if appropriately programmed, and computer / computer devices adapted for various tasks associated with embodiments of the present invention. And a combination of a dedicated circuit / programmable circuit.

  In one aspect of the present invention, the inventor has now realized that it simplifies the process of creating, maintaining, and updating customized software applications by providing a visual IDE environment. Unlike the prior art, the inventor has realized that code must be embedded in multiple components that can be configured to add or remove functionality.

  In accordance with an embodiment of the present invention, a visual integrated design editor architecture (VIDEO) is provided in which components and component properties may be manipulated to produce plasma processing system component analysis software. Embodiments of the present invention also provide component layout design and component property values to be stored as a markup language, such as an extensible markup language (XML) file. Embodiments of the present invention further provide an XML file to be executed by the runtime loader. As described herein, runtime loader refers to software that reads a file and executes XML.

  In one embodiment of the present invention, a VIDEO environment is provided in which customized software applications (eg, plasma processing system component analysis software) may be created, maintained, and updated. In one embodiment of the invention, the method can be used for the implementation of VIDEO. For example, consider a situation where a user wishes to produce an inspection planning software application. By using VIDEO, the user may produce multiple layouts (eg, inspection design layout, recipe design layout, etc.). In one example, a user may create an inspection design layout for an inspection planning software application. In one embodiment, the user can add multiple components (such as text boxes, list boxes, check boxes, etc.) to the IDE for creating a layout (eg, drag and drop components onto the editor). The layout may be produced.

  Unlike the prior art, the user does not have to program the code to define the component. With VIDEO, users can create customized software applications that can be executed without programming knowledge. In one embodiment, the user may define a component specification (eg, function). By configuring each component, functions are not limited, but define the physical characteristics of the component, define the load specification, define the sequence of functions, define the logical criteria, It may include identifying tables, and code for handling data entry. Each configurable component may be associated with a rule for defining parameters, so the task of debugging the program by the compiler may be eliminated.

  In yet another embodiment, VIDEO may be able to configure a component by capturing external data internally. In one example, VIDEO may access multiple databases and provide a list of fields that the user can select. In another example, VIDEO may access data stored on the tool. By incorporating external data, VIDEO may provide the user with a dynamic way to access the external data when configuring the component. Thus, VIDEOA can eliminate the need for the user to search for external data.

  Once the inspection design layout is finalized, in one embodiment, the user may save the software application as an XML file. Unlike the prior art, files produced by VIDEO do not require a compiler to debug the program and / or generate an executable file. In one embodiment of the present invention, the VIDEO environment may provide a runtime loader that may be used to execute customized software applications. The runtime loader may read the XML file to assemble a GUI interface for use by the end user. The runtime loader may be used to load a plurality of different software applications (eg, inspection design, report design, recipe design, configuration design, etc.). In one embodiment, the same layout data may be used for different purposes. In one example, an XML file with an inspection design layout may be used to generate an inspection plan. The same XML file may be used to provide a report of the data collected by the inspection plan.

  A better understanding of the features and advantages of the present invention may be gained with reference to the drawings and the following description.

  FIG. 2 illustrates a simple development cycle for a customized software application using VIDEO in one embodiment of the present invention. In order to explain how the steps of FIG. 2 are applied, FIGS. 3 to 7 are described in parallel with FIG. The examples shown in FIGS. 3-7 are specific to automatic inspection & characterization (ATAC).

  In an initial step 202, the need for a customized software application may be confirmed.

  In the next step 204, the user may use VIDEO to start the process of creating a software application. In one embodiment, the user may or may not be a programmer.

  FIG. 3 illustrates an example of a VIDEO user interface in one embodiment of the present invention. In one embodiment, VIDEO may include an open source designer host library such as that provided by Microsoft®. VIDEO may include an editor 302, a component box 304, and a property box 306.

  In the next step 206, the user may design a GUI for the software application. In one example, to create a GUI for a format, a programmer adds components (such as text boxes, list boxes, check boxes, etc.) to the IDE to create a layout for the format. May be.

  FIG. 4 shows an example of a VIDEO user interface with components in the editor for one embodiment of the present invention. In one example, the user may begin creating a customized software application by dragging component 408 (ie, AtacComboBox) from component box 404 to editor 402.

  In a next step 208, the user may configure each component by manipulating and / or selecting properties (eg, parameters). FIG. 5 shows an example of how components are defined within a VIDEO environment in one embodiment of the invention. Editor 502 may include a plurality of components dragged from component box 504. In one example, text boxes (520, 522, 524, and 526) are examples of AtacTextBox from component box 504, and labels (530, 532, 534, 536, 538, 540, 542, 544, And 546) are examples of AtacLabel from component box 504. As each component is placed on the editor 502, each component may be moved around on the editor 502 to create a desired layout for the GUI.

  For each component of the desired layout, a function for each component may be defined. In one example, the user may set properties in the property box 506 for each component. In one embodiment, the user may configure each component by selecting a property from a predefined list (eg, a drop-down list). The predefined list may be used to minimize human error (eg, typo) and frustration (eg, unable to remember the location of the table field). In another embodiment, the user may configure each component by manipulating properties (eg, by entering parameters). Properties that may be set include, but are not limited to, user interface functions, logic operations functions, input functions, and output functions.

  In one embodiment, component user interface features may be configured. For example, consider the situation where an ATAC inspection plan is designed. The user may set different physical characteristics of each component in order to create a visually attractive design layout. Physical features that may be manipulated may include, but are not limited to, font size, font color, background color, text alignment, border color, and the like.

  In one embodiment, component input / output capabilities may be configured. In one embodiment, the input / output functionality of the component may be associated with data from an external source. Data from an external source may in one embodiment be retrieved from a database and / or an external device (eg, gas cylinder bin, process module, etc.). In one example, the user may select from a list of tables and / or a list of table fields (as can be seen from data field list 550), thereby associating the component's data input / output with the table. Enable. In another example, VIDEO may retrieve data regarding the plasma processing system, thereby allowing the user to define the conditions of the processing chamber. By connecting to an external environment, VIDEO may provide information to the user that may dynamically retrieve data from external sources and help set component properties.

  In one embodiment, the logical operation function of the component may be set. In one example, a logical operation function that may be defined is a sequence for executing an ATAC inspection plan (eg, identifying portions to be inspected before retrieving inspection specifications from a database). In another example, criteria (e.g., if-else conditions, do-while loops, etc.) for executing a portion of an ATAC inspection plan may be defined. In yet another example, code for handling data (eg, collected data, manually entered data, data retrieved from an external source, etc.) may be defined.

  In the next step 210, the layout design and component properties may be saved as an XML file. This method does not require a compiler to debug the program and / or generate an executable file. See FIG. 6 for an example of an XML file.

  In a next step 212, the customized software application may be distributed to end users. FIG. 7 shows an example of a customized software application being executed in one embodiment of the present invention.

  Because VIDEOA requires no programming knowledge and requires minimal training time, users can easily use VIDEO to create customized software applications to meet everyday use. be able to. Furthermore, changes and / or updates to customized software applications can be easily performed without the need for tedious programming changes and / or recompilation.

  FIG. 8 shows a block diagram illustrating the overall VIDEO environment in one embodiment of the invention. The overall VIDEO environment may be divided into two parts: a VIDEO part 890 and a runtime loader part 892. VIDEO portion 890 shows a block diagram associated with creating, maintaining, and / or updating a customized software application. The runtime loader portion 892 shows a block diagram associated with executing a customized software application.

  The VIDEO portion 890 may include a VIDEO 802, which may be invoked to create a customized software application. VIDEO 802 allows the user to lay out the design for the GUI by dragging and dropping components onto the editor. The user can also set properties for each component to define the function of each component. In one embodiment, VIDEO may be connected to external environment 810 to retrieve data regarding database information 812 and / or external device 814 (eg, plasma processing tools, appliances, electronic devices, etc.). Once the GUI layout is complete, the user may save the information to generate an XML file. In one example, the inspection design layout may be saved as an XML file 804. In another example, the recipe design layout may be saved as an XML file 806.

  The runtime loader portion 892 may include a runtime loader 820 that reads an XML file (eg, 804 and / or 806) to reconfigure the GUI interface 822 for use by the end user. be able to. In one embodiment, the end user may be the same person who created the customized user interface. The runtime loader 820 may be used to load various applications (eg, inspection design, report design, recipe design, configuration design, etc.). In other words, the runtime loader 820 can be used to load any kind of customized software application as long as the customized software application is stored in XML format.

  In one embodiment, the same layout data may be used for different purposes. In other words, when the GUI interface 822 is reconfigured, the end user can be provided with an opportunity to determine how the GUI interface 822 can be used. In one example, an XML file 804 with an inspection design layout generates an inspection plan 832 that may provide guidance to an end user when inspecting a portion, and collect and store the inspection results. May be used to The same XML file 804 with the test design layout may be used to provide a test plan and a report 834 of the collected data. Further, the same XML file 804 with the inspection design layout may be used to generate a PDF report 836, which may be saved and / or shared with other users. In another example, an XML file 806 with a recipe design layout may be used to generate a settings file 842 that is used to set up tools for processing a board. It may be loaded onto a plasma processing tool. Again, the same XML file 806 with the recipe design layout may be used to provide the report 844 and / or PDF report 846.

  As can be seen from the embodiments of the present invention, VIDEO provides a simple visual IDE that does not require programming skills and / or knowledge by the user. By simplifying the creation of customized software applications, the production process is now provided to users who understand the application requirements. Furthermore, changes and / or updates to customized software applications can be easily implemented without the need to perform debugging and / or compilation. Therefore, VIDEOA can eliminate high overhead and reduce development time.

  Although the invention has been described with reference to several preferred embodiments, there are alterations, substitutions, and equivalents to those embodiments, which are included within the scope of the invention. Also, for convenience, the title of the invention, the summary of the invention, and the abstract are provided here, but should not be used to interpret the claims set forth herein. It should also be noted that there are many alternative ways of implementing the methods and apparatus of the present invention. While various examples have been provided herein, these examples are provided by way of illustration and are not intended to limit the invention. Further, in this application, a set of “n” items means zero or more items present in the set. Accordingly, the appended claims should be construed to include all such modifications, substitutions, and equivalents that fall within the spirit and scope of the invention.

Claims (9)

A method for generating plasma processing system component analysis software, the method comprising:
(A) defining component specifications for a plurality of components, each of the plurality of components for analyzing a plasma processing system component, a user interface function, a logic operation function, an input function, and an output Perform at least one of the functions,
The steps to define the component specification are:
(A1) selecting a plurality of components from a component panel of a visual integrated design editor architecture (VIDEO), thereby placing the plurality of components in a layout format in the VIDEO;
(A2) specifying each property of the plurality of components by performing at least one of selecting from predefined properties and defining a parameter for the property; The predefined properties for the plurality of components are defined by an external source, the external source being at least one of a database and an external device;
(A3) defining at least one of the plurality of components by defining a physical feature, defining a load specification, defining a logical reference, and identifying a code for handling a data entry Defining a component specification, including:
(B) After defining the component specification, the plurality of components in a markup language configured to be executable by a runtime loader provided to the VIDEO without requiring pre-compilation. Saving step;
Including methods.   The method of claim 1, wherein selecting the plurality of components from the component panel includes dragging and dropping the plurality of components onto an integrated design editor.   The method of claim 1, wherein the markup language is an extensible markup language. A product comprising a computer readable program storage medium having computer readable code configured to generate plasma processing system component analysis software therein,
(A) computer readable code to assist a user in defining component specifications for a plurality of components, each of the plurality of components having a user interface function for analyzing a plasma processing system component; Performing at least one of a logical operation function, an input function, and an output function;
The computer readable code is
(A1) computer readable code for selecting a plurality of components from a component panel of a visual integrated design editor architecture (VIDEO), thereby placing the plurality of components in a layout format in the VIDEO;
(A2) A computer for designating each property of each of the plurality of components by performing at least one of selecting from predefined properties and defining parameters for the property Computer readable code, wherein the predefined properties for the plurality of components are defined by an external source, the external source being at least one of a database and an external device;
(A3) defining at least one of the plurality of components by defining a physical feature, defining a load specification, defining a logical reference, and identifying a code for handling a data entry Computer readable code, including computer readable code for setting;
(B) After defining the component specification, the plurality of components in a markup language configured to be executable by a runtime loader provided to the VIDEO without requiring pre-compilation. Computer readable code for storing
A product comprising a program storage medium including   The product of claim 4, wherein the computer readable code for selecting the plurality of components from the component panel includes computer readable code for dragging and dropping the plurality of components onto an integrated design editor.   The product of claim 4, wherein the markup language is an extensible markup language. A computer apparatus for generating plasma processing system component analysis software comprising:
(A) each of a plurality of components that implement at least one of a user interface function, a logical operation function, an input function, and an output function for defining a component specification,
(A1) The plurality of components can be selected from a component panel of a visual integrated design editor architecture (VIDEO), thereby placing the plurality of components in a layout format in the VIDEO after being selected;
(A2) by performing at least one of selecting from predefined properties and defining parameters for the properties, the properties of each of the plurality of components can be set; The predefined properties for the plurality of components are defined by an external source, the external source being at least one of a database and an external device;
(A3) defining at least one of the plurality of components by defining a physical feature, defining a load specification, defining a logical reference, and identifying a code for handling a data entry Multiple components to configure,
(B) A runtime loader provided to the VIDEO configured to execute the plurality of components, the plurality of components being executable by the runtime loader without requiring pre-compilation. A runtime loader stored in a markup language configured to be
(C) a circuit for performing work on the plurality of components;
A device comprising:   The computer apparatus according to claim 7, wherein the plurality of components are selectable from the component panel by dragging and dropping the plurality of components onto an integrated design editor.   The computer apparatus according to claim 7, wherein the markup language is an extensible markup language.