IEC 61131-3 & POO Codesys : types, POU, classes, héritage, interfaces, pointeurs

Comprendre la programmation orientée objet dans Codesys : FB, méthodes, propriétés, héritage, interfaces et architecture IEC

📘

Types de Données IEC 61131-3

Types Elémentaires & Conventions- Chaque type de variable IEC possède un préfixe recommandatif (PLCopen) pour une lisibilité immédiate.

VAR
    xEnable     : BOOL := FALSE;    // x : Boolean (1 bit)
    bByteVal    : BYTE := 16#FF;    // b : Byte (8 bits, masques)
    iCounter    : INT := -120;      // i : Integer signatif (16 bits)
    uiCount     : UINT := 40000;    // ui : Unsigned Int (16 bits)
    diEncoder   : DINT := 100000;   // di : Double Int (32 bits)
    rTemp       : REAL := 23.5;     // r : Float simple précision (32 bits)
    lrPrecision : LREAL := 3.14159; // lr : Float double précision (64 bits)
    tDelay      : TIME := T#2s500ms;// t : Durée (TIME)
    sDevName    : STRING[30] := 'Pump_1'; // s : Chaîne ASCII
END_VAR

Structures, Énumérations & Alias- Les types utilisateur (DUT) permettent d'encapsuler la donnée. Préfixes : st (Struct), e (Enum), a (Array).

// TYPE ENUM (eState)
TYPE eAxisState : (INIT, STOPPED, MOVING, ERROR); END_TYPE
// TYPE STRUCT (stConfig)
TYPE stAxisConfig :
STRUCT
    rMaxSpeed : REAL := 1000.0;
    rAccel    : REAL := 100.0;
    xReversed : BOOL := FALSE;
END_STRUCT
END_TYPE
// Declaration
VAR
    eState : eAxisState := eAxisState.INIT;
    stCfg  : stAxisConfig;
    aSpeed : ARRAY[1..5] OF REAL := [10.0, 20.0, 30.0, 40.0, 50.0];
END_VAR

🧩

Unités d'Organisation de Programme (POU)

PROGRAM (PRG) vs FUNCTION (FUN)- Un PRG a une mémoire permanente et est exécuté par une Tâche. Une FUN est sans mémoire (pure) et retourne une valeur unique.

// FUNCTION (Sans état interne)
FUNCTION F_CelsiusToFahrenheit : REAL
VAR_INPUT
    rCelsius : REAL;
END_VAR
    F_CelsiusToFahrenheit := (rCelsius * 9.0 / 5.0) + 32.0;
END_FUNCTION
// Utilisation dans un PRG
PROGRAM PLC_PRG
VAR
    rAmbTempC : REAL := 21.5;
    rAmbTempF : REAL;
END_VAR
    rAmbTempF := F_CelsiusToFahrenheit(rAmbTempC);
END_PROGRAM

FUNCTION_BLOCK (FB) - L'Instance et la Mémoire- Un FB possède un état interne conservé entre chaque cycle. En POO, il sert de classe d'objet.

FUNCTION_BLOCK FB_Blinker
VAR_INPUT
    tToggleTime : TIME := T#1s;
END_VAR
VAR_OUTPUT
    xOut : BOOL;
END_VAR
VAR
    tonTimer : TON; // Bloc temporisateur standard IEC
END_VAR
tonTimer(IN := NOT tonTimer.Q, PT := tToggleTime);
IF tonTimer.Q THEN
    xOut := NOT xOut;
END_IF

⚙️

POO CODESYS - Classes, Méthodes & Propriétés

Encapsulation & Spécificateurs d'Accès- Un FB joue le rôle de Classe. Les Méthodes et Propriétés permettent de séparer l'interface de l'implémentation (PUBLIC, PRIVATE, PROTECTED, INTERNAL).

FUNCTION_BLOCK FB_Valve
VAR_OUTPUT
    xIsOpen : BOOL; // Visible depuis l'extérieur
END_VAR
VAR PRIVATE
    iErrorID : INT := 0; // Masqué pour les accès externes direct
END_VAR
// METHOD PUBLIC : Action exécutable sur l'objet
METHOD PUBLIC Open : BOOL
    xIsOpen := TRUE;
    Open := TRUE;
END_METHOD

Propriétés (PROPERTY) - Getters & Setters- Permettent de lire ou modifier de manière contrôlée des variables internes sans passer par des entrées directes.

// PROPERTY Speed : REAL (Contrôle d'accès à rInternalSpeed)
PROPERTY PUBLIC Speed : REAL
// Getter (Lecture)
GET
    Speed := rInternalSpeed;
// Setter (Écriture avec validation)
SET
    IF Speed > 100.0 THEN
        rInternalSpeed := 100.0;
    ELSE
        rInternalSpeed := Speed;
    END_IF

🏗️

POO CODESYS - Héritage & Interfaces

Héritage (EXTENDS)- Un FB enfant hérite des variables, propriétés et méthodes de son parent, et peut surcharger (override) son comportement.

// FB Parent
FUNCTION_BLOCK FB_Sensor
VAR
    rRawValue : REAL;
END_VAR
METHOD PUBLIC Read : REAL
    Read := rRawValue;
END_METHOD
// FB Enfant (Extension)
FUNCTION_BLOCK FB_CalibratedSensor EXTENDS FB_Sensor
VAR
    rOffset : REAL := 1.5;
END_VAR
// Surcharge de la méthode Read
METHOD PUBLIC OVERRIDE Read : REAL
    Read := SUPER^.Read() + rOffset; // Appel du parent via SUPER^
END_METHOD

Interfaces (INTERFACE & IMPLEMENTS)- Définit un contrat standardisé. Permet le polymorphisme et le découplage fort (Ex: I_Drive, I_Logger).

// INTERFACE I_Actuator
INTERFACE I_Actuator
METHOD Run : BOOL
END_METHOD
METHOD Stop : BOOL
END_METHOD
END_INTERFACE
// FB Implémentant l'Interface
FUNCTION_BLOCK FB_Conveyor IMPLEMENTS I_Actuator
METHOD Run : BOOL
    // Implémentation spécifique au convoyeur
    Run := TRUE;
END_METHOD
METHOD Stop : BOOL
    Stop := TRUE;
END_METHOD

🔗

Pointeurs, Références & Gestion Mémoire

Pointeurs (POINTER TO) vs Références (REFERENCE TO)- Utilisés pour passer des objets légers sans copie mémoire. Les Références gèrent le déférencement automatiquement.

VAR
    stData : stAxisConfig;
    pData  : POINTER TO stAxisConfig; // Adresse mémoire explicit (ADR)
    refData: REFERENCE TO stAxisConfig; // Alias sécurisé (REF=)
END_VAR
// Pointeur
pData := ADR(stData);
IF pData <> 0 THEN
    pData^.rMaxSpeed := 500.0; // Déférencement obligatoire (^)
END_IF
// Référence
refData REF= stData;
IF __ISVALIDREF(refData) THEN
    refData.rMaxSpeed := 500.0; // Accès direct transparent
END_IF

Pointeur Spécial THIS^- Accès explicite à l'instance courante du Function Block dans ses propres méthodes.

METHOD PUBLIC SetSelfParam : BOOL
VAR_INPUT
    rMaxSpeed : REAL;
END_VAR
    // Ambiguïté levée grâce à THIS^
    THIS^.rMaxSpeed := rMaxSpeed;
END_METHOD

📐

Conventions de Nommage & Architecture IEC/POO

Tableau Synthetique des Préfixes Standardisés- Conventions d'écriture unifiées pour l'ensemble du projet CODESYS (PLCopen / Guidelines).

// PREFIXES D'OBJETS ET TYPES
PRG_   : Program (ex: PRG_MotionControl)
FB_    : Function Block (ex: FB_AxisServo)
F_     : Function (ex: F_MathCalc)
I_     : Interface (ex: I_MotorControl)
ST_    : Structure (ex: ST_AlarmData)
E_     : Enumeration (ex: E_MachineMode)
GVL_   : Global Variable List (ex: GVL_IO)
// PREFIXES DE VARIABLES & SCOPE
g_     : Variable Globale (ex: g_xEmergencyStop)
i_     : Entrée de FB/FUN (ex: i_rSetPoint)
q_     : Sortie de FB/FUN (ex: q_xDriveReady)
iq_    : InOut de FB/FUN (ex: iq_stStatus)

Règles d'Or d'Architecture en Automatisme- Principes de conception pour une application modulaire, maintenable et testable.

1. ZÉRO VARIABLE GLOBALE EN ÉCRITURE : Les GVL doivent être en lecture seule.
   Utiliser des méthodes / interfaces pour échanger des données.
2. UN FB = UNE RESPONSABILITÉ : Ne pas créer un FB monolithique 'Tout-en-un'.
3. DÉCOUPAGE PAR TÂCHES :
   - Task_Fast (1-2ms) : Régulation, Fast IO, Safety
   - Task_Main (10ms)  : Sequencier, Logique Métier, POO
   - Task_HMI (50-100ms) : Traitement IHM, Alarmes, Gateway
4. VÉRIFICATION DES RÉFÉRENCES : Toujours valider les pointeurs (ADR != 0)
   et références (__ISVALIDREF) avant toute lecture/écriture.