Siemens PLC Data Types – Complete STEP 7 & TIA Portal Guide

• Choose the smallest practical type that still covers the engineering range.
• Use signed or unsigned types deliberately instead of treating every value as a generic integer.
• Group repeated machine objects with STRUCTs and PLC data types / UDTs.
• Confirm support on the target CPU before using newer long, Unicode, reference or generic types.

1. Why Siemens PLC Data Types Matter

Data types are easy to overlook because they sit behind every tag, parameter and data-block member. But the type you choose affects memory usage, usable range, arithmetic behavior, interfaces and code readability. A poor choice can lead to overflow, unnecessary memory allocation or code that is difficult to maintain.

2. Siemens PLC Data Type Families

3. Binary Types: BOOL, BYTE, WORD, DWORD and LWORD

At the lowest level, PLCs process individual bits and groups of bits. BOOL represents one logical state: TRUE or FALSE. It is ideal for switches, permissives, interlocks, alarm states and running feedback.

SCL example – BOOL logic

VAR
  pump_enabled : BOOL := FALSE;
  pump_fault : BOOL := FALSE;
END_VAR

pump_enabled := start_button AND NOT pump_fault;

For grouped binary data, Siemens provides BYTE (8 bits), WORD (16 bits) and DWORD (32 bits). On newer platforms, LWORD extends the same concept to 64 bits. These types are useful for status words, masks, raw device data and bitwise operations.

VAR
  device_status : DWORD := 0;
END_VAR

device_status.0 := 1;    // Device ready
device_status.2 := 1;    // Communication OK

4. Whole Numbers: Signed and Unsigned Integers

Integer types are the workhorses of counting, indexing and discrete calculations. Signed types allow negative and positive values, while unsigned types use the same bit width entirely for zero and positive values.

SCL example – production totals

VAR
  total_parts_produced : DINT := 0;
  parts_this_cycle : INT := 50;
  daily_target : DINT := 10000;
END_VAR

total_parts_produced := total_parts_produced + parts_this_cycle;

Unsigned types are particularly useful when a value can never be negative. They can represent a larger positive range than a signed type of the same width and also communicate that engineering intent to anyone reading the program.

VAR
  led_brightness : USINT := 75;
  pwm_value : USINT;
END_VAR

pwm_value := (led_brightness * 255) / 100;

5. Decimal Values: REAL and LREAL

REAL is a 32-bit floating-point type commonly used for analog values, process variables, scaling and engineering calculations. LREAL is a 64-bit floating-point type used where higher precision or a wider numeric range is required and supported by the CPU.

VAR
  voltage : REAL := 10.5;
  current : REAL := 2.3;
  power : REAL;
END_VAR

power := voltage * current;

6. Timer and Duration Types: S5TIME, TIME and LTIME

S5TIME is a legacy Siemens time format retained for compatibility with older projects. TIME is the standard IEC duration type and is widely used for delays, elapsed times and timer parameters. LTIME extends duration handling on supported modern CPUs with much larger range and finer resolution.

VAR
  input_signal : BOOL;
  timer_value : TIME := T#0s;
  max_delay : TIME := T#5s;
  output_signal : BOOL := FALSE;
END_VAR

IF timer_value < max_delay THEN
  timer_value := timer_value + T#10ms;
ELSE
  output_signal := TRUE;
END_IF;

7. Calendar and Clock Types

Automation systems often need both durations and actual timestamps. DATE stores a calendar date, while TIME_OF_DAY (TOD) stores a time of day. Legacy DT (DATE_AND_TIME) combines date and clock information for timestamping and logging.

Newer platforms add types such as DTL, which exposes individual timestamp fields including year, month, day, weekday, hour, minute and second. Higher-resolution long variants include LDT and LTOD on supported CPUs.

VAR
  current_dtl : DTL;
END_VAR

IF (current_dtl.weekday = 5) AND (current_dtl.hour = 22) THEN
  is_maintenance_day := TRUE;
END_IF;

8. Text Types: CHAR, STRING, WCHAR and WSTRING

CHAR stores a single one-byte character, while STRING stores a sequence of single-byte characters. On S7-1200/1500-class systems, standard STRING is commonly declared with a maximum of up to 254 characters. For Unicode text, newer platforms provide WCHAR and WSTRING.

VAR
  device_type : STRING := 'Pump';
  device_number : INT := 3;
  device_id : STRING;
END_VAR

device_id := CONCAT(device_type, '_', INT_TO_STRING(device_number));
// Result: 'Pump_3' 

9. ARRAY, STRUCT and PLC Data Types / UDTs

Complex data types are essential for scalable automation software. A reusable PLC data type / UDT groups related fields into one named engineering object. For example, speed, direction, current, status and enable information for a motor can be defined once and reused consistently across data blocks and block interfaces.

TYPE Motor_Control
  STRUCT
    speed : INT;
    direction : BOOL;
    current_draw : REAL;
    status : STRING;
    enabled : BOOL;
  END_STRUCT
END_TYPE

VAR
  main_motor : Motor_Control;
END_VAR

main_motor.speed := 1800;
main_motor.enabled := TRUE;

An anonymous STRUCT is useful when the grouped layout is required only locally. An ARRAY creates an indexed collection of elements of the same type and is ideal for sensor banks, recipes, production values and repeated machine data.

VAR
  sensor_array : ARRAY[1..16] OF REAL;
  max_reading : REAL := 0.0;
END_VAR

FOR sensor_index := 1 TO 16 DO
  IF sensor_array[sensor_index] > max_reading THEN
    max_reading := sensor_array[sensor_index];
  END_IF;
END_FOR;

10. POINTER, ANY, REFERENCE TO and VARIANT

Advanced Siemens programming includes several forms of indirect or generic data access. Classic POINTER and ANY types are strongly associated with legacy S7 programming and compatibility scenarios. Modern projects increasingly use more type-aware mechanisms where supported.

REFERENCE TO provides typed references on supported newer CPUs, while VARIANT is used in generic block interfaces when the concrete data type can vary at runtime and the called instruction is designed to handle that behavior.

VAR
  temperature : REAL := 25.0;
  temp_ref : REFERENCE TO REAL;
END_VAR

temp_ref := ADR(temperature);
temp_ref^ := 30.0;

FUNCTION Log_Value
  VAR_INPUT
    value : VARIANT;
    label : STRING;
  END_VAR
BEGIN
  // Generic processing depends on the supported VARIANT instructions.
END_FUNCTION

11. System and Hardware Types

STEP 7 also provides predefined types for system functions and physical hardware. Examples include standardized timer/counter structures, error-information structures and communication parameter types. Hardware-related types represent configured devices and I/O resources so program blocks can work with engineering objects rather than only raw numeric addresses.

12. Which Siemens CPU Supports Which Data Types?

The following quick-reference table follows the supplied STEP 7 data-type overview. Always check the exact CPU firmware and TIA Portal version before treating the table as a compile-time guarantee.

13. Siemens PLC Data Type Best Practices

• Right-size the type. Do not allocate a large numeric type when a smaller range is guaranteed and the smaller type improves clarity.
• Use signed and unsigned values intentionally. Select unsigned types when negative values are impossible and the CPU/platform supports them.
• Build reusable UDTs for complex equipment. Repeated device structures are easier to maintain when their members are centrally defined.
• Check the target CPU. Long, Unicode, reference and generic types are not universal across all S7 generations.
• Keep time-critical logic efficient. Avoid unnecessary floating-point and heavy string manipulation inside tight cyclic loops.
• Declare realistic string lengths. Reserving only the required text length improves memory discipline and documents the intended interface.