HMI recipe entry rejects fractional digits: fix the scale

Why the value field refuses the decimal point

Analog input modules hand the PLC integers. Most convert the measured signal into a raw 16-bit count over a fixed full-scale range, and conventions such as 0 to 4000 or 0 to 8000 counts at full scale are common analog-input practice. Your scaling logic turns counts into engineering units. On a tenths scale, a reading of 78.8 °F lives in the register as the integer 788.

The decimal only exists on the screen. Display objects are configured to place it: one platform documents the property for integer tags as 'Shift decimal places' on the I/O field, and other packages set the decimal places shown at run time in the display object itself; one knowledge-base page on numeric display scale configuration for decimals walks through that setup. The PLC never sees a number with a point in it.

A recipe value field stores the number that downloads to the register, so it takes whole numbers on the same scale. In at least one major recipe editor this is documented behavior: the min and max fields accept a decimal point while the value field does not. Where a raw count becomes a reading, and why a scale value can disagree with the analog input, is covered in why the scale value differs from the PLC analog input.

Symptoms and what each points to

• Raw data view shows 788, the numeric display shows 78.8. The register holds tenths and the display shifts one place. This pairing is correct; nothing here is broken yet.
• You enter 200 in the recipe and the setpoint shows 20.0. 200 tenths is 20.0 °F. The value went out ten times low because whole degrees were typed into a tenths chain.
• Only 2000 looks right on entry. The keypad was never broken. 2000 tenths is 200.0 °F, and with an integer-only value field, 2000 is the correct entry.
• The meter endpoints are 150 to 500 and the needle pegs, while the numeric display reads 78.8. The source holds tenths (788) and the span is in whole degrees. The same span on tenths needs endpoints of 1500 and 5000.
• The temperature reaches the displayed setpoint and the output never switches. The comparison is seeing two different scales or two different encodings, BCD against binary.

Five values to record before you change anything

Write these down together, because each one carries a scale and an encoding:

1. The raw PLC value and its encoding. 788 in a BCD data view is a different word from 788 in binary: read as a plain 16-bit binary number, the BCD word is 1928, and dividing it by 10 gives 192 where the true reading is 78. Convert BCD to binary before any arithmetic; what goes wrong when PLC BCD conversion loses digits in division covers that failure in detail.
2. The decimal place setting on the numeric display.
3. The meter's source address, displayed format, and both endpoints.
4. The recipe value exactly as stored for one product.
5. Both operands at the PLC comparison instruction.

Compare lines 1 and 2. A raw 788 against a displayed 78.8 means one shifted decimal place and a tenths scale, and the rest of the chain has to match them.

Fix: run the whole chain on one scale

Pick one scale and apply it at all five points. Both paths work; mixing them is what breaks the output.

Path A: keep tenths. The register stays on the 788-style scale, the display shifts one place, the recipe value for a 200.0 °F setpoint is 2000, the meter endpoints for 150.0 to 500.0 °F are 1500 and 5000, and the PLC compares the converted raw value against 2000. Apply exactly one conversion. A tag that already holds tenths, scaled by 10:1 and then formatted with one decimal place, is a documented case of the decimal portion vanishing: one display shift, no second scale. Recipe numbers that arrive as floats and must land in 16-bit integer registers get their own treatment in passing whole numbers from an HMI recipe float to 16-bit integers.

Path B: whole degrees. Convert BCD to binary, then divide by 10 once in the PLC. Integer division discards the remainder: 788 becomes 78, so 78.8 displays as 78, the recipe stores 200, and the meter endpoints are 150 and 500. The divide-once-then-compare pattern for analog temperatures is laid out in a guide to dividing, scaling and comparing an analog temperature. The cost is resolution: setpoints land on whole degrees, so a 200.5 °F target cannot be hit exactly. Setting 200 trips at 200.0 °F, half a degree early; setting 201 trips at 201.0 °F, half a degree late. Check whether your processor's integer division truncates or rounds, because rounding moves the trip point by up to 0.5 °F.

Keep both operands of the comparison in the same encoding. A BCD raw value compared straight against a binary 2000 trips near 80.0 °F: the word for 80.0, BCD 800, already reads 2048 as binary and passes the test.

Worked example: a 200.0 °F setpoint on a tenths source

The input card is scaled so the register holds tenths of °F. The converted raw value right now is 788, the screen shows 78.8 °F, and the product needs the output to switch on at 200.0 °F with a meter span of 150.0 to 500.0 °F.

Path A, step by step:

1. Convert the BCD word to binary: 788.
2. Recipe value field for the product: 2000. The editor shows the plain integer; that is expected.
3. Numeric display: shift one decimal place, so 2000 reads 200.0 and 788 reads 78.8.
4. Meter endpoints: 1500 and 5000, displayed as 150.0 and 500.0.
5. PLC comparison: binary raw value >= 2000 switches the output. With 0.1 °F register resolution, the switch lands on the 2000 count, at 200.0 °F.

Path B, same plant:

1. BCD to binary: 788. Divide by 10: 78, remainder discarded.
2. Recipe value: 200.
3. Numeric display: 0 decimal places, so 788 tenths reads 78 and the 0.8 is gone.
4. Meter endpoints: 150 and 500.
5. Comparison: converted value >= 200. The count crosses at raw 2000, so the trip still lands at 200.0 °F, but the 200.5 °F target stays out of reach: 200 trips at 200.0 °F and 201 at 201.0 °F.

Decision for this case: if the product tolerance is tighter than half a degree, or the operator needs to command 200.5, run Path A. If whole degrees are enough, Path B is simpler everywhere downstream.

When the operator must type a decimal point

If the process needs decimal setpoints and the recipe keypad cannot enter them, stop using the recipe sheet for that number. Numeric entry objects can write to staging registers instead: the operator enters the value on a tenths-scaled entry object, the PLC validates the range and the format, and a PLC-initiated transfer moves the validated value into the active setpoint register on a trigger. In multi-product setups that transfer needs pointer logic for the source and destination ranges, which is real ladder work, not a change to one screen object.

Validate the staged number before it becomes active. Validating high and low HMI setpoints before they reach the PLC keeps a low value from crossing a high one, and clamping HMI numeric entry limits in PLC ladder logic holds an out-of-range entry inside the meter's 1500 to 5000 span. Test the staging and transfer logic with the output disabled before it drives a production machine.

Load the recipe and watch the comparison

After the change, watch the PLC, not just the screen. Monitor both operands at the comparison instruction while a product loads: the active setpoint register must show 2000 on a tenths chain at the moment the screen displays 200.0. Then walk the boundaries: enter the 1500 and 5000 recipe values and watch the meter endpoints, and let the temperature or a simulator cross 2000 while you watch the output bit.

The screen alone cannot confirm that the correct integer reached the comparison, so record the raw value, converted value, recipe entry, active setpoint, and meter reading for one operating condition and keep the sheet with the program. If a value arrives on the wrong scale after a later edit, the sheet shows which of the five points moved.

The decision

Recommendation: keep the tenths scale end to end whenever the trip point matters to the product or the operator needs a decimal: recipe value 2000 for a 200.0 °F setpoint, one shifted decimal place on the display objects, meter endpoints 1500 and 5000, and a binary comparison against 2000 in the PLC. Use the divide-by-10 route only when whole degrees are enough, and set the value knowing the trip lands on a whole degree. When the recipe keypad cannot express the number the process needs, stage the entry in registers, validate and convert it in the PLC, and copy it to the active setpoint on a PLC trigger.

Questions