OTE (Output Energize) is the standard output coil instruction in ladder logic: on every scan it writes the rung condition to its bit — 1 when the rung is true, 0 when the rung is false.
Join 1900+ learners practicing PLC programming
How it works
The detail that separates OTE from every input instruction is that it always writes. A true rung writes a 1; a false rung actively writes a 0. An OTE bit is therefore never "left alone" — it is refreshed on every single program scan. This is what makes OTE non-retentive: stop scanning the rung (fault, mode change, an enclosing false MCR zone) or cycle power, and the bit drops to 0. For most machine outputs — motors, valves, lamps — that de-energize-on-failure behaviour is exactly what you want.
The write happens to the output image table during the program scan, not to the physical terminal. Only after the last rung executes does the output-scan phase copy the image to the real output modules. Practical consequence: if two rungs contain an OTE addressing the same bit, both writes happen in memory and the later rung wins — the field device only ever sees the final value. This "last rung wins" rule is the root cause of a whole family of baffling why-does-my-output-not-turn-on bugs, and it is why duplicate OTE destinations are treated as a programming error (Studio 5000 flags them as duplicate destructive bit references).
A rung can also hold multiple OTE coils — branched in parallel at the end of the rung — and all of them follow the same rung condition. What a rung cannot do in Allen-Bradley ladder is continue to the right of an OTE: the coil ends the logic path. Conditions go on the left, results go on the right.
When the process needs an output that survives a false rung — an alarm that stays latched until acknowledged, a fault flag that must persist through a power cycle — OTE is the wrong tool. That is the job of the OTL/OTU latch pair or a Set/Reset coil, which write only when their rung is true and are covered on their own page.
Across vendors
| Platform | Name / syntax | Notes |
|---|---|---|
| Allen-Bradley (Studio 5000 / RSLogix) | OTE | Instruction mnemonic OTE tag — the ( ) coil. Non-retentive; duplicate OTE destinations are flagged as errors. |
| IEC 61131-3 (CODESYS, OpenPLC) | Coil | The graphical coil -( )- in LD; Structured Text writes the same thing as an assignment: Motor := Start AND NOT Stop; |
| Siemens (TIA Portal) | = (assign coil) | The -( )- coil in LAD; in STL the assignment instruction = "Motor". Also non-retentive. |
| Mitsubishi (GX Works) | OUT | OUT Y0 drives output Y0 with the current rung result. OUT to the same device twice raises a double-coil warning. |
Every dialect has this instruction and every dialect gives it the same two properties: written every scan (true or false) and non-retentive. Only the name changes — OTE, coil, =, OUT.
In practice
| Guard_Closed Auto_Mode Cycle_Req Conveyor | |-----] [-----------] [---------] [--------------( )--|
Three series conditions ANDed together drive one OTE. Every scan evaluates the whole rung: all three bits at 1 → Conveyor written 1; any bit at 0 → Conveyor written 0 on that same scan. There is no memory here — the output is a pure, continuously refreshed function of its inputs, which makes rungs like this trivially safe to reason about.
| Tank_Low Fill_Valve | |----] [----------------------------------------( )----| | Manual_Fill Fill_Valve | |----] [----------------------------------------( )----|
Both rungs write Fill_Valve. When Tank_Low is 1 but Manual_Fill is 0, rung 1 writes a 1 into the output image — and rung 2, scanned later, immediately overwrites it with 0. The valve never opens, and rung 1 even highlights green in the editor while it happens, which is what makes this bug so disorienting to troubleshoot.
The fix is one rung with the conditions in parallel: Tank_Low OR Manual_Fill driving a single OTE. One bit, one OTE — treat that as a hard rule.
Gotchas
Two OTE coils writing the same bit
Last rung scanned wins; earlier rungs are silently overwritten in the output image. Combine the conditions into one rung with parallel branches instead. If you inherit code with duplicates, the cross-reference tool is your friend.
Expecting an OTE to remember anything
OTE writes 0 the moment its rung goes false — including when a surrounding MCR zone disables the rung or the routine stops being scanned via JSR. State that must persist needs OTL/OTU or a seal-in branch.
Reading the physical output mid-scan
The OTE writes the output image; terminals update only at the end of the scan. Logic later in the same scan that examines the output bit sees the new value, but the field device does not change until the output scan. For sequencing within a scan this distinction occasionally matters.
Logic to the right of the coil
In AB ladder the OTE terminates the rung — you cannot put contacts after it. If you find yourself wanting "output, then more conditions", you actually want a second rung (or an internal bit).
Drop the instruction on a rung in the browser simulator, toggle the inputs, and watch the rung state, accumulator values and outputs update scan by scan.
Questions
OTE stands for Output Energize — the Allen-Bradley name for the standard output coil. Each scan, it writes the rung condition to its bit: 1 if the rung is true, 0 if false. Because a false rung writes 0 (rather than leaving the bit alone), OTE is non-retentive.
Both rungs write the bit in the output image, and the rung scanned last wins — the earlier write is overwritten before outputs are updated. This is the classic "rung is green but the output is off" bug. Use a single OTE with parallel input branches instead.
OTE writes its bit every scan, true or false, so the bit drops as soon as the rung goes false. OTL (Output Latch) writes only a 1, and only when its rung is true — the bit then stays 1 through false rungs and (for retentive tags) power cycles until a separate OTU unlatches it.
Yes, in the normal configuration. When a controller faults or goes to program mode, outputs are reset or forced to their configured safe state, and because OTE is non-retentive its bits are written to 0 when scanning resumes with false rungs. Never rely on that instead of a hardwired safety circuit, though.