Guide détaillé : Structure du langage ladder + Fiche pratique

Le langage ladder (ou ladder logic) est un langage de programmation graphique utilisé principalement pour programmer des automates programmables industriels (API/PLC). Il est très populaire dans l’automatisation industrielle en raison de sa similitude avec les schémas électriques de relais, ce qui le rend facilement compréhensible par les électriciens et les ingénieurs. Ce guide détaille la structure du langage ladder, les éléments fondamentaux qui le composent, et comment les utiliser pour construire un programme.

1. Vue d’ensemble du langage ladder

Le langage ladder est représenté graphiquement sous la forme d’une « échelle » avec des lignes verticales et horizontales. L’échelle est constituée de deux barres verticales, appelées rails, et d’une série d’instructions qui se trouvent entre ces rails, symbolisant des connexions électriques logiques. Chaque instruction dans le programme ladder se trouve sur un « échelon » entre les deux rails.

Les échelons sont exécutés de haut en bas, et chaque échelon est évalué de gauche à droite. Si une condition est vraie sur un échelon, elle permet au « courant logique » de passer d’un côté à l’autre et d’activer ou de désactiver une sortie.

2. Éléments de base du ladder

Le langage ladder se compose de plusieurs éléments de base. Voici les principaux :

2.1 Contacts

Les contacts représentent des entrées dans le programme. Ils simulent le comportement des interrupteurs ou des boutons poussoirs, et ils peuvent être soit normalement ouverts (NO) ou normalement fermés (NC).

Contact normalement ouvert (NO) : Il permet au courant de passer uniquement lorsque la condition est vraie (contact fermé).

  |----[  ]----|   → Passe le courant lorsque la condition est vraie

Contact normalement fermé (NC) : Il bloque le passage du courant lorsque la condition est vraie (contact ouvert). Il permet au courant de passer lorsque la condition est fausse.

  |----[ / ]----|   → Passe le courant lorsque la condition est fausse

2.2 Bobines

Les bobines représentent des sorties dans le programme ladder. Elles sont activées ou désactivées selon les conditions des contacts sur le même échelon.

Bobine simple (sortie activée) : La bobine est activée lorsque le courant logique la traverse.

  |----(  )----|   → Active une sortie

Bobine à réinitialisation (sortie désactivée) : Elle est utilisée pour réinitialiser ou désactiver une sortie.

  |----( / )----|   → Désactive une sortie

2.3 Temporisateurs (Timers)

Les temporisateurs sont utilisés pour introduire un délai dans l’activation ou la désactivation d’une sortie.

Temporisateur à déclenchement (TON) : Il déclenche un événement après une période donnée une fois que l’entrée est vraie. Il commence à compter lorsque la condition est vraie.

  |----[ TON ]----|  → Temporisateur à activation

Temporisateur à désactivation (TOF) : Il commence à compter lorsque la condition devient fausse, et désactive la sortie après un délai.

  |----[ TOF ]----|  → Temporisateur à désactivation

2.4 Compteurs (Counters)

Les compteurs sont utilisés pour compter le nombre d’occurrences d’un événement (comme le passage d’un produit devant un capteur).

Compteur ascendant (CTU) : Incrémente la valeur du compteur lorsque l’entrée associée est vraie.

  |----[ CTU ]----|   → Compte vers le haut

Compteur descendant (CTD) : Décrémente la valeur du compteur.

  |----[ CTD ]----|   → Compte vers le bas

2.5 Instructions logiques

Le langage ladder permet également d’utiliser des instructions logiques telles que les opérations ET, OU, et NON, de manière implicite dans la manière dont les contacts sont disposés.

Opération ET : Elle est représentée par des contacts placés en série. Tous les contacts doivent être vrais pour que la sortie soit activée.

  |----[ NO ]----[ NO ]----( OUTPUT )----|  → Les deux conditions doivent être vraies pour activer la sortie.

Opération OU : Elle est représentée par des contacts placés en parallèle. Si l’un des contacts est vrai, la sortie est activée.

  |----[ NO ]----------------( OUTPUT )----|
  |----[ NO ]-------------------------------|

3. Construction d’un programme ladder

Un programme ladder est constitué d’une série d’échelons. Chaque échelon peut être comparé à une ligne d’instructions. Voici comment construire un programme ladder simple :

Exercice pratique : Allumer une lampe avec un bouton poussoir

Objectif : Créer un programme pour allumer une lampe lorsqu’un bouton poussoir est pressé.

Entrées/Sorties :

Bouton poussoir (PB) – NO
Lampe (LAMP) – Sortie

Logique :

Le bouton poussoir PB est normalement ouvert (NO).
Quand le bouton est pressé, la lampe s’allume.

|----[ PB ]-----------------( LAMP )----|

Explication :

Lorsque PB est pressé, le contact est fermé et la bobine LAMP est activée, allumant ainsi la lampe.

Exemple avec temporisateur : Activation d’une alarme après 5 secondes

Objectif : Activer une alarme 5 secondes après l’activation d’un capteur.

Entrées/Sorties :

Capteur (SENSOR) – NO
Alarme (ALARM) – Sortie
Temporisateur (TIMER) – 5 secondes

Logique :

Le capteur est activé lorsqu’il détecte un objet.
Une fois activé, un temporisateur de 5 secondes commence.
Après 5 secondes, l’alarme s’active.

|----[ SENSOR ]----------------[ TON, 5s ]-----( ALARM )----|

Explication :

Lorsque SENSOR est activé, le temporisateur (TON) commence à compter. Après 5 secondes, la bobine ALARM est activée.

4. Exemples complexes de logique ladder

Exemple 1 : Contrôle d’un moteur avec arrêt d’urgence et capteur

Objectif : Le moteur doit démarrer quand un bouton est pressé et s’arrêter si le capteur détecte une surcharge ou si un bouton d’arrêt d’urgence est activé.

Entrées/Sorties :

Bouton de démarrage (START) – NO
Capteur de surcharge (OVERLOAD_SENSOR) – NO
Arrêt d’urgence (EMERGENCY_STOP) – NO
Moteur (MOTOR) – Sortie

|----[ START ]----[ NOT OVERLOAD_SENSOR ]----[ NOT EMERGENCY_STOP ]----( MOTOR )----|

Explication :

Le moteur MOTOR démarre lorsque le bouton START est pressé, à condition qu’il n’y ait pas de surcharge (OVERLOAD_SENSOR) et que le bouton d’arrêt d’urgence (EMERGENCY_STOP) ne soit pas activé.

Exemple 2 : Compteur de produits avec réinitialisation

Objectif : Un compteur compte les produits passant devant un capteur, et se réinitialise après avoir atteint un total de 10.

Entrées/Sorties :

Capteur de produits (PRODUCT_SENSOR) – NO
Compteur (COUNTER)
Réinitialisation (RESET_BUTTON) – NO

|----[ PRODUCT_SENSOR ]----------------[ CTU, COUNTER ]----|
|----[ RESET_BUTTON ]------------------( COUNTER_RESET )---|

Explication :

Chaque fois qu’un produit passe devant PRODUCT_SENSOR, le compteur (COUNTER) est incrémenté. Quand RESET_BUTTON est pressé, le compteur est réinitialisé.

5. Meilleures pratiques en programmation ladder

Nommez clairement les variables : Utilisez des noms descriptifs pour les entrées et sorties comme START_BUTTON, MOTOR_ON, etc., pour faciliter la lecture du programme.
Utilisez des commentaires : Ajoutez des commentaires aux échelons pour expliquer la logique, surtout pour les programmes complexes.
Modularité : Si possible, divisez les grandes tâches en petites sous-fonctions ou blocs pour améliorer la lisibilité et la maintenabilité.
Testez et simulez régulièrement : Utilisez un simulateur pour tester chaque partie de votre programme avant de l’exécuter sur un automate réel.

Ce guide fournit une base solide pour comprendre la structure du langage ladder et ses composants. Avec de la pratique, vous pourrez aborder des projets plus complexes dans le domaine de l’automatisation industrielle.

Fiche Pratique : Structurer un Programme Complexe en Langage Ladder

Cette fiche pratique explique comment structurer un programme complexe en langage ladder pour des applications industrielles. Elle couvre les concepts clés, les étapes pour structurer un programme, et fournit des exemples pratiques de modularité et de gestion de séquences dans le contrôle des automates programmables industriels (API/PLC).

1. Concepts de Base du Langage Ladder

Contacts et Bobines : Les contacts (entrées) et bobines (sorties) sont les éléments de base du ladder. Les contacts peuvent être normalement ouverts (NO) ou normalement fermés (NC).
Temporisateurs et Compteurs : Les temporisateurs (TON, TOF) permettent d’introduire des délais, et les compteurs (CTU, CTD) servent à compter des événements ou produits.
Modules : Un programme complexe est souvent structuré en modules, chaque module gérant une fonction spécifique (ex. : contrôle d’une machine).
Séquences : Les séquences gèrent les étapes de processus en automatisant le démarrage ou l’arrêt d’éléments en fonction de conditions prédéfinies.

2. Importance de la Structure Modulaire

Structurer un programme ladder en modules offre plusieurs avantages :

Lisibilité : Facilite la compréhension du programme en séparant chaque tâche dans un bloc distinct.
Maintenance : Simplifie la modification et la mise à jour des programmes.
Réutilisation : Les modules peuvent être réutilisés dans d’autres programmes similaires.

3. Étapes pour Structurer un Programme Complexe en Modules

Étape 1 : Définir les Fonctions du Programme

Décomposez le système en plusieurs fonctions logiques. Par exemple, dans un système de pompage, les fonctions pourraient inclure :

Contrôle de la Pompe 1
Contrôle de la Pompe 2 en cas de panne de la pompe 1
Gestion du niveau d’eau avec des capteurs haut/bas

Étape 2 : Identifier les Entrées et Sorties

Pour chaque fonction, identifiez les entrées (capteurs, boutons, conditions) et sorties (moteurs, pompes, alarmes). Assurez-vous d’avoir une liste claire avant de commencer la programmation.

Étape 3 : Créer un Module Ladder pour Chaque Fonction

Programmez chaque fonction comme un module séparé. Par exemple :

Module 1 : Démarrage de la pompe 1
Module 2 : Activation de la pompe 2 en cas de panne de la pompe 1
Module 3 : Alarmes et indicateurs

Étape 4 : Assurer la Séquence Logique et les Interdépendances

Utilisez des temporisateurs et des compteurs pour gérer les séquences ou les étapes spécifiques. Dans un système de production, la machine 2 peut démarrer seulement après un délai suivant le démarrage de la machine 1.

4. Exemple Pratique : Programme de Contrôle pour une Chaîne de Production avec 3 Stations

Objectif : Structurer un programme ladder pour une chaîne de production. Chaque station démarre de manière séquentielle après une temporisation définie, avec arrêt automatique après un certain nombre de produits.

Éléments du Programme

Entrées :
Bouton de démarrage (START_BUTTON)
Bouton d’arrêt d’urgence (EMERGENCY_STOP)
Capteur de produit (PART_SENSOR)
Sorties :
Station 1 (STATION_1_ON)
Station 2 (STATION_2_ON)
Station 3 (STATION_3_ON)
Signal de maintenance (MAINTENANCE_SIGNAL)
Modules :
Module de démarrage et arrêt d’urgence
Module de séquence des stations
Module de comptage et maintenance

Structure Ladder des Modules

Module de Démarrage et Arrêt d’Urgence

   |----[ START_BUTTON ]--------------------( SYSTEM_START )-------|
   |----[ EMERGENCY_STOP ]------------------( SYSTEM_STOP )--------|

SYSTEM_START active le système lorsque le bouton de démarrage est pressé.
SYSTEM_STOP arrête immédiatement tout le système si le bouton d’arrêt d’urgence est activé.

Module de Séquence des Stations

Station 1 démarre immédiatement après l’activation de SYSTEM_START.
Station 2 démarre après 10 secondes de fonctionnement de Station 1.
Station 3 démarre après 5 secondes de fonctionnement de Station 2.

   |----[ SYSTEM_START ]-------------------( STATION_1_ON )---------|
   |----[ STATION_1_ON ]--[ TON1, 10s ]----( STATION_2_ON )---------|
   |----[ STATION_2_ON ]--[ TON2, 5s ]-----( STATION_3_ON )---------|

Module de Comptage et Maintenance

Un capteur compte le nombre de produits passant devant Station 1.
Si le compteur atteint 200, le système s’arrête et le signal de maintenance est activé.

   |----[ PART_SENSOR ]------------------[ CTU, COUNTER ]-----------|
   |----[ COUNTER >= 200 ]---------------( MAINTENANCE_SIGNAL )-----|

PART_SENSOR incrémente le compteur chaque fois qu’un produit passe.
Lorsque COUNTER atteint 200, MAINTENANCE_SIGNAL est activé, signalant l’arrêt du système pour maintenance.

5. Conseils pour Structurer des Programmes Ladder Complexes

Organisez les Échelons : Regroupez les échelons par fonction et utilisez des commentaires pour faciliter la compréhension.
Utilisez des Marques de Mémoire : Pour les valeurs temporaires ou intermédiaires, utilisez des marques de mémoire, ce qui rend le programme plus lisible.
Employez les Temporisateurs et Compteurs Judicieusement : Structurez les séquences avec des temporisateurs et des compteurs pour gérer les délais et les quantités.
Testez Chaque Module Indépendamment : Simulez chaque module séparément pour vous assurer que chaque partie fonctionne avant d’assembler le programme complet.
Documentez le Programme : Incluez des commentaires et documentations pour chaque module et variable.

6. Schéma Résumé de Structure Ladder pour une Chaîne de Production

|----[ Démarrage et Arrêt d'Urgence ]--------------------------------------------------|
| |----[ START_BUTTON ]--------------------( SYSTEM_START )---------------------------|
| |----[ EMERGENCY_STOP ]------------------( SYSTEM_STOP )----------------------------|

|----[ Séquence des Stations ]---------------------------------------------------------|
| |----[ SYSTEM_START ]-------------------( STATION_1_ON )----------------------------|
| |----[ STATION_1_ON ]----[ TON1, 10s ]----( STATION_2_ON )--------------------------|
| |----[ STATION_2_ON ]----[ TON2, 5s ]-----( STATION_3_ON )--------------------------|

|----[ Comptage et Signal de Maintenance ]---------------------------------------------|
| |----[ PART_SENSOR ]------------------[ CTU, COUNTER ]------------------------------|
| |----[ COUNTER >= 200 ]---------------( MAINTENANCE_SIGNAL )------------------------|

7. Avantages d’une Structure Modulaire en Ladder

Facilité de Débogage : Les erreurs peuvent être localisées dans des modules spécifiques.
Souplesse et Flexibilité : Chaque module peut être modifié sans affecter le reste du programme.
Scalabilité : De nouveaux modules peuvent être ajoutés sans perturber la logique existante.