Aller au contenu
ELECTRONICS ENGINEERINGelectronics-engineering.com
Conception de systèmes automatisés

Programmer les automates : IEC 61131-3, temps de réponse et blocs fonctionnels

Les cinq langages, temps de réponse au pire cas démontré avec un exemple, tâches et priorités, un bloc fonctionnel en texte structuré, bonnes pratiques de conception et d'essai.

https://www.electronics-engineering.com/fr/programmation-des-automates-iec-61131-3-texte-structure-temps-de-reponse/

Pas encore de vote : soyez le premier à noter cette page.

Le logiciel d’une installation moderne peut compter des centaines de milliers de lignes et rester en service pendant des décennies, modifié par des personnes différentes. La norme IEC 61131-3 fixe les langages des automates, mais écrire un bon programme demande aussi les règles du génie logiciel. Dans cette leçon, nous regardons les langages de la norme, le temps de réponse d’un automate au pire cas avec sa démonstration et un exemple, les tâches et les priorités, les blocs fonctionnels avec un exemple en texte structuré, et les bonnes pratiques de conception et d’essai.

Les langages

L’IEC 61131-3 définit cinq langages, qui peuvent coexister dans le même projet :

  • LD (ladder diagram, langage à contacts) : le schéma à relais, lisible par les électriciens, adapté à la logique booléenne simple (leçon de Contrôle des processus sur les automates) ;
  • FBD (function block diagram, schéma de blocs fonctionnels) : des blocs reliés par des fils, naturel pour les boucles de régulation ;
  • ST (structured text, texte structuré) : un langage textuel proche du Pascal, avec expressions, boucles et structures ; le mieux adapté aux algorithmes, aux calculs et aux machines à états ;
  • SFC : les séquences (leçon sur les séquences) ;
  • IL (instruction list, liste d’instructions), proche de l’assembleur, déclaré obsolète dans la troisième édition de la norme.

La troisième édition (2013) a ajouté la programmation orientée objet : méthodes, interfaces, héritage des blocs fonctionnels.

Le cycle et le temps de réponse

Un automate travaille en cycle : il lit toutes les entrées dans une image mémoire, exécute le programme sur cette image, écrit toutes les sorties. Le cycle dure T_s, de moins d’une milliseconde à quelques dizaines.

Temps de réponse d'un automate au pire cas
Chaque cycle de durée T s comprend la lecture des entrées I, l’exécution du programme P et l’écriture des sorties O. Si l’entrée x change juste après avoir été lue, elle n’est vue qu’au cycle suivant, et la sortie y change à la fin de ce cycle : environ deux cycles plus tard.

Théorème. Le temps entre le changement d’une entrée et le changement de la sortie qui en dépend est au plus d’environ 2T_s, plus le filtre d’entrée et les retards de sortie.

Démonstration. Dans le pire cas, l’entrée change juste après la lecture des entrées : le programme de ce cycle utilise encore l’ancienne valeur, et la nouvelle est lue au début du cycle suivant, après presque T_s. Le programme la traite et la sortie est écrite à la fin de ce cycle, après encore T_s. En tout, presque 2T_s, auxquels s’ajoutent le filtre d’entrée (contre les rebonds et le bruit) et le temps de commutation de la sortie. ∎

Exemple. Un cycle de 10 ms, un filtre d’entrée de 3 ms, une sortie à relais de 10 ms : jusqu’à 2\cdot 10 + 3 + 10 = 33 ms. Une impulsion d’entrée plus courte qu’un cycle peut même ne jamais être vue. Pour les événements rapides, on utilise des entrées d’interruption, des compteurs rapides matériels ou des tâches à cycle plus court.

Tâches et priorités

Le programme est divisé en tâches de périodes et de priorités différentes : une tâche rapide (1-2 ms) pour les fonctions critiques, une normale (10-20 ms) pour la logique, une lente (100 ms ou plus) pour les fonctions de service, plus des tâches déclenchées par événement. C’est le même ordonnancement à priorités fixes que dans les systèmes temps réel (leçon de Systèmes d’exploitation sur les systèmes temps réel) : la charge des tâches rapides doit rester basse, et l’automate surveille le temps de cycle avec un chien de garde qui amène les sorties en état sûr s’il est dépassé.

Les blocs fonctionnels

Un bloc fonctionnel (FB) est un module avec des entrées, des sorties et une mémoire interne ; on en crée autant d’instances qu’il y a de machines identiques. La norme en fournit quelques-uns, comme les temporisateurs (TON, TOF, TP) et les détecteurs de front (R_TRIG). Un exemple en texte structuré : la commande d’une pompe comme machine à états, avec protection thermique et réarmement.

FUNCTION_BLOCK FB_Pump
VAR_INPUT
    Start, Stop, Thermal : BOOL;      (* Thermal = thermal relay tripped *)
END_VAR
VAR_OUTPUT
    Contactor, Alarm : BOOL;
END_VAR
VAR
    State : INT := 0;                 (* 0 stopped, 1 running, 2 fault *)
END_VAR

CASE State OF
    0:  Contactor := FALSE;
        IF Start AND NOT Stop AND NOT Thermal THEN State := 1; END_IF;
    1:  Contactor := TRUE;
        IF Thermal THEN State := 2;
        ELSIF Stop THEN State := 0; END_IF;
    2:  Contactor := FALSE;
        Alarm := TRUE;
        IF NOT Thermal AND Stop THEN      (* reset: fault cleared and confirmed *)
            Alarm := FALSE; State := 0;
        END_IF;
END_CASE;
END_FUNCTION_BLOCK

Chaque état déclare explicitement ses sorties ; le défaut a la priorité sur l’arrêt ; le réarmement exige que la cause ait disparu et une action de l’opérateur, si bien que la pompe ne redémarre pas toute seule. Dix pompes sont dix instances du même bloc, testé une seule fois.

Les bonnes pratiques

  • Structure : de petits blocs à but clair ; pas de variables globales utilisées partout ; des noms parlants et une convention partagée.
  • Séparation entre logique de process, gestion des modes, alarmes et interface opérateur.
  • Bibliothèques de blocs testés pour les composants récurrents (moteurs, vannes, régulateurs), qui uniformisent le code et réduisent les erreurs.
  • Gestion de versions du code, avec l’historique des modifications : les environnements modernes exportent les projets dans un format textuel (PLCopen XML) précisément pour cela.
  • Essais : tests des blocs sur simulateur, tests automatiques de non-régression, et mise en service virtuelle avec un modèle de l’installation (leçon sur la mise en service).
  • Commentaires qui expliquent pourquoi, non comment.
  • Pour la commande de mouvement, les spécifications PLCopen normalisent les blocs (MC_MoveAbsolute et semblables) entre constructeurs (leçon sur les entraînements).
S’abonner
Notifier de
guest
1 commentaire
Le plus ancien
Plus récent Les plus votés
1
0
Vous avez apprécié cet article ? Merci de laisser un commentaire.x