Make an HMI button advance one stage in a PLC sequence

Why one press runs every stage

The wiring you have now is a momentary button feeding a PD contact, the one-shot contact that is true for a single scan on the edge you choose, and that contact executes a jump to the next stage. Every stage carries the same rung. Two things combine to walk the sequence.

A press is long in scan time. A finger press on a panel button commonly lasts 100 to 300 ms, and a small PLC completes a scan in 1 to 10 ms, so the panel bit is present for dozens of passes. The page on how many PLC scans a momentary button bit stays on works the same arithmetic for a plain momentary button.

A jump moves execution. Stage logic is scanned in order, and a jump leaves the current stage and continues at the destination stage's rungs within the same pass. If the transition condition there is still true, that stage jumps too. Each stage's rung carries its own edge contact on the same panel bit, so the walk can finish every stage in one pass. Releasing the button a little sooner changes nothing, because the whole walk fits inside the press many times over.

Which of the two dominates is a property of your controller's stage execution. The check below reads the difference off the stage number.

Symptoms and what each one points to

Read your symptoms against this list before touching the ladder.

• One press lands on the final stage. The transition condition stays true as each new stage is evaluated, so every stage's jump rung fires before the press clears.
• Rising and falling PD contacts behave the same. Edge polarity picks the scan the request appears in. The destination stage still finds a true condition, so the polarity change leaves the cascade in place.
• The stage number climbs while you hold the button and stops when you release. The panel bit is present for the whole press and is never consumed, so each pass advances one more stage.
• The stage number jumps several steps in the instant you press. The walk is running inside a single scan pass, and release timing has nothing to do with it.
• After you add a reset rung, presses are missed or advance two stages. The panel write and the ladder reset are landing in the same pass and fighting over the bit. Check write timing next.

Watch two values before you edit

Do the test with the machine unable to start anything, because a cascading sequence can switch outputs on within milliseconds. Then watch two values together in the controller's online view or the panel's data watch: the request bit and the stage number.

Press once and hold for a normal press. If the stage number climbs while your finger is down and stops when you lift it, the press is spanning many scans and no rung is consuming the request. If the stage number moves several steps in one instant, the walk is inside a single pass, and only a change of structure will stop it.

Also confirm who owns the bit. The panel writes it and the ladder resets it, and the two land at different points in the scan; the article on how HMI button writes meet the PLC input scan shows that timing. If your reset rung and the panel write overlap, you get the missed-press symptom above.

Change the button to a request the ladder resets

The fix separates the operator's press from the controller's decision.

1. Change the button action from momentary to its set on function. The press sets a request bit and leaves it set. Reserve that bit for this one command.
2. Delete the direct jump from the panel side. The panel requests an advance; the ladder performs it. This is the same handshake as making an HMI button turn on a PLC output through a command bit.
3. Add one acceptance rung: request bit on, and the sequence is in a stage that is allowed to advance. That rung jumps to the next stage and resets the request bit in the same rung, so the request is consumed in the scan that accepts it.
4. Let no other rung touch the request bit. The destination stage never sees it, because it is already reset when the pass reaches the new stage's logic.
5. Keep the request bit separate from the stage-active bits. One bit means the operator asked to advance; the stage bits say where the sequence is.

Check: press once and release. The stage number moves one step, the request bit returns to off, and nothing else moves until the next press. If the stage number still moves more than once, the request is reaching the next stage's logic in the same pass it was accepted, and the pointer below is the cure.

Give the sequence one owner with a pointer

Stop editing the per-stage jump rungs and move the sequence order into one place. Keep a current-stage register. When a request is accepted, compute the next stage in the defined order and write it once, and block a second write until the request has been reset and a new press sets it. The end of the sequence becomes explicit: hold at the last stage, wrap to the first, or enter a completion state, whichever the machine needs.

A pointer gives you three things the repeated rungs never will. The sequence order lives in one place, so adding or reordering stages is one edit. Each press maps to exactly one transition, by construction. And the stage number is ordinary data you can watch, log, or compare against limits. Many controllers also offer a sequencer or drum instruction that advances one step on an event trigger you configure; that instruction is the same idea built in.

Check: press your way through the whole sequence. The stage value increases by exactly 1 per press, and the last stage performs the end behavior you defined.

Worked example: a 200 ms press against a 5 ms scan

Inputs, and where each comes from:

• Press length: 200 ms, taken as the middle of the 100 to 300 ms a momentary press on a panel button commonly lasts. This is a human-timing figure, not a data sheet value.
• Scan time: 5 ms, taken as the middle of the 1 to 10 ms a small PLC typically needs per scan. Also a general figure; your controller's online view usually shows the real scan time.
• Sequence: the staged program on this page, one jump rung per stage.

The rule in words: scan passes during the press equals press length divided by scan time.

The arithmetic: 200 ms / 5 ms = 40 passes.

The result: with the original momentary-to-jump wiring, up to 40 stage transitions are available during one press. A sequence with up to 40 stages reaches its final stage while your finger is still down; a 10-stage sequence gets there in the first 10 passes. If the walk runs inside a single pass, it finishes in about 5 ms.

The decision: the fault is any advance count above one stage per press. With the set-on request consumed in its acceptance rung, the same 200 ms press still produces exactly one transition, because passes 2 through 40 find the request already reset. If your watch still shows the stage number moving more than once per press, the pass is re-using the request, and the pointer is the fix.

Which fix to build

Recommendation: Change the panel button to its set on action, wire the ladder to consume the request with one jump-and-reset rung, and keep that handshake whatever the stage count. Move to the one-step pointer when a single press still advances more than one stage after the reset, or when you expect to reorder stages, because the pointer keeps the order in one place and gives one transition per press by construction.

If you also want a notice or andon screen beside the machine, our shop-floor displays cover that side.

Questions