AUTOMATISME EN LOGIQUE PROGRAMMÉE

# AUTOMATISME EN LOGIQUE PROGRAMMÉE ## Généralités sur les Automates ### Introduction Bienvenue à ce cours sur les généralités des automates. L'automatisme est partout autour de nous, des feux de circulation aux lignes de production industrielles. Au cœur de nombreux systèmes automatisés se trouvent les automates programmables industriels (API). Ce cours vous donnera une introduction à ce qu'est un automate, comment il est structuré, comment il fonctionne et pourquoi il est si important dans le monde moderne. ### Concepts Clés #### Qu'est-ce qu'un Automate Programmable Industriel (API) ? Un Automate Programmable Industriel, souvent désigné par son acronyme API, est un ordinateur spécialisé conçu pour contrôler des processus industriels. Il est robuste, fiable et capable de fonctionner dans des environnements difficiles (poussière, humidité, vibrations). Les API remplacent les systèmes de commande câblés complexes et offrent une grande flexibilité. * **Rôle principal :** Gérer et contrôler automatiquement des machines ou des processus, en exécutant un programme logique prédéfini. * **Logique :** Les API exécutent une logique soit **combinatoire** (la sortie dépend uniquement de l'état actuel des entrées), soit **séquentielle** (la sortie dépend de l'état actuel des entrées ET des états précédents). #### Structure d'un Automate Un automate est généralement composé de plusieurs modules qui travaillent ensemble : * **Unité Centrale de Traitement (CPU) ou Processeur :** C'est le « cerveau » de l'automate. Il exécute le programme, gère les entrées/sorties et assure la communication. * **Mémoire :** Elle stocke le programme utilisateur, les données (valeurs des entrées/sorties, compteurs, temporisateurs) et le système d'exploitation de l'API. * **RAM (Random Access Memory) :** Volatile, utilisée pour le programme en cours d'exécution et les données temporaires. * **ROM (Read Only Memory) ou EEPROM :** Non-volatile, stocke le système d'exploitation et parfois le programme utilisateur. * **Modules d'Entrées/Sorties (E/S) :** Ils permettent à l'automate de « percevoir » et d'« agir » sur le monde extérieur. * **Modules d'entrées :** Reçoivent les signaux des capteurs (boutons, interrupteurs, capteurs de fin de course, etc.). Les signaux peuvent être numériques (tout ou rien) ou analogiques (tension ou courant variable). * **Modules de sorties :** Envoient des commandes aux actionneurs (moteurs, vérins, voyants, relais, etc.). Les signaux peuvent être numériques ou analogiques. * **Alimentation :** Fournit la puissance électrique nécessaire au fonctionnement de l'automate et de ses modules. * **Interface de programmation :** Un port de communication (USB, Ethernet, série) pour connecter un ordinateur avec un logiciel de programmation spécifique à l'API. #### Principe de Fonctionnement : Le Cycle de Scrutation Un automate fonctionne selon un cycle répétitif appelé « cycle de scrutation » ou « cycle d'exécution » : 1. **Lecture des Entrées :** L'API lit l'état de toutes ses entrées et les stocke dans une image mémoire des entrées. 2. **Exécution du Programme :** Le CPU exécute le programme utilisateur instruction par instruction, en utilisant l'état des entrées stocké et les valeurs internes. 3. **Mise à jour des Sorties :** Les résultats de l'exécution du programme sont stockés dans une image mémoire des sorties, puis transférés physiquement aux modules de sorties, ce qui active ou désactive les actionneurs. 4. **Tâches de maintenance :** L'API effectue des autodiagnostics et des communications. Ce cycle se répète en continu, généralement en quelques millisecondes. #### Avantages des Automates * **Flexibilité :** Le programme peut être modifié facilement sans recâblage. * **Fiabilité :** Conçus pour des environnements industriels exigeants. * **Facilité de diagnostic :** Les logiciels de programmation offrent des outils pour détecter les pannes et simuler le fonctionnement. * **Coût-efficacité :** Réduit le câblage et le temps d'installation par rapport aux systèmes à relais. * **Compacité :** Moins encombrant que les armoires électriques traditionnelles. #### Domaines d'Application Les API sont utilisés dans une multitude de secteurs : * **Industrie manufacturière :** Lignes d'assemblage, machines-outils. * **Robotique :** Contrôle des mouvements et séquences des robots. * **Gestion de processus :** Stations d'épuration, centrales électriques, chaînes de production agroalimentaire. * **Bâtiment :** Systèmes de chauffage, ventilation, climatisation (CVC), contrôle d'accès. * **Transport :** Feux de circulation, systèmes de contrôle ferroviaire. ### Vocabulaire * **Automate Programmable Industriel (API) :** Ordinateur industriel dédié au contrôle de processus. * **CPU :** Unité Centrale de Traitement, le cœur de l'automate. * **Entrées/Sorties (E/S) :** Interfaces permettant la connexion de l'automate au monde physique (capteurs et actionneurs). * **Capteur :** Dispositif qui détecte un phénomène physique (présence, température, pression) et le convertit en signal électrique pour l'automate. * **Actionneur :** Dispositif qui convertit un signal électrique de l'automate en une action physique (moteur, vérin, voyant). * **Cycle de scrutation :** Le processus répétitif de lecture des entrées, exécution du programme et mise à jour des sorties de l'API. * **Logique combinatoire :** Logique où la sortie dépend uniquement de l'état actuel des entrées. * **Logique séquentielle :** Logique où la sortie dépend de l'état actuel des entrées et de l'historique (états précédents). * **GRAFCET :** Langage de description fonctionnelle du comportement séquentiel d'un automatisme, souvent utilisé pour la programmation des API. ### Exemples d'Applications #### 1. Contrôle d'un feu de circulation Un API peut gérer un carrefour simple. Les entrées seraient des capteurs de présence de véhicules (boucles magnétiques) et des temporisateurs. Les sorties seraient les feux rouges, oranges et verts pour chaque direction. Le programme gérerait la séquence et la durée des feux en fonction de la circulation. #### 2. Système de convoyeur Dans une usine, un API peut contrôler un tapis roulant. Les entrées peuvent inclure des boutons de démarrage/arrêt, des capteurs de détection de colis et des capteurs de fin de course. Les sorties pourraient être le moteur du tapis, un bras pousseur ou un voyant d'erreur. L'API démarrerait le tapis, déplacerait les colis et les arrêterait aux positions appropriées. #### 3. Porte automatique Une porte automatique de supermarché est un exemple simple. Les entrées sont des capteurs de présence (radar ou infrarouge) de chaque côté de la porte. La sortie est le moteur qui ouvre ou ferme la porte. L'API reçoit le signal d'un capteur, envoie l'ordre d'ouverture, attend un certain temps, puis envoie l'ordre de fermeture si aucun autre capteur n'est activé. ### Exercices 1. Quel est le rôle principal d'un Automate Programmable Industriel dans un système de production ? 2. Listez les quatre composants principaux d'un automate et décrivez brièvement leur fonction. 3. Expliquez le principe du cycle de scrutation d'un API. 4. Pour une machine à laver, identifiez au moins deux types d'entrées et deux types de sorties qui pourraient être gérées par un API. ### Devoirs 1. Faites une recherche sur les grandes marques d'API (par exemple, Siemens, Rockwell Automation, Schneider Electric) et citez au moins un modèle d'API pour chaque marque. 2. Proposez un système automatisé simple de votre choix (ex: remplissage d'une cuve, arrosage automatique d'un jardin) et listez les entrées et sorties nécessaires à son fonctionnement. 3. Expliquez la différence entre une entrée/sortie numérique et une entrée/sortie analogique. Donnez un exemple de capteur et d'actionneur pour chaque type. ### Résumé En résumé, l'Automate Programmable Industriel (API) est un élément essentiel de l'automatisation moderne. Il est constitué d'une unité centrale, de mémoire, de modules d'entrées/sorties et d'une alimentation. Son fonctionnement repose sur un cycle de scrutation répétitif qui lui permet de lire les informations du processus, d'exécuter un programme logique et d'agir sur les équipements. Grâce à sa flexibilité et sa fiabilité, l'API est devenu indispensable dans un large éventail d'applications industrielles et quotidiennes, rendant nos systèmes plus efficaces et plus sûrs. ## Programmation par schéma à contacts ### Introduction Bienvenue dans cette leçon sur la programmation par schéma à contacts, un élément fondamental de l'automatisme en logique programmée. À l'ère de l'industrie moderne, la capacité à contrôler et automatiser des machines est essentielle. Les schémas à contacts, ou "Ladder Diagram" en anglais, représentent une méthode graphique et intuitive pour concevoir et implémenter la logique de commande des systèmes automatisés, notamment via les Automates Programmables Industriels (API). Inspirés des schémas électriques à relais, ils vous permettront de visualiser et de comprendre facilement le fonctionnement séquentiel et combinatoire des processus. ### Concepts Clés #### Qu'est-ce que la logique à contacts (Ladder Logic) ? La logique à contacts est un langage de programmation graphique utilisé pour programmer les Automates Programmables Industriels (API). Elle est conçue pour ressembler aux schémas de câblage des circuits à relais électromécaniques. C'est un langage très visuel, où la logique est représentée par des "échelons" (rungs) qui simulent des circuits électriques. * **Langage graphique :** Facile à lire et à comprendre pour les techniciens et ingénieurs ayant une formation en électricité. * **Base :** Repose sur le principe des contacts (interrupteurs) et des bobines (relais ou sorties). * **Application :** Principalement utilisée pour les commandes séquentielles et les systèmes de sécurité. #### Composants de base d'un schéma à contacts Un schéma à contacts est structuré comme une échelle, avec deux barres verticales représentant l'alimentation électrique et des lignes horizontales (les échelons) contenant la logique de contrôle. ##### Les lignes d'alimentation (Rails) * **Rail gauche :** Représente la source de puissance (par exemple, 24V DC ou phase). * **Rail droit :** Représente le retour de puissance (par exemple, 0V DC ou neutre). ##### Les contacts (Entrées) Les contacts sont les éléments qui détectent des conditions (état d'un bouton, d'un capteur, etc.). Ils sont placés sur les échelons et contrôlent le passage du "courant logique". * **Contact Normalement Ouvert (NO) :** Symbole `| |` * Laisse passer le courant logique lorsque la condition associée est vraie (l'entrée est active). * Analogue à un bouton poussoir START ou un capteur de présence. * **Contact Normalement Fermé (NC) :** Symbole `|/|` * Coupe le courant logique lorsque la condition associée est vraie (l'entrée est active). * Laisse passer le courant logique lorsque la condition associée est fausse (l'entrée est inactive). * Analogue à un bouton poussoir STOP ou un capteur de position. ##### Les bobines (Sorties) Les bobines sont les éléments qui activent des actions (allumer une lampe, démarrer un moteur, etc.). Elles sont placées à l'extrémité droite des échelons. * **Bobine standard :** Symbole `( )` * S'active (se met à 1) si le chemin logique qui la précède est vrai (le "courant logique" atteint la bobine). * Représente une sortie physique (relais, voyant, moteur) ou une variable interne de l'API. ##### Les fonctions spéciales (Timers, Compteurs) Les API offrent également des blocs fonctionnels plus complexes comme : * **Temporisateurs (Timers) :** Permettent de gérer des délais (par exemple, temporisation à l'enclenchement TOF, temporisation à la désactivation TON). * **Compteurs (Counters) :** Permettent de compter des événements (par exemple, un nombre de pièces). #### Principe de fonctionnement Un API exécute son programme de manière cyclique, selon un processus appelé "cycle de scan" : 1. **Lecture des entrées :** L'API lit l'état de toutes ses entrées physiques et les stocke dans sa mémoire. 2. **Exécution du programme :** L'API parcourt le programme échelon par échelon, de haut en bas et de gauche à droite. Pour chaque échelon, il évalue la logique des contacts. Si le chemin logique est vrai (le courant "circule"), la bobine associée est activée. Sinon, elle est désactivée. 3. **Mise à jour des sorties :** Une fois le programme entièrement exécuté, l'API met à jour l'état de ses sorties physiques en fonction des bobines activées ou désactivées en mémoire. Ce cycle se répète en permanence, permettant à l'API de réagir en temps réel aux changements des entrées et de contrôler les sorties en conséquence. #### Structure d'un programme Ladder Un programme Ladder est une série d'échelons indépendants ou interdépendants. Chaque échelon représente une ligne logique qui doit être évaluée. Exemple simple d'un échelon : `| |----( )` (Un contact active une bobine). #### Avantages et Inconvénients * **Avantages :** * **Simplicité de lecture :** Ressemble à un schéma électrique, intuitif pour les électriciens. * **Facilité de débogage :** Le flux logique est facile à suivre. * **Idéal pour les séquences :** Efficace pour les applications de contrôle séquentiel et combinatoire. * **Robustesse :** Langage standardisé et très répandu dans l'industrie. * **Inconvénients :** * **Moins adapté aux algorithmes complexes :** Difficile de gérer des calculs complexes ou des traitements de données volumineux. * **Gestion des données :** Moins performant pour la manipulation de chaînes de caractères ou de structures de données avancées. * **Peut devenir encombrant :** Pour des programmes très vastes et complexes, la lisibilité peut diminuer. ### Vocabulaire * **Automate Programmable Industriel (API / PLC) :** Dispositif électronique programmable utilisé pour l'automatisation des processus industriels. * **Schéma à contacts (Ladder Diagram) :** Langage de programmation graphique pour API basé sur la logique des relais électriques. * **Contact NO (Normalement Ouvert) :** Contact qui est ouvert (ne laisse pas passer le courant) au repos et qui se ferme lorsqu'il est actionné. * **Contact NC (Normalement Fermé) :** Contact qui est fermé (laisse passer le courant) au repos et qui s'ouvre lorsqu'il est actionné. * **Bobine (Coil) :** Représente une sortie physique ou une variable interne de l'API qui est activée lorsque la logique de l'échelon est vraie. * **Échelon (Rung) :** Une ligne horizontale dans un schéma à contacts, contenant une logique d'entrée et au moins une bobine de sortie. * **Entrée (Input) :** Signal provenant d'un capteur, d'un bouton poussoir, d'un interrupteur, etc., lu par l'API. * **Sortie (Output) :** Commande envoyée par l'API vers un actionneur, un voyant, un contacteur de moteur, etc. * **Temporisateur (Timer) :** Bloc fonctionnel qui introduit un délai dans la logique de contrôle. * **Compteur (Counter) :** Bloc fonctionnel qui compte des impulsions ou des événements. ### Exemples #### 1. Démarrage direct d'une lampe Une lampe (L1) s'allume lorsque l'on appuie sur un bouton poussoir (BP1). ``` | |-----------------( ) |BP1| |L1| ``` #### 2. Démarrage/Arrêt d'un moteur avec maintien Un moteur (M) démarre avec un bouton poussoir (BP_START), s'arrête avec un bouton poussoir (BP_STOP), et possède un auto-maintien. ``` | | |/| ( ) ----|BP_START|---|BP_STOP|-----|M | | | | |-----|M |---------- ``` *Explication :* Quand `BP_START` est pressé, la bobine `M` est activée. Le contact `M` en parallèle avec `BP_START` s'auto-maintient. `BP_STOP` (NC) coupe le circuit pour arrêter le moteur. #### 3. Commande avec condition de sécurité Un ventilateur (V) ne peut démarrer que si un interrupteur de sécurité (IS) est fermé et qu'un bouton de marche (BM) est pressé. ``` | | | | ( ) ----|IS|------|BM|----------|V | ``` *Explication :* `IS` est un contact normalement fermé (représente que la porte est fermée, donc le contact est conducteur). `BM` est un bouton normalement ouvert. Le ventilateur `V` s'active si `IS` est fermé ET `BM` est pressé. ### Exercices 1. **Exercice 1 :** Proposez un schéma à contacts pour allumer une lampe (L1) avec deux interrupteurs (I1, I2) en **série** (la lampe s'allume si I1 ET I2 sont fermés). 2. **Exercice 2 :** Proposez un schéma à contacts pour allumer une lampe (L2) avec deux interrupteurs (I3, I4) en **parallèle** (la lampe s'allume si I3 OU I4 est fermé). 3. **Exercice 3 :** Un moteur (M1) doit démarrer si un bouton poussoir (BP_MARCHE) est activé, et s'arrêter si un bouton poussoir (BP_ARRET) est activé. Le moteur doit rester en marche après que le BP_MARCHE soit relâché. (Utilisez le principe d'auto-maintien). ### Devoir à la maison 1. **Projet 1 : Conception d'un circuit de démarrage temporisé.** Un moteur (M2) doit démarrer 5 secondes après l'activation d'un bouton poussoir (BP_DEMARRAGE). Un bouton poussoir (BP_ARRET) doit l'arrêter immédiatement, même pendant la temporisation. Dessinez le schéma à contacts. 2. **Projet 2 : Système de remplissage simple.** Une pompe (P1) doit s'activer quand un capteur de niveau bas (CLB) est actif (N.O.) et s'arrêter quand un capteur de niveau haut (CLH) est actif (N.C.). Il doit y avoir un bouton d'arrêt d'urgence (AU) qui arrête la pompe instantanément. Proposez un schéma à contacts complet. ### Résumé En résumé, la programmation par schéma à contacts est un outil puissant et visuel pour l'automatisation industrielle. Elle se base sur la logique des circuits électriques à relais, utilisant des contacts (Normalement Ouvert et Normalement Fermé) pour les entrées et des bobines pour les sorties. Le principe de fonctionnement est cyclique : l'API lit les entrées, exécute la logique échelon par échelon, puis met à jour les sorties. Malgré sa simplicité apparente, elle permet de gérer une multitude de processus séquentiels et est le langage de prédilection pour de nombreux systèmes de commande basés sur des Automates Programmables Industriels (API). Maîtriser ce langage est une compétence essentielle pour quiconque souhaite travailler dans le domaine de l'automatisation. ## Programmation par fonction bloc Diagram (diagramme de bloc fonctionnel) # Programmation par fonction bloc Diagram (diagramme de bloc fonctionnel)\n\n## Introduction\nBienvenue dans cette leçon sur l'automatisme en logique programmée. Aujourd'hui, nous allons explorer une méthode de programmation très visuelle et intuitive pour les automates programmables industriels (API) : le Diagramme de Blocs Fonctionnels (FBD). Cette approche graphique simplifie la compréhension et la conception des systèmes de commande.\n\n## Concepts Clés\n### Qu'est-ce que le Diagramme de Blocs Fonctionnels (FBD) ?\n* **Définition :** Le FBD est un langage de programmation graphique pour API, normalisé par la norme CEI 61131-3. Il représente le programme comme un circuit électronique où les fonctions logiques sont des blocs.\n* **Représentation visuelle :** Similaire aux schémas électroniques, il utilise des symboles pour les fonctions logiques et des lignes pour représenter le flux de données.\n\n### Éléments de base d'un FBD\n* **Entrées (Inputs) :** Représentent les signaux provenant des capteurs ou des boutons (ex: `I0.0`, `Start_Button`).\n* **Sorties (Outputs) :** Représentent les actions sur les actionneurs (ex: `Q0.0`, `Motor_On`).\n* **Fonctions (Functions) :** Opérations logiques ou arithmétiques (ex: AND, OR, NOT, ADD). Elles n'ont pas de mémoire interne.\n* **Blocs Fonctionnels (Function Blocks - FB) :** Blocs réutilisables avec une mémoire interne (ex: Timers, Counters, PID controllers). Les valeurs internes sont conservées entre les cycles de scan.\n* **Connecteurs :** Les lignes connectent les sorties d'un bloc aux entrées d'un autre, indiquant le flux de données ou de contrôle.\n\n### Fonctions FBD courantes\n#### Portes logiques\n* **AND (ET) :** La sortie est vraie si toutes les entrées sont vraies.\n* **OR (OU) :** La sortie est vraie si au moins une entrée est vraie.\n* **NOT (NON) :** La sortie est l'inverse de l'entrée.\n* **XOR (OU Exclusif) :** La sortie est vraie si une seule entrée est vraie.\n\n#### Minuteurs (Timers)\n* **TON (Timer On-Delay) :** Retarde l'activation d'une sortie. Sa sortie `Q` passe à VRAI après que son entrée `IN` est VRAI pendant le temps `PT`.\n* **TOF (Timer Off-Delay) :** Retarde la désactivation d'une sortie. Sa sortie `Q` reste à VRAI pendant `PT` après que son entrée `IN` est passée à FAUX.\n* **TP (Pulse Timer) :** Génère une impulsion de durée fixe `PT` lorsque son entrée `IN` passe à VRAI.\n* *Exemple de notation pour un timer :* `TON(IN := Start_Button, PT := T#5S, Q => Motor_Output, ET => Elapsed_Time)`\n\n#### Compteurs (Counters)\n* **CTU (Count Up) :** Compte les impulsions montantes (`CU`). La sortie `Q` passe à VRAI quand la valeur courante (`CV`) atteint la valeur prédéfinie (`PV`). `R` réinitialise le compteur.\n* **CTD (Count Down) :** Décompte les impulsions montantes (`CD`). `L` charge la valeur `PV` dans `CV`.\n* **CTUD (Count Up/Down) :** Combine les fonctions de comptage et décomptage.\n* *Exemple de notation pour un compteur :* `CTU(CU := Sensor_Pulse, R := Reset_Button, PV := 10, Q => Part_Count_Reached, CV => Current_Count)`\n\n### Fonctionnement d'un programme FBD\n* **Balayage (Scan Cycle) :** L'API exécute le programme de manière cyclique.\n 1. Lecture des entrées.\n 2. Exécution du programme (bloc par bloc, généralement de gauche à droite, de haut en bas).\n 3. Écriture des sorties.\n* **Flux de données :** Les valeurs circulent des entrées vers les blocs, sont traitées, et leurs résultats sont passés aux blocs suivants, jusqu'aux sorties.\n\n### Avantages et inconvénients du FBD\n#### Avantages\n* **Visualisation claire :** Facile à comprendre pour les électriciens et techniciens habitués aux schémas logiques.\n* **Débogage simplifié :** Le flux logique est évident, facilitant la recherche d'erreurs.\n* **Modularité :** Permet de créer des blocs réutilisables, améliorant la structuration du programme.\n* **Simplicité pour la logique combinatoire :** Idéal pour des fonctions logiques simples et des applications de contrôle direct.\n\n#### Inconvénients\n* **Moins adapté pour des algorithmes complexes :** Peut devenir encombrant et difficile à lire pour des tâches séquentielles très longues ou des calculs mathématiques complexes.\n* **Peut être moins compact :** Moins dense que des langages textuels comme le Structured Text (ST) pour certaines applications.\n\n## Vocabulaire\n* **API (Automate Programmable Industriel) :** Ordinateur spécialisé utilisé pour automatiser des processus industriels.\n* **FBD (Function Block Diagram) :** Langage de programmation graphique pour API, partie de la norme CEI 61131-3.\n* **Bloc Fonctionnel (FB) :** Unité de programme réutilisable avec mémoire interne (ex: Timer, Counter, PID).\n* **Fonction (Function) :** Unité de programme sans mémoire interne qui effectue une opération spécifique (ex: AND, OR, ADD).\n* **Entrée (Input) :** Signal physique ou logique provenant de l'extérieur du système vers l'API (ex: capteur, bouton).\n* **Sortie (Output) :** Signal physique ou logique envoyé par l'API vers l'extérieur du système (ex: actionneur, voyant).\n* **Logique combinatoire :** Logique où l'état de la sortie dépend uniquement de l'état actuel des entrées.\n* **Logique séquentielle :** Logique où l'état de la sortie dépend non seulement des entrées actuelles, mais aussi de l'historique des états précédents (via des mémoires, timers, compteurs).\n\n## Exemples\n### Exemple 1 : Démarrage et arrêt d'un moteur\nUn moteur doit démarrer lorsqu'un bouton `Start_Button` est pressé, et s'arrêter lorsqu'un bouton `Stop_Button` est pressé. Un bouton `Emergency_Stop` arrête également le moteur immédiatement.\n\n* **Logique FBD :**\n 1. Utilisez un bloc de mémorisation (SET/RESET ou SR Latch). L'entrée SET serait activée par `Start_Button`.\n 2. L'entrée RESET serait activée par la logique `Stop_Button` OU `Emergency_Stop`.\n 3. La sortie de ce bloc de mémorisation contrôlerait directement la sortie `Motor_Output`.\n\n### Exemple 2 : Système de ventilation temporisé\nUne ventilation doit se mettre en marche pendant 10 secondes après la détection d'une présence. Après les 10 secondes, elle s'arrête automatiquement.\n\n* **Logique FBD :**\n 1. L'entrée `IN` d'un bloc **TON (Timer On-Delay)** est connectée au `Presence_Sensor`.\n 2. Le temps prédéfini `PT` du TON est réglé à `T#10S` (10 secondes).\n 3. La sortie `Q` du TON est connectée directement à la sortie `Ventilation_Output`.\n\n## Exercices\n1. **Question :** Citez trois avantages de la programmation FBD par rapport à une programmation textuelle (comme le Structured Text).\n2. **Question :** Expliquez la différence fondamentale entre une ## Programmation en LADDER (LD) ### Introduction Bienvenue à cette leçon sur la programmation en LADDER (LD), un langage essentiel dans le monde de l'automatisme industriel. Le LADDER, aussi appelé langage à contacts, est le langage de programmation le plus répandu pour les Automates Programmables Industriels (API). Sa particularité est sa ressemblance graphique avec les schémas électriques à relais, ce qui le rend intuitif pour ceux qui sont familiers avec l'électricité. Dans ce cours, nous allons explorer les bases de la programmation LADDER, ses éléments constitutifs et comment l'utiliser pour créer des logiques de contrôle simples. ### Concepts Clés #### Qu'est-ce que le LADDER Diagram (LD) ? Le LADDER Diagram est un langage de programmation graphique qui simule le fonctionnement des circuits logiques à relais. Il est largement utilisé pour programmer les API, qui sont les "cerveaux" des systèmes automatisés dans les usines et les processus industriels. * **Langage Graphique :** Il utilise des symboles graphiques pour représenter les contacts, les bobines et d'autres fonctions. * **Basé sur les Relais :** Sa structure est dérivée des schémas de câblage des relais électromécaniques. * **Applications :** Contrôle de machines, processus de fabrication, systèmes d'emballage, etc. #### Éléments de Base du LADDER Un programme LADDER est composé de "barres d'alimentation" verticales et d'"échelons" horizontaux. * **Rails (Barres d'alimentation) :** * La barre gauche représente la source d'alimentation (phase). * La barre droite représente le retour (neutre). * **Échelons (Rungs) :** * Lignes horizontales contenant la logique de contrôle. * Chaque échelon représente un circuit logique indépendant. #### Contacts Les contacts sont les éléments d'entrée (capteurs, boutons, interrupteurs) ou des états internes. * **Contact Normalement Ouvert (NO ou N.O.) :** * Symbole : `--| |--` * Est ouvert par défaut et se ferme lorsqu'il est activé. * Permet au courant de passer quand il est "vrai" ou "actionné". * **Contact Normalement Fermé (NC ou N.F.) :** * Symbole : `--|/|--` * Est fermé par défaut et s'ouvre lorsqu'il est activé. * Bloque le courant de passer quand il est "vrai" ou "actionné". #### Bobines Les bobines sont les éléments de sortie (moteurs, lampes, actionneurs) ou des états internes (mémoires). * **Bobine de Sortie :** * Symbole : `--( )--` * S'active (s'alimente) lorsque le chemin logique qui la précède est vrai. * Représente une sortie physique ou un bit de mémoire interne. * **Bobine Set (S) / Reset (R) :** * `--(S)--` : Met un bit à 1 (actif) et le maintient même après la disparition de la condition. * `--(R)--` : Met un bit à 0 (inactif). #### Fonctions Logiques Fondamentales * **Fonction ET (AND) :** * Deux contacts en série. * La sortie est activée si ET seulement si toutes les entrées sont activées. * Exemple : `--| |-- --| |-- --( )--` * **Fonction OU (OR) :** * Deux contacts en parallèle. * La sortie est activée si AU MOINS une des entrées est activée. * Exemple : ``` --| |---- --| |----( )-- ``` * **Fonction NON (NOT) :** * Utilise un contact Normalement Fermé (NC). * La sortie est activée si l'entrée n'est PAS activée. * Exemple : `--|/|-- --( )--` #### Temporisateurs (Timers) Les temporisateurs sont des fonctions qui introduisent un délai dans la logique. * **Temporisateur à l'Enclenchement (TON - Timer ON Delay) :** * Déclenche sa sortie après un certain délai si son entrée est active. * La sortie reste active tant que l'entrée est active. * **Temporisateur au Déclenchement (TOF - Timer OFF Delay) :** * Maintient sa sortie active pendant un certain délai après que son entrée soit devenue inactive. #### Compteurs (Counters) Les compteurs sont utilisés pour compter des événements. * **Compteur Incrémental (CTU - Count Up) :** * Incrémente sa valeur à chaque impulsion sur son entrée de comptage. * Active une sortie lorsque la valeur comptée atteint une valeur prédéfinie. * **Compteur Décrémental (CTD - Count Down) :** * Décrémente sa valeur à chaque impulsion. * Active une sortie lorsque la valeur comptée atteint zéro (ou une valeur prédéfinie inférieure). #### Bits Internes (Mémoires Internes) Ce sont des variables internes à l'API qui ne sont pas liées directement à des entrées/sorties physiques. Elles sont utilisées pour stocker des états intermédiaires, des drapeaux ou pour simplifier des logiques complexes. Elles fonctionnent comme des relais auxiliaires virtuels. ### Vocabulaire * **API (Automate Programmable Industriel) :** Ordinateur industriel robuste utilisé pour contrôler des processus. * **LADDER (LD) :** Langage de programmation graphique pour API, basé sur la logique à relais. * **Contact Normalement Ouvert (NO) :** Contact qui laisse passer le signal lorsqu'il est activé. * **Contact Normalement Fermé (NC) :** Contact qui bloque le signal lorsqu'il est activé. * **Bobine :** Élément de sortie (physique ou interne) qui s'active sous condition. * **Échelon :** Ligne horizontale dans un programme LADDER représentant un circuit logique. * **Temporisateur :** Fonction qui introduit un délai dans la logique (TON, TOF). * **Compteur :** Fonction qui compte des événements (CTU, CTD). * **Série :** Disposition de contacts pour réaliser une logique ET. * **Parallèle :** Disposition de contacts pour réaliser une logique OU. * **Bit interne :** Variable de mémoire interne à l'API, utilisée pour la logique intermédiaire. ### Exemples #### 1. Commande simple ON/OFF Un bouton poussoir (BP1) allume une lampe (L1). ``` --| |--( )-- BP1 L1 ``` #### 2. Logique ET Deux boutons poussoirs (BP1 et BP2) doivent être pressés simultanément pour allumer une lampe (L1). ``` --| |--| |--( )-- BP1 BP2 L1 ``` #### 3. Logique OU L'un ou l'autre de deux boutons poussoirs (BP1 ou BP2) allume une lampe (L1). ``` BP1 ------| |------ ( )-- BP2 L1 ------| |------ ``` #### 4. Circuit d'Autoretention (Démarrage/Arrêt) Un bouton poussoir "Start" (BP1) démarre un moteur (M1). Un bouton poussoir "Stop" (BP2) l'arrête. Le moteur doit rester allumé après avoir relâché "Start". ``` BP1 M1 ------| |----| |------ BP2 ( )-- ------|/|-------------M1-- ``` ### Exercices 1. Dessinez le schéma LADDER pour un système où un voyant lumineux (V1) s'allume uniquement si DEUX capteurs (C1 et C2) détectent un objet ET qu'un interrupteur de sécurité (S1) est fermé. 2. Dessinez le schéma LADDER pour un système où une pompe (P1) se met en marche si un bouton "Démarrer" (BP_D) est pressé, et s'arrête si un bouton "Arrêter" (BP_A) est pressé. Utilisez le principe d'autoretention. De plus, la pompe doit s'arrêter automatiquement si un capteur de niveau bas (CNB) est activé. 3. Expliquez la différence fondamentale entre un temporisateur TON et un temporisateur TOF, en donnant un exemple d'application pour chacun. ### Devoir 1. **Feu de signalisation simplifié :** Concevez un programme LADDER pour un feu de signalisation piéton simple. Un bouton poussoir piéton (BP_Pieton) active un voyant "Traversez" (V_Vert) pendant 5 secondes, puis l'éteint. Un voyant "Attendez" (V_Rouge) est allumé le reste du temps. Ignorez les transitions complexes pour le moment. 2. **Compteur de pièces :** Vous devez concevoir un système qui compte trois pièces passant devant un capteur (CP_Piece). Une fois que trois pièces ont été détectées, un bras manipulateur (BM) doit s'activer pendant 2 secondes pour les déplacer, puis se désactiver. Le compteur doit se réinitialiser après l'activation du bras pour recommencer un nouveau cycle. Incluez un bouton de réinitialisation manuel (BP_Reset). ### Résumé Nous avons parcouru les bases de la programmation LADDER, un langage visuel et puissant, essentiel pour l'automatisme industriel. Nous avons appris que les programmes LADDER sont construits avec des rails et des échelons, utilisant des contacts (NO, NC) comme entrées et des bobines comme sorties. Nous avons également exploré comment implémenter les fonctions logiques ET, OU et NON, ainsi que l'utilisation des temporisateurs (TON, TOF) et des compteurs (CTU, CTD) pour des logiques plus complexes. La maîtrise du LADDER est une compétence clé pour toute personne travaillant avec des Automates Programmables Industriels, permettant de comprendre et de créer des logiques de contrôle efficaces pour une multitude d'applications industrielles. ## Programmation en GRAFCET ### Introduction Bienvenue à cette leçon sur le GRAFCET ! Dans le domaine des automatismes, il est essentiel de pouvoir décrire clairement le comportement séquentiel d'un système. Le GRAFCET, acronyme de **G**raphe **F**onctionnel de **C**ommande **É**tape **T**ransition, est un outil graphique standardisé et puissant qui nous permet de le faire. Il est largement utilisé pour concevoir, analyser et documenter les systèmes automatisés, notamment pour la programmation des automates programmables industriels (API). Comprendre le GRAFCET est une compétence fondamentale pour tout technicien ou ingénieur en automatisme. ### Concepts Clés #### Qu'est-ce que le GRAFCET ? Le GRAFCET est un langage graphique qui décrit la partie commande d'un système automatisé. Il permet de représenter les différentes étapes d'un processus et les conditions de passage d'une étape à l'autre. C'est un outil intuitif qui facilite la communication entre les concepteurs, les programmeurs et les maintenanciers de systèmes automatisés. #### Les Composants de Base du GRAFCET Le GRAFCET est construit à partir de quelques éléments fondamentaux : * **Les Étapes :** * Représentées par un carré ou un rectangle numéroté (ex: 1, 2, 3...). Chaque étape représente un état stable du système. * **Étape initiale :** C'est l'étape par laquelle le cycle commence. Elle est représentée par un double carré (ex: 1). * **Action associée :** Chaque étape peut déclencher une ou plusieurs actions lorsqu'elle est active. Ces actions sont décrites dans un rectangle relié à l'étape. * Une étape peut être **active** ou **inactive**. * **Les Transitions :** * Représentées par un trait horizontal. Une transition marque le passage d'une ou plusieurs étapes précédentes à une ou plusieurs étapes suivantes. * **Condition de réceptivité :** Chaque transition est associée à une condition logique (booléenne). Le franchissement de la transition n'est possible que si la condition de réceptivité est vraie ET que toutes les étapes immédiatement précédentes sont actives. * Exemple de condition de réceptivité : `BP_Marche` (bouton poussoir marche), `detecteur_haut = 1`, `t_1s / X2` (temporisation d'une seconde après activation de l'étape 2). * **Les Liaisons Orientées :** * Représentées par des flèches. Elles relient les étapes aux transitions et les transitions aux étapes, indiquant le sens d'évolution du processus. #### Les Règles d'Évolution du GRAFCET Le fonctionnement d'un GRAFCET est régi par cinq règles fondamentales : 1. **Règle d'initialisation :** Au début, seules les étapes initiales sont actives (on parle de *marquage initial*). 2. **Règle de franchissement d'une transition :** Une transition est franchissable si : * Toutes les étapes immédiatement précédentes sont actives. * Sa condition de réceptivité est vraie. 3. **Règle d'activation et de désactivation d'étapes :** Le franchissement d'une transition entraîne l'activation des étapes immédiatement suivantes et la désactivation des étapes immédiatement précédentes. Les activations et désactivations sont simultanées. 4. **Règle des évolutions simultanées :** Si plusieurs transitions sont simultanément franchissables, elles sont toutes franchies simultanément. 5. **Règle de l'activation et de la désactivation d'une même étape :** Si une étape doit être simultanément activée et désactivée, elle reste active. #### Les Structures de Base du GRAFCET Le GRAFCET permet de modéliser des comportements complexes grâce à des structures simples : * **Séquence linéaire :** Le déroulement normal du processus (Étape -> Transition -> Étape). * **Divergence en OU (Sélection de séquence) :** Une étape conduit à plusieurs transitions exclusives. Une seule des séquences est choisie en fonction des conditions de réceptivité. Représentée par un seul trait horizontal avant la transition. * **Convergence en OU :** Plusieurs séquences se rejoignent vers une seule étape. Représentée par un seul trait horizontal après la transition. * **Divergence en ET (Séquences simultanées) :** Une étape conduit à plusieurs transitions qui sont toutes franchies en même temps, lançant des séquences parallèles. Représentée par deux traits horizontaux parallèles. * **Convergence en ET :** Plusieurs séquences parallèles doivent toutes se terminer avant de converger vers une seule étape. Représentée par deux traits horizontaux parallèles. #### Actions Associées aux Étapes Les actions sont ce que le système fait lorsque l'étape est active. Elles peuvent être de différents types : * **Action continue :** L'action est réalisée tant que l'étape est active (ex: `Moteur = 1` si Moteur tourne tant que l'étape est active). * **Action conditionnelle :** L'action est réalisée tant que l'étape est active ET qu'une condition supplémentaire est vraie (ex: `Pompe = 1 / capteur_niveau_bas` si la pompe s'active seulement si le capteur est bas). * **Action mémorisée (SET/RESET) :** L'action est déclenchée à l'activation de l'étape (SET) ou à la désactivation (RESET) et reste active ou inactive jusqu'à l'ordre inverse. Ex : `S (Voyant_vert)` active le voyant, `R (Voyant_vert)` le désactive. * **Action temporisée :** L'action ne se déclenche qu'après un certain délai suivant l'activation de l'étape ou s'arrête après un délai. Ex : `Vérin_sortie / t1s` (sortir le vérin après 1 seconde). ### Vocabulaire * **GRAFCET :** Graphe Fonctionnel de Commande Étape Transition. * **Étape :** Un état stable du système, représenté par un carré. * **Transition :** Point de passage d'une étape à une autre, associé à une condition. * **Condition de réceptivité :** Expression logique qui doit être vraie pour qu'une transition soit franchie. * **Liaison orientée :** Flèche indiquant le sens d'évolution entre étapes et transitions. * **Action :** Opération effectuée par le système lorsque l'étape est active. * **Étape initiale :** Étape par laquelle le cycle débute, représentée par un double carré. * **Marquage :** L'ensemble des étapes actives à un instant donné. * **Divergence en OU (sélection) :** Choix d'une séquence parmi plusieurs possibles. * **Convergence en OU :** Rassemblement de plusieurs séquences en une seule. * **Divergence en ET (simultanéité) :** Lancement de plusieurs séquences parallèles. * **Convergence en ET :** Attente de la fin de plusieurs séquences parallèles avant de continuer. ### Exemples #### Exemple 1 : Commande d'un éclairage avec bouton poussoir Décrivons un GRAFCET pour allumer et éteindre une lampe avec un seul bouton poussoir (BP). * **Étape 1 (Initiale) :** Lampe éteinte, en attente de l'appui sur le bouton. * Action : `Lampe = 0` (ou rien, la lampe est éteinte par défaut). * **Transition 1-2 :** Condition de réceptivité : `BP_appui` (le bouton est appuyé). * **Étape 2 :** Lampe allumée, en attente du prochain appui. * Action : `Lampe = 1`. * **Transition 2-1 :** Condition de réceptivité : `BP_appui`. Ce GRAFCET très simple illustre le passage d'un état à l'autre basé sur une même condition, mais à des moments différents du cycle. #### Exemple 2 : Remplissage et vidange d'une cuve Considérons une cuve avec un capteur de niveau bas (`Niv_Bas`), un capteur de niveau haut (`Niv_Haut`), une vanne de remplissage (`Vanne_Remplir`) et une vanne de vidange (`Vanne_Vidanger`). Un bouton poussoir (`BP_Cycle`) lance le cycle. * **Étape 1 (Initiale) :** Cuve vide, vannes fermées, en attente de démarrage. * Actions : `Vanne_Remplir = 0`, `Vanne_Vidanger = 0`. * **Transition 1-2 :** Condition : `BP_Cycle`. * **Étape 2 :** Remplissage de la cuve. * Action : `Vanne_Remplir = 1`. * **Transition 2-3 :** Condition : `Niv_Haut`. * **Étape 3 :** Attente avant vidange (pour un mélange par exemple, simulons avec une temporisation). * Action : Aucune action spécifique immédiate. * **Transition 3-4 :** Condition : `t_5s / X3` (temporisation de 5 secondes après l'activation de l'étape 3). * **Étape 4 :** Vidange de la cuve. * Action : `Vanne_Vidanger = 1`. * **Transition 4-1 :** Condition : `Niv_Bas`. ### Exercices 1. **Identification des éléments :** Pour le système de feux tricolores (vert, orange, rouge) avec un cycle fixe, identifiez les étapes, les transitions et les actions. Ne tenez pas compte des feux piétons pour le moment. 2. **Dessin de GRAFCET simple :** Dessinez le GRAFCET d'une perceuse dont le cycle est : *Démarrage du moteur* (si pièce présente), *Descente du foret*, *Remontée du foret*, *Arrêt du moteur* (si foret en position haute). 3. **Conditions de réceptivité :** Une transition T1-2 a pour condition `(capteur_A AND capteur_B) OR capteur_C`. L'étape 1 est active. Décrivez quand la transition sera franchie. * L'étape 1 est active, \(capteur\_A = 1\), \(capteur\_B = 0\), \(capteur\_C = 0\). * L'étape 1 est active, \(capteur\_A = 1\), \(capteur\_B = 1\), \(capteur\_C = 0\). * L'étape 1 est active, \(capteur\_A = 0\), \(capteur\_B = 0\), \(capteur\_C = 1\). ### Devoirs 1. **Conception de GRAFCET :** Une machine de distribution de boissons propose trois choix : café, thé, chocolat. Chaque boisson a un bouton. Une fois la boisson choisie, la machine verse le liquide, puis attend 3 secondes et revient à l'état initial. Concevez le GRAFCET de ce système, en incluant une étape initiale, les sélections et les actions de distribution. 2. **Analyse de GRAFCET :** On vous donne le GRAFCET suivant (description textuelle, imaginez le dessin) : * Étape 1 (initiale) : Action `Voyant_attente = 1` * Transition 1-2 : Condition `BP_Depart` * Étape 2 : Actions `Moteur_A_Marche = 1`, `S (Voyant_A_Allume)` * Transition 2-3 : Condition `t_10s / X2` (après 10 secondes d'activation de l'étape 2) * Étape 3 : Actions `Moteur_A_Marche = 0`, `R (Voyant_A_Allume)`, `Moteur_B_Marche = 1`, `S (Voyant_B_Allume)` * Transition 3-1 : Condition `Capteur_Fin_B` Décrivez le comportement de ce système du début à la fin. ### Résumé En résumé, le GRAFCET est un outil graphique indispensable pour la conception et la programmation des systèmes automatisés. Il repose sur des éléments simples – les étapes, les transitions et les liaisons orientées – et des règles d'évolution précises. La maîtrise des structures de base comme les séquences linéaires, les sélections (divergence/convergence en OU) et les séquences simultanées (divergence/convergence en ET) est cruciale pour modéliser des automatismes complexes. Les actions associées aux étapes permettent de définir le comportement concret du système. Une bonne compréhension du GRAFCET est la clé pour programmer efficacement des automates et pour analyser le fonctionnement de n'importe quel système séquentiel.