Industry News, Trends and Technology, and Standards Updates

You've heard the expression, “you can’t make an omelet without breaking a few eggs.” That is, you shouldn't be surprised if you end up destroying a few things in the process of achieving your goal. When it comes to building a new piece of equipment, do you really want to risk breaking a few wafers, or worse yet, hurting personnel or equipment, to develop your new tool control software? I think everyone would answer with a resounding “No!”
In the March 2016 blog post on CIMControlFramework Work Breakdown, simulation was listed as one of the eleven points to be taken into consideration when developing an equipment control application using CIMControlFramework (CCF). In addition to personnel and hardware safety, there are other reasons to use simulation when developing equipment control applications, namely:

• You want to start testing your software as early as possible, often this is before your equipment is finished. Then when your equipment is ready, integrating your tested software with your hardware will proceed smoothly and minimize delays in your time to market.

• If you have an existing tool and you’re upgrading your tool control software, scheduling software testing time while still allowing other engineering teams (mechanical, process, etc.) to get their jobs done is challenging.

• The hardware components that comprise your tool, e.g. robots, load locks, and process modules, will not be finished at the same time. You want to test your software with real hardware as soon as possible, while still simulating the missing equipment components.

• Tool time is valuable. It's nice to be able to test your software without using the valuable tool time where possible.

• It is likely that your tool will have more than one configuration, customized for each of your clients. Setting up different hardware configurations in order to develop and test your tool control software is time consuming. You want to be able to test your software for all of your equipment configurations in timely manner.

CCF provides a simulator that you can use to test your tool control software during development, and before you run the software on the real hardware. Running against a simulator first will expose issues in your software without damaging people, material and hardware. CCF’s simulator simulates real hardware, which means it is not necessary to add conditional checks in your software to check when it is running with a simulator versus real hardware.

CCF’s simulator features include:

• Simulation of atmospheric and vacuum hardware components, e.g. load locks, vacuum pumps, vacuum gauges, etc.

• Simulating delivery and removal of carriers to load ports, both manually and automatically using E84 handshaking.

• Simulation of robot moves for both atmospheric and vacuum robots.

• Simulation of I/O.

• Simulation of hardware faults, to safely test error handling.

• Simulate running single jobs or cycling wafers for endurance testing.

Additionally, CCF provides other tools to help you test your software without hardware.  CCF provides a Visual Studio template, and a number of classes and interfaces to aid you in developing simulation software for your process module or other custom hardware. Use the Visual Studio template to start development of GUI user controls for simulated hardware. Implement CCF’s I/O simulation interfaces for generating inputs to your tool control software and writing outputs to your simulated hardware. Tie the two sides together using CCF’s simulation client and server to handle the communication.

With these CCF tools, you can develop and test your tool control software without hardware. When hardware is available, you can test your software with your tool with a high degree of confidence that it will perform as expected.

Avoid “breaking a few eggs” and develop your tool control software with CCF and test it using CCF simulation features.

To learn more about CCF, visit the CIMControlFramework page on our website!

“Can you hear me now?”

A Cimetrix blog post on March 15, 2016 entitled “CIMControlFramework Work Breakdown”mentions that CIMControlFramework (CCF) includes ASCII serial drivers and IO providers.  What does that mean and why should you care?

Equipment automation is all about creating software that controls hardware—combining individual components into a harmonious whole, with each piece playing its own unique part.  A critical aspect of control is the ability to communicate—and that is where CCF’s ASCII serial driver and IO providers can help you create your equipment application.

The .NET Framework, like many software development platforms, provides built-in support for serial ports and TCP/IP ports.  This built-in support is great for low-level, binary communication, but hardware devices often just need a simple ASCII connection.  For such hardware, CCF’s ASCII serial driver frees you from worrying about the connection and the underlying implementation.  You can focus on the content of the message instead of the mechanics of delivery.  It’s like using a telephone—you want to focus on the conversation rather than worrying about how the sounds are transmitted between the phones. 

Another common class of hardware uses signals to communicate.  These signals can be as simple as only having two possible values (think “on” and “off”) or having a range of values, like a temperature.  Each signal also has a direction—it is either an input or an output.  For input signals, the value is determined by the hardware and read by the software.  Output signal values are determined by the software and sent to the hardware.  For example, control software might use an output signal to turn a light on and off, and an input signal from a photocell to verify the light is on or off.  This class of hardware is called I/O (short for input/output) devices and is supported by CCF.

CCF includes support for communicating with ASCII serial and I/O devices to make your job easier.  Don’t spend your time and effort asking the hardware “Can you hear me now?”  Use CCF and focus on combining the parts into the harmonious whole. 

To learn more about CCF, visit the CIMControlFramework page on our website!

In Sir Arthur Conon Doyle’s A Scandal in Bohemia, Sherlock Holmes tells Watson, “It is a capital mistake to theorize before one has data. Insensibly one begins to twist facts to suit theories, instead of theories to suit facts.”

In a March 2016 blog post on CCF work breakdown Cimetrix listed eleven points to be taken into consideration when starting an equipment control application using CIMControlFramework (CCF). One of the tasks in the work breakdown is to determine what kind of data collection and storage is to be used in your CCF application and determine how that data is to be stored.

CCF provides several mechanisms for collecting and storing data. These include:

• History Objects

• Full GEM Interface

• Full EDA/Interface A Interface

• Centralized DataServer

The remainder of this blog post will look at each of these items in more detail.

History Objects

In early iterations of CCF, users noticed when using logging, there were certain messages that they wanted to be able to query without the overhead of having to search all log messages. To help accommodate this need, History objects were introduced. Some examples of these objects in CCF are EPT History, Wafer History and Alarm History. When an important event happens in the life of a history object, a log message is written to a database table (configured during CCF installation) that corresponds to that type of object. That database table can be queried for the specific historical information for only that type of data. 

Full GEM/GEM 300 Interface

As described in a CCF blog post from February 15, 2017, CCF comes standard with a fully implemented GEM and GEM 300 interface. The GEM standards allow users to set up trace and event reports for the collection of GEM data. No additional programming is required by the application developer to have access to the GEM data collection.

Full EDA/Interface A Interface

The same blog post of February 15th also states that CCF comes standard with a fully implemented Freeze II and E164 compliant EDA interface. EDA can be used to set up data collection plans based on Events, Exceptions and Traces. With the E157 standard and conditional trace triggers, EDA makes it easy to zero in on the data you want without having to collect all data and then sift through it later.

Centralized DataServer

In order to create, initialize, populate and pass data, CCF uses a centralized DataServer object. The DataServer is responsible for creating the dynamic EDA equipment modelas well as populating CIMConnect with Status Variables, Data Variables, Collection Events and Alarms. All this is done at tool startup so that the data available exactly matches the tool that is in use.

Data is routed to the DataServer which then updates the appropriate client – such as EDA, GEM or the Operator Interface. An equipment control application can register to receive an event from the data server when data changes. Users can key off of this event to capture that data and route it to a database as desired. Since all tool manufacturers have different requirements for which database to use and how data is written to that database, CCF leaves the actual SQL (or equivalent) commands for writing the data to the equipment application developer.

With CCF Data collection and storage is … Elementary.

To learn more about CCF, visit the CIMControlFramework page on our website!

What does this mean and why should I care?

The SEMI standards for 300mm Semiconductor Manufacturing Equipment can be an overwhelming burden of information to understand, let alone implement.

The GEM standards comprise over 450 pages of documentation: E4, E5, E30, E37, E37.1, E172, E173.

The 300mm standards add another 280 pages: E39, E40, E87, E90, E94, E116, E157, E148.

And the EDA standards pile on an additional 480 pages: E120, E125, E128, E132, E134, E138, E164.

That’s over 1200 pages of standards documents filled with requirements and implementation information. 

On top of that GEM and EDA collect data differently from the equipment.  See a post we did on data collection for more information on those differences.

Implementing the requirements defined in those standards without an SDK would be a very brave undertaking.  Even with SDKs for the standards, it would be a fair amount of work, when all you really want to do is get your equipment automated.

In addition, it is very important that those standards be implemented correctly in order for your equipment to be smoothly integrated and accepted into each fab.  Different fabs use the standards slightly differently or have additional requirements.   This requires experience.

GEM300 and EDA standards implementation is a very large burden.

So what does this mean?

One of the large tasks for the EDA standards is defining a hierarchical model of the equipment and what data it can produce in XML per the schemas defined in the standards.   Creating the initial model and keeping it up to date as the equipment evolves is a tedious task.  In addition, that model must be conformant to the E164 standard (which has over 10 pages of requirements on its own).   See our blog post on conformance testing. CCF does this for you, producing an E164 compliant EDA model in the background based on your CCF programming. See our blog post on CCF dynamic model creation further details.  CCF also builds the GEM interface model for you at the same time.

Further, CCF is completely GEM compliant and 300mm compliant, using the Cimetrix CIMConnect and CIM300 products which have been successfully deployed in every 300mm fab around the world on many different equipment types.

Twelve hundred pages of standards, compliantly implemented, at no additional effort.  That is what this means.

Turn that donkey into a goat and use CCF.

To learn more about CCF, visit the CIMControlFramework page on our website!

You have designed the ultimate process that will revolutionize the semiconductor industry.  The parts have been collected, the process module assembled.   But now you need the software to make all the components work together.

As described in a recent CIMControlFramework (CCF) blog post around designing recipes, the recipe is the secret sauce for your process.  The recipe is used to direct the hardware to perform the process; How much time in a step, temperature, gas flow, pressure, etc.

The recipe provides directions to the process module on how to perform the processing.  How and when to enable/disable hardware components.  What setpoints to be set for components.  How much time to spend on any given step.  The process module (PM) software that you develop will take the recipe that you have defined and perform the operations using that recipe. CCF stays out of your way to allow to create your secret sauce.  

CCF makes integrating your process module easy.  CCF provides a simple process module interface that allows CCF to know when to prepare for processing, prepare for transfer, and process using the supplied recipe.

 Your process module hardware may be made up of any number and types hardware components, E.g.  Mass Flow Controller(s), valves, chuck, etc. that will be used to process the recipe. Since CCF does not use proprietary interfaces and does use C# and Visual Studio, creating interfaces to your hardware is much easier and left to you to design and develop these drivers. CCF makes it easy to connect to your hardware, whether it is via a PLC or talking directly to the hardware. 

CCF makes it incredibly simple to report data to a UI, a GEM host and even an EDA client.  Declare your status variable, update, and publish.  The data is reported to all three for you automatically!!

CCF takes the stress out of the necessary evil of moving material through the equipment to get it to your process module. It provides an interface for interacting with your process module allowing you to spend your time where it matters most - creating your secret sauce to help make you successful!

To learn more about CCF, visit the CIMControlFramework page on our website!

Over the past several months, we have posted a number of blogs dealing with the testing of SEMI’s Equipment Data Acquisition (EDA / aka Interface A) standards suite. The first of these posts connected the importance of this topic to the increased adoption of the EDA standards across the industry, and broke the overall problem domain into its three major components. 

Subsequent postings provided additional detail in each of these areas:

• Compliance testing – does the equipment adhere to the specifications described in the SEMI Standards? 

• Performance and stability testing– does the equipment meet the end users’ performance and availability specifications? 

• Equipment metadata model conformance testing – does the equipment model delivered with the interface represent the tool structure and content anticipated by the end customer? 

To bring this series to a close, this post addresses the “as-is” state of EDA testing as it is practiced today by the advanced semiconductor manufacturers who are requiring EDA interfaces on new equipment purchases and the suppliers who provide that equipment. 

For compliance testing, the three options in general use include: 

1. ECCE Plus product- this software tool was originally developed under contract with the International Sematech Manufacturing Initiative (ISMI) to validate the fidelity, usability, and interoperability of early versions of the standard; it can used to manually execute a set of procedures documented in the “ISMI Equipment Data Acquisition (EDA) Evaluation Method for the July 2010 Standards Freeze Level: Version 1.0” document (see title page below) to exercise most of the capabilities called for in the standard; note that this is the only commercially available solution among the three.

1. Company-specific test suites – one major chip manufacturer (and early adopter of EDA) maintains its own partially-automated set of compliance tests, and provides this system to its equipment suppliers as a pre-shipment test vehicle. This set of tests is then used in the fab as part of the tool acceptance process; however, this system also includes a number of company-specific automation scenarios, which are not available for outside use. This highlights the need to support custom extensions in an industry-validated tester if it is to be commercially viable.

2. In-house custom test clients – this is a variation of #2 that some of the major OEMs have chosen as their economies of scale dictate; the problems with this approach are that a) the test clients must be kept current with the EDA standards, which are themselves a moving target, and b) unless thoroughly validated by the eventual customers of the equipment, there is no guarantee that passing these tests will satisfy the final acceptance criteria for a given factory. 

For performance and stability testing, there are no automated solutions currently available. The ISMI EDA Evaluation Method does describe some rudimentary performance evaluation procedures, but these no longer reflect the expectations of the customers with many years of accumulated EDA production experience. Clearly a better solution is needed.

Finally, for metadata model conformance testing, the only available solution is the Metadata Conformance Analyzer (MCA) that was commissioned by Sematech and implemented by NIST (National Institute of Standards and Technology). It has not been updated in almost five years, and exhibits a number of known issues when applied to a SEMI E164-compliant equipment model (E164 = Specification for EDA Common Metadata), so it will be increasingly insufficient as more companies require full Freeze II / E164 specification compliance. 

The good news in all this is that Cimetrix has recognized and anticipated this emerging need, and is actively addressing it on our product roadmap. If you want to know more about EDA testing and/or discuss your specific needs, please contact Cimetrix for a demonstration of this exciting new capability!

Anyone above a certain age will be able to tell you what you get when you combine two all-beef patties, special sauce, lettuce, cheese, pickles, onions – on a sesame seed bun. There are many who would argue that what sets a Big Mac apart from other burgers – and has made it one of the best-selling products of all time – is the special sauce.

In a March 2016 blog post, Cimetrix listed eleven points to be taken into consideration when starting an equipment control application using CIMControlFramework (CCF). One of the things to consider is how you want to provide process and path information through the tool using recipes. This blog post delves a little deeper into the recipe aspect of equipment control applications.

In CCF, recipes are either process recipes or sequence recipes.

A process recipe contains the instructions to be carried out by a particular process module. These instructions can range from temperature settings to types of gas to flow. The most important aspect of any tool control application is allowing the tool manufacturer to do what they do best – perform their process better than anyone else in the world. The process recipe allows tool manufacturers to add their special sauce to the wafer. CCF provides a sample process recipe implementation as well as very simple process recipe editor. Since recipes are generally custom for each tool manufacturer, CCF application developers usually want to customize the recipe contents for a process recipe.

If the processing of material is the special sauce, the rest of the application, moving the wafer through the tool, is a necessary evil. To assist in moving material through the tool, CCF also provides a sequence recipe. A sequence recipe determines which process recipes are to be run, at which modules to run them, and the order in which this is to occur. CCF provides a sample sequence recipe editor that can be used in creating sequence recipes or customized for each tool manufacturer’s needs.

Both process and sequence recipes can be created on the tool or downloaded from a factory host. CCF provides a handler that receives recipes from the host and stores them in the Recipe Server. Regardless of where the recipes are created, CCF’s Recipe Server stores the recipes locally and passes them in to the scheduler when a job is to be run. The Recipe Server allows recipes to be stored as Engineering recipes while they are being finalized. They can then be promoted to Production recipes for use in a production environment. 

By making use of recipes in CCF, you can ensure that your special sauce is applied to material processing to help make your tool one of the best-selling in history.

To learn more about CCF, visit the CIMControlFramework page on our website! 

Our bodies are amazing machines. Ask a man off the street what they see when they look at someone, they will probably talk about skin, hair and eye color, height and weight and other external defining characteristics. Ask a doctor and they may see issues relating to what’s going on in the person’s organs and overall internal function. Ask a molecular biologist and they’ll talk about the chemical pathways that allow things to work at the cellular level. Much like our bodies, computer controlled systems are made up of many layers. Starting with electrons moving through conductive and semi-conductive materials, abstraction layer is added upon abstraction layer to create components, circuits, assemblies until finally a computer is created. In the same way layers of software control this computer from the BIOS up through layers in the operating systems and culminating in the application the user sees. Similar to the way doctors and biologists work at different levels of abstraction within their domains, we as engineers know about, work with and think about our system at various abstraction levels. However, the end user is like that man on the street, all they see are the external characteristics. Because of this, the operator interface is among the most important parts of the system.

SEMI established the E95 standard as general guidelines for screen layout of tool control software. CIMControlFramework (CCF) provides a standards conforming shell into which various screens may be added to create a complete operator interface. This allows the tool manufacturer to focus on the unique needs of their tool and have no worry about meeting the standard.

There are several general steps to create an operator interface using CCF:

1. Decide on the technology. In the Windows desktop software world, there are two primary ways of developing a user interface: WinForms and Windows Presentation Foundation (WPF). CCF has historically supported the WinForms environment providing many fully functional WinForms screens. It has also supported WPF, but only provided a single example WPF screen. Cimetrix is in the process of updating WPF support and adding multiple fully functional WPF screens out of the box. Either environment may be used based on what the tool manufacturer’s developers deem appropriate.

2. Establish the requirements. The purpose of the operator interface is for the tool to provide the operator with information about what it’s currently doing and for the operator to tell the tool what to do. Determining the correct way to do this can be one of the hardest parts of designing a user interface. This step is where the best level of abstraction is established. The user should have sufficient information to understand what’s happening without being overwhelmed by too much data. The user should also have enough control to do what needs to be done without having to worry about too many details. The analysis for this step is often done by multi-disciplinary teams using analog methods like whiteboards and pen and paper. Creating avatars for different types of users and then writing stories about what those users will want to do is a good way to help flesh out what’s needed by the operator interface.

3. Evaluate pre-built screens against the requirements. Once the target is established, the screens provided by CCF can be examined for fitness. How well do they fit the target? Some screens may be close enough to the requirements to be used as is. Other screens may be close but require some tweaks to meet the specific needs. Finally, some screens may need to be built from components provided by CCF to satisfy the unique specifications of a particular tool.

4. Assemble the screens into an application. Once a list of needed screens is created, the final step is to put everything together. This is generally the most time consuming part of building an operator interface. This phase is when any custom screens are built or modifications made to existing screens. Finally, all the screens, both custom and pre-built, are added to the framework provided by CCF. CCF has a number of labs to help understand how the various user interface components work together to provide a cohesive whole.

CCF provides the structure, pre-built screens and tools to assist in creating custom ones to give your tool a beautiful skin.

To learn more about CCF, visit the CIMControlFramework page on our website!

How do you eat a whale? One bite at a time. 

In a March 2016 blog post entitled CIMControlFramework Work Breakdown, Cimetrix listed eleven points to be taken into consideration when starting an equipment control application using CIMControlFramework (CCF). One of the things to consider is how you want to control the material moving through the tool – or scheduling of material. This blog post delves a little deeper into the scheduling aspect of equipment control applications.

Doctoral dissertations and entire books have been written to discuss scheduler theory. Because of sheer volume of information available regarding scheduling and scheduling theory, the topic can come across as a little (or a lot) intimidating. CCF aims to take the scare factor out of scheduling and allow equipment control application developers to fully control the movement of material through their tool.

CCF provides a framework for a reactive, rule-based scheduler. You, as the application developer and in conjunction with your customer needs, get to decide what decisions are important when creating your scheduler. One of the first things you need to do when developing a scheduler is to ask questions to help you determine the rules for scheduling. Some questions you may ask:

• What is the most important thing I am attempting to accomplish with my scheduler?

  • Is throughput the most important?

  • Is path predictability most important?

• How can I ensure that when I pick material up that there is a destination available to put it?

• If two components need a robot to take action (pick up or place material), which action takes precedence?

• Do the process chambers need to be prepared before receiving material to process?

• What is the wafer flow scenario (is there a specific order that material must follow)?

  • Does the material need to be aligned before processing?

  • Does the material need to be acclimatized before processing?

  • Does the material need to be cooled before returning to the carrier?

• Are there any maintenance tasks that have to be performed periodically in the tool that have to be accounted for in scheduling?

This is by no means an exhaustive list of questions, but these are the types of questions that need to be answered when creating your scheduler. 

The scheduling framework provided by CCF allows you to translate these rules into C# conditional statements. No proprietary scripting languages need to be learned. No specific configuration training is required. C# developers can use industry standard IDEs to put these rules into scheduling practice.

Once the scheduling rules are determined, it can still be intimidating to know how to start creating your scheduler. Cimetrix provides a few basic, as well as more advanced,of  scheduling labs that fully explain how to translate your rules into a functional scheduler. These labs can be completed in as little as a few hours. The labs explain the scheduling theory used by Cimetrix and allow users to create functional schedulers in a short amount of time. Many CCF users can create a working scheduler in one week.

Cimetrix also provides complete working examples of atmospheric and vacuum schedulers as part of CCF. Another lab provided by Cimetrix clearly describes how to start with one of these working schedulers and modify it to suit your scheduling needs.

The CCF scheduling framework allows the software to be hardware agnostic. In other words, it is not tightly coupled to device drivers. This allows tool manufacturers to change out hardware without having to make scheduler changes to support the new hardware.

Although scheduling may seem like an intimidating whale to eat, CCF helps break the tasks down into bite-sized chunks.

To learn more about CCF, visit the CIMControlFramework page on our website!

In 1976, Blue Oyster Cult released their hit song, “Don’t Fear the Reaper”.  In 2000, Saturday Night Live produced a fictitious, but humorous skit around the production of the “Don’t Fear the Reaper” called, “More Cowbell”.  The “More Cowbell” skit put a very light hearted spin on the production of the hit song.   After seeing that skit, I can never hear that song the same way. The cowbell, for as small a piece it plays, is a huge part of the song.

The same can be said for the hardware that is used in Semiconductor manufacturing tools.  Tool control boils down to controlling the hardware. Without controlling the hardware, the UI and factory automation will not amount to much if the robot doesn’t move. Everything from the robot, down to a simple presence sensor on a load port is needed. What may seem to be the simplest device can be the most prominent.  Each device plays an important part in the process. 

A Cimetrix blog post on March 15, 2016 entitled CIMControlFramework Work Breakdown, identifies driver integration as one of the first steps that needs to be done in the work breakdown for a CIMControlFramework (CCF) application. It may seem intimidating to create a driver to control hardware. There is the need to connect to the device. There is some number of commands and possible responses to deal with.  It can be overwhelming, but can be conquered by understanding what needs to be done to control a device through a driver.

Let’s look at how to go about developing a driver.

1. Understand the interface to the device using any and all documentation available.  The documentation will provide information on how to send commands and interpret the responses.
   1. Does the device control only one device or many?
   2. What is the communication protocol to the device?
      1. TCP/IP
      2. Serial ports
   3. What are the commands?  How are the commands composed?
   4. What are the responses?
   5. Will the device need to be polled?
   6. Will the device send unsolicited messages? 
2. Understand what needs to be controlled on the device for the tool. 
   1. Will you only need to use a subset of the interface or the entirety of the interface?  If just a subset, then there is only a need to write those initially.
3. Writing code to “talk” to the device
   1. Do you have a simulator for the device?
      This one is important, especially if the hardware has limited availability.  If needed, a simple simulator can be developed to at least validate communications, then expanded over time to simulate faults or other conditions.
      
      As the tool begins to come together, each simulator will become invaluable when developing the other parts of the tool and coordinating the devices together. 
   2. Unit tests can be useful to verify that the driver behaves as expected before using on actual hardware.  Unit tests can also provide regression testing should changes be made to a driver.
      Some areas to consider unit testing;
      
      1. Handling of failure to connect
      2. Handling of failure to send to the device or receive from the device
      3. Handling of return values
   3. Start out simple, just get a connection to the device to begin with.  Next send a simple command and inspect the response.  Create a success and build upon the successes!

In the end, a driver will be sending commands and getting and interpreting a response. For every device you create a driver for you’ll also become the expert on that device.

Even though it can be intimidating to start, developing drivers is one of the fun parts of tool development. There is nothing more exciting than seeing the hardware begin to dance in the fashion that has been choreographed in your software

CCF provides utilities and examples to help create drivers for your hardware and easily integrate them into the application, to assist you to orchestrate and provide more cowbell in your tool control. 

To learn more about CCF, visit the CIMControlFramework page on our website!