WinCC Tag Scaling: Convert Integer PLC Values to Float Tags

Siemens WinCC Tag Logging archives the value present in the internal WinCC tag. When the source PLC tag is an integer and the application requires one-decimal precision (for example, scaling 254 to 25.4), configuring the WinCC tag as Integer and applying linear scaling causes the archived value to be rounded to 25 rather than stored as 25.4. The fix is to switch the WinCC tag data type from Signed 16/32-bit to Float 32-bit, apply linear scaling with a gain of 0.1, and constrain the display precision with an I/O field output format string such as 99.9. This guide details both WinCC V7.x and WinCC Professional (TIA Portal) configuration paths, explains the IEEE 754 floating-point representation that produces the 25.7999992370605 artifact, and provides a VBScript action reference for projects that still need script-based scaling inside cyclic tag logging.

Overview

Integer PLC tags are widely used for analog values when the field device returns scaled counts (for example, 0-5000 representing 0.0-500.0 °C). When WinCC Tag Logging records these values with acquisition type On Change, an action (VBScript or C) cannot be assigned at the archive level to transform the value before storage. The only mechanism that runs for every change without an action is the linear scaling parameter built into WinCC Tag Management. Linear scaling itself does not round values; the rounding occurs only when the destination WinCC tag is configured as an integer data type, because integers have no fractional bits. Promoting the WinCC tag to Float 32-bit (or Float 64-bit for high-precision loops) preserves 25.4 in the archive while the PLC retains its native INT / DINT representation.

Problem Statement: Integer Tags Round After Linear Scaling

Consider a S7-1500 PLC exposing "ProcessValue" : INT with raw counts 0-1000 representing 0.0-100.0 %. The standard WinCC V7.x project maps this tag to a WinCC tag of type Signed 16-bit with linear scaling enabled:

When the PLC value is 254, the linear scaling engine computes 254 * 0.1 = 25.4, but because the destination tag is an integer, the result is truncated to 25 before it ever reaches the Tag Logging archive. Tag Logging therefore records 25 instead of 25.4 for every change event. The issue is identical in TIA Portal WinCC Professional when the HMI tag is configured as Int or DInt.

Prerequisites

• WinCC V7.4 SP1, V7.5, V7.5 SP1, or V7.5 SP2 (project loaded on the engineering station)
• OR WinCC Professional V16 / V17 / V18 inside TIA Portal
• AS-OS connection configured (S7-MPI, S7-TCP, named connection, or OPC UA)
• Source PLC tag defined as INT, DINT, or WORD
• Tag Logging archive created with acquisition type On Change or Cyclic
• User rights to edit Tag Management and Tag Logging in WinCC Explorer / TIA Portal

Root Cause: Why Integer Tags Round After Linear Scaling

WinCC performs linear scaling through the formula Output = (Input × Gain) + Offset at the I/O layer of the tag driver. The scaled result is then written to the internal tag buffer using the tag's declared data type. When the declared data type is an integer variant (Signed 16-bit, Unsigned 16-bit, Signed 32-bit, Unsigned 32-bit), the runtime truncates the fractional portion of every scaled value because integer storage allocates zero bits for the decimal component. Truncation in WinCC follows round-toward-zero, so 25.4 becomes 25, and 25.9 becomes 25 (not 26). Linear scaling is therefore not at fault; the data type of the destination tag is.

Solution: Configure WinCC Tag as Float 32-bit with Linear Scaling

The solution is a one-property change in Tag Management: change the WinCC tag's data type from Signed 16-bit to Float 32-bit (or Float 64-bit for high-resolution loops). The linear scaling configuration remains identical, and Tag Logging automatically consumes the new data type. The S7 PLC side does not need any modification; the integer raw value continues to be read over the AS-OS connection and converted by WinCC.

Linear Scaling Formula in WinCC

WinCC V7.x and WinCC Professional both implement:

OutputValue = (RawValue × Gain) + Offset

// Examples for the scenario above
Gain  = 0.1
Offset = 0.0

RawValue = 254   → OutputValue = 25.4
RawValue = 1000  → OutputValue = 100.0
RawValue = 7     → OutputValue = 0.7

The Gain and Offset fields are the only two parameters required. WinCC does not store the raw PLC value at this point - all consumers of the tag (HMI screens, Tag Logging, archives, scripts) read the scaled float value.

Step-by-Step: WinCC V7.x Configuration

1. Open WinCC Explorer on the engineering station and load the project in Open Project mode.
2. Right-click Tag Management and choose Open.
3. Select the desired driver (for example, SIMATIC S7-1200, S7-1500 Channel) and locate the existing integer tag (e.g. ProcessValue).
4. Right-click the tag and choose Properties.
5. On the General tab, change Data Type from Signed 16-bit to Float 32-bit.
6. On the same dialog, switch to the Linear Scaling section and enable the checkbox.
7. Enter Gain = 0.1 and Offset = 0.0. (Equivalent: Value range start = 0, Value range end = 1000 in PLC units mapped to 0.0 to 100.0 scaled units.)
8. Click OK to apply.
9. Open Tag Logging, expand the archive, and confirm the tag is listed. The archive column now shows the float data type.
10. Save the WinCC project and trigger a recompile.

Step-by-Step: WinCC Professional (TIA Portal) Configuration

1. Open the TIA Portal project containing the HMI device.
2. Expand HMI Tags in the project tree and double-click the tag (e.g. ProcessValue).
3. In the tag properties, change the Data type drop-down from Int or DInt to Real (Float 32-bit) or LReal (Float 64-bit).
4. In the Linear scaling group, enter Gain = 0.1 and Offset = 0.0. The linear scaling dialog also accepts Endianness and bit-packing fields for advanced use cases.
5. Compile the HMI station and download to the runtime.
6. Open the HMI Tags table in the runtime and verify the value 25.4 for a PLC value of 254.

IEEE 754 Floating-Point Artifacts: 25.7999992370605 Explained

After switching to a float data type, engineers frequently observe artifacts such as 25.7999992370605 instead of 25.8. The artifact is not a bug in WinCC, the PLC, or the linear scaling engine - it is a fundamental property of IEEE 754 binary floating-point arithmetic.

Why 25.8 Becomes 25.7999992370605

The IEEE 754 single-precision (32-bit) format stores numbers as (-1)sign × 1.mantissa × 2exponent. The mantissa field has 23 explicit bits plus one implicit leading bit, giving 24 bits of precision, equivalent to approximately 7 decimal digits of significance. The double-precision (64-bit) format has a 52-bit mantissa, giving approximately 15 decimal digits of significance. The decimal value 25.8 cannot be expressed as a finite sum of negative powers of two; its nearest IEEE 754 single-precision representation rounds to a value roughly 5.96 × 10-8 below 25.8, which the runtime prints as 25.7999992370605. WinCC is therefore displaying the closest float representation - the user's intended 25.8 literally does not exist in the IEEE 754 single-precision world.

For more detail, see the IEEE 754 standard and the Single-precision floating-point format reference.

I/O Field Output Format Strings

WinCC I/O fields and trend views accept a Output Format string that constrains the decimal display. The format specifier uses Microsoft .NET-style placeholders. To display the scaled value with one decimal place, use:

Output Format: 99.9
or with thousands separator: n1
or fixed-width zero-padded: 000.0

With the format string 99.9, the value 25.7999992370605 is rendered to the operator as 25.8. The underlying float is unchanged; only the textual display is rounded. For two-decimal precision, use 99.99; for engineering notation, use 0.00E+00.

Tag Logging Acquisition Types and the Action Constraint

WinCC Tag Logging supports three acquisition types per archive column:

This is exactly the constraint the source scenario describes: an On Change archive cannot host an action to divide the integer by 10. Linear scaling on the WinCC tag itself is the correct mechanism because the scaling happens before the value reaches the archive, so it applies to every acquisition type transparently.

VBScript Action for Cyclic Tag Logging (Reference)

For projects that nevertheless use a VBScript action on a cyclic archive, the canonical pattern is to read the raw integer tag, divide, and write to a separate float tag that the archive consumes. The raw tag stays as integer, the scaled tag is float. WinCC V7.x VBScript:

' VBScript action attached to a cyclic Tag Logging trigger (1 s)
Dim rawValue, scaledValue

rawValue = HMIRuntime.Tags("ProcessValue_Raw").Read
scaledValue = rawValue / 10.0

HMIRuntime.Tags("ProcessValue_Scaled").Write scaledValue

For the C script variant in WinCC V7.x, use GetTagFloat / SetTagFloat from the stdlib include:

// C script inside a cyclic Tag Logging action (WinCC V7.x)
#include "apdefap.h"

BOOL _main(char* lpszPictureName)
{
    DWORD rawValue = 0;
    float scaledValue = 0.0f;

    rawValue = GetTagDWord("ProcessValue_Raw");
    scaledValue = (float)rawValue / 10.0f;

    SetTagFloat("ProcessValue_Scaled", scaledValue);
    return TRUE;
}

The same pattern applies in TIA Portal WinCC Professional using JavaScript inside an HMI script: HMIRuntime.Tags("ProcessValue_Scaled").Write(rawValue / 10.0);

Verification Procedure

1. Force the PLC value to a known integer (for example, set DB1.DBW0 = 254 in the S7 watch table).
2. Open WinCC Explorer > Tag Management and double-click the scaled tag. The Current Value indicator should display 25.4, not 25 and not 25.799999….
3. Open Tag Logging, select the archive, and click Display & Acknowledge. Confirm the most recent value is 25.4.
4. Export the archive to CSV via Tag Logging > Archive > Export and inspect with Notepad or Excel. The CSV cell must contain 25.4 (or the underlying IEEE 754 value); the human-readable trend view applies the Output Format string.
5. Add an I/O field on a screen bound to the scaled tag and set the Output Format to 99.9. The field must render 25.8 when the PLC value is 258.
6. Force a sequence of test values (0, 1, 25, 254, 1000) and confirm none of them is truncated.

Troubleshooting Matrix

Field-Proven Tips

• For control loops with setpoint precision better than 0.01, use Float 64-bit (LReal / double) on both the HMI tag and the PLC tag to avoid cumulative rounding in long archives.
• When using linear scaling with negative gains (e.g. for inverted signals), add a Limit Value monitor to detect overflow into the engineering range.
• If the scaled value is used in a WinCC OnlineTrendControl, configure the Value Axis > Decimal Places explicitly. Trends do not inherit the I/O field's Output Format string.
• For redundant WinCC servers, linear scaling parameters are part of the project and replicate automatically; do not set scaling on a runtime tag in C scripts, as runtime-side scaling does not persist across restart.

FAQ