Reading Linear Scaled Process Values in WinCC Runtime

Linear scaling in WinCC maps a raw PLC value to an engineering value at the HMI tag boundary. Once configured in Tag Management > Tag Properties, the transform is applied transparently to every read and write of the tag in runtime. An I/O field bound to a scaled tag displays the engineering value, and any value the operator enters is converted back to the raw value before being written to the PLC. The same applies to VBScript and C script access when the script is bound to the scaled tag, not to a raw tag you have re-implemented by hand.

This article documents the scaling equation, configuration in WinCC V7/V8 and TIA Portal (WinCC Comfort/Advanced/Professional), runtime access via I/O fields, VBScript, and C scripts, the manual inverse conversion you must apply if you bypass the tag, and the verification procedure that proves the mapping is correct before commissioning.

Linear Scaling Fundamentals

WinCC's linear transform implements the affine equation:

y = a · x + b

where:

• x = raw value from the PLC (integer in PLC engineering units, e.g., 0–27648 for a S7 analog input normalized to the SIMATIC range)
• y = scaled process value exposed to WinCC, in the engineering unit (e.g., degrees Celsius, bar, liters per minute)
• a = slope (gain). WinCC calls this the gradient or factor.
• b = offset. Optional; defaults to 0 in most dialogs.

For the common case described in the field report (data divided by 10 to display as tenths), the factor is a = 0.1 and the offset is b = 0, giving y = 0.1 · x. A raw PLC value of 235 becomes a displayed value of 23.5. If the operator must be able to enter a value, the I/O field binds to the same scaled tag, and WinCC applies the inverse automatically on every write.

To reverse the transform when the operator types a new value into an I/O field, WinCC computes the inverse:

x = (y − b) / a

If the user types 23.5 into the I/O field, the tag writes 235 back to the PLC. There is no rounding step inside the dialog-based transform; if the displayed value and the raw integer both have fractional precision, the conversion goes through the floating-point representation of the tag and is only rounded to the PLC's data type at the boundary.

Configuring Linear Scaling in WinCC Tag Management

Open the tag properties and switch to the Properties tab. Under Linear scaling, tick Active and enter the end points of the mapping. WinCC will derive the slope and offset from the two end points, but you can also enter a and b directly when you have them pre-computed.

For S7 analog inputs the PLC range end should be 27648 (or 27649 on older CPUs), not the raw 16-bit count 32767. Using 32767 introduces a 2.38× scale error because the S7 normalizes the input to 0–27648 by design and uses 27649–32767 for the over-range and overflow diagnostic values described in the S7 analog module manuals.

You can override the computed a and b with explicit values when you need a non-linear mapping through a single linear segment (e.g., a 4–20 mA input mapped to a 0.0–10.0 bar process range with a 4 mA zero suppression), or when the PLC range is wider than the operating window (e.g., mapping 0–27648 → 0–150 °C, then clamping at the dialog limits so that values above 150 °C are reported as out-of-range rather than scaled up).

Configuration in TIA Portal (WinCC Comfort / Advanced / Professional)

In TIA Portal, open the HMI tag's properties and expand Linear scaling. Per the Siemens Support entry ID 109054417 (STEP 7 Basic V13.1, applying linear scaling to a tag):

"To apply linear scaling to a tag, you must specify one value range on the HMI device and one on the PLC. The value ranges will be mapped to each other linearly."

Enter the PLC range in PLC and the HMI range in HMI; the tool stores the resulting a and b on the tag. The transform runs at runtime and is visible to I/O fields, faceplate tags, alarm limits, and any script that reads the tag symbolically. TIA Portal also writes the scaling to the device's runtime file, so the same configuration is loaded when the panel boots from the project.

Configuration in WinCC V7 / V8 (Classic)

In WinCC V7/V8 (the classic, non-TIA generation), open the Tag Management editor, double-click the tag, and switch to the Properties tab. Tick Linear scaling and enter the two end-point pairs. Per the Siemens Support entry ID 109780723 (scaling a process value in WinCC V7/V8):

"Here you must read the value of the PLC variable, divide it by the scaling factor (1000, for example) and pass it as a process value."

WinCC stores the slope and offset with the tag in the project's database. The transform is applied at the HMI runtime layer, so a faceplate, an archive tag, and a script reading the same tag all see the scaled value without further conversion.

Runtime Data Flow

Reading and Writing Scaled Values in I/O Fields

Bind an I/O field to the scaled tag, not to the raw PLC variable:

1. In the Graphics Designer (WinCC V7/V8) or the screen editor (TIA Portal), drag an I/O field onto the picture.
2. Open Configuration > Tag (WinCC V7/V8) or Properties > General > Tag (TIA Portal).
3. Select the scaled WinCC tag (the same tag you configured linear scaling on). Do not select the raw PLC tag.
4. Set the data format to match the engineering unit: Float32 for fractional values (tenths, hundredths), Decimal for integer counts, Long Integer for large counter values.
5. Set the field type to Input/Output if the operator must be able to change the value at runtime; Output if the value is read-only.
6. Set the field length to a value wide enough to display the full range (e.g., 6 characters for 0.0–100.0 °C, 8 characters for 0.000–100.000).

At runtime, the I/O field shows the engineering value (e.g., 23.5). When the operator types a new value (e.g., 24.0) and confirms, WinCC applies the inverse transform and writes the raw value (240) to the PLC. No script is required.

Accessing Scaled Values via VBScript

VBScript reads and writes the scaled value when the script is bound to the scaled tag. The script never sees the raw integer unless you deliberately read the underlying PLC tag.

Read scaled process value

' "Temperature_Process" is a scaled HMI tag with linear scaling enabled
Dim pv
pv = HMIRuntime.Tags("Temperature_Process").Read
HMIRuntime.Trace "Process value: " & pv & " °C"

Write scaled process value

' Operator entered 75.0 °C in a popup; write it back through the scaled tag
Dim newPv
newPv = 75.0
HMIRuntime.Tags("Temperature_Process").Write newPv

Read raw value (diagnostics only)

To read the raw integer directly, reference the underlying PLC tag, not the scaled HMI tag:

' "DB1_Temp_Raw" is the unscaled PLC tag in the tag list
Dim raw
raw = HMIRuntime.Tags("DB1_Temp_Raw").Read
HMIRuntime.Trace "Raw value: " & raw

Use the raw read only for diagnostics or for control logic that needs the integer form (e.g., comparing against a bit pattern). For operator dialogs, faceplate displays, and any value that the operator can change, always use the scaled tag.

Accessing Scaled Values via C Script

C scripts in WinCC V7 use the GetTag / SetTag family. Like VBScript, the script reads the scaled value when bound to a scaled tag.

Read scaled process value

// "Temperature_Process" is a scaled HMI tag
float pv = 0.0f;
GetTagFloat("Temperature_Process", &pv);
printf("Process value: %f °C\r\n", pv);

Write scaled process value

float newPv = 75.0f;
SetTagFloat("Temperature_Process", newPv);

Manual inverse calculation (only when bypassing the tag)

If you must read the raw PLC variable and convert it yourself, apply the inverse of the configured transform. The general form is:

processValue = (rawValue − b) / a

For the source example (raw divided by 10, i.e., a = 0.1, b = 0):

// C script reading a raw integer and computing the engineering value
int raw = 0;
GetTagSDWord("DB1_Temp_Raw", &raw);
float pv = raw / 10.0f;        // (rawValue - 0) / 0.1 == raw * 10
printf("Process value: %f\r\n", pv);

For the write direction:

rawValue = round( (processValue − b) / a )

// C script writing a process value back to a raw integer
float pv = 75.0f;
int raw = (int)((pv - 0.0f) / 0.1f + 0.5f);   // round to nearest integer
SetTagSDWord("DB1_Temp_Raw", raw);

Per the Siemens Support entry ID 109780723, when the script bypasses the scaled tag you must perform this conversion explicitly: read the PLC variable, divide by the scaling factor, and pass the result as a process value.

Where to Apply the Scaling: HMI Tag vs. PLC

Linear scaling can live on the HMI tag, in the PLC (using the S7 SCALE / UNSCALE FCs from the Standard Library, or the new SCALE_X / NORM_X / SCALE instructions in S7-1500), or in both. The right place depends on who consumes the value:

Mixing both is acceptable but requires discipline: keep the HMI scaling and the PLC scaling in lockstep, and document both in the tag comment. A mismatch (e.g., HMI scaled twice, or PLC scaled and HMI scaled again) is the single most common source of off-by-a-factor-of-10 errors at commissioning.

Numeric Format and Data Type Considerations

The scaled tag value's data type is determined by the tag definition, not by the configured scaling. If the raw tag is a 16-bit integer and you scale it to a 0.0–100.0 °C range, the scaled value is still a 16-bit integer internally (multiplied by 10 in WinCC's internal storage as 0–1000 tenths). I/O fields configured as Float32 will show one decimal place; I/O fields configured as Decimal will show an integer.

For S7 analog inputs, use the following mapping convention:

The 4 mA zero suppression on a 4–20 mA input is implemented in the PLC analog module (or the channel configuration in TIA Portal) by setting x₁ to the value the module returns at 4 mA, typically 0 for a Siemens AI8 module, not by adjusting the WinCC linear scaling.

Faceplate, Archive, and Alarm Considerations

The same scaled tag should be reused across faceplates, archive configurations, and alarm limits. Mixing scaled and raw references in the same faceplate is a common source of operator confusion: one label shows 23.5 °C and another shows 235, and the operator cannot tell which is the engineering value.

For tag logging, the archive configuration references the scaled tag directly. WinCC stores the scaled value in the archive; no further conversion is applied on read-back, and the historical trend displays the engineering value. If you accidentally reference the raw tag in the archive, the trend will show 0–27648 (or 0–65535) instead of the engineering range, and a downstream report will need to scale the values before plotting.

For alarm limits, define the limit values in engineering units (e.g., HH = 95.0 °C, H = 80.0 °C, L = 5.0 °C, LL = 0.0 °C) on the scaled tag. WinCC applies the limit comparison after the linear transform, so a raw PLC value of 26266 (≈ 95.0 °C) trips the HH alarm. Defining the same limits on the raw tag would require 26266 instead of 95.0, which is unreadable in the alarm log.

Runtime Verification Procedure

Confirm the scaling is correct before commissioning:

1. Open the WinCC project in Runtime and navigate to the picture with the I/O field.
2. Force the underlying PLC tag to three known raw values: zero (0), midpoint (13824 for a 0–27648 range), and full scale (27648).
3. Read the I/O field. It must show 0.0, 50.0, and 100.0 respectively for the 0–100 °C example.
4. Type a new engineering value (e.g., 75.0) in the I/O field and confirm. Watch the raw PLC tag in the STEP 7 / TIA Portal watch table; it must hold the raw integer (e.g., 20736 for 75.0 °C on a 0–27648 → 0.0–100.0 °C scale).
5. Trigger a tag trace (WinCC V7/V8: Tag Logging > Tag Simulation; TIA Portal: Tools > Tag trace) on both the raw and scaled tags to confirm the linear relationship over the full range.
6. Verify the boundary behavior: type a value above the configured maximum (e.g., 150.0) and confirm the write is clamped to the configured end-point, or rejected, depending on the tag's overflow configuration.
7. Verify the inverse path on a write: type a fractional value (e.g., 23.7) and confirm the raw integer is rounded to the nearest representable value (237 in the divide-by-10 case).

Troubleshooting Matrix

Best Practices

• Configure scaling on the HMI tag, not in a script. The transform is then visible to every consumer (I/O field, faceplate, alarm limit, archive) without duplication.
• Keep a and b as static configuration. If you need different ranges per screen, define separate scaled tags rather than animating the gradient with an internal tag at runtime.
• Document the configured mapping in the tag's comment field so the conversion is auditable at commissioning.
• For asymmetric transforms (e.g., square-root extraction on read, linear on write), use a separate internal tag and a script, not the dialog-based linear scaling.
• For S7 analog inputs, set x₁ / x₂ to the actual S7 normalized range (0–27648) rather than the raw 16-bit count (0–65535) to avoid a 2.38× scale error.
• Use the same scaled tag in faceplates, archive configurations, and alarm limits. Mixing scaled and raw references in the same faceplate is a common source of operator confusion.
• Test the inverse path explicitly: type a fractional value, confirm the raw integer, and check for rounding drift.
• If you must change the scaling range after deployment, recompile and re-download the HMI project; the change is not hot-reloadable from the runtime.
• For multi-panel deployments, define the scaled tag once in the shared tag list and reuse it on every panel rather than redefining it per device.

FAQ