SECS/GEM Explained: SEMI E5, E30 and E37 HSMS, GEM300 and How Semiconductor Fab Equipment Talks to the MES (2026)

SECS/GEM Explained: SEMI E5, E30 and E37 HSMS, GEM300 and How Semiconductor Fab Equipment Talks to the MES (2026)

SECS/GEM Explained: SEMI E5, E30 and E37 HSMS, GEM300 and How Semiconductor Fab Equipment Talks to the MES (2026)

A modern 300 mm fab runs hundreds of process tools, each worth millions of dollars, and almost none of them speak OPC UA to the factory host. They speak SECS/GEM, a family of SEMI standards whose core ideas date to the 1980s and 1990s and which is still being revised in 2026. The current SEMI E30 GEM revision in the SEMI store is E30-0526, and the SEMI committees are actively debating a secure, gRPC-based successor transport. If you are building a fab digital twin, an equipment integration server or an FDC pipeline, you will spend more time inside S6F11 event reports than inside any dashboard. This guide walks the whole stack: SECS-II message encoding, HSMS sessions and timers, GEM state models, the GEM300 job standards, and EDA “Interface A”. It ends with a working Python host sketch, illustrative sizing numbers and a decision matrix against OPC UA.

What this covers: the SEMI E4/E5/E30/E37 layer cake, byte-level HSMS framing, collection events and reports, GEM300 carriers and jobs, host architecture, failure modes, and when SECS/GEM, EDA or OPC UA is the right interface.

Context and Background

SECS/GEM is the de facto equipment-to-host interface of the semiconductor industry. It is not one standard but a stack. SEMI E4 (SECS-I) moves messages over RS-232 serial links. SEMI E37 (HSMS) moves the same messages over TCP/IP. SEMI E5 (SECS-II) defines what the messages contain. SEMI E30 (GEM) defines which messages a tool must support and how the tool must behave when it receives them. In the industry shorthand, “SECS/GEM” usually means E5 plus E30 running over E37.

The reason this stack has survived three decades of IT churn is economic, not technical. A fab buys tools from dozens of suppliers, and each fab’s host software (the manufacturing execution system, or MES, plus its equipment integration layer) must control all of them. GEM gives every tool the same behaviour model, so the host team writes one integration pattern and repeats it per tool. Fabs write the interface into the purchase specification. A tool without a compliant SECS/GEM interface does not get bought.

The 300 mm transition around the turn of the century added the GEM300 standards on top of GEM: object services (E39), process jobs (E40), carrier management (E87), substrate tracking (E90), control jobs (E94) and equipment performance tracking (E116). According to the Cimetrix GEM300 white paper, HSMS is the transport required in all 300 mm fabs, and E30 plus E39 are prerequisites for every GEM300 standard. Later, the EDA suite (Equipment Data Acquisition, also called Interface A) added a separate, high-bandwidth data path for process engineers.

If you already know industrial interoperability from the machine-tool world, the closest analogues are the companion specifications we covered in umati vs MTConnect vs OPC UA for machine tools. The difference is maturity of the behavioural contract. GEM does not just expose data. It defines what “online”, “remote” and “event enabled” mean, and fabs have decades of qualification history behind those meanings. That is why the semiconductor equipment automation world treats SECS/GEM as the control-plane contract and treats newer protocols as data-plane add-ons.

Two practical facts shape everything below. First, SEMI standards are paywalled; the E30, E37 and E5 product pages each list a non-member price of $380 (member $286) in the SEMI store. Second, the authoritative behaviour lives in those documents, so anything not visible on a public page is described here at the level of widely implemented practice, and labelled where it matters.

How the SECS/GEM Protocol Stack Works, Layer by Layer

SECS/GEM is a layered protocol stack in which HSMS (SEMI E37) carries framed messages over TCP/IP, SECS-II (SEMI E5) defines self-describing stream/function messages built from typed items, and GEM (SEMI E30) specifies which of those messages equipment must support and the state models that govern host control, event reporting, alarms and recipes.

SECS/GEM protocol stack showing GEM300, GEM E30, SECS-II E5, HSMS E37 and the separate EDA Interface A path from equipment to the MES

Figure 1: The SECS/GEM layer cake. GEM300 builds on GEM, which uses SECS-II messages carried by HSMS or legacy SECS-I. EDA is a parallel, read-only data path.

The diagram reads top to bottom as “who decides what”. The host’s MES and equipment integration server (EIS) issue intent, such as starting a control job. GEM300 standards translate that intent into objects such as carriers, process jobs and substrates. GEM defines the behaviour every tool shares. SECS-II turns that behaviour into concrete messages, and HSMS frames those messages on a TCP socket. The dotted SECS-I path still exists on older 200 mm and back-end tools. The EDA path on the right is deliberately separate: it carries high-rate data to engineering clients but, per the Cimetrix Interface A overview, offers no equipment control or configuration features.

Layer 1 — SECS-II messages: streams, functions and self-describing items

SEMI E5 organises messages into “categories of activities, called streams, which contain specific messages, called functions”, per the E5 abstract. The current revision listed there is E5-0725. A message is written SxFy, so S1F13 is stream 1, function 13. Odd functions are primary messages and the next even function is the reply. A primary with the wait bit (W-bit) set demands a reply; function 0 (SxF0) aborts a transaction.

The streams you will touch daily are few. Stream 1 is equipment status and communication setup. Stream 2 is equipment control and diagnostics: constants, remote commands, trace setup and report definitions. Stream 5 is alarms, stream 6 is data collection, stream 7 is process programs (recipes), stream 10 is terminal services and stream 14 is the E39 object services used by GEM300. The table below lists the messages that matter most, with names as they appear in the secsgem function reference.

Message Name Direction What it is for
S1F1 / S1F2 Are you there / On-line data Either Liveness and identity (model, software revision)
S1F3 / S1F4 Selected equipment status request / data Host to tool Poll status variables by SVID
S1F13 / S1F14 Establish communications request / ack Either GEM communication handshake
S1F15, S1F17 Request off-line, request on-line Host to tool Control state changes
S2F13, S2F15 Equipment constant request, new EC send Host to tool Read and write ECIDs
S2F23 Trace initialize send Host to tool Periodic sampling of SVIDs
S2F33, S2F35, S2F37 Define report, link event report, enable/disable event report Host to tool Dynamic event report configuration
S2F41, S2F49 Host command send, enhanced remote command Host to tool START, STOP, PAUSE, PP-SELECT and similar
S5F1 / S5F2 Alarm report send / ack Tool to host Alarm set and clear
S6F1 Trace data send Tool to host Periodic trace samples
S6F11 / S6F12 Event report send / ack Tool to host The workhorse of data collection
S7F3, S7F5, S7F19 Process program send, request, current EPPD Either Recipe upload, download and listing
S10F3 Terminal display single Host to tool Operator messages on the tool screen
S14Fx Object services Host to tool GEM300 attribute get/set

The data inside a message is a tree of typed items. Each item starts with a format byte whose upper six bits encode the type and whose lower two bits say how many length bytes follow (one to three). Then come the length bytes and the payload. You can verify this from the encoded example in the secsgem items documentation: an ASCII item “Hallo” encodes as 0x41 0x05 followed by five characters, where 0x41 is ASCII type code octal 20 with one length byte. A list encodes as 0x01 plus an item count, and a one-byte unsigned integer as 0xA5.

The supported types are list (L), binary (B), boolean, ASCII (A), JIS-8, signed integers of 1, 2, 4 and 8 bytes (I1 to I8), unsigned integers U1 to U8, and floats F4 and F8. Because every item carries its own type and length, a host can parse an unknown message without a schema. That self-description is why SECS-II has aged better than many fixed-layout fieldbus protocols. The cost is overhead: a 4-byte float costs 6 bytes on the wire, which matters for the sizing later.

Size limits follow from the length field. The Inductive Automation SECS/GEM documentation gives a single-item maximum of 16,777,215 bytes (three length bytes), an HSMS message maximum of 4,294,967,295 bytes (a 32-bit length field) and a SECS-I message maximum of 7,995,148 bytes.

Layer 2 — HSMS SEMI E37: framing SECS-II on TCP

HSMS replaced the serial SECS-I link with TCP/IP. SEMI E37 defines generic services: connect, select (start a logical session), send data, link test, deselect, separate and reject. The current revision in the SEMI store is E37-0222. The subordinate standard E37.1-0819 defines HSMS-SS, the single selected-session mode used for point-to-point host-tool links. The general-session variant, E37.2 (HSMS-GS), is listed as withdrawn.

Every HSMS frame is a 4-byte big-endian length followed by a 10-byte header and an optional SECS-II body. The secsgem encoding of a link-test request with system ID 2 is 00 00 00 0a ff ff 00 00 00 05 00 00 00 02, shown in the secsgem HSMS messages page. Read it as: length 10, session ID 0xFFFF, header byte 2 (W-bit plus stream) 0, header byte 3 (function) 0, PType 0, SType 5, and four system bytes.

For a data message, the session ID carries the device ID, byte 2 carries the W-bit in its top bit plus the 7-bit stream number, byte 3 carries the function, and SType is 0. The system bytes are a transaction ID: the reply echoes them, which is how a host matches an S6F12 to the S6F11 it acknowledges. Control messages use other SType values: 1 and 2 for select request and response, 3 and 4 for deselect, 5 and 6 for link test, 7 for reject and 9 for separate.

One side is “active” and opens the TCP connection; the other is “passive” and listens. In practice the equipment is usually passive and the host connects, but both arrangements exist. Port numbers are configuration, not standard; 5000 is a common default in drivers such as secsgem and the Critical Manufacturing driver.

Layer 3 — GEM SEMI E30: behaviour, not just messages

GEM is where SECS/GEM stops being a wire format and becomes a contract. The E30 abstract says GEM “specifies which messages to use, when, and the resulting activity”, and it provides “a single consistent method” where SECS-II offers several. It separates fundamental requirements from additional capabilities. It references E4, E5, E37, E42, E139, E172 and E173; the last is the XML SECS-II Message Notation (SMN) used for machine-readable message documentation.

As commonly summarised from the E30 compliance section (the full text is paywalled), GEM’s fundamental requirements include the state models (communication, control and processing), equipment processing states, host-initiated S1F13/S1F14 scenarios, event notification, on-line identification, error messages, documentation and control of the tool from the operator console. Additional capabilities include dynamic event report configuration, variable data collection, trace data collection, status data collection, alarm management, remote control, equipment constants, process program management, material movement, terminal services, clock, limits monitoring and spooling. A supplier’s SECS/GEM compliance statement says which of these the tool implements. The fab’s equipment-automation specification then says which it requires.

The data model under GEM is a set of numbered identifiers. Status variables (SVIDs) are always-valid values such as chamber pressure or clock. Data variables (DVIDs, often just VIDs) are valid only at a specific event, such as the lot ID when a lot completes. Equipment constants (ECIDs) are host-settable configuration values. Collection events (CEIDs) are things that happen, such as “process started” or “wafer moved”. Alarms have ALIDs. Reports (RPTIDs) are host-defined bundles of variables linked to events.

The dynamic report mechanism is the heart of GEM data collection. The host defines a report with S2F33 (RPTID plus a list of VIDs), links it to an event with S2F35 (CEID plus list of RPTIDs), and enables the event with S2F37. From then on, each time the event fires, the tool sends S6F11 containing the CEID and every linked report’s values. The host acknowledges with S6F12. That indirection lets each fab decide what it wants to know without the supplier changing firmware.

Walk-through: From TCP Connect to the First Event Report

Knowing the layers is not the same as knowing what happens when a tool powers up. This section walks one connection end to end, then covers the state models, GEM300 and the host architecture that consumes the data.

HSMS semi E37 sequence from TCP connect and Select through S1F13 establish communications, S2F33 S2F35 S2F37 report setup, S6F11 event reports and Linktest

Figure 2: A typical HSMS-SS session bring-up and report configuration, followed by steady-state event reporting and link testing.

The sequence shows the minimum a SECS/GEM host does before it gets useful data. HSMS-level messages (Select, Linktest) manage the session; SECS-II messages (S1F13 onwards) manage GEM. Note that S1F13 can be sent by either side. The diagram shows the equipment initiating, which is common when the tool’s communication state is enabled at boot.

Step 1 — TCP connect and HSMS Select

The active side opens the TCP socket. Within the T7 window it must send a Select.req; the passive side answers with a Select.rsp carrying a status code. Until select succeeds, the connection is in the NOT SELECTED state and no data messages may flow. If no select arrives before T7 expires, the passive side closes the socket. Once selected, the connection is in the SELECTED state and SECS-II traffic can start.

Step 2 — GEM establish communications

GEM layers its own handshake on top of HSMS. The initiator sends S1F13 and waits for S1F14 with COMMACK 0 (accepted). If the reply does not arrive, the initiator waits a configurable “establish communications timeout” and tries again. Only after this exchange is the GEM communication state COMMUNICATING. Many integration bugs come from confusing the two layers: an HSMS session can be SELECTED while GEM is still waiting for S1F14.

Step 3 — Report configuration

The host now configures data collection. A clean host first clears old configuration, because a tool may retain reports and links from a previous host session. It sends S2F37 with an empty list to disable all events, then S2F35 and S2F33 with empty lists to clear links and reports. Then it defines its own reports and enables only the events it needs. The open-source secsgem library’s subscribe_collection_event does exactly the three-message S2F33, S2F35, S2F37 sequence shown in the diagram, as its host handler source shows.

Step 4 — Steady state

From here, the tool sends S6F11 when an enabled event fires, S5F1 when an enabled alarm sets or clears, and S6F1 if a trace is running. The host sends S2F41 remote commands, S7 recipe messages and S1F3 status polls as needed. Every primary with the W-bit set must be answered within T3. Idle connections are probed with Linktest at an interval the integrator chooses.

HSMS timers T3, T5, T6, T7 and T8

The HSMS SEMI E37 timers are where most production incidents start, so it is worth being precise about what each one bounds. The descriptions below follow E37 terminology as reflected in the WinCC OA SECS configuration reference and common driver documentation. SEMI E37 defines the timers and their permitted ranges; the defaults in the right-hand column come from one shipping driver, the Critical Manufacturing Connect IoT SECS/GEM driver, and are an example rather than a standard value.

Timer What it bounds Failure symptom when mis-set Example default (one driver)
T3 Reply timeout: time to wait for the secondary of a W-bit primary Too short: spurious timeouts on large recipe uploads. Too long: host blocks on a dead tool 60 s
T5 Connection separation: minimum wait before reconnecting after a close Too short: reconnect storms that flood the tool’s TCP stack 10 s
T6 Control transaction timeout: wait for Select, Deselect or Linktest responses Too short on busy tools: link declared dead during a GC pause 10 s
T7 Not-selected timeout: how long a TCP connection may stay unselected Too long: half-open sockets pile up on the passive side 10 s
T8 Network intercharacter timeout: max gap between bytes of one message Too short on congested links: truncated frames and resets 10 s
Linktest interval How often to probe an idle selected connection Too long: dead links detected minutes late 60 s

T1, T2 and T4 belong to SECS-I serial links; the same driver documents T1 and T2 defaults of 1 s and T4 of 15 s. The engineering judgement is that T3 should be sized per message family, not globally. A 50 MB recipe upload over a congested tool network can legitimately take longer than a status poll, and some hosts override T3 per transaction for S7 messages.

GEM State Models: Communication, Control and Processing

The GEM state models define who is allowed to do what, when. They are the part of SECS/GEM that integrators most often under-implement, and they are the part fab automation teams test hardest during tool acceptance.

GEM communication state model with WAIT CRA, WAIT DELAY and COMMUNICATING, and the GEM control state model with HOST OFF-LINE, ON-LINE LOCAL and ON-LINE REMOTE

Figure 3: Simplified GEM communication and control state models. The communication state must reach COMMUNICATING before on-line control is meaningful.

The left half of the figure is the communication state model. When communication is enabled, the tool sends S1F13 and enters WAIT CRA (waiting for the communication request acknowledge). If no acceptable S1F14 arrives, it moves to WAIT DELAY, waits, and retries. A good S1F14 moves it to COMMUNICATING. Losing the link drops it back to the not-communicating substates. These state names match those used in the secsgem GEM handler source, which branches on WAIT_CRA, WAIT_DELAY and COMMUNICATING.

The right half is the control state model, which decides whether the host may control the tool. The full E30 model is paywalled; the summary here follows the widely implemented structure. Off-line has substates for equipment off-line, attempting on-line and host off-line. On-line has two substates. In ON-LINE LOCAL, the operator controls processing and the host may only collect data and change some settings. In ON-LINE REMOTE, the host may issue remote commands such as START and STOP. Kontron AIS summarises this as Online-Remote, Online-Local and Offline, setting “operator and host access rights”.

The processing state model is the one GEM leaves to the supplier. E30 defines its shape and requirements but each tool type has its own states. Kontron AIS cites idle, executing and pause as typical examples, and many tools add setup or ready states. The collection events on transitions between these states (for example “processing started” and “processing completed”) are the most important CEIDs a host subscribes to, because they drive MES lot tracking, cycle-time metrics and OEE.

The practical SECS/GEM rule: never send S2F41 START to a tool without first checking that the control state is ON-LINE REMOTE and the processing state allows it. A tool in ON-LINE LOCAL will reject the command with a non-zero HCACK, and a host that does not interpret HCACK codes ends up with lots that the MES thinks are running but are not.

GEM300 Standards: Carriers, Jobs and Substrates

GEM alone works for a tool processing one lot at a time with an operator loading cassettes. A 300 mm fab is fully automated, with FOUPs (front-opening unified pods) delivered by overhead transport, so GEM300 adds an object model for material and work. The GEM300 standards, with their roles per the Cimetrix GEM300 white paper, are:

Standard Name What it models
E39 Object Services (OSS) Generic object model; get and set attributes via stream 14
E40 Processing Management Process jobs: which recipe runs on which substrates
E87 Carrier Management (CMS) Carrier ID and slot map verification, load port states and reservations
E90 Substrate Tracking Each wafer’s location and processing state inside the tool
E94 Control Job Management Control jobs grouping carriers and process jobs into one unit of work
E116 Equipment Performance Tracking (EPT) Busy, idle and blocked states with blocked reasons
E148 Time Synchronization NTP-based clock sync and the TS-Clock object
E157 Module Process Tracking Per-module, per-step reporting during recipe execution

E30 and E39 are prerequisites for all of them, and E94 additionally requires E40. A typical automated run looks like this. The AMHS delivers a FOUP to a load port using the E84 parallel I/O handshake. E87 reads the carrier ID, the host verifies it, the tool maps the slots and the host verifies the slot map. The host then creates an E40 process job naming a recipe and substrates and an E94 control job grouping process jobs and carriers. E90 reports each substrate as it moves from carrier to chamber and back, and E116 reports whether the tool was productive or blocked.

SEMI E84, the “Enhanced Carrier Handoff Parallel I/O Interface” in the SEMI store, is not a SECS message standard at all. It defines optical parallel I/O signals between the transport vehicle and the load port, the handoff sequence and error recovery, according to Kontron AIS. It matters here because an E84 handoff fault surfaces in the host as an E87 carrier state that never advances, and the two must be debugged together.

GEM300 is not optional plumbing. Most fab MES integrations treat the E87, E40 and E94 event streams as the source of truth for WIP. If the host’s model of a control job disagrees with the tool’s, wafers get stranded in a FOUP that the MES believes is finished. This is the same class of state-divergence bug discussed in our semiconductor fab digital twin reference architecture, where the twin is only as good as its reconciliation with GEM300 object states.

Host Architecture: Who Talks SECS/GEM to the Tools

In most fabs the MES never opens an HSMS socket directly. An equipment integration layer sits between them, and its design decides how robust the whole semiconductor equipment automation stack is.

Fab host architecture where GEM300 tools connect over HSMS to an equipment integration server feeding MES, recipe management, AMHS, FDC and a data platform, with EDA Interface A as a parallel trace path

Figure 4: A reference host architecture. The equipment integration server owns the SECS/GEM sessions; EDA clients pull high-rate trace data in parallel.

The equipment integration server (EIS), sometimes called a station controller or cell controller, holds one SECS/GEM session over HSMS per tool. It translates MES intent (“run lot X with route step Y on tool Z”) into GEM300 objects and SECS-II messages. In the other direction it turns S6F11 events into MES transactions such as track-in, track-out and wafer moves. Commercial EIS products exist from several automation vendors, and many fabs build their own on top of a commercial SECS/GEM driver.

The recipe management system (RMS) keeps golden copies of process programs. It uses stream 7 to upload a recipe from a tool, compare it with the golden version and download a corrected one. Some fabs also check the recipe body against the golden copy at each PP-SELECT event before allowing the tool to start. Recipe drift is a well-known source of yield excursions, so this SECS/GEM loop is worth automating early.

The material control system (MCS) and AMHS move FOUPs between stockers and load ports. The E84 handoff happens between the vehicle and the tool; the host learns about it through E87 carrier events over SECS/GEM.

Fault detection and classification (FDC) and statistical process control (SPC) consume sensor data. Here the architecture splits. GEM trace data (S2F23 and S6F1) and event-attached variables can feed FDC, but the SECS/GEM session is shared with control traffic. EDA (Interface A) gives FDC its own channel. This is the main reason EDA exists: process engineers want 10 Hz or faster sensor data without risking the session that controls lot movement.

Finally, the data platform (a historian, a lakehouse or a unified namespace) receives a curated copy. We covered the general pattern in our unified namespace architecture guide. For fabs, the rule is one-way: the UNS consumes from the EIS and EDA clients, and nothing in the UNS writes back to a tool. Control stays in the SECS/GEM path, where state models protect it.

Legacy tools with SECS-I serial ports usually connect through a terminal server or protocol converter that exposes them as HSMS to the EIS. That works, but the converter becomes a single point of failure that must be monitored like a tool.

Python sketch: a minimal SECS/GEM host with secsgem

The open-source secsgem package is a Python implementation of SECS/GEM by Benjamin Parzella. At the time of writing, PyPI lists version 0.3.0, released 14 September 2024, licensed LGPL-2.1-or-later, requiring Python 3.8 or newer, and classified “3 – Alpha”. It is excellent for learning, simulators and test harnesses. It is not a substitute for a qualified commercial driver on a production tool.

The sketch below uses the 0.3.0 API: HsmsSettings, GemHostHandler, subscribe_collection_event, send_remote_command and the collection_event_received and alarm_received events. The CEIDs, VIDs and remote command name are placeholders. Every tool’s GEM manual defines its own.

import logging
import secsgem.common
import secsgem.gem
import secsgem.hsms

logging.basicConfig(level=logging.INFO)

# Placeholder IDs -- take real values from the tool's GEM manual
CEID_PROCESS_COMPLETE = 1001
VID_LOT_ID, VID_PPID, VID_WAFER_COUNT = 2001, 2002, 2003


class FabHost(secsgem.gem.GemHostHandler):
    def __init__(self, settings):
        super().__init__(settings)
        self.events.collection_event_received += self.on_event
        self.events.alarm_received += self.on_alarm

    def on_event(self, data):
        # data keys in secsgem 0.3.0: ceid, rptid, values, handler, peer
        logging.info("CEID %s RPTID %s values %s",
                     data["ceid"], data["rptid"], data["values"])

    def on_alarm(self, data):
        # data keys: code, alid, text, handler, peer
        logging.warning("ALID %s code %s %s",
                        data["alid"], data["code"], data["text"])


settings = secsgem.hsms.HsmsSettings(
    address="10.0.0.50",          # tool IP (tool is passive here)
    port=5000,
    connect_mode=secsgem.hsms.HsmsConnectMode.ACTIVE,
    device_type=secsgem.common.DeviceType.HOST,
)

host = FabHost(settings)
host.enable()

if host.waitfor_communicating(timeout=30):
    host.clear_collection_events()          # remove stale reports and links
    host.subscribe_collection_event(
        CEID_PROCESS_COMPLETE,
        [VID_LOT_ID, VID_PPID, VID_WAFER_COUNT],
    )
    print(host.request_svs([1, 2, 3]))     # S1F3 status poll, placeholder SVIDs
    host.go_online()                        # S1F17 request on-line
    # Only in ON-LINE REMOTE; check HCACK in the reply
    reply = host.send_remote_command("START", [])
    print(reply)
else:
    logging.error("GEM communication not established")

Three details in that sketch reflect production lessons. First, clear_collection_events runs before subscribing, because stale report definitions from an earlier session cause S2F33 to be rejected with a “RPTID already defined” style acknowledge. Second, the host waits for the GEM COMMUNICATING state, not just a TCP connection. Third, the remote command reply is inspected rather than assumed. In a real EIS, that reply’s HCACK value would drive the MES transaction. The event callback signature (a single data dict) follows the 0.3.0 source; older 0.1.x releases used a different handler style, so pin the version.

For testing without hardware, secsgem also provides an equipment handler, so you can run a simulated tool in one process and the host in another. That pairing is the cheapest way to rehearse report configuration, alarm handling and reconnection before touching a real tool.

Sizing SECS/GEM Traffic: A Worked, Illustrative Example

Fab teams routinely ask whether a SECS/GEM link can carry their data-collection plan. The arithmetic is simple once you know the item encoding. The numbers below are illustrative assumptions for a hypothetical etch tool, not measurements from any specific equipment.

Event reports. Assume each wafer generates 40 enabled collection events across load, transfer, process and unload. Each S6F11 carries one report with 20 variables averaging 8 payload bytes plus 2 bytes of item header, plus list headers and IDs. Call it about 260 bytes of SECS-II body plus 14 bytes of HSMS framing, so roughly 275 bytes per event. At one wafer per minute, that is 40 events per minute, or about 11 KB per minute per tool. Even 500 such tools generate under 100 KB per second of event traffic. Event reporting is never the bandwidth problem.

Trace data. Now assume FDC wants 200 F4 sensor values at 10 Hz via S2F23 trace, with a group size of 10 samples per S6F1. Each F4 item costs 6 bytes on the wire, so one sample of 200 values is about 1,200 bytes plus list overhead. Ten samples per message makes roughly 12 KB per S6F1, sent once per second. That is about 12 KB per second, or roughly 100 kbit/s, per tool. Across 500 tools the fab carries around 6 MB per second, or about 50 Mbit/s, of trace traffic. The network copes easily; the risk is elsewhere.

Where it actually breaks. The bottleneck is the tool controller and the host’s message loop, not the wire. A tool that must serialise 10 messages per second of trace alongside control traffic can delay an S6F11 or a Linktest response beyond T6 or T3. A host that processes messages single-threaded per tool can fall behind and stop acknowledging S6F11, which makes the tool spool or time out. This is why trace above a few hertz migrates to EDA, and why the EIS must decouple socket reads from business processing with a queue per session.

Treat these as order-of-magnitude checks. Real sizing should use the tool’s GEM manual, its documented trace limits, and a soak test with the actual report set.

SECS/GEM vs EDA vs OPC UA: A Decision Matrix

The question in 2026 is rarely “SECS/GEM or something else”. It is which interface carries which job. The matrix below compares the three options a fab or equipment supplier realistically has. It reflects the verified properties cited in this article plus the author’s practitioner judgement for the “fit” rows.

Criterion SECS/GEM (E5, E30, E37) EDA / Interface A (E120, E125, E132, E134) OPC UA (with companion specs)
Primary purpose Control plus event and alarm reporting High-rate read-only data acquisition General information modelling and access
Transport HSMS over TCP, legacy RS-232 SOAP/XML over HTTP(S) in Freeze II; gRPC proposed for Freeze 3 OPC UA binary or PubSub
Equipment control Yes, via remote commands and GEM300 jobs No Possible, not standardised for fab tools
Security model None in HSMS itself; relies on network isolation E132 client authentication and authorization Built-in certificates and policies
Fab acceptance Mandatory in purchase specs Required for new equipment in many fabs Rare at fab host level
Data rate fit Events, alarms, modest trace High-frequency trace, metadata-rich Wide range
Self-description Namelist requests (S1F11, S1F21, S1F23, S2F29) E125 Equipment Self-Description Full address-space browse
Best fit Lot control, WIP, alarms, recipes FDC, run-to-run, virtual metrology Sub-fab, facilities, cross-industry tools

A few points need emphasis. EDA “does not replace SECS/GEM or GEM300 because it provides no equipment control or configuration features”, in the words of the Cimetrix Interface A overview, which lists Freeze II revisions such as E125-0710 and E134-0710. Freeze 3, which replaces SOAP/XML with gRPC and Protocol Buffers via E179, has been in progress for years. A June 2025 committee update from PDF Solutions reported that the intended final Freeze 3 ballot (7321A) failed and was being reworked, and that E178 will declare the Freeze 3 version once the ballots pass. We have not been able to confirm from a public SEMI source, this run, whether Freeze 3 was declared later in 2025 or 2026. Treat its status as something to check with your SEMI membership contact.

OPC UA wins on security and information modelling, and the same committee update shows SEMI itself discussing a secure GEM transport using gRPC and TLS as an alternative to HSMS. That proposal had not been approved at the time of the report. For general OPC UA modelling practice, our OPC UA companion specification implementation tutorial shows what a well-designed information model looks like. For fab tools, the realistic 2026 posture is SECS/GEM for control, EDA for engineering data, and OPC UA at the edges where SEMI standards do not reach, such as facilities and sub-fab equipment.

Beyond the Front-End Fab: Back-End, PV and SMT

SECS/GEM is not limited to wafer fabs. Back-end assembly and test equipment, such as die bonders, wire bonders, test handlers and probers, commonly ships with GEM interfaces, because the same semiconductor companies own those factories and reuse their host software. The same logic extends to many photovoltaic and flat-panel lines, where suppliers with semiconductor heritage offer GEM as the default host interface. The protocol does not care what the substrate is; GEM300 objects such as carriers and substrates generalise reasonably well.

Electronics assembly took a different path from SECS/GEM. SEMI’s SMT-ELS suite includes SEMI A1, “Specification for Horizontal Communication (HC) Between Equipment for Factory Automation System”, and SEMI A1.1, “Specification for Media Interface for A Horizontal Communication (HC) Between Equipment”, according to a SEMI Standards Watch article on SMT-ELS. These target machine-to-machine coordination along an SMT line rather than vertical host control.

The IPC family is more widely deployed in SMT and PCB assembly. IPC-2591, Connected Factory Exchange (CFX), reached Version 2.0 in February 2025, per the IPC-2591 V2.0 table of contents. CFX uses AMQP v1.0 as its primary transport and JSON as its encoding. The same document describes CFX as complementing IPC-HERMES-9852, the machine-to-machine board-handover standard it calls an advanced replacement for SMEMA, with CFX adding vertical messaging alongside Hermes’ line-level control.

The contrast is instructive. CFX is publish/subscribe and broker-based, with human-readable JSON; SECS/GEM is point-to-point, request/reply and binary. CFX makes fan-out to many consumers easy; SECS/GEM makes per-tool control semantics explicit and testable. If you run a mixed site with a wafer-level packaging line next to an SMT line, expect to operate both, bridged at the data platform rather than at the tool.

Trade-offs, Gotchas, and What Goes Wrong

SECS/GEM’s longevity hides real sharp edges. These are the failure modes that cost the most time in tool integrations.

No transport security. HSMS has no built-in authentication or encryption. Anyone who can reach the tool’s port can send S2F41 or download a recipe. Fabs mitigate this with segmented tool networks and firewalls, and SEMI’s 2025 discussion of a secure GEM transport shows the gap is recognised. Treat the tool network as a safety zone in the IEC 62443 sense. Our ISA-95 and ISA-99 standards guide covers the zoning model.

“GEM compliant” is not one thing. Because most of GEM is additional capabilities, two compliant tools can differ widely. One supports trace data, the other does not; one implements limits monitoring, the other ignores S2F45. Always read the compliance table and test against the fab’s own equipment-automation specification. SEMI E192, a guide for equipment adoption criteria for GEM and related standards, exists precisely because of this ambiguity.

Stale configuration. Tools often persist reports, links and enabled events across reboots and host changes. A host that subscribes without clearing first gets rejections or, worse, duplicate events. Clear, then configure, every time GEM communication is established.

Spooling surprises. When the link drops, a tool with spooling enabled stores messages and replays them later. A host that is not ready for a burst of old S6F11s can misapply stale events to current lots. Decide explicitly whether to purge or replay the spool after an outage, and timestamp everything with the tool clock, synchronised per E148 where supported.

Blocking the session. Long S7 recipe transfers and high-rate trace share one HSMS session with control. A host that waits synchronously on a large transfer can miss T3 deadlines on other transactions. Use asynchronous handling and per-message-family timeouts.

Variable ID drift across software revisions. A tool software upgrade can renumber or redefine SVIDs and CEIDs. Store the tool’s model name and software revision from S1F2 and S1F14, and treat a change as a re-qualification trigger for the host’s mapping.

Over-collecting. Enabling every event with every variable is tempting and destructive. It increases tool CPU load, stresses the host and buries useful signals. Collect what a defined consumer needs, and route high-rate data to EDA.

Practical Recommendations

Start every SECS/GEM project from the fab’s equipment-automation specification and the tool supplier’s GEM manual, not from a generic driver. The spec tells you which capabilities and GEM300 standards are mandatory; the manual tells you the actual IDs, remote commands and state transitions. Build a tool simulator early, either from the supplier or with an open-source library such as secsgem, so host logic is tested before the tool arrives.

Architect the host so that each tool’s HSMS session is isolated, its messages are queued, and business processing never blocks socket reads. Keep control and data separate: SECS/GEM for lot control, alarms and recipes; EDA for high-rate engineering data; a one-way feed into the data platform for analytics. Treat timers as configuration that operations can tune per tool, and log every timeout with the message and system bytes so incidents can be reconstructed.

Finally, plan for change. Freeze 3 and secure GEM transport proposals are moving through SEMI committees, and tool software upgrades will change your variable maps. Version your tool mappings like code.

Checklist before go-live:

  • Fab equipment-automation spec and tool GEM compliance statement reviewed side by side.
  • Communication, control and processing state handling tested, including ON-LINE LOCAL rejections.
  • Clear-then-configure report setup on every COMMUNICATING transition.
  • T3, T5, T6, T7, T8 and link-test interval set per tool and documented.
  • Spool purge or replay policy decided and tested.
  • Recipe upload, compare and download loop wired to the RMS.
  • Tool network segmented; no route from office IT to HSMS ports.
  • Soak test with the real report and trace set at peak wafer rate.

Frequently Asked Questions

What is the difference between SECS and GEM?

SECS refers to the message layers: SECS-I (SEMI E4) for serial transport and SECS-II (SEMI E5) for message content, organised as streams and functions built from typed items. GEM (SEMI E30) is the behaviour standard built on SECS-II. It specifies which messages equipment must support, how it must respond, and the state models for communication, control and processing. SECS tells you how to say something; GEM tells you what to say and what must happen. In practice, people say SECS/GEM to mean the combination, usually carried over HSMS.

What is HSMS in SECS/GEM?

HSMS, High-Speed SECS Message Services, is SEMI E37. It carries SECS-II messages over TCP/IP instead of RS-232 serial. Each message is framed with a 4-byte length and a 10-byte header holding the session or device ID, stream, function, W-bit, message type and system bytes. HSMS adds session control messages such as Select, Linktest and Separate, and timers T3, T5, T6, T7 and T8. SEMI E37.1 defines HSMS-SS, the single-session mode used for typical host-to-tool links. The general-session mode E37.2 has been withdrawn.

What are GEM300 standards?

GEM300 is the set of SEMI standards layered on GEM for automated 300 mm fabs. The core set is E39 object services, E40 process jobs, E87 carrier management, E90 substrate tracking, E94 control jobs and E116 equipment performance tracking, with E148 time synchronisation and E157 module process tracking often included. They model carriers, wafers and jobs as objects the host can create and monitor. GEM300 lets fabs run lights-out with automated material handling, while GEM alone mostly suits operator-loaded tools.

Is SECS/GEM being replaced by OPC UA?

Not for fab tool control in the near term. SECS/GEM is embedded in fab purchase specifications, host software and decades of qualification practice. OPC UA offers better security and information modelling, and it is used around the fab in facilities and some sub-fab systems. SEMI’s own direction is to evolve its standards rather than switch: EDA Freeze 3 moves Interface A to gRPC, and a secure GEM transport using gRPC and TLS has been discussed in committee. Expect coexistence, with SECS/GEM for control.

What is the difference between SECS/GEM and EDA Interface A?

SECS/GEM is the control and event interface between a tool and the fab host; it starts jobs, reports events and alarms and manages recipes. EDA, also called Interface A, is a separate data-acquisition interface defined by standards such as E120, E125, E132 and E134. It lets authorised engineering clients collect high-rate, metadata-rich data without loading the control session. EDA has no equipment control functions, so it complements SECS/GEM rather than replacing it. Freeze II uses SOAP/XML; Freeze 3 moves to gRPC.

Can I implement a SECS/GEM host in Python?

Yes, for learning, simulation and test harnesses. The open-source secsgem package, version 0.3.0 on PyPI under LGPL-2.1-or-later, provides HSMS settings, a GEM host handler, an equipment handler and stream/function classes. It can subscribe to collection events, send remote commands and manage process programs. It is marked alpha, so production fabs typically use commercial drivers that have passed tool acceptance testing. A Python host is still valuable for prototyping report plans and verifying a supplier’s GEM implementation before integration.

Further Reading

References

  1. SEMI. SEMI E30 — Specification for the Generic Model for Communications and Control of Manufacturing Equipment (GEM), revision E30-0526. https://store-us.semi.org/products/e03000-semi-e30-specification-for-the-generic-model-for-communications-and-control-of-manufacturing-equipment-gem
  2. SEMI. SEMI E37 — Specification for High-Speed SECS Message Services (HSMS) Generic Services, revision E37-0222, with E37.1-0819 HSMS-SS. https://store-us.semi.org/products/e03700-semi-e37-high-speed-secs-message-services-hsms-generic-services
  3. SEMI. SEMI E5 — Specification for SEMI Equipment Communications Standard 2 Message Content (SECS-II), revision E5-0725. https://store-us.semi.org/products/e00500-semi-e5-specification-for-semi-equipment-communications-standard-2-message-content-secs-ii
  4. SEMI. SEMI E84 — Specification for Enhanced Carrier Handoff Parallel I/O Interface. https://store-us.semi.org/products/e08400-semi-e84-specification-for-enhanced-carrier-handoff-parallel-i-o-interface
  5. Cimetrix. GEM300 White Paper (2020). https://www.cimetrix.com/hubfs/docs/Whitepapers/GEM300-WhitePaper-2020.pdf
  6. Cimetrix. SEMI EDA/Interface A Standards Overview. https://www.cimetrix.com/InterfaceA
  7. PDF Solutions. North America Information and Control Committee update (June 2025). https://www.pdf.com/north-america-information-control-committee-winter-2025-update/
  8. PDF Solutions. EDA Freeze 3 update (September 2022). https://www.pdf.com/eda-freeze-3-update/
  9. B. Parzella. secsgem 0.3.0, PyPI and documentation. https://pypi.org/project/secsgem/ and https://secsgem.readthedocs.io/en/latest/
  10. Critical Manufacturing. Connect IoT SECS/GEM driver documentation. https://help.criticalmanufacturing.com/userguide/automation/definition/automation-protocol/automation-protocol-protocols/driver_secsgem/
  11. IPC. IPC-2591 Connected Factory Exchange (CFX) Version 2.0 table of contents (February 2025). https://www.electronics.org/TOC/IPC-2591-V2.0-TOC.pdf
  12. SEMI. SMT-ELS Standards Watch update (2019). https://semi.org/en/products-services/standards/standards-watch-newsletter/smt-els-update-2019

By Riju — about

Comments

No comments yet. Why don’t you start the discussion?

Leave a Reply

Your email address will not be published. Required fields are marked *