S5TIME to TIME Conversion in Siemens STEP 7 and TIA Portal

The S5TIME data type is the legacy timer format carried forward from SIMATIC S5 into the S7-300, S7-400, S7-1200, and S7-1500 families. It is still used by the S_ODT, S_ODTS, S_PULSE, S_PEXT, and S_OFFDT timer functions, by the coil instructions SP, SE, SD, SS, and SF, and by most HMI input fields that ask the operator for a preset time. Modern applications, however, expect an IEC 61131-3 TIME value (DINT, milliseconds) so it can be added, multiplied, scaled, compared, and used inside arithmetic expressions. This reference covers three production-ready conversion paths: STEP 7 Classic FC33/FC40, TIA Portal explicit conversion, and a manual SCL implementation, together with the BCD layout, range limits, BR bit behavior, and HMI integration.

S5TIME Binary Layout

S5TIME occupies one 16-bit WORD. The lower two bits encode the time base; the upper 12 bits hold a BCD value of 0 to 999. The effective duration is duration = BCD_value × time_base. The structure follows the S7-300/400 System Software manual and is identical on S7-1200 and S7-1500.

Bits 2 and 3 are always 0. Examples of encoded values:

• S5T#0s = W#16#0000
• S5T#1s = W#16#1001 (BCD 1, base 10 ms = 10 ms; PLC stores as 1 s because base 10 is incompatible, instead the editor picks base 1 s with BCD 1)
• S5T#2m30s = W#16#3252 (BCD 250, base 1 s = 250 s after rendering; rendered value uses 150 s / 10 s base = W#16#2315, since 150 × 10 s = 1500 s = 25 min)
• S5T#9990s = W#16#3999 (BCD 999, base 10 s)

Range and Time-Base Selection

The IEC TIME data type on S7 is a signed 32-bit value in milliseconds. The range is -2_147_483_648 ms to +2_147_483_647 ms (approximately ±24.86 days). S5TIME is always non-negative, so the only relevant bound is the upper end.

STEP 7 picks the time base that yields the most precise representation of the entered value. Selecting a smaller base (better resolution) reduces the achievable maximum. Programming tools display the value with the chosen base plus the BCD value, e.g. S5T#250ms = base 10 ms, BCD 25; S5T#1h30m = base 10 s, BCD 540.

Prerequisites

• STEP 7 V5.x for the FC33/FC40 path (S7-300/400, plus S7-1200/1500 in compatibility mode). TIA Portal V14 or higher for explicit conversion (S7-1200/1500).
• CPU with firmware that supports the required instruction set. S7-1500 needs firmware V1.8 or later for some S5TIME_TO_TIME overloads of SCL (see TIA Portal help for the specific instruction version).
• The "Standard Library > IEC Function Blocks" library installed in STEP 7 Classic. In TIA Portal, the standard conversion instructions are shipped with the basic libraries; no extra package is required.
• For HMI integration, a tag connection (M, DB, or I/O) typed as S5TIME from the PLC. The HMI tag will display the value as S5T#xxxs automatically.

Method 1: STEP 7 Classic with FC33 and FC40

FC33 (symbolic name S5TI_TIM) converts S5TIME to TIME. FC40 (symbolic name TIM_S5TI) converts TIME to S5TIME. Both blocks are in the "Standard Library > IEC Function Blocks" section of STEP 7 Classic.

FC33 S5TI_TIM - S5TIME to TIME

Calling example in STL (S7-300/400):

      CALL  FC    33
       IN   :=   DB10.DBX0.0  // S5TIME source, e.g. MW20
       RET_VAL:=  MD30        // TIME result in ms
      NOP   0

Calling example in LAD/FBD: drag FC33 from the IEC Function Blocks library onto the network, connect a tag of type S5TIME to IN, and a tag of type TIME (DWORD) to RET_VAL.

FC40 TIM_S5TI - TIME to S5TIME

STL example:

      CALL  FC    40
       IN   :=   MD40        // TIME source in ms
       RET_VAL:=  MW50        // S5TIME result
      NOP   0

Method 2: TIA Portal Explicit Conversion for S7-1500

The S7-1500 system family supports direct explicit type conversion instructions between S5TIME and TIME/DWORD. The conversion is described in the TIA Portal help under "Data types > Data type conversion for S7-1500 > Timers (S7-1500) > Explicit conversion of S5TIME".

Available instructions:

These conversions are documented in the TIA Portal online help; see TIA Portal V20: Explicit conversion of S5TIME (S7-1500) for the official instruction set, status flags, and overloads.

SCL usage example (TIA Portal V16+):

// DB "RecipeTimes"
VAR
    s5Preset       : S5TIME;    // HMI input
    timeMs         : TIME;      // IEC value in ms
    s5FromArith    : S5TIME;    // result of arithmetic, fed to S_ODT
END_VAR

timeMs := S5TIME_TO_TIME(s5Preset);    // e.g. S5T#2m30s -> T#2m30s0ms
// perform arithmetic on timeMs:
timeMs := timeMs + T#10s;
// re-encode for an S5-style timer:
s5FromArith := TIME_TO_S5TIME(timeMs);

ENO (enable output) is set to 0 if the source value would overflow the destination. Connect ENO to a global error marker or to the "ERR" input of a downstream block to detect overflow without polling BR.

LAD/FBD on S7-1500

The converters are available as boxes under "Instructions > Converter operations". Drag S5TIME_TO_TIME or TIME_TO_S5TIME onto a network, connect the source tag and the destination tag, and compile. The status word and AR1/AR2 are not affected because the converter uses the standard IEC call interface.

Method 3: Manual SCL Conversion (S7-300/400/1200/1500)

If the FC library is unavailable, the conversion can be implemented manually by reading the time base and the BCD value, then multiplying. The implementation below matches the FC33 algorithm exactly.

FUNCTION "S5TimeToTime" : Time
VAR_INPUT
    s5Input : S5TIME;
END_VAR
VAR_TEMP
    wRaw    : WORD;
    nBase   : INT;          // 0..3
    nBcd    : DINT;         // 0..999
    nResult : DINT;
END_VAR
BEGIN
    wRaw  := DWORD_TO_WORD(S5TIME_TO_DWORD(s5Input));
    nBase := WORD_TO_INT(wRaw AND 16#0003);
    // BCD lives in bits 4..15, value 0..999
    nBcd  := BCD16_TO_DINT(SHR(IN:=WORD_TO_INT(wRaw AND 16#FFF0), N:=4));
    CASE nBase OF
        0: nResult := nBcd * 10;          // 10 ms steps
        1: nResult := nBcd * 100;         // 100 ms steps
        2: nResult := nBcd * 1000;        // 1 s steps
        3: nResult := nBcd * 10000;       // 10 s steps
    ELSE
        nResult := 0;
    END_CASE;
    "S5TimeToTime" := DINT_TO_TIME(nResult);
END_FUNCTION

BCD16_TO_DINT is available in the "Standard Library > IEC Function Blocks" of TIA Portal. If the IEC function is missing, replace it with a nibble-wise decode loop:

FUNCTION "BcdToDint" : DINT
VAR_INPUT
    iBcd : INT;
END_VAR
VAR_TEMP
    i    : INT;
    n    : DINT;
    nib  : INT;
    src  : INT;
END_VAR
BEGIN
    src := iBcd;
    n   := 0;
    FOR i := 0 TO 3 DO
        nib := src AND 16#000F;
        IF nib > 9 THEN
            "BcdToDint" := -1;            // invalid BCD
            RETURN;
        END_IF;
        n   := n * 10 + nib;
        src := src SHR 4;
    END_FOR;
    "BcdToDint" := n;
END_FUNCTION

HMI Integration and Tag Mapping

HMI panels expect S5TIME for the legacy timer input fields. The recommended wiring is to keep a single S5TIME tag at the HMI boundary, convert once to TIME, perform the application logic in TIME, and convert back only when a value must be fed to an S5-style timer. This avoids drift caused by repeated round-trips between the two formats.

For Node-RED environments, the Siemens S5Time converter flow wraps the conversion into two function nodes (Seconds to S5Time and S5Time to Seconds) that produce the same wire format as FC40 and FC33. Use it for tag mirrors that go to a Node-RED dashboard or to a cloud historian. For Ignition, store the TIME value in the PLC, expose it as a DINT (milliseconds) OPC tag, and let the Ignition expression language format the display value; do not try to consume S5TIME directly from the OPC server because most OPC stacks do not know the S5TIME encoding.

Verification Procedure

1. Create a new VAT (variable table) or watch table in STEP 7 or TIA Portal. Add the S5TIME source tag and the TIME result tag.
2. Force the S5TIME value to known points: S5T#0s, S5T#10ms, S5T#1s, S5T#1m, S5T#1h, S5T#2h46m30s, and S5T#9990s.
3. Read the TIME result. It must equal the duration in ms. For example, S5T#2h46m30s = 9990 s = 9_990_000 ms.
4. Reverse direction: write a TIME value T#9990s to the FC40 input. Read the S5TIME output; it must be S5T#9990s and BR/ENO must be 1.
5. Write a TIME value above the S5TIME maximum, e.g. T#10000s. The S5TIME output must be clipped to S5T#9990s and BR/ENO must be 0. Connect BR to a status bit in the VAT and verify the bit is reset.
6. Force the S5TIME raw cell to W#16#FFFF (BCD invalid, base 11) and read the TIME output. Some versions of FC33 return T#0s with BR = 0; the TIA Portal S5TIME_TO_TIME returns T#9990s with ENO = 0. Document the chosen behavior in the function description.

Troubleshooting Matrix

Edge Cases and Field Notes

Negative TIME values. The S5TIME data type has no sign bit, so any negative TIME passed to FC40 or TIME_TO_S5TIME is treated as out of range. The output becomes S5T#0s and BR/ENO is 0 on S7-1500, and the block also returns S5T#0s with BR = 0 on S7-300/400. Add a sign check before calling the encoder when the upstream arithmetic can produce negative durations.

Zero handling. Both encoders treat T#0s and S5T#0s identically (W#16#0000). Decoders preserve the value. This is the safe default for HMI pre-population.

Time-base ambiguity. A S5TIME value of W#16#1000 is BCD 100 with base 00 (10 ms) and represents 1 000 ms. A S5TIME value of W#16#1010 is BCD 10 with base 10 (1 s) and also represents 10 000 ms. The two encodings are not equivalent because the round-trip S5TIME → TIME → S5TIME will choose the most precise base. The result is the same effective duration but the raw WORD will change. Treat the S5TIME WORD as an opaque value, never as a checksum.

Library name in TIA Portal. On S7-1500 the explicit conversion is in the instruction catalog under "Basic instructions > Converter operations". On S7-1200 with firmware V4.0 or later the same instructions are available; on older S7-1200 firmware the explicit converters do not exist and the manual SCL implementation must be used.

Safety and SIL applications. For F-CPU work, keep the time value in TIME inside the standard program and route only the preset through S5TIME. Do not feed the encoder output back into a safety-related timer instruction; the S5TIME data type is not part of the F-runtime signature.

References and Linked Documentation

• TIA Portal V20: Explicit conversion of S5TIME (S7-1500)
• Siemens S5Time converter (Node-RED flow)