Resolving GT_STRNG SCL FC15 Errors in TIA Portal Programming

Problem Overview: GT_STRNG Compilation Failures in SCL

When engineers first use the GT_STRNG (greater-than string compare) function in Siemens SCL within TIA Portal, they frequently encounter a cluster of compiler errors on a single line. The typical failure pattern looks like this:

The compiler then reports any combination of the following diagnostics on the offending line:

• "Invalid input, in/out, output parameter" (reported twice)
• "Invalid Assignment" (reported twice)
• "Invalid or missing function type"

These five errors on one line are not five independent faults; they are cascading symptoms of one or two underlying mistakes. The same error cluster appears whether the block is declared as a FUNCTION (FC) or a FUNCTION_BLOCK (FB), and it is independent of the STRING length used (e.g., STRING[1], STRING[2], or the default STRING[254]).

For background on how SCL expressions are constructed and how the compiler binds operands to operators, see the Siemens SCL Expressions and Operations reference in the TIA Portal help system.

Root Cause Analysis: Three Failure Modes

Across multiple reproductions of this error, the root cause always falls into one of three categories. Confirm each in order before changing any code.

Failure Mode 1 — Wrong Parameter Names

The single most common cause. SCL's named-parameter call syntax requires the parameter identifiers declared in the FC interface, not user-defined names. The interface of GT_STRNG in the standard library uses the formal parameters:

Writing STRING_COMP1 := ... or any other custom name causes the compiler to reject both bindings, then to flag the assignment to STRING_CRANE_VALUE as invalid, and finally to declare the function type itself invalid because no valid call could be resolved. Five errors from one mistake.

Failure Mode 2 — Wrong FC Number

The standard GT_STRNG is FC15 in the SIMATIC S7-1200/1500 standard library. A closely named neighbour, FC16 (I_STRNG, integer-to-string conversion), has a completely different interface. If the symbol table or program element is dragged from a different category, FC16 can be silently substituted, producing the same error cluster because I_STRNG takes an integer input, not a string.

Failure Mode 3 — Interface Declaration Mistakes

Two specific declaration patterns trigger the error:

1. Declaring the FC as FUNCTION FC16 : BOOL (i.e., naming the wrong FC, see Mode 2).
2. Declaring FUNCTION FC100 : BOOL correctly but with VAR_INPUT parameters of type STRING (no length) when the call site passes STRING[1] — although this typically produces a warning, not the five-error cluster, it can mask Mode 1.

Correct GT_STRNG Syntax in SCL

The corrected function (FC) declaration that compiles cleanly:

FUNCTION FC100 : BOOL
VAR_INPUT
  String_Comp1 : STRING;
  String_Comp2 : STRING;
END_VAR
BEGIN
  FC100 := GT_STRNG(S1 := String_Comp1, S2 := String_Comp2);
END_FUNCTION

The corrected function block (FB) declaration:

FUNCTION_BLOCK FB100
VAR_INPUT
  String_Comp1 : STRING[1];
  String_Comp2 : STRING[2];
END_VAR
VAR_OUTPUT
  STRING_CRANE_VALUE : BOOL;
END_VAR
BEGIN
  STRING_CRANE_VALUE := GT_STRNG(S1 := String_Comp1, S2 := String_Comp2);
END_FUNCTION_BLOCK

Note the structural differences between an FC and an FB:

For a deeper walkthrough of creating the block, defining the interface, and entering SCL code in TIA Portal, see Writing your first SCL Code in TIA Portal (note: third-party tutorial, treat as supplementary reference, not an official Siemens manual).

STRING Data Type Details for SCL

The STRING type in S7-1200/1500 is not a C-style null-terminated array. It is a structured type with two internal fields:

When you declare STRING[1], the compiler reserves the 2-byte header plus 1 character (3 bytes total). STRING[2] reserves 4 bytes, and the default STRING without a length specifier is 254 characters (256 bytes total).

Critical detail for GT_STRNG: the comparison is performed using the actual length and the character codes in left-to-right ASCII order. A single-character STRING[1] holding the character '@' (ASCII 64) compares correctly against '!' (ASCII 33) and '%' (ASCII 37). Padding characters beyond the actual length are not inspected.

Field-Example: Crane Identifier Discrimination

A common industrial use case is discriminating between two crane IDs encoded as the first character of a STRING tag. Suppose the data block DB_CraneID contains a STRING[1] tag that will hold either '!' (ASCII 33, crane A) or '@' (ASCII 64, crane B). The decision threshold is '%' (ASCII 37), which sits between the two valid characters.

FUNCTION_BLOCK FB_CraneID_Detect
VAR_INPUT
  CraneChar : STRING[1];
END_VAR
VAR_OUTPUT
  IsCraneB : BOOL;
END_VAR
BEGIN
  // If CraneChar > '%' it must be '@' (Crane B)
  IsCraneB := GT_STRNG(S1 := CraneChar, S2 := '%');
END_FUNCTION_BLOCK

This pattern is robust because the two possible inputs are non-overlapping and well-separated in ASCII space. It avoids substring or numeric parsing entirely and executes in a single PLC scan-cycle with deterministic timing on an S7-1500.

Step-by-Step Troubleshooting Procedure

Use this ordered checklist when you see the GT_STRNG error cluster. Do not skip steps — early steps rule out the most common cause in seconds.

1. Verify the FC number. Open the symbol table and confirm the entry for GT_STRNG maps to FC15 (or the equivalent number for your CPU/firmware). Cross-check by double-clicking the call in the program editor and reading the block number in the call properties dialog.
2. Verify the FC is available. In TIA Portal, ensure the standard library "IEC Function Blocks" or the CPU-specific standard library is included in the project. On S7-1200 CPUs, FC15 is part of the CPU firmware; on S7-1500 it is part of the program resources.
3. Inspect the FC interface. Right-click the GT_STRNG call → "Go to definition" or "Open block". Confirm the input parameters are named S1 and S2 and the return type is BOOL. Do not assume the parameter names from memory.
4. Rewrite the call with the correct formal parameter names. Replace any custom names with S1 and S2 exactly as declared.
5. Match the function or function block return convention. For an FC, assign the result to the FC's own name (FC100 := GT_STRNG(...)). For an FB, assign the result to a VAR_OUTPUT BOOL.
6. Compile and check the diagnostics window. If errors remain, read each message verbatim — TIA Portal often emits a more specific cause (e.g., "STRING length mismatch") in the second pass.
7. If errors persist: temporarily simplify the call to GT_STRNG(S1 := 'A', S2 := 'B') with hard-coded literals. If this compiles, the issue is in how the input variables are scoped or sized.

FB vs FC: Choosing the Right Block Type

Although both an FB and an FC can host a GT_STRNG call, the choice has practical consequences for production code.

Use an FC when:

• The comparison has no internal state (no latch, edge detection, or counter).
• You want minimal memory footprint — FC temporaries live on the L stack and are released when the FC returns.
• You are calling the same comparison logic many times in one cycle with different inputs.

Use an FB when:

• You need to hold state across calls (e.g., a hysteresis flag for "crane B has been detected").
• You want to encapsulate the comparison inside a reusable block with its own multi-instance inside a parent FB.
• You need the block to appear in the call hierarchy with its own instance DB for diagnostics.

For the crane ID example, an FC is sufficient. For a "debounced" detection with rising-edge memory, an FB is required.

Common Pitfalls and Edge Cases

Pitfall 1 — Comparing STRINGs of Different Declared Lengths

STRING[1] and STRING[2] are not the same type to the compiler. Passing a STRING[2] to a VAR_INPUT declared as STRING[1] may compile with a warning or fail outright depending on TIA Portal version. Use the same declared length on both sides, or use the generic STRING (default 254) at the interface boundary.

Pitfall 2 — Comparing an Initialized-Empty STRING

Calling GT_STRNG(S1 := '', S2 := '') compiles cleanly but always returns FALSE because the actual length is zero for both operands and the comparison short-circuits. Use this only as a syntactic test, not a meaningful comparison.

Pitfall 3 — Forgetting That Strings Are Left-Justified

Assigning 'A ' (A followed by space, ASCII 65 then 32) to a STRING[2] produces the byte sequence 65 32, not 65 00. GT_STRNG compares position by position and will return FALSE if the first position matches but the second is smaller. This is rarely a problem with single-character identifiers but matters for multi-character tags.

Pitfall 4 — Mistaking GT_STRNG for I_STRNG

FC15 (GT_STRNG) and FC16 (I_STRNG) are adjacent in the standard library. Drag the FC from the correct folder: GT_STRNG is in the "String functions" or "Comparison functions" group, I_STRNG is in the "Conversion functions" group.

Verification Procedure

After applying the fix, confirm correct behaviour with these checks.

1. Compile clean. The error list should show zero errors and zero warnings on the modified block.
2. Download to the PLC. In TIA Portal: click "Download to device" (or press Ctrl+L) and select the target CPU. Wait for the "Download successful" confirmation.
3. Go online and monitor. Open the FB/FC instance in online mode. Force String_Comp1 := '!' and String_Comp2 := '%' in the watch table. STRING_CRANE_VALUE should evaluate to FALSE.
4. Force the second test pair. Force String_Comp1 := '@' and String_Comp2 := '%'. STRING_CRANE_VALUE should evaluate to TRUE.
5. Test boundary equality. Force both inputs to '%'. STRING_CRANE_VALUE must be FALSE (strictly greater-than, not greater-than-or-equal).
6. Test empty strings. Force both to ''. Result must be FALSE; verify no scan-time watchdog error is raised.
7. Capture online help text. With the cursor on the GT_STRNG call, press F1 to confirm the official Siemens help shows parameters S1, S2, and return BOOL.

Compiler Diagnostic Reference

Map from TIA Portal error message to root cause:

Performance and Execution Timing

On an S7-1500 CPU (firmware V2.5 and later, the GT_STRNG function executes in single-digit microseconds for STRINGs under 32 characters. For STRING[254] operands, the worst-case time is dominated by the byte-by-byte compare loop and stays below 50 µs on a typical S7-1515. There is no need to pre-compute hash codes or lengths; the standard library implementation is already optimal for PLC use.

On an S7-1200, expect 5–10× longer execution times. If the comparison runs in a fast OB (<1 ms), consider whether the call frequency is acceptable, though in practice GT_STRNG is rarely a bottleneck.

Firmware and Library Compatibility

The IEC standard string comparison functions (EQ_STRNG, NE_STRNG, GT_STRNG, GE_STRNG, LT_STRNG, LE_STRNG, I_STRNG, S_STRNG) are present in:

• All S7-1200 CPUs from firmware V1.0 onward (part of CPU firmware, not a separate library)
• All S7-1500 CPUs from firmware V1.0 onward
• All S7-300/400 CPUs with the "Standard Library → IEC Function Blocks" included

If GT_STRNG is missing from the catalog in TIA Portal, check that the project's library references include the CPU-specific standard library for your target. On older STEP 7 V5.x projects migrating to TIA Portal, the FC numbers may have shifted; always re-verify by opening the block rather than relying on legacy documentation.