• TIA Portal datatypes (S7-1500 / S7-1200 / S7-400 / S7-300)
  • TIA Coding of data types
  • TIA Coding of the memory area
• Simatic classic datatypes (S7-400 / S7-300)
• Data-types
  • Pointer
  • ANY
  • Variant
  • ARRAY
  • Real
  • Char
  • WChar
  • String
  • WString
  • S5time
  • IEC Timers
• Indirect addressing in Simatic Classic
• Indirect addressing in TIA Portal
  • TIA Portal slice access

List of data types used by Simatic S7. The page contains the more modern TIA variable types as well as the earlier S7-classic types.

There are four data types in: Boolean, Text, Numeric, and Date/Time. Each data type defines the format of information that can be entered into a data field and stored in your database.

The following table lists the coding of data types for the ANY pointer:

The following table lists the coding of the memory areas for the ANY pointer:

Pointer ## ANY ## Variant ## ARRAY ## Real ## Char ## WChar ## String ## WString ## S5time ## IEC Timers ##

An example above to the pointer: P#DB100.DBX14.0 WORD 4
The following elements make up a pointer:

You cannot use MOVE to access pointer data. This is because the Pointer is considered an “Any” data type, which MOVE does not accept. BLKMOV must be used instead, and in order to use that, Optimized Data must be turned off!

A parameter of the type POINTER is a pointer that can point to a specific tag. It occupies 6 bytes (48 bits) in memory and may contain the following tag information:

• DB number, or 0 if the data is not stored in a DB
• Memory area in the CPU
• Tag address

The following figure shows the structure of parameter type POINTER:

An ANY type parameter points to the start of a data area and specifies its length. An ANY pointer occupies 10 bytes of memory and may contain the following information:

Data type:
Data type of the elements of the data area

Repetition factor:
Number of elements of the data area

DB number:
Data block that contains the declaration of data area elements.

Memory area:
Memory area of the CPU that stores the data area elements.

Start address of the data in the format “byte.bit”:
Data area start identified by the ANY pointer.

Zero pointer:
Use the zero pointer to indicate a missing value. A missing value may indicate that no value exists, or that the value is not yet known. A zero value represents the absence of a value, but is also a value.

In the programming languages SCL and STL, memory of any kind can be transferred upon a block call if an ANY pointer has been programmed at a block parameter.

The ANY pointer cannot, however, store any information on the structure of the memory. For example, the ANY pointer does not save the information that it points to a tag of the PLC data type. The ANY pointer sees this as an ARRAY of BYTE.

Parameters of the ANY data type can be passed to system function blocks (SFBs) or system functions (SFCs).

A parameter of the VARIANT type is a pointer that can point to tags of different data types other than an instance. The VARIANT pointer can be an object of an elementary data type, such as INT or REAL. It can also be a STRING, DTL, ARRAY of STRUCT, UDT, or ARRAY of UDT. The VARIANT pointer can recognize structures and point to individual structure components. An operand of data type VARIANT occupies no space in the instance data block or work memory. However, it will occupy memory space on the CPU.

A tag of the VARIANT type is not an object but rather a reference to another object. Individual elements of the VARIANT type can only be declared on formal parameters within the block interface of a function in the VAR_IN, VAR_IN_OUT and VAR_TEMP sections. For this reason, it cannot be declared in a data block or in the static section of the block interface of a function block, for example, because its size is unknown. The size of the referenced objects can change.

You can use VARIANT to generate generic function blocks or functions. When a block is called, you can connect the parameters of the block to tags of any data type. When a block is called, the type information of the tag is transferred in addition to a pointer to the tag. The code of the block can then be executed according to its type in line with the tag transferred during runtime.

If, for example, a block parameter of a function has the VARIANT data type, then a tag of the integer data type can be transferred at one point in the program, and a tag of the PLC data type can be transferred at another point in the program. With the help of the VARIANT instructions, the function is then in a position to react to the situation without errors.

The Array data type represents a data structure that consists of a fixed number of components of the same data type. All data types except Array are permitted.

A tag with the Array data type always starts at a WORD limit.

The array components are addressed by means of an index. In the array declaration, the index limits are defined in square brackets after the keyword Array. The low limit must be smaller than or equal to the high limit. An array may contain up to six dimensions, the limits of which can be specified separated by a comma.

Length: Number of components * length of the data type
Format: Array [low limit…high limit] of <data type>
Index limits: Depending on the CPU, the storage capacity of a data block is limited and the number of components of the Array is therefore also limited. However, you may initialize the addressing of the array components at any position within index limits.
Index limits (16-bit limits): [-32768..32767] of <data type>
Index limits (32-bit limits): [-2147483648..2147483647] of <data type>
Data type: Bit strings, integers, floating-point numbers, timers, character strings, structures

• Sign (of Mantissa) : 0: positive, 1: negative
• (Biased) exponent : The exponent field needs to represent both positive and negative exponents.
• (Normalised) mantissa : Mantissa is part of a number in scientific notation or a floating-point number, consisting of its significant digits.

An operand of data type CHAR has a length of 8 bits and occupies one BYTE in the memory.

The CHAR data type stores a single character in ASCII format. You can find information on the encoding of special characters under “See also > STRING”.

Length (bits): 8
Format: ASCII characters
Value range: ASCII character set
Example of value inputs: 'A', CHAR#'A'

An operand of data type WCHAR (Wide Characters) has a length of 16 bits and occupies two BYTE in the memory.

The WCHAR data type saves a single character of an expanded character set which is stored in Unicode format. However, only a subset of the entire Unicode range is covered. When a control character is entered, it is represented with a dollar sign.

Length (bits): 16 bit
Format: Unicode
Range of values: $0000 - $D7FF
Example of value input: WCHAR#'a'

String types in S7 are not NULL “terminated” like C-style strings. They instead have 2 “hidden” characters that precede the string data. The first hidden character is the maximum size of the string, which is 'n' in the example above, and the second hidden character is the actual length of the string (i.e. the number of characters stored).

So the string definition MyStr: STRING[10]:=“abcdef” would contain the following ASCII codes:

10, 06, 97, 98, 99, 100, 101, 102

10: maximum (declared) length of the character string
06: the current length of the string
97, 98: “a”, “b”,..

Length (bits): n + 2 (An operand of the STRING data type occupies two bytes more than the specified maximum length in the memory)
Format: ASCII character string incl. special characters
Value range: 0 to 254 characters
Example of value inputs: 'Name', STRING#'NAME'

An operand of data type WSTRING (Wide String) stores several Unicode characters of data type WCHAR in one character string. If you do not specify a length, the character string has a preset length of 254 characters. In a character string, all characters of the Unicode format are permitted. This means you can also use Chinese characters in a character string.

Length (bits): n + 2 (An operand of the WSTRING data type occupies two WORDs more in the memory than the specified maximum length)
Format: Unicode character string;
Range of values: Preset value: 0 to 254 characters, maximal possible value: 0 to 16382
Example of value inputs: WSTRING#'Hello World'

When declaring an operand of data type WSTRING you can define its length using square brackets (for example WSTRING[10]). If you do not specify a length, the length of the WSTRING is set to 254 characters by default. You can declare a length of up to 16382 characters (WSTRING[16382]).

The specification of the characters occurs in single quotes and always with the qualifier WSTRING#.

A character string can also contain special characters. The escape character $ is used to identify control characters, dollar signs and single quotation marks.

The maximum length of the character string can be specified during the declaration of an operand using square brackets after the keyword WSTRING (for example, WSTRING[4]). If the specification of the maximum length is omitted, the standard length of 254 characters is set for the respective operand.

If the actual length of a specified character string is shorter than the declared maximum length, the characters are written to the character string left-justified and the remaining character spaces remain undefined. Only occupied character spaces are considered in the value processing.

Access to block parameters of data type WSTRING
Operands of the data type WSTRING can be transferred as parameters up to the maximum length for blocks with “optimized” access.

For function blocks (FB) with “standard” access, operands of the data type WSTRING can be declared as parameters in all sections of the block interface except in the section “InOut”. For a function (FC) with “standard” access, only operands of the data type STRING can be transferred as parameters.

The function value of an FC in the “Return” section and expressions in the SCL programming language are another exception to this rule. In these cases, the WSTRING tag must not be longer than 1022 characters. If you need a WSTRING tag with more than 1022 characters, declare a tag of the data type “WSTRING” with the required character length in the section “Temp” and assign the function value to the tag.

Example
The example below shows the byte sequence if the WSTRING[4] data type is specified with output value 'AB':

• Underscores in time and date are optional
• It is not necessary to specify all time units (for example: T# 5h10s is valid)
• Maximum time value = 9,990 seconds or 2H_46M_30S

You can find more information about these timer types here: SCL commands (timer, counter)

In many cases, indirect addressing may be necessary in PLC technology. Its typical application is the preparation of signals for communication and SCADA, as well as the transformation of communication and SCADA signals and the “unpacking” of bits.

For example

• In the case of SCADA transmission, it is easier to use a WORD and transfer 16 bits in it
• Modbus communication is based on WORD registers. These are easy to handle with indirect addressing
• Many measuring units use two of the Modbus WORD registers (DWORD) to transfer one REAL. Structurally, DWORD and REAL are not the same, but the signals can be easily read with indirect addressing

• from Bit to: BYTE, WORD, DWORD
• from Byte to: WORD, DWORD
• from Word to: DWORD

bit := byte.%X1;    // bit 1 from byte
bit := word.%X4;    // bit 4 from word
bit := dword.%X11;  // bit 11 from dword 
 
byte := word.%B1;   // 2.byte from word
byte := dword.%B2;  // 3. byte from dword
 
word := dword.%W0;  // 1. word from dword

// FC Input : inWord (Word)
// FC output: 16 variable bit0..bit15 (Bool)
// splitting
#bit0 := #inWord.%X0;
#bit1 := #inWord.%X1;
#bit2 := #inWord.%X2;
#bit3 := #inWord.%X3;
#bit4 := #inWord.%X4;
#bit5 := #inWord.%X5;
#bit6 := #inWord.%X6;
#bit7 := #inWord.%X7;
#bit8 := #inWord.%X8;
#bit9 := #inWord.%X9;
#bitA := #inWord.%X10;
#bitB := #inWord.%X11;
#bitC := #inWord.%X12;
#bitD := #inWord.%X13;
#bitE := #inWord.%X14;
#bitF := #inWord.%X15;

// FC Input: 16 variable bit00..bit15 (Bool)
// FC Output : OUT (Word)
// JOIN
// Assemble bits to a word
#OUT.%X0 := #bit00;
#OUT.%X1 := #bit01;
#OUT.%X2 := #bit02;
#OUT.%X3 := #bit03;
#OUT.%X4 := #bit04;
#OUT.%X5 := #bit05;
#OUT.%X6 := #bit06;
#OUT.%X7 := #bit07;
#OUT.%X8 := #bit08;
#OUT.%X9 := #bit09;
#OUT.%X10 := #bit10;
#OUT.%X11 := #bit11;
#OUT.%X12 := #bit12;
#OUT.%X13 := #bit13;
#OUT.%X14 := #bit14;
#OUT.%X15 := #bit15;

This page has been accessed for: Today: 2, Until now: 1011