Scheduling substrate routing and processing

Abstract

The method includes the step of identifying a bottleneck operation among a plurality of operations within a sequence recipe. The plurality of operations are associated with transporting and processing a plurality of substrates in a substrate processing system. The method further includes the step of determining a tack time for the plurality of substrates based on the bottleneck operation. The tack time is the amount of time between a first substrate entering the substrate processing system and a second substrate entering the substrate processing system. The method further includes the step of determining a plurality of queue times. Each of the plurality of queue times corresponds to an individual operation among the plurality of operations. The method further includes the step of causing the plurality of substrates to be processed by the substrate processing system based on the tack time and the plurality of queue times.

Description

Technology Field

[0001] The present disclosure relates to scheduling in manufacturing systems, such as substrate processing systems, and specifically to scheduling of substrate routing and processing in manufacturing systems. Background Technology

[0002] Products are produced by performing one or more manufacturing processes using manufacturing equipment. For example, substrate processing equipment is used to produce substrates by transporting substrates to processing chambers and performing processes on the substrates within the processing chambers. For reference, the technology forming the background of the present invention is disclosed in the following published patent application. (Patent Document 1) US 2008 / 0216077 A1 (2008.09.04)

[0003] The following is a simplified summary of the present disclosure to provide a basic understanding of some aspects of the present disclosure. This summary is not an extensive overview of the present disclosure. It is not intended to identify any core or important elements of the present disclosure, nor is it intended to describe any scope of any specific implementations or claims of the present disclosure. Its sole purpose is to present some concepts of the present disclosure in a simplified form as an introduction to the more detailed description to be provided later.

[0004] In one aspect of the present disclosure, the method comprises the step of identifying a bottleneck operation among a plurality of operations in a sequence recipe. The plurality of operations are associated with transporting and processing a plurality of substrates in a substrate processing system. The method further comprises the step of determining a takt time for the plurality of substrates based on the bottleneck operation. The takt time is the amount of time between a first substrate entering the substrate processing system and a second substrate entering the substrate processing system. The method further comprises the step of determining a plurality of queue times. Each of the plurality of queue times corresponds to an individual operation among the plurality of operations. The method further comprises the step of causing the plurality of substrates to be processed by the substrate processing system based on the takt time and the plurality of queue times.

[0005] In another aspect of the present disclosure, a non-transient machine-readable storage medium storing instructions, wherein the instructions, when executed, cause a processing device to identify a bottleneck operation among a plurality of operations in a sequence recipe. The plurality of operations are associated with transporting and processing a plurality of substrates in a substrate processing system. The processing device further determines a tack time for the plurality of substrates based on the bottleneck operation. The tack time is an amount of time between a first substrate entering the substrate processing system and a second substrate entering the substrate processing system. The processing device further determines a plurality of queue times. Each of the plurality of queue times corresponds to an individual operation among the plurality of operations. The processing device further causes the plurality of substrates to be processed by the substrate processing system based on the tack time and the plurality of queue times.

[0006] In another aspect of the present disclosure, the system comprises a memory and a processing device coupled to the memory. The processing device identifies a bottleneck operation among a plurality of operations in a sequence recipe. The plurality of operations are associated with transporting and processing a plurality of substrates in a substrate processing system. The processing device further determines a tack time for the plurality of substrates based on the bottleneck operation. The tack time is an amount of time between a first substrate entering the substrate processing system and a second substrate entering the substrate processing system. The processing device further determines a plurality of queue times. Each of the plurality of queue times corresponds to an individual operation among the plurality of operations. The processing device further causes the plurality of substrates to be processed by the substrate processing system based on the tack time and the plurality of queue times. Brief explanation of the drawing

[0007] The present disclosure is illustrated by example, not by limitation, in the accompanying drawings.

[0008] FIG. 1a is a block diagram illustrating an exemplary system architecture according to specific embodiments.

[0009] FIG. 1b is a processing system according to specific embodiments.

[0010] FIGS. 2a-b are flowcharts of methods associated with scheduling substrate routing and processing according to specific embodiments.

[0011] FIG. 3 illustrates a sequence chart according to specific embodiments.

[0012] FIG. 4 is a block diagram illustrating a computer system according to specific embodiments. Specific details for implementing the invention

[0013] Techniques regarding substrate routing and scheduling of processing are described in this specification.

[0014] Products are produced by performing one or more manufacturing processes using manufacturing equipment. For example, substrate processing equipment is used to process substrates (e.g., wafers, semiconductors, displays, etc.). A substrate processing system processes substrates based on a sequence recipe that includes different operations such as transfer operations (e.g., robots transferring substrates to different locations), processing operations (e.g., processing of substrates within processing chambers), and cleaning operations (e.g., cleaning of processing chambers after processing operations). For example, in semiconductor processing, multilayer features are manufactured on substrates using specific processing sequence recipes having multiple processing operations. A substrate processing system (e.g., a cluster tool) includes multiple processing chambers for performing a process sequence of a sequence recipe (e.g., a sequence of process recipe operations completed in the processing chambers of the cluster tool) without removing the substrates from the processing environment (e.g., the substrate processing system). The substrate processing system has a limited number of robots for performing transfer operations and a limited number of processing chambers for performing processing operations. For the substrate to move to the next operation, the substrate must complete the preceding operation, a processing chamber of the corresponding type must be available, and a corresponding robot must be available.

[0015] In conventional systems, substrate transfer and processing operations are controlled based on the current state of the system. In conventional systems, given different possible routings of substrates to different possible processing chambers via different possible robots, wafers are routed in many different random sequences with inconsistent timings. The randomness and different timings of the routings cause different waiting times, random delays, and reduced throughput for substrates within different processing chambers. In conventional systems, different substrates will exhibit different behaviors based on the state of the system. For example, because resources (e.g., robots, processing chambers, etc.) are available at this point, a first substrate will have no waiting time. If the next chamber is processing the previous substrate, the subsequent substrate will wait in the chamber. Different waiting times for substrates cause non-uniformity between substrates (e.g., inconsistency, non-uniform substrate surface properties). For example, in a thermal process, the longer a substrate waits after a thermal operation is completed, the lower the substrate temperature becomes, which will cause non-uniform surface temperatures in the next operation within the sequence. In another example, in a wet process, the longer the substrate waits after the wet chemical process operation is completed, the more chemical reactions will occur on the surface of the substrate.

[0016] The randomness and differing timing of routings make the completion time of a batch of substrates unknown, causing additional delays in the removal of a batch of substrates (e.g., removal of a cassette of processed substrates) and the provision of a new batch of substrates to a substrate processing system (e.g., docking of a new cassette of unprocessed substrates). In conventional systems, consistency between substrates is not enforced, and throughput is reduced due to randomness and delays.

[0017] In conventional systems, the substrate is transferred to the next process location when the next process location is empty and the robot is available. However, such "move when available" logic causes a deadlock when the sequence flow involves revisit operations. For example, the first chamber (CH A ) or the second chamber (CH B ) performs 50-second processes, followed by a third chamber (CH) that performs 200-second processes. C ) or the 4th chamber (CH D ) follows, and then CH A or CH B A deadlock occurs when a (50-second process) follows. CH where the first substrate executes a 200-second process C It is in, and the second substrate is also CH executing a 200-second process. D It is in, and CH A and CH B If it is empty, the conventional system CH executes a 50-second process on the third substrate A It will be moved to, and CH executing the 50-second process on the 4th substrate B It will be moved to. The first and second substrates CH C and CH D After completing the processes in, the next operation for the first and second substrates is CH A and CH B It must be performed in, but CH A and CH BDeadlock occurs because it is occupied by the third and fourth substrates. Increasing the speed of the sequence recipe (e.g., a more aggressive feed rate) causes deadlock in the substrate processing system (e.g., causing additional delays, substrate non-uniformity, and damage to wafers and the substrate processing system), while decreasing the speed of the sequence recipe (e.g., a less aggressive feed rate) causes reduced throughput. Given the randomness of routing, different timings, and unknown completion times, conventional systems often face deadlocks and / or reduced throughput.

[0018] The devices, systems, and methods disclosed herein provide scheduling of sequence recipe operations, such as substrate routing, substrate processing, and processing chamber cleaning, in a substrate processing system (e.g., an integrated processing system). The devices, systems, and methods control substrate routing and processing in the substrate processing system (e.g., through a processing device executing sequencer and / or tack control) for improved system throughput and improved substrate-to-substrate consistency.

[0019] The processing device receives topology information of a substrate processing system and historical timing information associated with the operations of a sequence recipe. The operations of the sequence recipe include one or more of transfer operations for transferring substrates in the substrate processing system, processing operations for processing substrates in the substrate processing system, and cleaning operations for cleaning processing chambers that perform processing operations. The historical timing information includes one or more of historical transfer timings (e.g., historical pickup time, drop-off time, transfer time, etc.), historical processing timings (e.g., by processing chamber type, by processing operation type), and historical cleaning timings (e.g., by processing chamber type, by processing operation type).

[0020] Processing logic identifies bottleneck operations of the operations in a sequence recipe. Bottleneck operations take longer than other operations within the sequence recipe. Based on the bottleneck operations, the processing device determines takt times (e.g., pace time, interval, entry rate, etc.) for the substrates. Takt time is the amount of time between a first substrate entering the substrate processing system and a subsequent substrate entering the substrate processing system.

[0021] The processing device additionally determines queue times (e.g., process recipe padding time) to ensure there are no conflicts between substrate transfer operations associated with the same robot. Each queue time corresponds to an individual operation (e.g., processing operation) of the operations in the sequence recipe. The queue time is an artificial delay of the substrate after the completion of the operation (e.g., currently being processed).

[0022] The processing device causes substrates to be processed by a substrate processing system based on tack times and queue times. The processing device causes a new substrate to enter the substrate processing system at every tack time (e.g., after a set amount of time) and causes different substrates to wait in different chambers based on the corresponding queue time.

[0023] In some embodiments, the processing device generates a schedule (e.g., a timetable) based on tak times and queue times, and allows substrates to be processed based on the schedule.

[0024] The embodiments of the present disclosure provide technical advantages. By processing substrates based on takt times and queue times, deadlocks and delays are avoided, greater throughput is achieved compared to conventional systems, and greater uniformity between substrates is achieved. By processing substrates based on takt times and queue times, the completion time of a group of substrates is predicted more accurately, which allows processed groups of substrates to be removed without delay and allows new groups of substrates to be provided without delay. This improves the throughput of processing groups of substrates compared to conventional systems.

[0025] While some embodiments of the present disclosure describe transporting and processing substrates in a substrate processing system, the present disclosure applies to other systems, such as manufacturing systems, that perform operations over time, in some embodiments.

[0026] FIG. 1a is a block diagram illustrating a system (100A) (e.g., exemplary system architecture, computing environment) according to specific embodiments. The system (100A) includes a client device (192), manufacturing equipment (184) (e.g., cluster tool, substrate processing equipment), sensors (186), measuring equipment (188), a controller device (190) (e.g., controller, server), and a data storage (140).

[0027] Client device (192), manufacturing equipment (184), sensors (186), measuring equipment (188), and controller device (190) are combined through a network (180) to allow substrates to be processed based on tak time (172) and queue times (174) (e.g., based on a schedule (176)). In some embodiments, the network (180) is a public network providing the client device (192) with access to the controller device (190), data storage (140), and other publicly available computing devices. In some embodiments, the network (180) is a private network providing the client device (192) with access to the manufacturing equipment (184), sensors (186), measuring equipment (188), data storage (140), and other privately available computing devices. The network (180) includes one or more wide area networks (WANs), local area networks (LANs), wired networks (e.g., Ethernet networks), wireless networks (e.g., 802.11 networks or Wi-Fi networks), cellular networks (e.g., Long Term Evolution (LTE) networks), routers, hubs, switches, server computers, cloud computing networks, and / or combinations thereof.

[0028] The controller device (190) (e.g., controller, server) includes one or more computing devices such as a rack-mount server, router computer, server computer, personal computer, mainframe computer, laptop computer, tablet computer, desktop computer, graphics processing unit (GPU), accelerator application-specific integrated circuit (ASIC) (e.g., tensor processing unit (TPU)). In some embodiments, the controller device (190) includes a scheduling component (194) for causing substrates to be processed based on tack time (172) and queue times (174) (e.g., based on a schedule (176)). In some embodiments, the scheduling component (194) is used to perform one or more operations of the methods (200A-B) of FIGS. 2a and 2b. In some embodiments, the controller device (190) is a controller of a semiconductor processing system and is used to control manufacturing equipment (184).

[0029] The client device (192) includes computing devices such as personal computers (PCs), laptops, mobile phones, smartphones, tablet computers, netbook computers, network-connected televisions (“Smart TVs”), network-connected media players (e.g., Blu-ray players), set-top boxes, over-the-top (OTT) streaming devices, operator boxes, etc. In some embodiments, the client device (192) displays a graphical user interface (GUI) to receive inputs and display outputs. In some embodiments, the client device (192) includes a scheduling component (194) for causing substrates to be processed based on tack times (172) and queue times (174) (e.g., based on a schedule (176)). In some embodiments, the scheduling component (194) is used to perform one or more operations of the methods (200A-B) of FIGS. 2a and 2b.

[0030] In some embodiments, a sequence recipe (150) is provided to a client device (192) (e.g., via user input). The sequence recipe (150) describes which possible processing chambers a substrate will visit at different stages and the process to be executed in each chamber. Then, the client device (192) generates a schedule (176) for substrate movements (e.g., based on tak times (172) and queue times (174), so that the substrates can be processed by manufacturing equipment (184) (e.g., in a cluster tool) at consistent timing with improved throughput.

[0031] In some embodiments, the scheduling component (194) is a tack control component that identifies bottleneck operations of the substrate processing flow on the manufacturing equipment (184) (e.g., cluster tool), resolves resource conflicts, and then generates a consistent schedule (176) for the substrates (e.g., based on tack time (172) and queue time (174). In some embodiments, the client device (192) transmits the schedule (176) (e.g., substrate processing schedule and instructions) to the controller device (190) (e.g., controller), and the controller device (190) causes the substrates to be processed by the manufacturing equipment (184) based on the schedule (176).

[0032] In some embodiments, the manufacturing equipment (184) (e.g., cluster tool) is part of a substrate processing system (e.g., integrated processing system). The manufacturing equipment (184) includes one or more of the following: an enclosure system (e.g., substrate carrier, front opening unified pod (FOUP), autoteach FOUP, process kit enclosure system, substrate enclosure system, cassette, etc.), a side storage pod (SSP), an aligner device (e.g., an aligner chamber), a factory interface (e.g., an equipment front end module (EFEM)), a load lock, a transfer chamber, one or more processing chambers, a robot arm (e.g., placed within the transfer chamber, placed within the front interface), etc. The enclosure system, SSP, and load lock mounted on the factory interface, and the robot arm positioned on the factory interface are intended to transfer contents (e.g., substrates, process kit rings, carriers, verification wafers, etc.) between the enclosure system, SSP, load lock, and the factory interface. An aligner device is positioned on the factory interface to align the contents. The load lock and processing chambers mounted on the transfer chamber, and the robot arm positioned within the transfer chamber are intended to transfer contents (e.g., substrates, process kit rings, carriers, verification wafers, etc.) between the load lock, processing chambers, and transfer chamber.

[0033] The manufacturing equipment (184) includes one or more processing chambers for producing substrates based on a sequence recipe (150), tak time (172), and queu times (174). The sequence recipe (150) includes a set of operations (152) for creating features on a substrate (e.g., depositing layers, manufacturing multilayer features).

[0034] Sensors (186) provide sensor data (e.g., sensor values, trace data) associated with manufacturing equipment (184) (e.g., associated with the creation of substrates by manufacturing equipment (184)). In some embodiments, sensor data is used to determine manufacturing parameters of manufacturing equipment (184). In some embodiments, sensor data is used for equipment health and / or product health (e.g., substrate quality). Manufacturing equipment (184) creates substrates according to a sequence recipe (150) based on tack times (172) and queue times (174) (e.g., schedule (176)) over a set period of time. Sensor data (e.g., trace data) is received from different sensors (186) over a set period of time (e.g., corresponding to at least part of the sequence recipe (150) or execution).

[0035] The measuring equipment (188) is used to determine measurement data corresponding to the products of the manufacturing equipment (184). In some embodiments, after the manufacturing equipment (184) deposits one or more layers on a substrate, the measuring equipment (188) is used to determine one or more of the thicknesses of the layers, the uniformity of the layers, the spacing between layers, etc. In some embodiments, the measuring equipment (188) includes an imaging device.

[0036] The data storage (140) is memory (e.g., random access memory), a drive (e.g., a hard drive, a flash drive), a database system, or other type of component or device capable of storing data. The data storage (140) includes multiple storage components (e.g., multiple drives or multiple databases) spread across multiple computing devices (e.g., multiple server computers). The data storage (140) stores sequence recipes (150), history information (160), topology information (170), tag times (172), queue times (174), and schedules (176) (e.g., schedules in a file).

[0037] The sequence recipe (150) includes operations (152). The operations (152) include transfer operations (154) (e.g., robot operations), processing operations (156) (e.g., chamber operations), and cleaning operations (158).

[0038] History information (160) includes timings (162). The timings (162) include history transfer timings (164), history processing timings (166), and history cleaning timings (168).

[0039] Topology information (170) includes information regarding manufacturing equipment (184) (e.g., components, quantities, capabilities, etc.).

[0040] The takt time (172) of the substrates (e.g., phase time, interval, entry rate, etc.) is the amount of time between the first substrate entering the substrate processing system and the subsequent substrate entering the substrate processing system.

[0041] Queue times (174) correspond to operations (152) (e.g., processing operations (156)) of the sequence recipe (150). Queue time (174) is an artificial delay of the substrate after the completion of the operation (152) (e.g., processing operation (156)).

[0042] A schedule (176) (e.g., a timetable) is based on tak time (172) and queue time (174). The schedule (176) is intended for processing a group of substrates. The schedule (176) defines tasks for manufacturing equipment (184) (e.g., related chambers and transporters) to complete a processing sequence assigned to each substrate in order to provide improved uniformity and improved throughput of the substrates.

[0043] In some embodiments, the data storage (140) stores sensor data from the sensors (186) (e.g., as history information (160)). The sensor data includes one or more values ​​of temperature (e.g., heater temperature), gap (SP), pressure, high frequency radio frequency (HFRF), low frequency radio frequency (LFRF), radio frequency (RF) power, voltage of the electrostatic chuck (ESC), current, flow, power, voltage, etc. In some embodiments, the sensor data is associated with or represents manufacturing parameters, such as hardware parameters (e.g., settings of the manufacturing equipment (184) or components (e.g., size, type, etc.)) or process parameters of the manufacturing equipment. The sensor data is provided while the manufacturing equipment (184) is performing manufacturing processes (e.g., equipment readings when processing products). In some embodiments, the sensor data is different for each substrate and / or layer.

[0044] In some embodiments, the data storage (140) stores measurement data from the measurement equipment (188) (e.g., as history information (160)). The measurement data includes image data, thickness values, interlayer spacing values, uniformity values, performance data, whether the layers of the substrate meet threshold values, indications of dispersion in the layers of the substrate, property data of the substrates, yield, substrate space film properties, dimensions (e.g., thickness, height, etc.), dielectric constant, dopant concentration, density, defects (e.g., whether the substrate and / or layer meet threshold properties, reasons why the substrate and / or layer do not meet threshold properties), etc. In some embodiments, the measurement data is for finished or semi-finished substrates. In some embodiments, the measurement data is different for each substrate and / or layer.

[0045] In some embodiments, sensor data and / or measurement data are used to determine whether the sequence recipe (150), tak time (172), queue times (174), and / or schedule (176) will be updated (e.g., to improve the quality of substrates, the health of manufacturing equipment (184), energy usage, etc.).

[0046] For the purpose of illustration rather than limitation, aspects of the present disclosure describe substrates being processed based on tack times (172) and queue times (174) (e.g., based on a schedule (176)). In some implementations, a heuristic model or a rule-based model is used to determine the tack times (172) and / or queue times (174). A scheduling component (194) monitors history information (160) to cause the generation of an offset table for the recipe (150). In some embodiments, a trained machine learning model is used to determine the tack times (172), queue times (174), and / or schedule (176). History sequence recipes and history information are used as data inputs and history tack times and history queue times (e.g., history schedules are used as target outputs for training the machine learning model). The recipe (150) and history information (160) are used as inputs to a trained machine learning model, and the tak time (172) and queue times (174) and / or schedule (176) are determined from the output of the trained machine learning model.

[0047] In some embodiments, the functions of the client device (192) and the controller device (190) are provided by a smaller number of machines. In some embodiments, the client device (192) and the controller device (190) are integrated into a single machine.

[0048] In some embodiments, one or more functions described as being performed by the client device (192) may also be performed on the controller device (190), if appropriate. In some embodiments, one or more functions described as being performed by the controller device (190) may also be performed on the client device (192), if appropriate. Additionally, functions attributed to a specific component may be performed by different or multiple components operating together. For example, in some embodiments, the controller device (190) causes the generation of tak time (172) and / or queue time (174), and in some embodiments, the client device (192) causes the generation of tak time (172) and / or queue time (174).

[0049] Additionally, the functions of a specific component may be performed by different or multiple components operating together. In some embodiments, the controller device (190) is accessed as a service provided to other systems or devices through appropriate application programming interfaces (APIs).

[0050] In the embodiments, "User" is represented as a single individual. However, other embodiments of the present disclosure include "User" as an entity controlled by a plurality of users and / or an automated source. For example, a set of individual users united as a group of administrators is considered a "User."

[0051] In some embodiments, parts of the disclosure refer to substrates being processed based on takt times (172) and queue times (174) (e.g., based on a schedule (176)) through substrate processing in a substrate chamber of a substrate processing system, but the disclosure generally applies to performing other processes based on takt times and / or queue times (e.g., through a manufacturing system).

[0052] FIG. 1b is a processing system (100B) according to specific embodiments (e.g., manufacturing equipment (184) which is a cluster tool for substrate processing). The processing system (100B) is configured to execute a sequence recipe (150) (e.g., a process sequence). In some embodiments, the processing system (100B) is a NOKOTA commercially available from Applied Materials®, Inc. in Santa Clara, California. TM It is an electroplating copper tool.

[0053] The processing system (100B) includes a transfer chamber (101) (e.g., an electroplating processing platform) and a factory interface (FI) (102) (e.g., FI, EFEM). The transfer chamber (101) includes a plurality of processing chambers (108, 110, 112, and 114) and two spinning ring maintenance (SRM) chambers (120) that are coupled to transfer chamber robots (104 and 105) (e.g., wet substrate transfer robots). The factory interface (102) is coupled to the robots (104 and 105) by the SRM chambers (120).

[0054] The factory interface (102) includes at least one docking station (e.g., a load port), at least one substrate transfer robot (138), and at least one substrate aligner device (129). The docking station (e.g., a load port) is configured to accommodate one or more forward-opening integrated pods (FOUPs) (128) (e.g., cassettes). Three FOUPs (128A, 128B, and 128C) are shown in FIG. 1. The substrate transfer robots (138A-B) are configured to transfer substrates from the factory interface (102) to SRM chambers (120). The aligner device (129) is configured to locate notches on the substrates. SRD (spin rinse drying) chambers (122) are configured to rinse and dry the substrates. The factory interface robot (138B) is configured to transfer substrates between the FOUP (128), the aligner device (129), and the SRM (120). The factory interface robot (138A) is configured to transport substrates between the SRM chambers (120) and the SRD chambers (122).

[0055] The SRM chamber (120) has a first port coupled to the factory interface (102) and a second port coupled to the transfer chamber (101) (e.g., an electroplating processing platform). The SRM chamber (120) includes a safetyseal chuck and de-chuck device for attaching (e.g., assembling) a safetyseal to a substrate and / or removing the safetyseal from the substrate.

[0056] In some embodiments, a safe seal (e.g., SafeSeal TMA SafeSeal is an assembly that protects a substrate (e.g., one or more parts of a substrate), seals the substrate before processing, and protects the substrate throughout operations (e.g., a multi-metal plating sequence). Pre-process seal leak testing and post-process cleaning, inspection, and verification ensure that each substrate is properly sealed and protected before the plating process begins. SafeSeals prevent tool downtime and wafer scrap for seal maintenance or replacement.

[0057] To facilitate the transfer of substrates between process chambers (108, 110, 112, 114 and 120) within the transfer chamber (101), two substrate transfer robots (104, 105) are placed within the transfer chamber (101) (e.g., an electroplating processing platform).

[0058] The processing system (100B) communicates with a controller device (190). The controller device (190) is a controller that controls process parameters of each substrate processing chamber (108, 110, 112, 114, 120, and 122) within the processing system (100B). In some embodiments, the controller device (190) provides sequencing and scheduling of substrates to be processed within the processing system (100B). The controller device (190) causes the substrates to be processed based on tack times (172) and queue times (174) (e.g., schedule (176)).

[0059] FIGS. 2a and 2b are flowcharts of methods (200A-B) associated with scheduling of substrate routing and processing according to specific embodiments. The methods (200A-B) are performed by processing logic comprising hardware (e.g., circuits, dedicated logic, programmable logic, microcode, processing devices, etc.), software (e.g., instructions executed on processing devices, general-purpose computer systems, or dedicated machines), firmware, microcode, or a combination thereof. In some embodiments, the methods (200A-B) are performed in part by a controller device (190) (e.g., a scheduling component (194)). In some embodiments, the methods (200A-B) are performed in part by a client device (192) (e.g., a scheduling component (194)). In some embodiments, a non-transient storage medium stores instructions that cause a processing device (e.g., a controller device (190), a client device (192), etc.) to perform one or more of the methods (200A-B) when executed by the processing device.

[0060] For the sake of brevity, the methods (200A-B) are described and explained as a series of actions. However, actions according to the present disclosure may occur in various sequences and / or simultaneously and together with other actions not presented and described herein. Furthermore, in some embodiments, not all of the illustrated actions are performed to implement the methods (200A-B) according to the disclosed claims. Additionally, those skilled in the art will understand and know that the methods (200A-B) may alternatively be represented as a series of interrelated states through state diagrams or events.

[0061] FIG. 2a is a flowchart of a method (200A) (e.g., a process sequence for plating three layers on a substrate) for substrate processing equipment (e.g., an integrated cluster tool, the manufacturing equipment (124) of FIG. 1a, and the processing system (100B) of FIG. 1b) according to specific embodiments.

[0062] In block (202) of method (200A), processing logic positions the substrate within a substrate processing system (e.g., a cluster tool). In some embodiments, in block (202), the substrate is positioned within a cluster tool on the FOUP (128A, 128B, or 128C) of FIG. 1B. In some embodiments, the FOUP (128) housing the substrate is docked onto a load port of the substrate processing system.

[0063] In block (204), the processing logic aligns the substrate in an aligner device (e.g., an aligner chamber). In some embodiments, in block (204), the substrate is aligned in the aligner device (129) of FIG. 1B.

[0064] In block (206), the processing logic attaches a safe seal (e.g., protective assembly, protective covering, etc.) to the substrate in the spinning ring maintenance (SRM) chamber. In some embodiments, in block (206), the substrate is moved to the SRM chambers (120) of FIG. 1b so as to be chucked from the safe seal.

[0065] In block (208), the processing logic pre-wets the substrate in a vacuum pre-wetting (VPM) chamber. In some embodiments, in block (208), the substrate is pre-wetted in the VPM chamber (108) of FIG. 1B.

[0066] In block (210), the processing logic plates the substrate with copper in the first processing chamber. In some embodiments, in block (210), the substrate is plated with copper in one of the available plating chambers (110) of FIG. 1B.

[0067] In block (212), the processing logic plates the substrate with nickel (Ni) in a second processing chamber. In some embodiments, in block (212), the substrate is moved to one of the available plating chambers (112) of FIG. 1B to be plated with Ni.

[0068] In block (214), the processing logic plates the substrate with a tin-silver alloy (SnAg) in a third processing chamber. In some embodiments, in block (214), the substrate is sent to the available plating chamber (114) of FIG. 1B to be plated with SnAg.

[0069] In block (216), the processing logic removes the safe seal from the substrate in the SRM chamber. In some embodiments, in block (216), the substrate is returned to the SRM chamber (120) of FIG. 1b to dechux the substrate from the safe seal.

[0070] In block (218), the processing logic spins and rinses the substrate in a spin rinse drying (SRD) chamber. In some embodiments, in block (218), the substrate is sent to one of the available SRD chambers (122) of FIG. 1B.

[0071] In block (220), the processing logic places the substrate into a cassette (e.g., FOUP). In some embodiments, after the processing operations are completed in block (220), the substrate is sent to the FOUP (128A, 128B, or 128C).

[0072] In some embodiments, tak times and queue times (e.g., schedules) are determined for a sequence recipe of method (200A), and method (200A) is performed based on the tak times and queue times (e.g., schedules) to provide improved throughput and improved inter-substrate consistency.

[0073] Referring to FIG. 2b, the method (200B) involves processing substrates in a substrate processing system (e.g., a cluster tool, the manufacturing equipment (184) of FIG. 1a, the processing system (100B) of FIG. 1b, etc.).

[0074] In block (240) of the method (200B), the processing logic receives topology information and historical timing information. In some embodiments, the processing logic receives a sequence recipe (e.g., operations (152) of the sequence recipe (150) of FIG. 1a). In some embodiments, the historical timing information includes historical transfer timings (e.g., average transfer timings over time, average pickup timings, average drop-off timings, average transport timings, etc.), historical processing timings (e.g., average processing chamber timings over time), and / or historical cleaning timings (e.g., average cleaning timings over time). In some embodiments, in block (240), a client device (e.g., client device (192) of FIG. 1a) receives inputs (e.g., topology information, historical information, etc.) from a controller (e.g., controller device (190) of FIG. 1a). The input includes topology information of a cluster tool that enumerates connected robots for each process location having possible robot tasks (e.g., the topology of the processing system (100B) of FIG. 1b) (e.g., for process location (P1L1), the connected robots are PR1 and PR2 capable of performing get / move / put tasks). In some embodiments, topology information for the processing system (100B) of FIG. 1b is exemplified in Table 1.

[0075] Process locations Connected Robot 1 Connected Robot 2 Connected Robot 3 Connected robot 4 P1L1 PR1 PR2 P1L2 PR1 PR2 P1R1 PR1 PR2 P1R2 PR1 PR2 P2L1 PR1 PR2 P2L2 PR1 PR2 P2R1 PR1 PR2 P2R2 PR1 PR2 P3L1 PR1 PR2 P3L2 PR1 PR2 P3R1 PR1 PR2 P3R2 PR1 PR2 P4L1 PR1 PR2 P4L2 PR1 PR2 P4R1 PR1 PR2 P4R2 PR1 PR2 P5L1 PR1 PR2 P5L2 PR1 PR2 P5R1 PR1 PR2 P5R2 PR1 PR2 S1L3 PR1 PR2 S1R3 PR1 PR2 S1L2 PR1 PR2 Fi1 Fi2 S1R2 PR1 PR2 Fi1 Fi2 S1L1 Fi1 Fi2 S1R1 Fi1 Fi2

[0076] In some embodiments, the input includes historical transfer timings such as those shown in Table 2 (e.g., robot timing, average timing for each robot task).

[0077] Robot movements Average (milliseconds (ms)) Fi acquisition 25000 Fi move 3000 Fi placement 4000 PR acquisition 3600 PR Move 5000 PR placement 2400

[0078] In some embodiments, the input includes a sequence for substrates such as those shown in Table 3 (e.g., historical operation timings, sequence recipe, processing operations, configured process sequence for the method (200A) of FIG. 2a).

[0079] In Table 3, the odd-numbered movements are robot movements, and Table 3 lists the assigned robots for transferring the substrate from the previous movement to the next movement.

[0080] Figure 2a Index movement category Destination locations (Fig. 1b chamber index) Number of modules Process recipe time (ms) Cleaning recipe time (ms) Queue time (ms) 1 robot Fi2 1 204 2 chamber AL (129) 1 3107 0 3 robot Fi2 1 206 4 chamber S1L2, S1R2 (120) 2 16609 0 5 robot PR1 1 208 6 chamber S1L3, S1R3 (108) 2 158283 0 7 robot PR2 1 210 8 chamber P1R2, P2R1, P2R2, P3R1, P3R2, P4R1, P4R2, P5R2 (110) 8 955595 0 9 robot PR1 1 212 10 chamber P4L1, P4L2, P5L1, P5L2 (112) 4 509578 0 11 robot PR2 1 214 12 chamber P1L1, P2L1, P2L2, P3L1, P3L2 (114) 5 782201 0 13 robot PR1 1 216 14 chamber S1L2, S1R2 (120) 2 0 39739 0 15 robot Fi1 1 218 16 chamber S1L21 S1R1 (122) 2 48724 0 17 robot Fi2 1

[0081] Operation 0 is not enumerated because Operation 0 is a cassette (e.g., FOUP) at the load port, e.g., the FOUP (128A, 128B, or 128C) of FIG. 1b. The last operation is also a robot operation. Operation 17 is transferring a substrate from the chamber (e.g., chamber (122) of FIG. 1b) at Operation 16 to the cassette (FOUP (128A, 128B, or 128C) of FIG. 1b). Even-numbered operations are processing operations (e.g., chamber operations). Processing operations enumerate a set of process chambers configured to perform the process for the processing operation. The number of processing chambers, the process recipe time, and the cleaning recipe time are enumerated.

[0082] The sequence recipe has a list of operations. The odd-numbered operations are for robot locations, where the first operation is a robot operation to pick up a substrate from a cassette docked at a load port. The even-numbered operations are for chamber locations. The sequence operation s is at the start time (S s It is (the timestamp when the sequence operation starts). For a robot sequence operation, S s is the timestamp when the robot starts picking the substrate from the previous location. For chamber operation, S sis the timestamp at the start of the process recipe (e.g., a processing operation in a processing chamber). The process recipe duration for sequence operation s is P s is. The queue time for operation s is Q s and is the duration for which the substrate remains in the chamber for sequence operation s after the process recipe is completed. The cleaning recipe duration for sequence operation s is C s is. The end time of sequence operation s is E s (e.g., the timestamp when the sequence operation ends). For a robot sequence operation, E s is a timestamp when the robot completes picking a substrate from the previous operation to the robot location, moves to a location for the next sequence operation, places it in an empty location for the next operation, or swaps it with a substrate for the next operation. For chamber operations, E s is the process recipe for that action and the timestamp when the queue time is completed.

[0083] A group of substrates (e.g., substrates in the first FOUP (128) of FIG. 1b) is (W i Defined as ), where i is in the range of 1 to W (e.g., 1 to 100). For the examples discussed in Table 3, each substrate (W i ) undergoes the same sequence of operations (e.g., method (200A) of FIG. 2a). The operations within the sequence are (S i It is mathematically expressed as ), where i is in the range of 1 to S (e.g., 1 to 17 in Table 3). Each substrate (W i ) is each operation (S) within the sequence defined in block (240). i ... undergoes. In some embodiments, in block (242), processing logic (e.g., of client device (192)) analyzes the sequence of substrates and identifies bottleneck operations of the substrate processing flow.

[0084] A substrate processing system (e.g., a cluster tool) is modeled as a black block, wherein substrates (products) placed in cassettes docked at load ports are sent into the black block, processed, and then returned to the cassettes. One substrate is sent into the black block at every tack time, and thus a substrate processing flow is established at every tack time. In response to the first substrate being sent into the cluster tool at time 0, the second substrate is sent into the cluster tool at 1*tack time, the third substrate is sent into the cluster tool at 2*tack time, and so on, until the Wth substrate is sent into the cluster at (W-1)*tack time. A substrate is picked up from the cassette at every tack time.

[0085] There are substrates (1 to W) located in cassettes docked to load ports. Each substrate has an N action sequence, where N is an odd number (e.g., the first action is a robotic action to pick up the substrate from the load port, the next action is a chamber action, and there is a robotic action between chamber actions to move the substrate from the previous chamber action to the next chamber action. The robotic actions are modeled as picking up the substrate from the location of the previous action, moving it to the location in the next action, and then dropping the substrate to the next action. The term "pick up" is used for "pickup," the term "move" is used for "move," and the term "place" is used for "drop off." The final action is a robotic action to place the substrate back into the load port (e.g., within the cassette). Table 3 shows an example of an N action sequence.

[0086] The processing logic determines the tag time that controls the time interval to be supplied to the substrate processing system, and the processing logic determines the queue time (Q) to adjust the robot picking time for even sequence operations to prevent robot tasks from colliding with each other (e.g., for non-collision). 2k An artificial delay of )(k = 1, 2, ..., N / 2) is added. Subsequently, the start timings for robot tasks and process tasks are generated for the substrates (e.g., based on queue time and / or tag time).

[0087] The start time for substrate i sequence operation 1 is S 1i = (i - 1) is the choice.

[0088] The start time of substrate i sequence operation s for odd sequence operations (robot operations) (where s = 1, 3, 5, ..., N) is as follows.

[0089] S si = (i - 1)Takt + (Mathematical Formula 1)

[0090] For example, for operation 3, the start time of substrate i is as follows.

[0091] S 3i = (i - 1)Takt +

[0092] S 3i = (i - 1)Takt + +

[0093] is the time duration for picking a substrate from operation 0 location (cassette) to operation 1 location (robot). is the time duration for moving the robot from operation 0 location (cassette) to operation 2 location. is the time duration for the robot to drop the substrate at operation 2 location (the substrate is already at operation 1 location: on the robot). is the process recipe time for operation 2. is the Q time for operation 2.

[0094] In another example, for operation 5, the start time of substrate i is as follows.

[0095] S 5i = (i - 1)Takt +

[0096] S 5i = (i - 1)Takt + +

[0097] is the time duration for picking the substrate from operation 0 location (cassette) to operation 1 location (robot). is the time duration for moving the robot from operation 0 location (cassette) to operation 2 location. is the time duration for the robot to drop the substrate at operation 2 location (the substrate is already at operation 1 location: on the robot). is the process recipe time for operation 2. is the Q time for operation 2. is the time duration for picking the substrate from operation 2 location to operation 3 location (robot). is the time duration for moving the robot from operation 2 location to operation 4 location. is the time duration for the robot to drop the substrate at operation location 4 (the substrate is already at operation location 3: on the robot). is the process recipe time for operation 4. is the Q time for operation 4.

[0098] The start time of substrate i sequence operation s for even sequence operations (chamber operations) (where s = 2, 4, 6, ..., N-1) is as follows.

[0099] S si = (i - 1)Takt + + (Mathematical Formula 2)

[0100] For example, for operation 4, the start time of substrate i is as follows.

[0101] S 4i = (i - 1)Takt + +

[0102] S 4i = (i - 1)Takt +

[0103] In another example, for operation 6, the start time of substrate i is as follows.

[0104] S 6i = (i - 1)Takt + +

[0105] S 6i = (i - 1)Takt + + +

[0106] In block (242), the processing logic identifies a bottleneck operation among the operations of the sequence recipe, and in block (244), the processing logic determines a takt time for the substrates (e.g., the same takt time for all substrates) based on the bottleneck operation.

[0107] In some embodiments, the processing logic identifies multiple bottleneck operations. In some embodiments, one or more bottleneck operations originate from one or more of the following regions: process boundary; robot boundary; and / or revisit boundary. The process boundary is a boundary defined by the process duration and the number of chambers. The robot boundary is a boundary defined by the total transfer duration for each robot. The revisit boundary is a boundary defined by the total process duration and the transfer durations of the revisit subsequence operations (e.g., subsequences of the revisit operation).

[0108] In some embodiments, the processing logic is an N operation sequence (N is odd): Sequence = {S1, S2, ..., S N Identify bottleneck behavior of}. S s represents a sequence operation. S1, S3, S5, ..., S N These are robot movements. S2, S4, ..., S N -1 are chamber operations. Chamber S s = {N s , P s , 1X C s , Q s} and, here N s is the number of chambers dedicated to operation s, and P s is the process recipe time, and C x is the 1X cleaning recipe time, and Q s is S s The algorithm for action s to adjust the robot picking time for is the added artificial delay time (e.g., queue time). Q i is set to 0 for i = 2, 4, ..., N-1.

[0109] Tact time is calculated for each sequence chamber operation i = 2, 4, ..., N-1 to identify process boundaries using the following equation.

[0110] Takt s =

[0111] T ex is the time for circuit board replacement. T ex is the time to remove the currently processed substrate from the chamber and supply the next substrate to the same chamber. ex It varies based on the situation of the robot serving the chamber.

[0112] S i -1 and S i +1 The "destination locations" for are identical, and S i -1 and S i +1 If the "destination locations" for are a single location, a single robot serves the chamber. The robot retrieves the substrate from the chamber to the blade (e.g., of the single robot); moves the blade with the substrate to the chamber of the next sequence operation; places the substrate from the blade to the chamber of the next operation; moves the empty blade to the chamber of the previous sequence operation; retrieves the next substrate from the chamber of the previous sequence operation; moves the blade with the next substrate to the current chamber; and places the next substrate from the blade to the current chamber. For example, refer to Operation 2 in Table 3. The time for substrate exchange is as follows.

[0113] T ex = (T get +T move +T put )+ T move +(T get +T move +T put )

[0114] S i -1 and S i +1If the "destination locations" for are not identical and the "destination locations" are two slot locations of the same robot, a dual-blade robot serves the chamber. While the next substrate from the chamber of the previous sequence operation is placed on one of the robot blades, the other robot blade remains empty and is oriented toward the current chamber. Once the current substrate is ready to be moved out, the robot retrieves the current substrate from the chamber onto the empty robot blade and places the next substrate from the other robot blade into the chamber. For example, refer to operations 6, 8, 10, and 12 in Table 3. The times for substrate exchange are as follows.

[0115] T ex = T get + T put

[0116] S i -1 and S i +1 The "destination locations" for are not identical, and S i -1 and S i +1 If the "destination locations" for belong to two different robots, two different single-blade robots serve the chamber. Once the substrate currently inside the chamber is ready to be moved out: S i +1 The robot designated in receives the substrate from the current chamber to the corresponding robot blade; S i -1 The robot specified in places the substrate from the corresponding robot blade into the current chamber. For example, refer to operations 4, 14, and 16. The time for substrate exchange is as follows.

[0117] T ex = T get +T put

[0118] In the example in Table 3, the takt times for the chamber operations are as follows:

[0119] Takt2= 27107 ms;

[0120] Takt4= 12104 ms;

[0121] Takt6= 82141 ms;

[0122] Takt8= 120199 ms;

[0123] Takt 10 = 128894 ms;

[0124] Takt 12 = 157640 ms;

[0125] Takt 14 = 23569 ms; and

[0126] Takt 16 = 36362 ms.

[0127] Robot tak time is calculated for each robot to identify robot boundaries. Robot r has movements {s1, s2, ..., s n It is associated with}. Robot Takt r is. For the sequence examples above in Table 3, the following is calculated.

[0128] Takt Fi2 = T(0,2)+T(2,4)+T(16,18)

[0129] T(0,2) = T get +T move +T put

[0130] T(2,4) = T get +T move +T put

[0131] T(16,18) = T get +T move +T put

[0132] Takt Fi2 = 3*(5000+3000+4000) = 36000 ms

[0133] TaktFi1 = T(14,16)

[0134] Takt Fi1 = T(14,16) = T get +T move +T put = 12000 ms

[0135] Takt PR = T(4,6)+T(6,8)+T(8,10)+T(10,12)+T(12,14)

[0136] T(4,6) = T get +T move +T put

[0137] T(6,8) = T get +T move +T put

[0138] T(8,10) = T get +T move +T put

[0139] T(10,12) = T get +T move +T put

[0140] T(12,14) = T get +T move +T put

[0141] Takt PR = 5*(3600+5000+2400) = 55000 ms

[0142] Tak times are calculated for revisit sequence actions to identify revisit boundaries. A single revisit loop exists from sequence action X to action Y (chamber actions). The same robot is used for these actions.

[0143] S x (N x , P x , Q x , C x ), S x +1 (Robot), Sx +2 (N x +2 , P x +2 , Q x +2 , C x + 2), ..., S y (N y , P y , Q y , C y Regarding ), S x and S y The modules for are identical (S x to S y forms a single loop). The takt time is calculated as follows.

[0144] Revisit-Tag = Max((T put + P x + Q x + C x + T get ) / N x + T move + (YX) / 2 * (T get +T put + T move ) + (T put + P y + Q y + C y +T get ) / N y , Max((P i + C i + Q i + T get + T put ) / N i ) (i = even # in x+1 to Y-1) )

[0145] The revisit loop is S x , S x +1 to y-1 , S y It is modeled as, where S x and S y forms a circle (e.g., a loop), and S x +1 to y-1 Eun S x and S yThese are non-revisit actions between.

[0146] The tak time for a revisit loop is the maximum between the following.

[0147] (T put + P x + Q x + C x + T get ) / N x + T move + (YX) / 2 * (T get +T put + T move ) + (T put + P y + Q y + C y +T get ) / N y

[0148] The revisit loop has three consecutive segments:

[0149] S x : (T put + P x + Q x + C x + T get ) / N x ;

[0150] One substrate S x From S y Move to: T move + (YX) / 2 * (T get +T put + T move );

[0151] S y : (T put + P y + Q y + C y +T get ) / N y .

[0152] The process boundary for non-revisit chamber operations between x and y is indicated as follows.

[0153] Max((P i + C i + Q i+ T get + T put ) / N i ) (i = even # in x+1 to Y-1) )

[0154] For the example in Table 3, operations 4 through 14 form a revisit loop. The sequence flow is {S1, S2, S3, S 4 to 14 , S 15 , S 16 , S 17 It is modeled as}. The takt time from operation 4 to operation 14 is displayed as follows.

[0155] Takt4 to 14 = Max((T put + P4+ Q4+ C4+ T get ) / N4+ T move + (14-4) / 2 * (T get +T put + T move ) + (T put + P 14 + Q 14 + C 14 +T get ) / N 14 , Max((P i + C i + Q i + T get + T put ) / N i ) (i = even # in 5 to 13) )

[0156] Takt4 to 14 = Max(Takt4 + T move + (14-4) / 2 * (T get +T put + T move ) + Takt 14, Max(Takt6, Takt 8, Takt 10, Takt 12 ))

[0157] Takt4 to 14= Max (12104 + 5*(11000) + 23569, Max (82141, 120199, 128894, 157640))

[0158] Takt4 to 14 = Max (90673, 157640) = 157640 (ms). Takt4 or Takt 14 If is larger, the bottleneck operation is shifted to the revisit loop. Now Takt 12 is still the bottleneck operation for the revisit sequence operations 4 through 14 (process boundary from operation 12).

[0159] The final select time is as follows, the transformed sequence flow {S1, S2, S3, S 4 to 14 , S 15 , S 16 , S 17 It is calculated for}.

[0160] Takt = Max(Takt2, Takt 4 to 14 , Takt 16 , Takt Fi2 , Takt Fi1 )

[0161] Takt = Max(27107, 157640, 36362, 36000, 12000) = 157640 ms

[0162] Takt 12 Operation 12 with = 157640 ms is identified as a bottleneck operation for the substrate sequence flow defined in Table 3. Takt 12 In response to identifying operation 12 of = 157640 ms as a bottleneck operation, a takt time of 157640 ms is used in the method (200A) of FIG. 2a.

[0163] In block (246), the processing logic determines the queue times. In some embodiments, to determine the queue times, the processing logic (e.g., of the client device (192) of FIG. 1a) determines the planned delay Q such that the following conditions are satisfied. i Model (e.g., queue time): for even sequence operations, enforce robot swaps for chamber operations with dual robot assignments where wafer exchange time is expected as swap time; resolve robot collisions for chamber operations with single robot assignments; and determine that delays are not added to one or more bottleneck operations.

[0164] To determine the queue times, the even numbers Q of the sequence operations i , i = 2, 4, ..., N / 2, 0 <= Q i <= Takt * N i - (Pi + Ci + T ex Constraints (e.g., sequence recipe constraints) are generated for ) (e.g., by processing logic) (i.e., for bottleneck operations, Q i must be 0, and for non-bottleneck operations, Q i has a range). T ex is the wafer exchange time following the description in blocks (242-244).

[0165] Each chamber sequence operation (even operations) is scanned (e.g., by processing logic) if the operation has a swappable robot assignment and 0 cleaning recipe time, such as in Operation 6, and Operation 5 is PR1 and Operation 7 is PR2, which indicates that PR2 picks up a wafer from Operation 6 and PR1 drops off the next wafer to Operation 6. Therefore, in the case of Operation 6, it has a swappable robot assignment. Operations 8, 10, and 12 also have swappable robots. Operation x has a swappable robot, and Operation x is N xAssume there are chambers, and that substrate x+1 is sent from operation x-1 to operation x and swapped with substrate 1. Q x is Q x = Nx * Takt - Px - (T get + T put It satisfies ). All Q variables are determined for these actions.

[0166] For each single-blade robot, a set of service time constraints is assigned, with an initial value of empty. For the robot service set: RS x = {}(x = 1, 2, ..., number of robots). For each even movement of a sequence with a single robot assignment, the equation for robot start picking time is as follows.

[0167] S xi = ((x - 1)Takt +

[0168] This is modeled by the tak time to have a relative robot picking time and robot termination time for operation I as follows.

[0169] S r [i] = mod Takt

[0170] The corresponding robot y is determined to be responsible for picking up the substrate from operation i and moving the substrate to operation i+2 (it is the robot designated in operation i+1), and S r [i] is RS y It is attached to. A set RS having two or more items i Each element of is checked. For any combination of two items within the same set (i.e., action x and action y), S r [x] and S r [y] does not have overlap for the service period. The maximum number of conditions to check is am.

[0171] For the examples in Table 3, the following are the results after generating mathematical constraints with Q variables for each sequence process operation.

[0172] Constraints (e.g., sequence recipe constraints) are each Q i Ga Q i The range that prevents bottleneck behavior from worsening after adding (i.e., 0 <= Q i <= Takt * N i - (Pi + Ci + T ex It is generated to have )). Takt, N i , P i , C i , and T ex is known for each operation, and therefore Q i The range for is calculated as follows:

[0173] 0 <= Q2<= 130533 ms;

[0174] 0 <= Q4<= 291071 ms;

[0175] 0 <= Q6<= 150997 ms;

[0176] 0 <= Q8<= 299526 ms;

[0177] 0 <= Q 10 <= 114928 ms;

[0178] 0 <= Q 12 <= 0 ms(bottleneck operation);

[0179] 0 <= Q 14 <= 268141 ms; and

[0180] 0 <= Q 16 <= 315280 ms.

[0181] To force robot swaps for swappable chamber actions, Q variables (Q s ) is Q for swappable actions (6, 8, 10, and 12) i = N x Takt - P x - (Tget + T put It is decomposed as ), and here:

[0182] Q6 = 150997 ms;

[0183] Q8 = 299527 ms;

[0184] Q10 = 114983 ms; and

[0185] (S 12 Because it is a bottleneck) Q12 = 0 m.

[0186] Single-blade robots (Fi1 and Fi2) (e.g., factory interface robots) are used in the following sequence operations: Fi1 for operation 14; Fi2 for operation 0 (picking from a cassette at a load port), operation 2, and operation 16.

[0187] 8 queue variables: Q2, Q4, Q6, Q8, Q 10 , Q 12 , Q 14 , and Q 16 This must be resolved. Q6, Q8, Q 10 , and Q 12 is resolved after forcing robot swaps for moves 6, 8, 10, and 12. The remaining Q2, Q4, Q 14 , and Q 16 Regarding, Q 14 A applies to robot Fi1, and since Fi1 has one associated motion, a robot collision exists for Fi1. Fi2 has three chamber motions to service (i.e., motions 0, 2, and 16), and therefore, for Fi2, there are three elements in RS (Robot Service Set). Since there is no Q variable for motion 0, Q2 and Q 16 ... must be resolved so as not to have overlap with elements within the robot service set for Fi2. The RS set for Fi2 has 3 elements: (S r [1], S r [3], S r

[17] ) has mathematical inequalities, and therefore there is no overlap between any two service periods among these elements.

[0188] (S r [1], S r [3]) For the mathematical inequalities, they are as follows:

[0189] ABS(S r [1] - S r [3]) > ; and

[0190] ABS(S r [3] - S r [1]) > .

[0191] (S r [1], S r

[17] ) For the mathematical inequalities, they are as follows:

[0192] ABS(S r [1] - S r

[17] ) > ; and

[0193] ABS(S r

[17] - S r [1]) > .

[0194] (S r [3], S r

[17] ) For the mathematical inequalities, they are as follows:

[0195] ABS(S r [3] - S r

[17] ) > ; and

[0196] ABS(S r

[17] - S r [3]) > .

[0197] In some embodiments, the processing logic (e.g., of the client device (192) of FIG. 1a) calls a solver (e.g., a linear programming (LP) solver, a linear optimization solver) to find optimized values ​​for Q variables in inequalities. The following should be checked: . Two inequalities are generated for each combination. There must be a total of N / 2 * (N / 2-1) inequalities with N / 2 Q variables. For the example in Table 3, there are six inequalities with two Q variables to solve, allowing the total computation time in the solver (e.g., LP solver) to be limited. In some embodiments, different types of solvers (e.g., linear optimization solvers) may be used to solve the Q variables to prevent overlap between any two robot service periods. The solver (e.g., LP solver) Q2 = 0, Q 16 = Returns the answer for 25307.

[0198] FIG. 3 illustrates a sequence chart (300) having resolved Q variables for the example of Table 3. FIG. 3 also illustrates robot operations within one tak period. FIG. 3 illustrates that there is no overlap between the three Fi2 operations, and that the operations for PR1 and PR2 are connected to form a swapping chain for swappable chamber operations.

[0199] In block (248), processing logic causes the substrates to be processed by the substrate processing system based on tack times and queue times. In some embodiments, processing logic (e.g., of the client device (192)) generates a schedule (e.g., a timetable) for W substrates based on tack times and queue values ​​(Q values) for each sequence operation. For substrates i = 1, 2, ..., W having N sequence operations, a start time for each robot operation or process operation is calculated. Odd sequence operations (robot operations) s = 1, 3, 5, ..., N are exemplified as follows.

[0200] S si = (i - 1)Takt + (Mathematical Formula 1)

[0201] Even sequence operations (chamber operations) s = 2, 4, 6, ..., N-1 are exemplified as follows.

[0202] S si = (i - 1)Takt + + (Mathematical Formula 2)

[0203] In some embodiments, the sorting action is applied after it is calculated and the "start times" for the robot and chamber process tasks are determined. The sorted task table is a schedule (e.g., a timetable).

[0204] In some embodiments, to have substrates processed, the processing logic transmits a schedule (e.g., timetable, tag time, and queue time) to a controller (e.g., controller device (190) of FIG. 1a and FIG. 1b), and the controller starts processing the substrates based on the schedule.

[0205] In some embodiments, topology information, historical timing information, and / or sequence recipes change over time. In some embodiments, one or more components that change the topology information are added to and / or removed from the substrate processing system. In some embodiments, one or more transfer operations, processing operations, and / or cleaning operations become faster or slower over time to change the historical timing information. In some embodiments, the method (200B) of FIG. 2b is repeated with updated topology information, updated historical timing information, and / or updated sequence recipes to generate one or more of an updated tak time, one or more updated queue times, and / or an updated schedule for processing substrates in the substrate processing system.

[0206] FIG. 3 is a sequence chart (300) according to specific embodiments. The sequence chart (300) includes resolved Q variables for the example of Table 3.

[0207] Tables 41-43 are updates to Table 3 showing the queue times determined by the method (200B) of Fig. 2B (Tables 42-43 are a continuation of Table 41).

[0208] Figure 2a index movement category Destination locations (Fig. 1b chamber index) Number of modules Process recipe time (ms) Cleaning recipe time (ms) Queue time (ms) 1 robot FI2 1 204 2 chamber AL (129) 1 3107 0 3 robot FI2 1 206 4 chamber S1L2, S1R2 (120) 2 16609 0 5 robot PR1 1 208 6 chamber S1L3, S1R3 (108) 2 158283 150997 7 robot PR2 1 210 8 chamber P1R2, P2R1, P2R2, P3R1, P3R2, P4R1, P4R2, P5R2 (110) 8 955595 299527 9 robot PR1 1 212 10 chamber P4L1, P4L2, P5L1, P5L2 (112) 4 509578 114983 11 robot PR2 1 214 12 chamber P1L1, P2L1, P2L2, P3L1, P3L2 (114) 5 782201 0 13 robot PR1 1 216 14 chamber S1L2, S1R2 (120) 2 0 39739 0 15 robot FI1 1 218 16 chamber S1L21 S1R1 (122) 2 48724 25307 17 robot FI2 1

[0209] Figure 2a index movement S s E s Chamber Tack Chamber Tack Adjustment Revisit option All tags 1 0 12000 157640 204 2 12000 15107 27107 27104 3 15107 27107 206 4 27107 43716 12104.5 12005 157640 5 43716 58316 208 6 58316 367596.4 82141.5 157640 7 367596.4 384596.4 210 8 384596.4 1656718 120199.4 157640 9 1656718 1656718 212 10 1656718 2281279 128894.5 157640 11 2281279 2298279 214 12 2298279 3080480 157640.2 157640 13 3080480 3093880 216 14 3093880 3093880 23569.5 3700 15 3093880 3105880 218 16 3105880 317991 39016 17 317991 3191911

[0210] Figure 2a index movement robot Rel start Rel exit period 1 FI2 0 12000 12000 204 2 3 FI2 15107 27107 12000 206 4 5 PR1 43716 58316 14600 208 6 7 PR2 52316 69316 17000 210 8 9 PR1 63316 80316 17000 212 10 11 PR2 74316 91316 17000 214 12 13 PR1 85316 98716 13400 216 14 15 FI1 98716 110716 12000 218 16 17 FI2 17107 39107 12000

[0211] As illustrated in FIG. 3, the sequence chart (300) illustrates when different robots start and end in Table 43. By making the operations of the sequence recipe (e.g., processing, transfer, cleaning, etc.) perform based on tak times and queue times (e.g., a schedule based on tak times and queue times), the robots do not have collisions. For example, robot PR1 completes operation 5 before being used for operation 9, and completes operation 9 before being used for operation 13.

[0212] FIG. 4 is a block diagram illustrating a computer system (400) according to specific embodiments. In some embodiments, the computer system (400) is a client device (192). In some embodiments, the computer system (400) is a controller device (190) (e.g., a server).

[0213] In some embodiments, the computer system (400) is connected to other computer systems (e.g., via a local area network (LAN), intranet, extranet, or the Internet). The computer system (400) operates as a server or client computer in a client-server environment or as a peer computer in a peer-to-peer or distributed network environment. In some embodiments, the computer system (400) is provided by a personal computer (PC), tablet PC, set-top box (STB), personal handheld terminal (PDA), cellular phone, web appliance, server, network router, switch, or bridge, or any device capable of executing a set of instructions (sequentially or otherwise) that specifies actions to be taken by said device. Additionally, the term “computer” will include any set of computers that execute a set (or a number of sets) of instructions individually or jointly to perform any one or more of the methods described herein.

[0214] In some embodiments, the computer system (400) includes a processing device (402) that communicates with each other via a bus (408), a volatile memory (404) (e.g., random access memory (RAM)), a non-volatile memory (406) (e.g., read-only memory (ROM) or electrically eraseable and programmable ROM (EEPROM)), and / or a data storage device (418).

[0215] In some embodiments, the processing device (402) is provided by one or more processors such as a general-purpose processor (e.g., a Complex Instruction Set Computing (CISC) microprocessor, a Reduced Instruction Set Computing (RISC) microprocessor, a Very Long Instruction Word (VLIW) microprocessor, a microprocessor implementing other types of instruction sets, or a microprocessor implementing a combination of types of instruction sets) or a specialized processor (e.g., an Application Specific Integrated Circuit (ASIC), a Field Programmable Gate Array (FPGA), a Digital Signal Processor (DSP), or a network processor). In some embodiments, the processing device (402) is provided by one or more of a single processor, multiple processors, a single processor having multiple processing cores, etc.

[0216] In some embodiments, the computer system (400) further includes a network interface device (422) (e.g., coupled to a network (474)). In some embodiments, the computer system (400) includes one or more input / output (I / O) devices. In some embodiments, the computer system (400) also includes a video display unit (410) (e.g., LCD), an alphanumeric input device (412) (e.g., keyboard), a cursor control device (414) (e.g., mouse), and / or a signal generating device (420).

[0217] In some implementations, a data storage device (418) (e.g., disk drive storage, fixed and / or removable storage devices, fixed disk drive, removable memory card, optical storage, NAS (network attached storage), and / or SAN (storage area-network)) comprises a non-transient computer-readable storage medium (424) that stores instructions (426) for encoding any one or more of the methods or functions described herein, including instructions for encoding the components of FIG. 1 (e.g., scheduling component (194), etc.) and for implementing the methods described herein. In some embodiments, a processor (402) comprises a scheduling component (194). In some embodiments, generated tag times, queue times, and / or schedules are stored in the data storage device (418).

[0218] In some embodiments, the instructions (426) also reside completely or partially in the volatile memory (404) and / or the processing device (402) during its execution by the computer system (400), and thus in some embodiments, the volatile memory (404) and the processing device (402) also constitute machine-readable storage media.

[0219] Although the computer-readable storage medium (424) is illustrated as a single medium in exemplary examples, the term “computer-readable storage medium” will include a single medium or multiple media (e.g., a centralized or distributed database, and / or associated caches and servers) that store one or more sets of executable instructions. The term “computer-readable storage medium” will also include any tangible medium capable of storing or encoding a set of instructions for execution by a computer that causes a computer to perform any one or more of the methods described herein. The term “computer-readable storage medium” will include, but is not limited to, solid-state memories, optical media, and magnetic media.

[0220] In some embodiments, the methods, components, and features described herein are implemented by individual hardware components or are integrated into the functions of other hardware components, such as ASICs, FPGAs, DSPs, or similar devices. In some embodiments, the methods, components, and features are implemented by firmware modules or functional circuits within the hardware devices. Additionally, the methods, components, and features are implemented by any combination of hardware devices and computer program components or by computer programs.

[0221] Unless specifically stated otherwise, terms such as “identify,” “calculate,” “determine,” “cause,” “receive,” “generate,” etc. refer to operations and processes performed or implemented by computer systems that manipulate and convert data represented as physical (electronic) quantities within computer system registers and memories into other data similarly represented as physical quantities within computer system memories or registers or other such information storage, transmission, or display devices. Additionally, terms such as “first,” “second,” “third,” “fourth,” etc., as used herein, are intended as labels to distinguish different elements and do not have ordinal meanings according to their numerical designations.

[0222] The examples described herein also relate to an apparatus for carrying out the methods described herein. In some embodiments, the apparatus comprises a general-purpose computer system specifically configured to carry out the methods described herein, or optionally programmed by a computer program stored in a computer system. Such a computer program is stored in a computer-readable tangible storage medium.

[0223] The methods and exemplary examples described herein are not inherently related to any specific computer or other device. Various general-purpose systems may be used in accordance with the teachings described herein, or in some embodiments, it may be found convenient to configure a more specialized device to perform each of the methods and / or their individual functions, routines, subroutines, or operations described herein. Examples of structures for various such systems are described above.

[0224] The foregoing description is intended to be illustrative rather than limiting. Although the present disclosure has been described with reference to specific exemplary examples and embodiments, it will be recognized that the present disclosure is not limited to the described examples and embodiments. The scope of the present disclosure should be determined by referring to the entire range of equivalents qualified for the claims, together with the following claims.

Claims

Claim 1 A method comprising: determining a plurality of queue times associated with a plurality of operations of a sequence recipe — said plurality of operations are associated with the production of a plurality of substrates in a substrate processing system, said plurality of operations include one or more revisit operations in which an individual substrate revisits a corresponding processing chamber —; identifying a plurality of time durations corresponding to said plurality of operations; calculating a takt time for said plurality of substrates based on the maximum time duration among said plurality of time durations — said takt time is a calculated pace time corresponding to an amount of time between a previous substrate entering the substrate processing system and a subsequent substrate entering the substrate processing system, said takt time is associated with said plurality of operations including said one or more revisit operations —; generating a schedule based on said takt time and said plurality of queue times; and transmitting said schedule to a controller of said substrate processing system, said controller is for controlling said substrate processing system to produce said plurality of substrates based on said schedule. Claim 2 A method according to claim 1, wherein each of the plurality of queue times is associated with a corresponding artificial delay of a corresponding substrate after the completion of a corresponding operation among the plurality of operations. Claim 3 A method according to claim 1, wherein the plurality of time durations are associated with a plurality of devices of the substrate processing system. Claim 4 A method according to claim 1, wherein the takt time is determined based on a bottleneck operation among the plurality of operations in the sequence recipe. Claim 5 A method according to claim 4, further comprising the step of receiving topology information and historical timing information associated with the substrate processing system, wherein the bottleneck operation is identified based on the topology information and the historical timing information. Claim 6 In claim 1, the plurality of operations are associated with transporting and processing the plurality of substrates in the substrate processing system. Claim 7 A method according to claim 1, further comprising the step of generating sequence recipe constraints having queue variables for the plurality of operations, and the step of determining the plurality of queue times comprising the step of solving the queue variables from the sequence recipe constraints using a linear programming solver. Claim 8 A method according to claim 1, wherein the step of determining the plurality of queue times is for resolving robot collisions of the substrate processing system. Claim 9 The method of claim 1, wherein the one or more revisiting operations include a revisiting sequence, and the method further includes the step of converting the revisiting sequence into a non-revisiting sequence including a subsequence performing the revisiting sequence. Claim 10 As a non-transient machine-readable storage medium storing instructions, said instructions, when executed, cause a processing device to: determine a plurality of queue times associated with a plurality of operations of a sequence recipe — said plurality of operations are associated with the production of a plurality of substrates in a substrate processing system, said plurality of operations include one or more revisit operations in which an individual substrate revisits a corresponding processing chamber —; identify a plurality of time durations corresponding to said plurality of operations; calculate a takt time for said plurality of substrates based on the maximum time duration among said plurality of time durations — said takt time is a calculated pace time corresponding to the amount of time between a previous substrate entering said substrate processing system and a subsequent substrate entering said substrate processing system, said takt time is associated with said plurality of operations including said one or more revisit operations —; generate a schedule based on said takt time and said plurality of queue times; A non-transient machine-readable storage medium for transmitting the above schedule to a controller of the substrate processing system, wherein the controller controls the substrate processing system to produce the plurality of substrates based on the above schedule. Claim 11 In claim 10, a non-transient machine-readable storage medium, wherein each of the plurality of queue times is associated with a corresponding artificial delay of a corresponding substrate after the completion of a corresponding operation among the plurality of operations. Claim 12 In claim 10, the plurality of time durations are non-transient machine-readable storage media associated with a plurality of devices of the substrate processing system. Claim 13 In claim 10, the takt time is determined based on a bottleneck operation among the plurality of operations in the sequence recipe, a non-transient machine-readable storage medium. Claim 14 In claim 13, the processing device is further for receiving topology information and history timing information associated with the substrate processing system, and the bottleneck operation is identified based on the topology information and the history timing information, a non-transient machine-readable storage medium. Claim 15 In claim 10, the plurality of operations are associated with transporting and processing the plurality of substrates in the substrate processing system, a non-transient machine-readable storage medium. Claim 16 A system comprising: a memory; and a processing device coupled to the memory, wherein the processing device comprises: determining a plurality of queue times associated with a plurality of operations of a sequence recipe — said plurality of operations are associated with the production of a plurality of substrates in a substrate processing system, said plurality of operations include one or more revisit operations in which an individual substrate revisits a corresponding processing chamber —; identifying a plurality of time durations corresponding to the plurality of operations; and calculating a tack time for the plurality of substrates based on the maximum time duration among the plurality of time durations — said tack time is a calculated phase time corresponding to the amount of time between a previous substrate entering the substrate processing system and a subsequent substrate entering the substrate processing system, said tack time is associated with the plurality of operations including the one or more revisit operations —; generating a schedule based on the plurality of queue times; and transmitting said schedule to a controller of the substrate processing system, said controller being for controlling the substrate processing system to produce the plurality of substrates based on said schedule. Claim 17 In claim 16, the system, wherein each of the plurality of queue times is associated with a corresponding artificial delay of a corresponding substrate after the completion of a corresponding operation among the plurality of operations. Claim 18 In claim 16, the plurality of time durations are associated with a plurality of devices of the substrate processing system. Claim 19 In claim 16, the system, wherein the takt time is determined based on the bottleneck operation among the plurality of operations within the sequence recipe. Claim 20 In claim 19, the processing device is further for receiving topology information and historical timing information associated with the substrate processing system, and the bottleneck operation is identified based on the topology information and the historical timing information, system.

Images