Fix an HMI numeric entry that resets to 0 after entry

What the symptom points to

Three observations together isolate this fault from everything else on the same screen:

• The keypad closes and no error appears. The entry object accepted the input and completed its write. The error check validates the transfer; it is not proof that the register holds the number you typed.
• The process responds but overshoots or runs away. The ladder decoded a number different from the one you entered, so the write landed in the wrong representation and the control loop is acting on it.
• The display returns to 0. The object's readback runs the register through its own configured type. A 16-bit integer word read as the high half of a 32-bit floating-point value decodes to about 1.4e-38, which displays as 0.0.
• Nothing changes anywhere, screen or process. Suspect the address or the communications path; HMI numeric display shows nothing: check the tag address first covers that fault.

An entry that gets refused or clamped at a limit is a different fault with different logic: the register receives a value your ladder logic has forced to a minimum or maximum, and the live monitor will show that clamped value holding steady where your entry should be.

Watch the register while you enter

The test that separates the causes takes one safe entry and one live monitor.

1. Open the ladder and find the exact word every rung that acts on the setpoint reads. Watch that word in the PLC programming software, set to raw or hexadecimal display.
2. Choose a test value the process tolerates. For a temperature loop, 150 °F works well: it fits a 16-bit signed integer (-32,768 to +32,767), a 16-bit unsigned integer (0 to 65,535), 16-bit BCD (0 to 9999) and a 32-bit float, so the stored pattern identifies the representation. If the setpoint drives heat, motion or pressure, put the loop in manual or stop the machine before you enter anything.
3. Enter 150 on the keypad and watch the word across at least three scans. Most PLC scans complete in under 10 ms, so a few seconds of watching covers many scan cycles.
4. Compare three numbers: what you typed, what the word holds, what the screen shows.

The outcomes split cleanly:

• The word holds 0x0096 (150) and the screen shows 0. The write is correct; a display object's type or format is decoding it wrongly. Fix the object.
• The word holds something else. The entry object wrote in the wrong representation and the ladder is decoding that pattern. The table below identifies which.
• The word never changes. The write went nowhere. Check the address and the path before anything else.
• The word takes 150 and then changes within a scan or two. A rung owns the register and overwrites your entry. Search the ladder for every instruction that writes to that word.

What the word pattern tells you

With 150 as the test value, each representation leaves a different fingerprint:

Sign mismatches leave their own fingerprint. Enter -10 into a signed register and the word reads 0xFFF6, which an unsigned ladder reads as 65,526; a freezer that never shuts off with a target of 65,526 is that fault exactly. A BCD read of a binary word produces the same class of wrong number in the other direction, which HMI panel shows nonsense numbers from a PLC BCD analog register covers.

Example: the display shows 0 while the setpoint works

A dryer holds part temperature at an operator setpoint stored in one 16-bit signed data word. The numeric entry object is configured as a 16-bit signed integer and matches the ladder. Above it sits a numeric display object copied from another screen, still configured as a 32-bit floating-point.

The operator enters 150 for a 150 °F target. The entry object writes 150 = 0x0096 into the word. The live monitor shows 0x0096 and the ladder holds the heater at 150 °F; the process is correct.

The display object reads the setpoint word as the first half of a 32-bit float and the unused word beside it as the second half: 0x00960000. The exponent field holds 1, so the value scales by 2^-126; the mantissa adds a factor of 1.171875; the product is about 1.4e-38, and the field shows 0.0. The screen says 0 while the machine holds exactly the setpoint you entered.

Set the display object's type to 16-bit signed and it reads 0x0096 as 150. Nothing in the ladder changes. The same arithmetic runs the overshoot case in reverse: an entry object left as a 32-bit float writes 150.0 as 0x43160000, the setpoint word receives the high word 0x4316, and the ladder compares against 17,174 °F, a target the heater never reaches.

Make the types match

Find the register's real representation from the ladder instructions that touch it, not from the engineering unit on the screen face. A BCD-to-binary conversion instruction on the word marks it as BCD. A compare against a negative constant marks it as a signed 16-bit integer. A rung that multiplies by 10 before the compare stores tenths as an integer, and the object then needs its decimal-places setting at 1.

Set every object that touches the word, entry and display alike, to that type; Change an HMI tag data type without rebuilding every object covers the change itself. Apply or download the HMI project the way your workflow requires, repeat the watched entry, and check that the monitor and the screen agree across several scans. If the word is right but the engineering value is off by a factor of ten, the type is correct and the decimal or scaling setting is not; Why the scale value differs from the PLC analog input walks that case. Do not add arithmetic in the ladder to make a mistyped word look right on screen; it hides the mismatch and the next person to open the project inherits it.

Recommendation: For any numeric entry that closes its keypad without an error, takes effect on the process, and then shows 0, put the live monitor on the register first and enter one safe test value such as 150 °F. Match the entry and display objects' data types to the representation the monitor reveals, retest the watched entry, and edit ladder logic only when the monitor shows a rung overwriting the register.

Questions