Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Inheritance and Interfaces

Two mechanisms let one piece of code work with many types: a function block can build on another one, and it can promise to provide a set of methods.

Extending a function block

EXTENDS takes everything from the base block, its members and its methods, and adds to it:

FUNCTION_BLOCK Sensor
    VAR
        raw: DINT;
    END_VAR

    METHOD Read: DINT
        Read := raw;
    END_METHOD
END_FUNCTION_BLOCK

FUNCTION_BLOCK ScaledSensor EXTENDS Sensor
    METHOD OVERRIDE Read: DINT
        Read := SUPER^.Read() * 10;
    END_METHOD
END_FUNCTION_BLOCK

OVERRIDE replaces a method of the base. SUPER^ is the same instance seen as the base type, so SUPER^.Read() runs the method that was replaced. Without SUPER^, a call to Read() inside ScaledSensor reaches the new one.

The members of the base are members of the derived block, but the body is not. A call to the derived block runs its own body only. Write SUPER^(); in that body to run the body of the base as well.

Dispatch

A call through a variable of the base type runs the method of the actual instance, not the one of the declared type:

VAR
    scaled: ScaledSensor;
    any: REF_TO Sensor;
    value: DINT;
END_VAR

any := ADR(scaled);
value := any^.Read();   (* the method of ScaledSensor *)

The same holds inside the base block: in a method of Sensor, both Read() and THIS^.Read() run the method of ScaledSensor when the instance is a ScaledSensor.

Take the address with ADR. REF gives a pointer to the exact type of its argument, so any := REF(scaled) warns that REF_TO Sensor and ScaledSensor are different types, although the call works.

This is what makes a list of different sensors possible: they all have Read, and each one brings its own.

Interfaces

An interface is a set of method declarations without bodies. A function block that names it in IMPLEMENTS must provide those methods, and a missing one is rejected:

INTERFACE ISensor
    METHOD Read: DINT
    END_METHOD
END_INTERFACE

FUNCTION_BLOCK Analog IMPLEMENTS ISensor
    VAR
        raw: DINT;
    END_VAR

    METHOD Read: DINT
        Read := raw;
    END_METHOD
END_FUNCTION_BLOCK

A variable of the interface type holds any instance that implements it, and a call through it reaches the instance:

VAR
    analog: Analog;
    sensor: ISensor;
    value: DINT;
END_VAR

sensor := analog;
value := sensor.Read();

A parameter of an interface type is the usual way to write code that works with every implementation:

FUNCTION Report: DINT
    VAR_INPUT
        device: ISensor;
    END_VAR

    Report := device.Read();
END_FUNCTION

A VAR_IN_OUT parameter, a function or method VAR_OUTPUT, a VAR_INPUT {ref} parameter and a REFERENCE TO of an interface type refer to the caller’s interface variable itself, and a function block output is copied into it without conversion. Pass a variable of exactly that interface. An instance, even one that implements the interface, and a variable of another interface are rejected with E126:

FUNCTION Calibrate: DINT
    VAR_IN_OUT
        device: ISensor;
    END_VAR
END_FUNCTION

Calibrate(sensor);  (* fine *)
Calibrate(analog);  (* error[E126]: Type mismatch: expected type 'ISensor' but received 'Analog'; assign 'analog' to a variable of type 'ISensor' before passing it to 'Calibrate' *)

A note (E159) at the declaration of device adds why: Parameter 'device' is passed by reference and needs a variable of type 'ISensor'.

To pass an instance, assign it to an interface variable first, as sensor := analog does above. To store a function block output in a variable of a parent interface, call the block and assign the output afterwards, for example block(); parent := block.result;.

Use an interface when the implementations have nothing in common but their operations, and EXTENDS when they share data or behavior.

Classes

Neither mechanism is limited to the function block. A CLASS is a function block without a body. It holds members and methods, and you reach it through its methods:

CLASS Formatter
    VAR
        width: DINT;
    END_VAR

    METHOD Pad: DINT
        Pad := width;
    END_METHOD
END_CLASS

A statement outside a method is rejected, because a class cannot have an implementation, and THIS is not available in a class either. Everything else, EXTENDS, IMPLEMENTS, methods, and properties, works as in a function block. Use a class for a type that has no cyclic behavior of its own.

Access modifiers

A block that others extend often wants to say which of its declarations they may use. A member or a method can carry PUBLIC, PRIVATE, PROTECTED, or INTERNAL for that:

FUNCTION_BLOCK Box
    VAR PROTECTED
        state: DINT;
    END_VAR

    METHOD PUBLIC Open: DINT
        Open := state;
    END_METHOD
END_FUNCTION_BLOCK

Warning

The compiler parses the four modifiers and then ignores them. They do not change what a caller may touch.

Every VAR member counts as private to the block that declares it, whatever the modifier says. A read of state from outside, and also from a block that extends Box, gets the warning Illegal access to private member Box.state. A modifier on a method changes nothing at all, so a PRIVATE method can be called from anywhere. The variable block decides what the outside may touch, not the modifier.

A POU and a method can also carry ABSTRACT or FINAL, and these two are parsed and ignored in the same way. A block declared FINAL can still be extended, a method declared FINAL can still be replaced, and a variable can take the type of a block declared ABSTRACT. A method declared ABSTRACT has no body, and a call to it returns the default value of its result type.

What’s next

One more mechanism writes code that works for many types, and it does so without instances: generic functions.