IMDTouchKnowledge BaseShop main store

Troubleshooting

Why an HMI Edit Box Shows a Value That Was Never Set

HMI and touchscreens Published 7 min read

Short answer

The number in an inline edit box is a draft, not a plant value: until the submission event runs, nothing has been written to the controller. Compare the box text with the controller readback to prove it, then move value entry into modal popups with explicit save and cancel paths and keep every overview display bound to readback.

On this page
  1. Draft, requested value and active setpoint are different numbers
  2. Why a typed draft on an overview reads as a fault
  3. Test whether the write ever happened
  4. Reading a 200 °C draft against a 500 °C active setpoint
  5. Move value entry into a modal popup
  6. The decision for each mismatch case
  7. Questions asked

The number in an inline edit box is a draft, not a plant value. Until the component's submission event runs — focus leaving the field, or a separate Set button — nothing has reached the controller, and the screen presents your typing as if it were the operating state. That is why an overview with a typed 200 °C against a process holding 500 °C looks like a runaway to the next person who walks up. This article separates the values involved, gives a test that proves whether the write happened, and ends with the rebuild rule: bind every real-time display to the controller readback, and do value entry only in a modal popup with explicit save and cancel paths, or on a configuration page that shows no live values.

Draft, requested value and active setpoint are different numbers #

An edit box holds text under the operator's control, and a live display shows whatever its binding last received. Read any disputed screen as four separate quantities:

  • Draft — the text sitting in the box. It exists only on the panel until the submission event runs.
  • Requested value — what the last completed write sent to the controller.
  • Active setpoint — what the controller is using right now, read back from its setpoint register. Controller logic, a mode change or another station can move it after your write.
  • Process measurement — the temperature, pressure or position the loop is actually producing. It lags the setpoint and proves nothing about the write.

A gap between the draft and the active setpoint is normal wherever an inline edit box sits on a live screen, and by itself it is not a controller fault: the box has no mechanism tying its text to the register.

Why a typed draft on an overview reads as a fault #

The overview screen is the one everyone trusts, which is exactly why a draft there is dangerous. An operator types a lower boiler setpoint into the box on the overview and gets pulled away before leaving the field or pressing Set. A second operator walks up, sees 200 °C in the box against a process holding 500 °C, reads the disagreement as a control failure and trips the machine. The write never happened; the shutdown did.

ANSI/ISA-101.01-2015, the high-performance HMI standard for process automation, builds its requirements around situation awareness: an operating display must present the true state of the process so that any viewer, trained or not, reads the plant correctly. A typed-but-unwritten draft fails that test because it shows an intention, not a state. Desktop software gets away with inline edit boxes because nothing on its screens refreshes; an HMI redraws live values continuously, so the stale draft sits beside live numbers and invites exactly the comparison that caused the trip.

Treat this as the safety note for the whole practice: a number that can mean two things on an operating screen is itself a hazard, so make an unfinished entry visible as an open transaction — a popup sitting on screen — instead of text the next viewer must interpret.

Test whether the write ever happened #

Work down this list before touching the running process:

  1. Open the entry component's configuration and find the submission event. There are only two arrangements: the box writes when focus leaves the field, or a separate Set or Submit button performs the write. Both can park a draft on the screen indefinitely — leaving the field is the trigger nobody completes when they walk away, and a button is the trigger that clicking elsewhere never presses.
  2. In a test environment, or with a change approved for the running process, type a test value and leave focus in the field. Read the setpoint back from the controller and record the number.
  3. Run the submission event, then read the setpoint again.
  4. If the readback did not move, check the write target first: the action must address the controller's setpoint register, not a display-only variable or an unrelated tag. Then check the communication diagnostics for a failed write or stale data, and finally the controller side for a mode or interlock that rejects or overwrites the request.
  5. Apply the scaling, units and precision the application is configured for before you call the readback wrong.

Closing a dialog proves the workflow ended, not that the write landed. A button that changes color after a click proves the click, not the write — and it assumes every viewer knows the color code.

Reading a 200 °C draft against a 500 °C active setpoint #

All three readings come from the same disputed overview screen: the edit box holds 200 °C, typed by an operator whose submission event never ran; the setpoint register read back from the controller holds 500 °C; the process measurement on the same screen reads 500 °C.

Compare the draft against the readback, never against the process value. Two gaps decide everything, and the threshold for both is zero: any nonzero draft gap means the entry was never written, and a zero process gap means the controller and the process agree.

  • Draft gap: 200 °C - 500 °C = -300 °C
  • Process gap: 500 °C - 500 °C = 0 °C

The -300 °C draft gap means the controller has never seen 200 °C: no write occurred, and the box is showing a draft. The 0 °C process gap means the process sits exactly at the active setpoint, so the loop, the actuator and the communication path are all healthy. The only fault on this screen is presentational.

Cancel or clear the draft first, then rebuild: overview numbers bound to the readback, entry moved into a modal popup. In the rebuilt screen the threshold stays zero and becomes visible — popup open means the value is not set; popup dismissed with the readback moved means it is. Had the readback instead moved to 200 °C while the process held 500 °C, the screen would be innocent and the investigation would move to the loop and the actuator.

Move value entry into a modal popup #

Rebuild value entry around an explicit transaction:

  • Single value. Attach the entry popup action — the numeric entry dialog that HMI packages let you put on a value display, a button or a caption — to a read-only value display bound to the readback. Touching the number opens the dialog, and the overview never holds editable text.
  • Several values, or extra explanation. Build a custom popup and open it modally, so it must be dismissed before the rest of the application responds. The open window is the feedback: popup visible means the value is not set. Modality matters because it blocks every background control until the operator finishes; the write-up of modal popups that block background input in Ignition Perspective shows how strictly a platform enforces that.
  • Keep the overview visible during entry. A popup that sits alongside the base screen preserves the readback context; the setup for non-replacing modal popups in RSView 32 documents that arrangement.
  • Color coding supports this and never replaces it. Distinguish measured values from setpoints by color — black for readings, blue for setpoints is a common plant convention — so a viewer tells entry from measurement at a glance, but color cannot tell a draft from a written setpoint.
  • Configuration pages. A settings page may use inline edit boxes only if it shows no real-time values and the operator must finish with Save or Cancel to return to supervision. With nothing live on the page, no number there can be mistaken for plant state.

These are the same situation-awareness rules behind designing HMI screens for clear operator decisions, so fold the change into any wider screen cleanup rather than treating it as a separate job.

The decision for each mismatch case #

  • Box text differs from the controller readback. The entry was never written. Cancel the draft, then rebuild: read-only overview displays bound to the readback, entry in a modal popup.
  • Readback matches the request but the process does not respond. The screen and the write path are proven; take the investigation to the loop — actuator, output signal, controller logic and mode.
  • Readback does not match the request after the submission event ran. Write-path fault. Check the binding address first, then communication diagnostics, then controller-side rejection, and keep the pending change visible until it is fixed.
  • Readback moved but the box still shows the old number. The box is holding its own stale text — a local buffer that does not refresh when the underlying value changes. That behavior alone is reason to remove inline boxes from live screens.

The threshold running through every case is zero: a display that can disagree with the readback by even one unit of measure is presenting a draft. Bind every live number to the readback and no draft can ever appear on the overview.

Questions asked

Does a modal popup freeze the process while it is open?

No. Modality blocks interaction with the rest of that application only. The controller keeps running, and another station, a remote client or controller logic can still change values while the popup waits. Treat the open popup as confirmation that your own entry is unresolved, not as a lock on the plant, and use the readback on the underlying screen as the true state.

How can I prove a write happened without disturbing the running process?

Use the event history. When event logging is enabled on the HMI or the controller, setpoint writes are recorded with a timestamp, so look for your submission in the HMI event log or the controller change log. No entry at your submission time means the value was never sent; an entry followed by an unchanged readback points at the write path rather than the screen.

Why does my edit box still show the old number after the value changed?

Because the box keeps its own text contents. The on-screen text is a local buffer the component manages, and it does not refresh from the channel just because the underlying value moved. Clearing the box from a script removes the stale text, but the field still accepts edits that may never be written, so the draft problem returns the next time someone types and walks away.

Should the entry popup write on OK, or live while the operator types?

On confirmation. The write belongs to the explicit save action, not to each keystroke: Save or OK sends the value once, and Cancel discards the draft and changes nothing. A field that writes as you type turns every digit into a plant command, which is the same missing-feedback problem an inline edit box has, only faster.

Keep reading

  • Troubleshooting

    Fixing Goto Display Buttons Locked by HMI Global Connections

    While the Global Connections remote display number is active — its DINT tag still holding 21 — FactoryTalk View ME disables every other form of navigation, so Goto Display buttons stay dead whether or not the popup is visible. Write 21 with a one-shot on bit A and let a startup macro on display 21 reset the tag to 0; the popup stays up and the buttons respond.

    HMI and touchscreens

  • How-to

    How to Enter Configuration Mode on a Touch HMI

    On a touch-only operator terminal you enter Configuration Mode by cycling power and pressing the small filled box that appears briefly in the lower-right corner during startup, while hold-both-arrow-keys instructions apply to keypad terminals with physical keys. An application button labeled GoTo Config. Screen reaches the same menu without a reboot.

    HMI and touchscreens

  • Explainer

    Designing HMI Screens for Clear Operator Decisions

    High performance HMI design under ANSI/ISA-101.01-2015 makes abnormal conditions easier to spot than normal operation: normal running renders flat and gray, saturated color appears only on deviations, and every icon, font and color follows one documented project style. Verify the style mechanism on a single screen before scaling to the full library.

    HMI and touchscreens