Round REAL Values to N Decimal Places in Siemens TIA Portal v18

When an S7-1200 logs a measured value such as 22.519432 to a CSV via DataLogWrite, the operator typically expects the on-screen value (22.52) to match the file. TIA Portal V18 does not expose a built-in "round to N decimals" instruction that returns a REAL. The ROUND instruction rounds to the nearest DInt and silently drops fractional information, so the engineer must assemble the result from VAL_STRG, arithmetic, or integer scaling. This reference documents every available technique, explains why the HMI shows 22.52 while the CSV shows 22.51999994, and gives the verification steps to prove the chosen method is stable on real hardware.

1. Problem Overview

Consider this S7-1200 scenario: an operator presses "Generate Report" on a TP700 Comfort panel. The PLC calls DataLogWrite to append one line of measured REAL data to a CSV stored in the CPU's internal flash. The HMI displays the same value to two decimal places (configured in the output field properties). When the operator opens the CSV in Excel, however, they see 22.51999994 instead of 22.52. The discrepancy has two distinct causes:

1. Precision drop in the file: DataLogWrite converts the REAL to its full 7-digit ASCII representation, including IEEE 754 noise, before writing. The HMI, by contrast, rounds the value at display time using the configured decimal count.
2. IEEE 754 representation error: The literal decimal 22.52 has no exact 32-bit binary equivalent. The nearest representable REAL is approximately 22.519999.... Operators see this as the PLC "lying" about the value.

Both issues can be fixed, but the fix depends on whether the data is destined for human display, persistent storage, or downstream Excel analysis. The next sections present three progressively more robust methods, starting with the simplest and ending with the technique recommended for regulated or high-integrity logs.

2. Why the ROUND Instruction Fails for Sub-Integer Precision

TIA Portal V18 ships the floating-point conversion instructions CEIL, FLOOR, ROUND, and TRUNC. All four return a DInt when the input is a REAL, and all four discard the fractional part. They do not accept a "decimals" parameter. A common mistake is to assume that ROUND(x, 2) would round to two decimals; that overload exists in many PC languages and in some PLC dialects, but not in the STEP 7 basic instruction set.

None of the four produce 22.52. To retain fractional precision, the engineer must either keep the result as REAL (using arithmetic) or convert to a STRING (using VAL_STRG) before the value reaches the file or the panel.

3. IEEE 754 Single-Precision Limitations in S7-1200

An S7-1200 REAL occupies 4 bytes and follows the IEEE 754 single-precision format: 1 sign bit, 8 exponent bits, 23 mantissa bits. Many decimal fractions, including 22.52, 1.3, and 0.1, have no exact binary representation, so they are stored as the closest representable approximation. When the PLC performs arithmetic on these approximations, the error compounds.

Three artifacts are common in field logs:

1. Noise in the low bits: 22.52 is stored as 22.519999... something. Reading the same tag back displays the rounded decimal the HMI applies, not the underlying bit pattern.
2. Non-zero addends: 0.1 + 0.2 in TIA Portal SCL evaluates to 0.30000000000000004, identical to the Windows result because both use the same IEEE 754 semantics.
3. Lossy scaling: Dividing a REAL by 3 and multiplying by 3 does not return the original value. The 23-bit mantissa gives roughly 7.22 significant decimal digits; after 4 to 5 multiplications the cumulative error is visible at the 6th decimal.

These artifacts are not bugs in the PLC firmware. They are the consequence of representing a 10-base decimal in a 2-base binary. The fix is to either mask the noise at the boundary (the HMI does this automatically) or eliminate it by storing scaled integers (Section 6).

4. Method 1: VAL_STRG Conversion (Recommended for HMI and DataLog)

VAL_STRG is a basic instruction in TIA Portal that converts a numeric value to a STRING with explicit control over precision, sign handling, and thousands separator. Passing the resulting STRING to DataLogWrite ensures the CSV contains exactly the digits you specified, no more, no less.

4.1 VAL_STRG Parameter Table

4.2 SCL Example (TIA Portal V18)

// Round a REAL to 2 decimals and write to STRING for DataLogWrite
// Call from OB1 or a dedicated FB on every measurement cycle

"dbLog".strTemp := '';  // optional clear

VAL_STRG(
    IN        := "dbLog".rMeasuredValue,    // REAL: 22.519432
    FORMAT    := 16#0000,                   // signed decimal, no hex, no thousands
    PRECISION := 2,                         // 2 decimal places
    SEPARATOR := FALSE,                     // no thousands separator
    STR       := "dbLog".strTemp,          // STRING[20] buffer
    RET_VAL   => "dbLog".iStrgErr          // 0 on success, <>0 if STR too short
);

IF "dbLog".iStrgErr = 0 THEN
    // Pass the STRING (not the REAL) to DataLogWrite
    "DataLogWrite_DB"(REQ := TRUE,
                      ID  := "dbLog".hLogID,
                      values := "dbLog".strTemp,
                      done => "dbLog".bWriteDone,
                      error => "dbLog".wWriteErr);
END_IF;

The STR buffer must be large enough to hold the result plus the STRING header (two length bytes plus the characters). For a 32-bit REAL with sign, integer part up to 9 digits, decimal point, and 7 decimals, the maximum output is 18 characters. Declare STRING[20] to keep one byte of headroom. If RET_VAL returns a non-zero value (typically 16#0007 for "string too short"), increase the buffer size.

4.3 SCL Variant Using WSTRING for WinCC Unified

WinCC Unified panels and Unified Comfort Panels expect Unicode strings. Declare the buffer as WSTRING and use the matching conversion instruction:

VAL_STRG(
    IN        := "dbLog".rMeasuredValue,
    FORMAT    := 16#0000,
    PRECISION := 2,
    SEPARATOR := FALSE,
    STR       := "dbLog".wstrTemp,        // WSTRING[20]
    RET_VAL   => "dbLog".iStrgErr
);

5. Method 2: Arithmetic Rounding (Multiply, Round, Divide)

If the application must keep the value as a REAL for further arithmetic (for example, summing, integrating, or PID control), use the classic two-step: scale up, round to integer, scale back down. The PLC-native version of the expression floor(x * 100 + 0.5) / 100 uses REAL_TO_DINT for the integer conversion and DINT_TO_REAL for the division.

// rInput  : REAL  (e.g. 22.519432)
// rOutput : REAL  (e.g. 22.52, but stored as the nearest REAL)

"dbMath".rScaled := "dbMath".rInput * 100.0;            // 2251.9432
"dbMath".diRound := REAL_TO_DINT("dbMath".rScaled + 0.5); // 2252
"dbMath".rOutput := DINT_TO_REAL("dbMath".diRound) / 100.0; // 22.52

This expression is idiomatic across many languages; the form floor(x * 100 + 0.5) / 100 appears in vendor documentation such as the HPE expression-language reference as a general-purpose two-decimal rule. In TIA Portal SCL, the explicit REAL_TO_DINT cast is preferred because it does not rely on implicit conversions that some firmware versions may warn about.

5.1 Caveats

• Tie behavior is configurable. REAL_TO_DINT truncates toward zero. Adding 0.5 first produces "round half up" for positive numbers and "round half toward zero" for negative numbers. For symmetric half-away-from-zero behavior, branch on the sign bit.
• The output is still a REAL. The value 22.52 is stored as the nearest binary float, not as the literal decimal. Pass the result to VAL_STRG if you need the file to contain 22.52 rather than 22.519999....
• Overflow. If |rInput| > 2.147e7 the intermediate DInt will overflow. Pre-check the range, or use LREAL (LRealToDInt variant) and accept the 53-bit mantissa range.

6. Method 3: Integer Scaling (Store as DInt with Implied Decimals)

The most robust approach for persistent logging, regulatory reporting, and downstream analytics is to abandon REAL for the stored value altogether. Multiply the measurement by 10^N and store the result as a DInt (or LReal if the range requires). The decimal point is implied by the program convention ("this tag is in hundredths").

// rInput  : REAL  (e.g. 22.519432)
// diCenti : DInt  (e.g. 2252, representing 22.52)
// To display: divide by 100.0 only at the HMI or in the CSV writer

"dbStorage".diCenti := REAL_TO_DINT("dbStorage".rInput * 100.0 + 0.5);

// For display only:
"dbDisplay".rShown := DINT_TO_REAL("dbStorage".diCenti) / 100.0;

Advantages:

• The integer 2252 is lossless. Re-scaling to REAL for display still produces a binary approximation, but the underlying measurement is captured exactly (within the original measurement precision).
• Excel analysis is simpler. The CSV column reads 2252 instead of 22.51999994. A header note such as Value (x 0.01) documents the implied scaling.
• No string conversion is required for DataLogWrite. The DInt writes cleanly without VAL_STRG.
• PID blocks, totalizers, and average calculations operate on stable integer values, eliminating cumulative rounding error from running sums.

7. DataLogWrite and CSV File Generation on S7-1200

The S7-1200 DataLog instruction set comprises FBs DataLogCreate (FB 80), DataLogOpen (FB 81), DataLogWrite (FB 82), DataLogClose (FB 83), DataLogNewFile (FB 84), DataLogClear (FB 85), and DataLogDelete (FB 86). When you pass a REAL to DataLogWrite, the firmware calls an internal float-to-ASCII routine that emits the full 7-digit IEEE 754 representation. When you pass a STRING, the firmware writes the buffer characters verbatim.

7.1 DataLogCreate Configuration Tips

1. Open DataLogCreate and define one column per measured variable. For STRING columns, set the maximum length to match the VAL_STRG output buffer (e.g. 20 characters).
2. Specify the storage location: Internal flash (load memory, ~2 MB on a typical S7-1200 CPU), SIMATIC Memory Card (SMC), or WebAPI/UserFiles (S7-1500 only).
3. Set the HEADER parameter to a comma-separated list of column names; this becomes the first row of the CSV.
4. Always evaluate STATUS from every DataLog call. Common error codes include 16#0001 (no memory), 16#0002 (file exists when CREATE), and 16#000A (file system full).

8. S7-1200 Internal Flash Memory Write Cycle Constraints

Internal load memory and SIMATIC Memory Cards both use NAND flash, which has a finite number of write/erase cycles per sector. The official Siemens support article "SMC - Service life of SIMATIC memory cards" quotes a typical figure of 500,000 write cycles for SMC cards. The internal flash on S7-1200 CPUs uses a similar NAND technology and should be treated as having the same endurance class, though the actual limit is firmware-dependent and not always published in the datasheet.

Worked example: a report-generation cycle that writes one CSV row every minute, 24/7:

Writes per year = 60 min/h * 24 h/day * 365 day/year = 525,600
Endurance        = 500,000 cycles
Service life     = 500,000 / 525,600 = 0.95 years (~347 days)

For a write-on-demand scenario ("operator presses Generate Report"), the 500,000 cycle limit corresponds to roughly 1,370 years of daily reports and is not a practical concern. For continuous logging, however, the limit becomes binding in well under a year. Mitigation strategies include:

• Buffer in work memory and flush less often. Accumulate rows in a STRING array, then write a batch every N minutes.
• Rotate to a new file. DataLogNewFile opens a fresh CSV; old files stay on the SMC but new writes hit a new sector.
• Use a removable SMC. The SMC can be replaced as part of preventive maintenance without changing the program.
• Offload to a network share. S7-1200 supports FTP (server) from firmware V4.1 onward; write to a NAS instead of the local flash.

9. HMI Display Consistency with WinCC

The HMI can be configured to display any number of decimal places, independent of the underlying tag format. This is why the operator sees 22.52 on screen but 22.51999994 in the file: the HMI does the rounding, the file does not.

9.1 WinCC Comfort / Advanced Output Field

1. Select the output field bound to the measurement tag.
2. Open Properties > Appearance > Format.
3. Set Display format to 999.99 (2 decimals) or use the "Decimal places" property.
4. Confirm the field binding is to the REAL tag, not to a derived STRING. If the binding is to the STRING from Section 4, the HMI will display the string verbatim (no extra rounding needed).

9.2 WinCC Unified Output Field

1. Open the screen and select the IO field.
2. In Properties > General, set Format to {N2} for 2 decimals.
3. For higher precision values, use {N4}, {N6}, etc.

10. Verification and Validation Procedure

Follow this checklist on the bench before deploying to production:

1. Watch-table check. Add the source REAL tag and the output STRING/DInt tag to a watch table. Force the source to known values (0.0, 22.519432, -3.14159, 9.99999) and confirm the output is correct for each.
2. Tie-break check. Force the source to a value that lands exactly on a midpoint, e.g. 22.505000 (rounds to 22.51 with round-half-up, or 22.50 with banker's rounding). Confirm the chosen method matches the documented behavior.
3. Range check. Force the source to the maximum and minimum expected process values, plus a 10% overrange. Confirm no overflow in the intermediate DInt or the STRING buffer.
4. DataLog round-trip. Trigger DataLogWrite for each test value. Extract the CSV from the SMC (or internal flash via WebAPI on S7-1500). Open in Excel and verify the column matches the expected rounded output.
5. HMI cross-check. View the same tag on the panel. Confirm the on-screen value matches the CSV value character-for-character.
6. Endurance smoke test. For continuous-logging applications, run 10,000 write cycles in a loop and inspect the SMC error count via RDSYSST or by reading the diagnostic buffer. Any non-zero STATUS from the DataLog FBs indicates the wear limit is being approached.

11. Troubleshooting Matrix

12. Method Selection Cheat Sheet

FAQ