A tag that snaps back after a panel write has two writers. Write a spare Boolean the ladder never touches and watch it online: if that write sticks, the panel path is fine and the fight is over who owns the production tag. Time how long the value holds, find the rungs that write it, and decide: ladder owns it, panel owns it, or another client does.
You write a setpoint from the panel, watch the number change, and a moment later it is back where it was. That is two writers sharing one tag, and the other writer went last. The quickest way to split the suspects is one test: write a spare Boolean the ladder never touches and watch the controller online. If that write sticks, the panel-to-controller path is good and your job moves from the panel's tag configuration to the ladder's references. This page gives the test, the symptoms and what each points to, one worked example that times the revert, and the ownership decision that ends the fight for the tag.
What each symptom points to
Reverts come in three shapes, and each shape names its writer. Match yours before you change anything.
- The value never moves at all. Either the write never lands (a wrong tag address, a display-only object, the wrong connection) or it lands and is erased inside one scan by an every-scan write. The spare-Boolean test below tells you which.
- The value holds for a while, then snaps back. A timed or conditional write in the ladder, or a second client such as another panel or a web client writing the same address. Controller makers document that simultaneous write access from the panel and the control program can overwrite data on the controller side.
- The value holds until the panel next boots. The panel's startup write: a linked tag comes up at its initialized value, commonly zero, and pushes it into the controller.
- Some tags take a write and others never do. The connection and driver are shared, so the difference sits in each tag's ladder references or in the object itself.
Time the hold before you open the ladder. The length is a fingerprint, and the worked example below reads it.
Test the write path with a spare Boolean
This test answers one question: does a write from the panel reach the controller at all?
- Find a Boolean the ladder never references. Your programming software's cross-reference or find-all-uses search lists every rung that reads or writes a tag; pick one with no entries in the program.
- Pick a tag that drives nothing, because a write to a live output, interlock or motion tag can move a running machine.
- Add a temporary write object on a test screen in the panel, using the same controller connection and the same tag-picking method as the failing control.
- Go online with the controller and watch that Boolean.
- Write it on and watch for 2 s, then write it off and watch it clear.
The spare tag changes and stays: the path is good, so go to the ladder sections below. The spare tag never changes: the path is the fault, and HMI reads the PLC but cannot write: how to prove why walks it fault by fault, from connection to tag address to object type.
Repeat the failing write while you watch the tag
Keep the controller online with the production tag on screen and press the real control on the panel. Record which of the three shapes appears: nothing, a brief hold then a snap-back, or a change that sticks. If the tag arrived in the panel through a tag import and has behaved dead from the start, an imported HMI tag that ignores PLC register writes covers the import-side causes first.
Then open the cross-reference for the production tag and list every rung that writes it: coils, moves, assignments. Next to each one, note what triggers it: every scan, a timer, a one-shot, a fault or a mode change. That list is the shortlist of writers.
Worked example: a speed setpoint that snaps back between scans
Inputs. The tag is a speed setpoint written from the panel, and the operator's write lands at t = 0. The controller's online diagnostics report a 10 ms scan time, a common figure for a small machine program: one pass over a few hundred rungs is single-digit milliseconds on a small controller, and your own diagnostics print the exact number before you judge your case. The cross-reference shows two candidate writers: an unconditional move that copies a master value into the setpoint every scan, and, in a second version of the program, the same move gated to a 1 s timer pulse.
Rule. A tag holds the last value written to it. Panel writes land between scans, so the next ladder instruction that writes the tag wins.
Arithmetic. Unconditional move: the panel's value survives until the move next runs, at most one scan, so it lasts 10 ms or less, and no panel display refresh is quick enough to show it. Timed move: the value survives until the next timer pulse, 0 to 1 s, plus at most one scan, so the worst case is 1 s + 10 ms = 1.01 s.
Result. In the first program the write looks dead. In the second the new value visibly holds for about a second, then reverts.
Decision. Measure the hold against the panel, or watch the tag online: no visible hold at all points to an every-scan writer; a hold that matches a timer period, here about 1 s and never more than 1.01 s, points to that timed write; a hold that ends when the panel boots points to the panel's startup write. Match the fingerprint to a rung on your shortlist, and you have the writer.
Decide who owns the tag
A write path that works plus a shortlist of writers leaves one decision: who owns the value. Three patterns cover nearly every floor fight.
The ladder owns the working value. The panel delivers an entry, it does not hold the value. Point the panel object at a separate entry tag, and add one rung that reads the entry on demand, clamps it to the allowed range and writes the working tag. The entry is consumed once, the working tag has one writer, and the revert disappears. Clamp HMI numeric entry limits in PLC ladder logic shows the clamp rung, and enforce HMI increment and decrement value limits in PLC logic handles plus and minus buttons the same way.
The panel owns the value between entries. The ladder writes the tag once, at initialization. Gate the copy with a first-scan-only condition, which most ladder environments provide, so it runs for one scan and never again. The operator's value then survives until someone changes it on purpose.
Another client owns part of the time. A second panel or a web client writing the same address produces the same snap-back. Give each client its own tag and let the ladder arbitrate between them, or agree on write windows so two writers never overlap.
Whichever pattern you pick, watch the production tag online through several normal machine cycles, then run the real production control under its approved conditions. Delete the temporary test object or move it to a clearly marked test screen before operators see it.
Recommendation: Run the spare-Boolean test before anything else, with the same connection and the same tag-picking method as the failing control. If the spare sticks, leave the panel's configuration alone and settle ownership in the ladder: entry tag with a clamp rung when the ladder owns the working value, first-scan initialization when the panel owns it. If the spare does not stick, fix the write path first; the ladder can wait.
When you also want a status screen on the floor
A fight over tag ownership is controller work, and no display swap fixes it. If the floor also needs a screen that only shows status, andon state or notices, that is a separate job: our shop-floor screens and andon-style boards are built for offline playback or your own Android app, they take no video input, and they are not a replacement for the panel or the controller in this article.
Questions
How do I find my controller's scan time?
Connect online with your programming software and open its diagnostics or controller status page: most show the current and maximum scan or cycle time while the controller runs. A small machine program commonly scans in single-digit milliseconds. Use your real figure in the timing test, because the revert fingerprint scales with it: an unconditional write erases a panel write within one scan, whatever that scan length is.
Does the panel need reconfiguring after the fix?
Usually no. The spare-Boolean result tells you: if the spare write stuck, the panel's connection, driver and tag map all work, and the change happens in the ladder or in which tag the operator's object targets. Only a failed spare test, a startup-write problem or a wrong tag address calls for work in the panel project. Keep the panel project file unchanged until the test says otherwise.
Why does the value revert right after the panel powers up?
A linked panel tag starts at its own initialized value, commonly zero, and pushes it into the controller during panel startup. Fix it in the panel project: initialize that tag to the value the controller holds in normal operation, or remove the automatic startup write and have the operator enter the value deliberately. The ladder is rarely involved in this version of the revert.
Planning information, not legal or engineering advice. Rules differ by place: check codes and permits with your local authority and your licensed trades.