An HMI numeric field that shows junk characters only when the value returns to zero is rendering a tiny floating-point residual in exponent notation. Suppress exponent notation in the panel's Panel Manager setup, download the project again, and repeat the count. The fix needs no new PLC logic.
An HMI numeric field that fills with junk characters only when the value returns to zero is not broken hardware and is not showing hexadecimal. It is printing a tiny floating-point residual, a value near 0.0000000075, through exponent notation. The exponential string does not fit the decimal format the field was built for, so characters like 189EGO3456 reach the screen. The fix is one checkbox: suppress exponent notation for floating-point data in the panel setup, download the project to the panel again, and repeat the count that produced the junk. No ladder logic needs rewriting and no increment button needs replacing. Below are the symptoms, the one-pass check that confirms the cause, the fix, and a worked example that puts a number on the residual.
What the junk characters are
The field in this fault is configured as a 32-bit floating-point Real, the single-precision format defined by IEEE 754, the binary floating-point standard. A 32-bit float carries a 24-bit significand, about 7 significant decimal digits. Decimal fractions such as 0.1 are stored as the nearest representable value: close, but not exact, the same way 1/3 has no exact decimal form. A count-down that should land exactly on zero can land a hair off it.
Panels draw such small magnitudes in exponent notation, the scientific form with a mantissa, an E and an exponent, such as 7.45E-09. Fed into a numeric field configured for a fixed decimal value, that string arrives as characters that look unrelated to the number. The characters change every run because the residual's exact low digits depend on the path the arithmetic took.
Junk near zero is a different fault from junk everywhere. Large positive values where small ones belong point to a data-format mismatch, which HMI shows large positive numbers: set the signed decimal data format covers.
Why counting back to zero leaves a residue
Two behaviors stack up. First, binary floating point rounds every arithmetic result to the nearest representable 32-bit value. Each 0.100 step is stored with a tiny positive offset, so three steps up do not cancel three steps down bit for bit. The worked example below puts numbers on the offsets.
Second, a forced value and a computed value are not the same number. Writing 0.0 into the register from the PLC software puts exact zero there, and the field prints 0.000 as expected. Counting back to zero through the increment buttons leaves the stored remainder of the arithmetic path. A forced zero that displays correctly while a counted zero shows junk is the strongest single clue in this fault: the tag and the field are fine up to the final rounding.
Away from zero everything reads normally, because exponent notation takes over only for very small or very large magnitudes. The junk is a near-zero signature.
Symptoms and what each one points to
| Symptom | What it points to | Next check |
|---|---|---|
| Junk characters only as the value nears zero, in both count directions; every other value reads normally | A tiny floating-point residual drawn in exponent notation | Read the Real register at the moment the junk appears |
| A forced 0.0 displays correctly, the counted zero does not | Exact zero written directly against a residual left by arithmetic | Repeat the count while watching the register in the PLC software |
| Junk across the whole range, or a value that never matches the PLC | Tag address, data type or field-format mismatch | Compare the panel tag, its data type and its width against the PLC register |
Read the register before you change anything
Put the PLC software online and watch the Real register while you repeat the count that produced the junk, down to zero from a positive start and up to zero from a negative start. Two outcomes decide the repair:
- The register sits just off zero, at a magnitude like 0.0000000075, when the field turns to junk. The representation is the cause, and the exponent option is the fix.
- The register reads exactly 0.000 and the field still shows junk. A format option will not repair that. Check the tag address, the data type and the field's decimal setup; show decimal flow values on an HMI numeric display covers how a numeric field's decimals and scaling map a register into digits.
Turn off exponent notation and download again
- Open the HMI project in the panel configuration software.
- Go to the Function tab, open Setup, then Panel Manager. This is the project-level setup window, so the option is set here once, not inside the numeric display object.
- Check Disable Exponent Notation. The panel software's help file documents the option as suppressing scientific notation when floating-point data is displayed. If your copy does not show it, search the help file shipped with your panel software for the option name.
- Download the revised project to the panel. If the download crawls, fix an HMI panel project download that takes 2 minutes lists the network-side causes worth checking.
- Repeat the exact count sequence that produced the junk: down to zero from a positive start, then up to zero from a negative start.
- Confirm the field prints 0.00, or zero to the decimals the field shows, at the end of both directions, and that ordinary values still read normally.
The option changes how the panel draws floating-point numbers. It changes nothing in the PLC, and the register keeps whatever the count left there.
Example: a 0.100-per-step count-down to zero in 32-bit floating point
Inputs:
- Step size 0.100 per press, in the sequence 0.000, 0.100, 0.200, 0.300, then back down. This is the count the traverse operator runs; the unit is the machine's traverse unit and the arithmetic does not depend on it.
- Field format 32-bit floating point, read from the numeric display's data-format setting.
- Stored constants from IEEE 754 single precision: the nearest 32-bit value to 0.1 is 0.100000001490116, an offset of +1.49E-9, and the nearest to 0.3 is 0.300000011920929, an offset of +1.19E-8.
Rule: subtracting the stored 0.1 from the stored 0.3 three times leaves the difference between the rounded constants. Each subtraction here lands on a representable 32-bit value, so no extra rounding disturbs the count.
0.300000011920929 - 0.100000001490116 = 0.200000010430813
0.200000010430813 - 0.100000001490116 = 0.100000008940697
0.100000008940697 - 0.100000001490116 = 0.000000007450581
Result: the register ends at 0.000000007450581, a residual of 7.45E-9. Counting the mirror direction, up from a stored -0.300000011920929 in 0.100 steps, leaves -0.000000007450581, which is why both directions showed the same junk. In exponent notation the value prints as 7.45E-09, a string of digits, a sign and an E that a field sized for 0.00 has no way to show as a plain decimal. The junk pattern reaches the screen and changes run to run with the low digits of the path.
Decision: the residual 7.45E-9 sits far below half of the field's last printed digit, 0.005 at two decimals. Suppressing exponent notation therefore displays 0.00, and one checkbox plus a re-download clears the fault. Had the register read exactly 0.000 at the junk moment, the checkbox would change nothing and the repair would move to the tag address, the data type and the field format.
Verify both directions after the fix
Record the Real while you approach zero from the positive side and again from the negative side. The field should follow the signed sequence, 0.100, 0.200, 0.300 counting down and the mirror image counting up. It should print 0.00 at zero in both directions with no changing characters. Enter or force a test zero once to confirm exact zero still displays, then remove the force the way your site's practice requires.
One safety check belongs here: the panel now draws zero while the register may still hold a residual. A traverse that seats on this value should still be returned to its true zero position by the machine's own procedure before the run continues.
The decision
Recommendation: When a floating-point field turns to junk only at values near zero after count-up or count-down arithmetic, check Disable Exponent Notation under Function, Setup, Panel Manager and download the project again before touching any ladder logic. Confirm first that the register sits just off zero at the moment of the junk. If it reads exactly 0.000, leave the checkbox alone and check the tag address, the data type and the field width.
Questions
Why do the junk characters change every time the value returns to zero?
The residual left at the end of a count depends on the path the arithmetic took: how many steps, which direction, and whether anything was forced along the way. Each path rounds the 32-bit results differently, so the low-order digits of the residual differ run to run. Those low digits are what the exponent string prints, which is why the characters on the field change each time and never read as a stable number.
Does turning off exponent notation change the value the PLC uses?
No. The option changes how the panel presents floating-point data on the screen. The Real register keeps whatever the count left there, residual included. If the traverse or the process needs an exact zero in the logic, that rule belongs in the control program as a tolerance or a zeroing step sized for the machine, and it should be checked in both directions of adjustment.
Can the exponent-style junk appear at values other than zero?
Yes. Exponent notation exists for magnitudes too large or too small to print comfortably as decimals, so a huge or tiny floating-point value can produce the same unreadable field. The near-zero case is the one operators meet most, because counts, positions and tare values are meant to end at exactly zero. The Disable Exponent Notation option is set once in Panel Manager, so it covers every floating-point field in the project at the same time.
Planning information, not legal or engineering advice. Rules differ by place: check codes and permits with your local authority and your licensed trades.