SCL Mathematics: Arithmetic, Comparison, Logic, and Conversion Operators

This reference covers all mathematical and logical operators available in Siemens SCL (Structured Control Language), including operator precedence, data type rules, and type conversion functions. SCL follows the IEC 61131-3 Structured Text standard with Siemens-specific extensions.

Arithmetic Operators#

Data type rules for arithmetic:

• INT + INT = INT
• INT + DINT = DINT (result takes the larger type)
• REAL + INT = REAL (floating-point wins)
• REAL + REAL = REAL
• INT / INT = INT (truncated, not rounded: 7 / 2 = 3, not 3.5)
• To get a REAL result from INT division: convert first, then divide

Example — Integer vs. REAL division:

// WRONG: integer division truncates
result_int := 7 / 2;           // result_int = 3 (not 3.5)

// RIGHT: convert to REAL first
result_real := INT_TO_REAL(7) / INT_TO_REAL(2);  // result_real = 3.5

Comparison Operators#

All comparison operators return BOOL (TRUE or FALSE).

Data type rules for comparison:

• Both operands must be compatible types
• INT can be compared with DINT (implicit conversion)
• REAL comparisons: beware of floating-point precision (use a tolerance band for equality checks)

Example — Floating-point comparison with tolerance:

// WRONG: exact equality on REAL is unreliable
IF temperature = 100.0 THEN ...    // may never be exactly 100.0

// RIGHT: use tolerance band
IF ABS(temperature - 100.0) < 0.1 THEN ...    // within 0.1 degrees

Logical Operators#

Logical operators work on BOOL values. When applied to WORD/DWORD, they operate bitwise.

BOOL examples:

// Motor runs if start pressed AND no fault AND not stopped
Motor := Start AND NOT Fault AND NOT Stop;

// Alarm if temperature too high OR pressure too high
Alarm := (Temp > 80.0) OR (Pressure > 6.0);

// Toggle: changes state on each call when trigger is TRUE
IF Trigger AND NOT Trigger_Old THEN
    Toggle := NOT Toggle;
END_IF;
Trigger_Old := Trigger;

Bitwise example (WORD):

// Mask bits 0-3 of a WORD
masked := input_word AND W#16#000F;   // keeps only lower 4 bits

// Set bit 7
output_word := input_word OR W#16#0080;

// Toggle bit 4
output_word := input_word XOR W#16#0010;

Operator Precedence (Highest to Lowest)#

Rule of thumb: Arithmetic first, then comparison, then logic. When in doubt, use parentheses — they make the code more readable and prevent precedence errors.

Type Conversion Functions#

SCL requires explicit conversion between incompatible types. On S7-1500, many conversions happen implicitly, but explicit conversion is best practice for portability and clarity.

Numeric Conversions#

BCD Conversions (Legacy Compatibility)#

Bit/Byte Conversions#

S7-1500 universal conversion: On S7-1500, you can also use the CONVERT instruction or implicit conversion in many cases.

Numeric Functions (Math Library)#

All trigonometric functions use radians, not degrees. To convert: radians := degrees * 3.14159 / 180.0;

Practical Example: Analog Scaling#

A common real-world application combining arithmetic, conversion, and comparison:

// Scale raw analog input (0–27648) to engineering units (0.0–100.0 bar)
VAR
    raw_value   : INT;      // From analog input module
    pressure    : REAL;     // Engineering units
    high_alarm  : BOOL;
END_VAR

pressure := INT_TO_REAL(raw_value) * 100.0 / 27648.0;

high_alarm := pressure > 85.0;  // Alarm at 85 bar

Analyze Your S5 Arithmetic Code#

PLCcheck Pro converts S5 arithmetic operations (+F, -F, ×F, :F) to clean SCL with correct type handling and overflow protection.

Upload code for conversion → | S5→S7 Migration Guide →

Part of the SCL Reference. Maintained by PLCcheck.ai. Not affiliated with Siemens AG.