Structs and enumerations

From loose variables to one thing

Every transmitter in the plant carries the same companions: a value, limits, a validity flag. With separate variables:

LT101_Value : REAL;
LT101_HiLim : REAL;
LT101_LoLim : REAL;
LT101_Bad   : BOOL;
LT102_Value : REAL;
LT102_HiLim : REAL;
(* ... and so on for forty transmitters *)

A hundred and sixty variables, and adding one field means editing forty places.

STRUCT

TYPE T_Analog :
STRUCT
  Value : REAL;
  HiLim : REAL;
  LoLim : REAL;
  Bad   : BOOL;
  HiAlm : BOOL;
END_STRUCT
END_TYPE

Then:

VAR
  LT101 : T_Analog;
  LT102 : T_Analog;
END_VAR

LT101.Value := RawLevel;
LT101.HiAlm := LT101.Value > LT101.HiLim;

Dot access, exactly like reading T1.Q from a timer. A fifth field is written once in the TYPE and appears on all forty.

Vendors call this a UDT, a user-defined type. It is also what lets a whole group of signals travel as one unit into a function block or out to the HMI.

Enumerations

This is where readability is really won. A state machine in numbers:

IF State = 2 THEN
  ...
ELSIF State = 5 THEN

What is 2? What is 5? You know today. You will not know in a year, and the technician opening the program at night never will. An enumeration gives the numbers names:

TYPE E_TankState : (
  Idle,
  Filling,
  Holding,
  Draining,
  Fault
);
END_TYPE

VAR
  State : E_TankState;
END_VAR

State := Filling;

CASE State OF
  Idle:
    ...
  Filling:
    ...
  Draining:
    ...
END_CASE;

Why the name beats the number

• It reads itself. IF State = Draining needs no comment and no spreadsheet.
• The compiler protects you. State := 7, or a value from a different enumeration, is rejected at build time instead of in the plant.
• It extends cleanly. Adding a state breaks nothing, and some compilers warn you about a CASE that no longer covers them all.
• It shows up by name in tools. The watch table says Draining, not 3.

You can pin the values when something external depends on them, such as a comms protocol:

TYPE E_Mode : (Manual := 0, Auto := 1, Service := 9); END_TYPE

If your compiler has no enumerations

Some older platforms do not. The acceptable fallback is named constants:

VAR CONSTANT
  ST_IDLE     : INT := 0;
  ST_FILLING  : INT := 1;
  ST_DRAINING : INT := 3;
END_VAR

You keep the readability and lose the compiler's protection against an invalid value. Still far better than a bare number in the middle of a CASE.

Not runnable in the lab

The lab supports neither TYPE, STRUCT nor enumerations. The lab program below uses an INT for the state with a comment explaining each number, which is the weakest form still worth accepting. Read it and notice how often you scroll back to that comment to follow the CASE.