Enumerations

An enumeration is a user-defined data type composed of a series of comma-separated components (enumeration values) for declaring user-defined variables. Moreover, you can use the enumeration components like constants whose identifier <enumeration name>.<component name> is recognized globally in the project.

You declare an enumeration in a DUT object, which you have already created in the project by clicking Add Object.

Declaration

Syntax

( {attribute 'strict'} )? // Pragma optional but recommended
TYPE <enumeration name> :
(
    <first component declaration>,
    ( <component declaration> ,)+
    <last component declaration>
)( <basic data type> )? ( := <default variable initialization> )? ;
END_TYPE

( ... )? : Optional
<component declaration> : <component name> ( := <component initialization> )?
<basic data type> : INT | UINT | SINT | USINT | DINT | UDINT | LINT | ULINT | BYTE | WORD | DWORD | LWORD
<variable initialization> : <one of the component names>

In an enumeration declaration, at least 2 components are usually declared. However, you can declare as many as you want. Every single component can be assigned its own initialization. Enumerations automatically have the basic data type INT, but you can specify another basic data type. Moreover, you can specify a component in the declaration with which an enumeration variable is then initialized.

The pragma {attribute 'strict'} causes a strict type test to be performed as described below.

Example

{attribute 'qualified_only'}
{attribute 'strict'}
TYPE COLOR_BASIC :
(
    yellow,
    green,
    blue,
    black
)
; // Basic data type is INT, default initialization for all COLOR_BASIC variables is yellow
END_TYPE

Enumeration with explicit basic data type

Extensions to the IEC 61131-3 standard

The basic data type for an enumeration declaration is INT by default. However, you can also declare enumerations that are based explicitly on another integer data type.

<basic data type> : INT | UINT | SINT | USINT | DINT | UDINT | LINT | ULINT | BYTE | WORD | DWORD | LWORD

Example

Enumeration with basic data type DWORD

TYPE COLOR :
(
    white := 16#FFFFFF00,
    yellow := 16#FFFFFF00,
    green := 16#FF00FF00,
    blue := 16#FF0000FF,
    black := 16#88000000
) DWORD := black; // Basic data type is DWORD, default initialization for all COLOR variables is black
END_TYPE

Strict programming rules

Hint

In CODESYS V3.5 SP7 and later, the pragma {attribute 'strict'} is added automatically in the first line when declaring an enumeration.

The strict programming rules are activated when adding the pragma {attribute 'strict'}.

The following code is considered a compiler error:

  • Arithmetic operations with enumeration components

    For example, an enumeration variable cannot be used as a counter variable in a FOR loop.

  • Assignment of a constant value, which does not correspond to an enumeration value, to an enumeration component

  • Assignment of a non-constant variable, which has another data type as the enumeration, to an enumeration component

Arithmetic operations can lead to undeclared values being assigned to enumeration components. A better programming style is to use SWITCH/CASE statements for processing component values.

Declaration and initialization of enumeration variables

Syntax

<variable name> : <enumeration name> ( := <initialization> )? ;

For a declaration of an enumeration variable with user-defined data type <enumeration name>, this can be initialized with an enumeration component.

Example

PROGRAM PLC_PRG
VAR
    colorCar: COLOR;
    colorTaxi : COLOR := COLOR.yellow;
END_VAR

The variable colorCar is initialized with COLOR.black. That is the default initialization for all enumeration variables of type COLOR and defined this way in the type declaration. The variable colorTaxi has its own initialization.

If no initializations are specified, then the initialization value is 0.

Example

PROGRAM PLC_PRG
VAR
    cbFlower : COLOR_BASIC;
    cbTree: COLOR_BASIC := COLOR_BASIC.green;
END_VAR

The variable cbFlower is initialized with COLOR_BASIC.yellow. That is the default initialization for all enumeration variables of type COLOR_BASIC. Because the enumeration declaration does not specify a component for initialization, the system automatically initializes with the component that has the value 0. This is usually the first of the enumeration components. However, it can also be another component that is not in the first position but explicitly initialized with 0.

The variable cbTree has an explicit initialization.

If no value is specified for both the type and the variable, then the following rule applies: If an enumeration contains a value for 0, then this value is the default initialization, and if not, then the first component in the list.

Example

Initialization with the 0 component

TYPE ENUM :
(
    e1 := 2,
    e2 := 0,
    e3
)
;
END_TYPE

PROGRAM PLC_PRG
VAR
    e : ENUM;
END_VAR

The variable e is initialized with ENUM.e2.

Initialization with the first component

TYPE ENUM2 :
(
    e1 := 3,
    e2 := 1,
    e3
)
;
END_TYPE

PROGRAM PLC_PRG
VAR
    e2 : ENUM2;
END_VAR

The variable e2 is initialized with ENUM.e1.

Unique access to enumeration components

Extensions to the IEC 61131-3 standard

The enumeration components can also be used as constant variables with the identifier <enumeration name>.<component name>. Enumeration components are recognized globally in the project and access to them is unique. Therefore, a component name can be used in different enumerations.

Example

Component blue

PROGRAM PLC_PRG
VAR
    cbFlower : COLOR_BASIC;
    colorCar : COLOR;
END_VAR

(* unambiguous identifiers although the component names are identical *)
cbFlower := COLOR_BASIC.blue;
colorCar := COLOR.blue;

(* invalid code *)
cbFlower := blue;
colorCar := blue;

See also