Move an HMI numeric entry decimal point from a PLC tag

Can a PLC tag move the decimal point on a numeric entry object?

Yes, on the documented pair, editor version 3.0 with panel firmware D.1, a numeric entry object lets you specify the position of the decimal point with a tag. A value your PLC program already holds, such as a recipe number, moves the point.

Some projects call the object a numeric button; the numeric entry object is the one that takes operator input, and the documented feature belongs to it. Once the position comes from a tag it behaves like any process value: the program writes it when the recipe or mode changes, and the object prints the point wherever the tag says. Two consequences follow. Check the installed pair before planning anything, because the feature lives in a version pair, and replacing the panel is the expensive route to a setting the existing pair may already have. The tag also belongs in the PLC program, where the recipe selection already lives, so the panel project needs no new logic of its own.

Which editor version and firmware expose the tag option?

Editor version 3.0 on the workstation and panel firmware D.1 on the panel, together. The editor revision history lists decimal point support among the version 3.0 additions, and the firmware download page for the panel says to upgrade to D.1 when you install that editor.

Both sides have to match, because the setting appears in the object's properties only when the pair is in place. Record the editor version from the editor's version screen on the workstation, and read the panel firmware from the panel's device information, before you plan the change. An editor at version 2.4 opens the same project file and shows the same objects, with the tag-controlled position missing from the settings, which is easy to read as a missing feature rather than a missing version. The vendor states the pairing in two places: the editor revision history, which lists decimal point among the version 3.0 additions, and the panel firmware download page, which instructs you to upgrade the firmware to D.1 when you install editor version 3.0.

What do you need before you start?

Four things: a workstation running editor version 3.0, the panel confirmed at firmware D.1, a saved copy of the current project on that workstation, and a PLC tag your program writes only when the required decimal position changes.

• Editor version 3.0 on the workstation. A 2.4 install moves up through the vendor's project migration, and the converted numeric objects get reviewed before you edit anything.
• The panel at firmware D.1, upgraded through the editor. Take the firmware upgrade at a maintenance stop, with the known-good project saved and the machine in a safe state.
• A PLC tag that changes only when the recipe or mode changes, with its data type matched to the value encoding the editor's help prints for the decimal position setting.
• Two known raw values for the bench test, one per position, such as 234 and 2345.

How do you bind the decimal position to the tag?

Open the numeric entry object's properties, enable the tag-controlled decimal position setting, bind it to the PLC tag, download the project, and confirm the panel accepts the download before you test anything.

1. Open the project in editor version 3.0. If it came up from 2.4, finish the migration and review the converted numeric objects first.
2. Upgrade the panel firmware to D.1 through the editor, machine stopped, project saved.
3. Open the numeric entry object's properties and enable the tag-controlled decimal position setting.
4. Bind that setting to the PLC tag, and match the tag's data type to the encoding the editor's help documents for the object.
5. Write the position value in the PLC program at recipe load, from the same variable that selects the recipe.
6. Download the project and confirm the panel accepts it without a compatibility error.

The release notes name the feature but not the encoding, so the number that selects one decimal place, two decimal places, and so on comes from the installed editor's object help. Prove every selectable value on the bench before the panel goes back on the machine. Keep the formatting in the panel project and the scaling in the PLC program apart; the next section shows what happens when they mix.

Why not scale the PLC value instead?

Scaling the PLC value changes the stored engineering number, so clamps, alarms, totals and trends all read a value ten times off; the tag-controlled decimal position moves the printed point in the panel and leaves the tag holding its true value.

A pair of numbers shows the damage. The tag holds 234 at a scaling of 0.1 mm per count, so the true value is 234 × 0.1 = 23.4 mm. Divide the tag by 10 in the PLC to fake a different point and every consumer changes with it: a low alarm set at 5.0 mm sees 2.34 and trips, a per-part totalizer adds 2.34 per part, and the trend logs a value ten times below the true reading. Why an HMI shows a value ten times too small covers that failure in full. The decimal position tag avoids the whole problem: 234 stays 234 in the PLC, and only the printed point moves, to 23.4. The same division of labor applies to raw and engineering units on an HMI trend: the program keeps raw counts, the panel prints engineering units, and neither does the other's job.

What does a worked example look like?

A test bench measures parts to 0.1 mm on one program and to 0.01 mm on the next: raw 234 at position 1 prints 23.4 mm, raw 2345 at position 2 prints 23.45 mm, and one PLC tag selects which on each program load.

Both programs write the position tag from the same recipe variable that selects the scaling, so the integer and the point move together. On a change from program A to program B, the PLC switches its stored resolution, writes 2 to the position tag, and the panel prints the next reading as 23.45. Run the check the other way and the mismatch exposes itself: raw 2345 printed at position 1 reads 234.5 mm, ten times the true value, which is the fastest bench indication that the position tag and the PLC scaling came from different sources. An operator typing an entry at position 2 keys 2, 3, 4, 5 into a field that shows two decimal places, and the release test below confirms the PLC receives 2345 back.

How do you prove it before releasing the panel?

Test every position the tag can select: read a known PLC value on the panel, key an entry through the same object, and confirm the PLC receives the raw integer your scaling expects, at each position.

• Read 234 from the program with the position tag at 1 and confirm the panel prints 23.4; read 2345 with the tag at 2 and confirm 23.45.
• Force a change of the position tag while the panel displays and watch the point move on the next update; a moving point confirms the binding points at the tag you wrote to.
• Key an entry through the object at each position and read the raw value back in the PLC. Operators type through this object, so a display-only pass leaves the write-back untested.
• Leave the ladder-side limits in place and confirm they still catch out-of-range entries; clamping HMI numeric entry limits in PLC ladder logic shows the pattern.

Recommendation: Check the editor version and the panel firmware before writing any PLC logic; configure the tag-controlled decimal position only on the editor version 3.0 with panel firmware D.1 pair; keep the PLC tag holding the unscaled integer; and release the panel only after an entry test writes back the expected raw value at every position the tag selects.

Why is the decimal point not following the tag?

Check four things in order: the firmware on the panel actually running the project, the tag bound in the object's properties, whether that PLC tag changes at all, and the editor version of the project you downloaded.

1. Firmware on the running panel. Read it again from the panel's device information; a spare panel can be the one actually serving the line while the unit you checked sits on the bench at D.1.
2. The binding in the object. Reopen the numeric entry object's properties and confirm the decimal position setting carries the tag name your program writes; a copied object can still carry the tag of the object it was copied from.
3. The tag itself. Force a value change from the PLC program and watch the object; a tag given a value at commissioning and untouched since cannot move the point.
4. The editor that produced the download. Confirm the workstation copy is version 3.0 and that the project on the panel came from it.

If the panel belongs to a different family, the same four checks apply with that maker's revision history in place of the versions above: numeric object release notes state the editor and firmware pair that added tag-controlled formatting, and the panel in front of you has to match it. If a check fails on a line that has to run, restore the known-good project and finish the pair on the bench first.

Questions