How-to
How to program a sealed motor starter rung in STEP 7 ladder
Short answer
Program the rung as Q0.0 = I0.1 AND I0.2 AND (I0.0 OR Q0.0): Start I0.0 in parallel with a seal-in contact on the output, Stop I0.1 and overload I0.2 in series, both normally closed field contacts sitting at logic 1. The seal-in contact holds Q0.0 on from the scan after Start is released; pressing Stop drops I0.1 to 0 and de-energizes the coil.
On this page
Program the motor starter as one network: Q0.0 = I0.1 AND I0.2 AND (I0.0 OR Q0.0). Start (I0.0) sits in a parallel branch with a normally open Q0.0 contact; Stop (I0.1) and the overload contact (I0.2) sit in series ahead of the coil, and every field signal feeds a normally open symbol in the logic because Stop and overload are wired normally closed. The output turns on in the scan Start is pressed, holds itself through its own contact from the next scan, and drops the moment Stop pulls I0.1 to logic 0. What follows maps the signals, enters the network in the editor, and proves all four states with the arithmetic shown.
The seal-in rung, and why it holds #
One scan has three parts: the CPU reads the inputs into the input image, solves the networks top to bottom against those bits, then writes the results to the outputs. The seal-in lives in the gap between solving and writing. In the scan where Start is pressed, the rung solves true and the CPU sets the output bit for Q0.0 to 1. On the next scan the normally open Q0.0 contact — which reads that output bit, not the terminal — evaluates true, so the parallel branch stays closed after the Start contact opens again. It is the PLC replacement for the holding contact an electrician once wired around a momentary Start button.
This circuit wants LAD: contacts and coils mirror the hard-wired starter diagram one for one. STEP 7 also offers STL, a mnemonic instruction list, and FBD, logic boxes with no contacts, but neither reads like power flow through a starter. If the project has not settled which engineering tool it runs on, what STEP 7 is in a PLC project settles that choice first.
If your start and stop signals are level signals that stay made — two float switches, for instance — you do not need a seal at all; latching two level inputs for pump start and stop control shows that pattern instead.
Map the signals before you enter anything #
| Address | Field device | Field contact | Healthy idle bit |
|---|---|---|---|
| I0.0 | Start push-button, momentary | Normally open | 0 until pressed |
| I0.1 | Stop push-button, momentary | Normally closed | 1 while closed |
| I0.2 | Overload relay contact | Normally closed | 1 while closed |
| Q0.0 | Motor-starter output coil | Coil | 0 before a start |
Two decisions in that table make the rung work. First, Stop and overload are wired normally closed, so both bits idle at logic 1; a broken Stop wire or a lost input supply drops the bit to 0, which the rung reads as a stop command — the failure direction is stop, not run. Second, because the normally closed field wiring already puts a 1 in those bits, every contact you program in this network is a normally open symbol: the logic tests the bit, not the mechanics of the field contact.
The I0.2 input reports the overload relay; the starter's own overload path is still what protects the motor, so this rung adds reporting, not protection.
These addresses assume the CPU's first digital inputs and outputs begin at byte 0. If the hardware configuration or reference data shows I0.0 or Q0.0 occupied with nothing physical behind it, why S7 reference data shows I0.0 and Q0.0 occupied without physical I/O explains where that comes from; shift the rung to free addresses and keep the structure.
Enter the network in STEP 7 #
- Open the project in TIA Portal or Simatic Manager and open the cyclic main program block for LAD editing.
- In a fresh network, place two normally open contacts in series and address them I0.1 and I0.2.
- After I0.2, open a parallel branch and place a normally open I0.0 contact in it.
- Add a second contact in that same branch, addressed Q0.0 — the seal-in.
- Close the branch into the output and assign the coil Q0.0.
- Save and compile, download the block to the CPU, and put the CPU in RUN.
- Switch the editor to online monitoring so contact and coil states show live, then go to the machine.
Work the arithmetic through the states #
Every state of this circuit is one Boolean evaluation, so prove it on paper before pressing anything. The network computes:
Q0.0 (new) = I0.1 AND I0.2 AND (I0.0 OR Q0.0 previous)
Start pressed, machine idle and healthy — I0.0 = 1, I0.1 = 1, I0.2 = 1, previous Q0.0 = 0:
(1 OR 0) = 1, then 1 AND 1 AND 1 = 1, so Q0.0 goes to 1 and the starter energizes.
Start released, one scan later — I0.0 = 0, I0.1 = 1, I0.2 = 1, previous Q0.0 = 1:
(0 OR 1) = 1, then 1 AND 1 AND 1 = 1, so Q0.0 stays 1 with nobody holding the button.
Stop pressed, Start already released — I0.0 = 0, I0.1 = 0, I0.2 = 1, previous Q0.0 = 1:
0 AND 1 AND (0 OR 1) = 0, so Q0.0 drops to 0 and the motor stops.
Idle, before any start — I0.0 = 0, I0.1 = 1, I0.2 = 1, previous Q0.0 = 0:
(0 OR 0) = 0, then 1 AND 1 AND 0 = 0, so Q0.0 stays off.
| Case | I0.0 | I0.1 | I0.2 | Q0.0 in | I0.0 OR Q0.0 | Q0.0 out | Motor |
|---|---|---|---|---|---|---|---|
| Idle, no start | 0 | 1 | 1 | 0 | 0 | 0 | Off |
| Start pressed | 1 | 1 | 1 | 0 | 1 | 1 | Starts |
| Start released | 0 | 1 | 1 | 1 | 1 | 1 | Runs, sealing |
| Stop pressed | 0 | 0 | 1 | 1 | 1 | 0 | Stops |
The idle row is also the state after Stop is released and after a CPU restart: the rung remembers nothing, because its only memory is the Q0.0 bit, and that bit is 0.
Verify it on the machine #
- In monitoring, with nobody at the buttons, I0.1 and I0.2 must both read 1. Either one reading 0 is a field problem — an open contact, a broken wire, missing input voltage — not a logic problem.
- Press Start: I0.0 shows 1, the rung solves true, Q0.0 shows 1, and the starter pulls in.
- Release Start: Q0.0 stays 1. If it drops out, the seal-in contact is missing, addressed to a bit other than the coil, or something else in the program is writing Q0.0.
- Press Stop: Q0.0 drops to 0 in that scan and the starter releases.
- With the machine in a safe state, open the Stop field circuit: the rung must drop Q0.0 exactly as it does for a pressed Stop, which is what the normally closed wiring guarantees. If it does not, the Stop button was wired normally open and the failure direction points toward run.
One network, four normally open contacts, one coil: the scan does the remembering, and the wiring fails toward stop.
Questions asked
Why are the Stop button and the overload contact wired normally closed?
So a failure drives the input to the stop state. The input bit sits at logic 1 while the normally closed field contact is closed; if the wire breaks, the terminal loses power, or the card is unplugged, the bit falls to logic 0 and the rung reads exactly like a pressed Stop, dropping the motor. A normally open stop wiring would turn those same failures into a start permission.
Can set and reset coils replace the seal-in branch?
Yes, the Siemens LAD manual builds its starter example with a Set coil: pressing start switch I 1.1 or I 1.3 sets Q 4.0, with the stop handled on the next network. With set and reset coils the network solved last wins, so order the reset after the set when stop must dominate; the plain seal-in rung is dominant by construction and needs no ordering.
Does the motor restart by itself after an overload trip is reset?
No. A trip opens the overload contact, I0.2 falls to logic 0, and Q0.0 de-energizes. When the contact is reset, I0.2 returns to logic 1, but the parallel branch is dead: I0.0 is 0 because nobody is pressing Start, and the Q0.0 contact is 0 because the coil is off. The motor stays off until someone presses Start.
How long must Start be held for the seal to take?
The CPU must see I0.0 at logic 1 in at least one scan, because the input image is read once per scan and the seal-in branch only works off the output bit it created in a previous scan. A human press lasts far longer than one scan, so a momentary button is enough; pulses generated inside the program or by fast field events can fall between scans and need edge detection, not a longer press.