PROGRAMMATION DES AUTOMATES PROGRAMMABLES INDUSTRIELS (API)

# PROGRAMMATION DES AUTOMATES PROGRAMMABLES INDUSTRIELS (API) ## L’automate TSX21 ### Introduction Bienvenue à cette leçon dédiée à un composant essentiel de l'automatisation industrielle : l'Automate Programmable Industriel (API). Nous allons explorer un modèle emblématique des années 90, le **TSX21** de Schneider Electric. Comprendre cet automate vous permettra d'appréhender les bases de la programmation et du fonctionnement des systèmes automatisés, des concepts qui restent fondamentaux même avec les technologies plus récentes. À la fin de cette leçon, vous serez capable de comprendre son architecture, ses principes de câblage et de programmation simple. ### Concepts Clés #### Qu'est-ce qu'un Automate Programmable Industriel (API) ? Un API est un dispositif électronique programmable utilisé pour automatiser des processus industriels. Il remplace avantageusement les systèmes câblés traditionnels (à base de relais) par une solution flexible et modifiable par logiciel. Sa fonction principale est de recevoir des informations des capteurs (entrées), de les traiter selon un programme défini, et de commander des actionneurs (sorties). #### Présentation de l'Automate TSX21 Le TSX21 est un micro-automate de la gamme Modicon TSX Micro de Schneider Electric. Bien qu'aujourd'hui obsolète, il a été largement utilisé et constitue une excellente base pour comprendre les architectures d'API. ##### Architecture Générale Un TSX21 est un automate "monobloc", c'est-à-dire que tous ses composants sont intégrés dans un seul boîtier. Il comprend typiquement : * **Unité Centrale (UC) ou CPU :** Le "cerveau" de l'API, il exécute le programme utilisateur et gère les communications. * **Alimentation :** Fournit l'énergie nécessaire au fonctionnement de l'automate et des modules d'E/S. * **Modules d'Entrées/Sorties (E/S) :** Permettent à l'API d'interagir avec le monde extérieur. Les entrées reçoivent des signaux (boutons poussoirs, capteurs, fin de course) et les sorties activent des actionneurs (lampes, moteurs, vérins). ##### Caractéristiques Principales (exemples typiques) * **Nombre d'E/S :** Variable selon les modèles (ex: 10 entrées / 6 sorties, 20 entrées / 12 sorties). * **Mémoire programme :** Généralement quelques kilo-octets (Ko), suffisante pour des applications simples. * **Ports de communication :** Souvent un port série (RS232) pour la connexion à un ordinateur de programmation. #### Principes de Programmation La programmation du TSX21 se fait principalement avec le logiciel PL7-2 (ou PL7-Pro pour des versions plus avancées) sur PC. Les langages supportés incluent : ##### Le Langage Ladder (ou "schéma à contacts") C'est un langage graphique inspiré des schémas électriques à relais. Il est intuitif car il représente la logique sous forme de contacts et de bobines. Une ligne de programme Ladder est appelée un "réseau" ou "rung". ##### Le Cycle de Scrutation C'est le mode de fonctionnement fondamental de tout API. Le TSX21 exécute son programme de manière cyclique et répétée : 1. **Lecture des Entrées :** L'API lit l'état de toutes ses entrées (on/off, valeur analogique) et les stocke dans une image mémoire. 2. **Exécution du Programme :** L'API exécute le programme utilisateur, réseau par réseau, en utilisant les valeurs de l'image mémoire des entrées. Les résultats des calculs et de la logique sont stockés dans une image mémoire des sorties. 3. **Écriture des Sorties :** L'API met à jour l'état physique de ses sorties en fonction de l'image mémoire des sorties. 4. **Tâches Internes et Communication :** L'API effectue d'autres tâches (autodiagnostic, communication) avant de recommencer le cycle. Le temps nécessaire pour un cycle de scrutation est appelé le **temps de cycle** ou **temps de scan**. Il est généralement de l'ordre de quelques millisecondes. #### Mise en Œuvre du TSX21 ##### Câblage des Entrées/Sorties * **Entrées :** Les capteurs (boutons, interrupteurs, capteurs de position) sont raccordés aux bornes d'entrée de l'API. Ils fournissent un signal (généralement 24V DC ou 230V AC) à l'API. * **Sorties :** Les actionneurs (lampes, voyants, contacteurs de moteur, électrovannes) sont raccordés aux bornes de sortie de l'API. L'API fournit un signal pour les activer. Il est crucial de respecter les tensions et courants admissibles par les bornes d'E/S. ##### Logiciel de Programmation Le logiciel PL7-2 (ou PL7-Pro) permet de créer, modifier, tester et transférer des programmes Ladder (ou Grafcet) vers le TSX21 via un câble de liaison série. ##### Téléchargement et Test du Programme Une fois le programme écrit, il est "téléchargé" (transféré) de l'ordinateur vers la mémoire de l'API. L'API peut alors être mis en mode "RUN" (exécution) pour tester le fonctionnement du programme avec l'installation réelle. ### Vocabulaire * **API (Automate Programmable Industriel) :** Dispositif électronique pour l'automatisation des processus. * **TSX21 :** Référence d'un modèle de micro-automate de Schneider Electric. * **E/S (Entrées/Sorties) :** Bornes par lesquelles l'API interagit avec l'environnement physique. * **Ladder :** Langage de programmation graphique pour API, basé sur des contacts et bobines. * **Grafcet (Graphe Fonctionnel de Commande Étape/Transition) :** Langage de spécification fonctionnelle des automatismes séquentiels. * **Cycle de Scrutation :** Processus cyclique de lecture des entrées, exécution du programme et écriture des sorties de l'API. * **Image Mémoire des Entrées/Sorties :** Zone de la mémoire de l'API où sont stockés temporairement les états des E/S physiques. * **UC (Unité Centrale) ou CPU :** Microprocesseur qui exécute le programme de l'API. * **Téléchargement :** Opération de transfert du programme de l'ordinateur vers l'API. * **Réseau (Ladder) :** Une ligne logique dans un programme Ladder. ### Exemples #### Exemple de Câblage Simple Imaginez que vous souhaitez allumer une lampe (sorties S0) lorsque vous appuyez sur un bouton poussoir (entrée E0) et éteindre la lampe en relâchant le bouton. * **Câblage Entrée E0 :** Reliez un bouton poussoir entre l'alimentation 24V (par exemple, la borne +24V de l'API si disponible ou une alimentation externe) et la borne d'entrée E0 de l'API. L'autre borne de l'entrée E0 est connectée au commun (0V). * **Câblage Sortie S0 :** Reliez une lampe entre la borne de sortie S0 de l'API et le commun (0V). La borne S0 sera connectée à la source de tension (ex: 24V) à travers un relais interne à l'API lorsqu'elle est activée par le programme. #### Exemple de Programme Ladder Simple Pour l'exemple de câblage ci-dessus, voici le programme Ladder : ```ladder |--[ E0 ]-------( S0 )--| ``` * `E0` représente le contact normalement ouvert (NO) associé à l'entrée 0. Quand le bouton est pressé, le contact se ferme. * `S0` représente la bobine associée à la sortie 0. Lorsque le contact `E0` est fermé, la bobine `S0` est alimentée, ce qui active la sortie physique S0 et allume la lampe. ### Exercices 1. Décrivez le rôle principal d'un API dans un système automatisé. 2. Énumérez les trois étapes principales du cycle de scrutation d'un API. 3. Pour quelles raisons le langage Ladder est-il considéré comme intuitif pour les électriciens ? 4. Vous souhaitez démarrer un moteur (connecté à la sortie S1) avec un bouton poussoir (connecté à l'entrée E2). Représentez le réseau Ladder correspondant. 5. Si le temps de cycle d'un API est de \( 10 \text{ ms} \), combien de fois par seconde le programme est-il exécuté ? ### Devoirs 1. Recherchez et décrivez au moins deux différences majeures entre un API moderne (par exemple, un M221 de Schneider Electric ou un S7-1200 de Siemens) et un TSX21. 2. Proposez un programme Ladder simple pour contrôler un feu de circulation piétonnier simplifié : un bouton poussoir piéton (entrée E0) déclenche l'allumage d'un voyant vert piéton (sortie S0) pendant 5 secondes, puis l'éteint. Vous pouvez représenter les temporisations par des instructions comme `TON` (Timer On Delay) si vous avez des notions de temporisateurs en Ladder. 3. Expliquez l'importance du concept d'"image mémoire" dans le fonctionnement des API. ### Résumé Cette leçon nous a permis d'explorer les fondements de l'automatisation industrielle à travers l'exemple de l'automate TSX21. Nous avons vu qu'un API est un système programmable composé d'une unité centrale, d'une alimentation et de modules d'entrées/sorties. Son fonctionnement repose sur un **cycle de scrutation** (lecture des entrées, exécution du programme, écriture des sorties). La programmation se fait souvent en langage **Ladder**, qui représente la logique de manière intuitive. La compréhension de ces concepts est cruciale pour aborder n'importe quel système d'automatisation, car les principes fondamentaux restent les mêmes, quelle que soit la génération d'API. ## L’automate PB100 et TSX47 ### Introduction Bienvenue à cette leçon sur les automates programmables industriels (API), des dispositifs essentiels dans le monde de l'automatisation industrielle. Nous allons explorer les concepts fondamentaux de la programmation des API, en nous concentrant sur deux exemples historiques mais représentatifs : l'automate PB100 et le TSX47. Comprendre leur fonctionnement vous donnera une base solide pour appréhender les systèmes d'automatisation modernes. ### Concepts Clés #### Qu'est-ce qu'un Automate Programmable Industriel (API) ? Un API est un ordinateur industriel robuste conçu pour automatiser des processus industriels. Il surveille les entrées, exécute un programme logique et commande les sorties pour contrôler des machines ou des processus. Les API sont omniprésents dans les usines, les chaînes de production et les systèmes de contrôle. #### Architecture Générale d'un API Un API est généralement composé des éléments suivants : * **Unité Centrale (UC) ou Processeur :** Le "cerveau" de l'API, qui exécute le programme et traite les données. * **Mémoire :** Stocke le programme utilisateur, les données et l'état des entrées/sorties. * **Mémoire programme :** Contient les instructions du programme utilisateur. * **Mémoire de données :** Contient l'état des entrées, des sorties, des variables internes, des temporisateurs et des compteurs. * **Modules d'Entrées/Sorties (E/S) :** Permettent à l'API de communiquer avec le monde extérieur. * **Modules d'entrées :** Reçoivent des signaux des capteurs (boutons poussoirs, détecteurs de présence, etc.). * **Modules de sorties :** Envoient des signaux aux actionneurs (moteurs, vérins, voyants, etc.). * **Alimentation :** Fournit l'énergie nécessaire au fonctionnement de l'API. * **Interface de communication :** Permet la connexion à un ordinateur de programmation ou à d'autres API. #### L'Automate PB100 Le PB100 était un automate programmable de petite taille de la gamme Merlin Gerin (ultérieurement absorbée par Schneider Electric). Il était principalement utilisé pour des applications simples d'automatisation. Sa programmation se faisait souvent en langage "Ladder" (schéma à contacts). #### L'Automate TSX47 Le TSX47, de la gamme TSX de Télémécanique (également Schneider Electric), était un automate plus puissant et modulaire, capable de gérer des applications plus complexes. Il pouvait être programmé avec plusieurs langages, dont le Ladder, la Liste d'Instructions (IL) et le Grafcet (Sequential Function Chart). #### Langages de Programmation des API Les principaux langages de programmation conformes à la norme IEC 61131-3 sont : * **Langage Ladder (LD) ou Schéma à contacts :** Représentation graphique des circuits électriques à relais. Il est intuitif pour les électriciens. * **Liste d'Instructions (IL) :** Langage textuel de bas niveau, proche de l'assembleur, utilisant des mnémoniques. * **Grafcet (SFC - Sequential Function Chart) :** Langage graphique pour décrire le comportement séquentiel d'un système à travers des étapes, des transitions et des actions. * **Texte Structuré (ST) :** Langage textuel de haut niveau, similaire au Pascal ou au C. * **Blocs Fonctions (FBD) :** Représentation graphique de fonctions logiques sous forme de blocs. ### Vocabulaire * **API (Automate Programmable Industriel) :** Ordinateur industriel pour l'automatisation. * **Entrée (E) :** Signal reçu par l'API (ex: état d'un bouton). * **Sortie (S) :** Signal envoyé par l'API (ex: activation d'un moteur). * **UC (Unité Centrale) :** Processeur de l'API. * **Mémoire :** Zone de stockage des données et du programme. * **Ladder :** Langage de programmation graphique utilisant des symboles de contacts et de bobines. * **Grafcet :** Langage graphique pour la description des séquences de contrôle. * **Capteur :** Dispositif qui détecte un événement physique et le convertit en signal électrique pour l'API. * **Actionneur :** Dispositif qui convertit un signal électrique de l'API en une action physique (ex: moteur, vanne). ### Exemples #### Exemple de Programmation Ladder Simple : Démarrage direct d'un moteur **Objectif :** Démarrer un moteur (S1) lorsqu'un bouton poussoir (E1) est activé et l'arrêter lorsqu'un autre bouton poussoir (E2) est activé. Voici comment cela pourrait être représenté en Ladder : ```ladder |----[ E1 ]----[ /E2 ]----( S1 )----| | | |----[ S1 ]--| ``` **Explication :** * `E1` est un contact normalement ouvert (NO) représentant le bouton de démarrage. * `/E2` est un contact normalement fermé (NF) représentant le bouton d'arrêt. * `S1` est la bobine de la sortie contrôlant le moteur. * La branche parallèle avec `S1` assure le maintien du moteur en marche (auto-maintien) même après le relâchement de `E1`. #### Exemple de Logique Booléenne Le principe des API repose sur la logique booléenne. Pour l'exemple ci-dessus, la condition pour que la sortie `S1` soit active peut être exprimée par l'équation booléenne suivante : \[ S1 = (E1 + S1) \cdot \overline{E2} \] Où : * `+` représente l'opération OU logique. * `\cdot` représente l'opération ET logique. * `\overline{E2}` représente la négation de `E2`. ### Exercices 1. Décrivez en vos propres mots la fonction principale d'un API dans un système automatisé. 2. Quelles sont les trois composantes principales de l'architecture d'un API ? Expliquez brièvement le rôle de chacune. 3. Si un capteur de niveau (entrée E3) détecte que le niveau d'un liquide est trop bas, et que vous voulez allumer une pompe (sortie S4) pour le remplir, comment écririez-vous cette logique simple en Ladder ? 4. Expliquez la différence entre une entrée et une sortie sur un API. Donnez un exemple de chaque. 5. Quel langage de programmation est particulièrement adapté pour décrire des séquences d'opérations ? ### Devoir 1. Recherchez les avantages et les inconvénients de l'utilisation d'API par rapport aux systèmes de contrôle câblés (à relais). Rédigez un court paragraphe pour chaque point. 2. Imaginez un système simple d'ouverture/fermeture automatique d'un portail. Identifiez les entrées (capteurs) et les sorties (actionneurs) nécessaires pour ce système. Proposez une séquence de fonctionnement (par exemple, un bouton d'ouverture, un bouton de fermeture, un capteur de fin de course ouvert, un capteur de fin de course fermé). Esquissez un diagramme Ladder pour contrôler ce portail. 3. Si l'automate PB100 ne disposait que d'un certain nombre limité d'entrées/sorties et de mémoire, quelles pourraient être les conséquences pour l'automatisation de processus complexes ? ### Résumé Dans cette leçon, nous avons découvert les automates programmables industriels (API) comme le PB100 et le TSX47. Nous avons exploré leur architecture fondamentale, comprenant l'unité centrale, la mémoire et les modules d'entrées/sorties. Nous avons également abordé les principaux langages de programmation comme le Ladder et le Grafcet, qui permettent de donner des "instructions" à l'API pour contrôler des processus industriels. Les API sont des outils puissants et essentiels pour l'automatisation, transformant les signaux des capteurs en actions via les actionneurs, suivant une logique programmée. La compréhension de ces bases est cruciale pour quiconque s'intéresse à l'ingénierie des systèmes automatisés. ## L’automate SLC100 AB et TSx27 ### Introduction Bienvenue à cette leçon sur les Automates Programmables Industriels (API), des dispositifs essentiels dans le monde de l'automatisation industrielle. Les API agissent comme le cerveau des machines, contrôlant des processus complexes avec une grande précision et fiabilité. Dans ce cours, nous allons explorer deux familles d'API historiquement et techniquement significatives : le SLC100 d'Allen-Bradley (AB) et la série TSx27 de Telemecanique (aujourd'hui Schneider Electric). Bien que certains de ces modèles soient considérés comme des générations précédentes, leur étude est fondamentale pour comprendre les bases de la programmation et de l'architecture des API modernes. ### Concepts Clés #### Qu'est-ce qu'un Automate Programmable Industriel (API) ? ##### Définition et rôle Un API est un ordinateur industriel robuste, conçu pour contrôler et automatiser des processus mécaniques ou des événements dans des environnements industriels. Il surveille des entrées (capteurs, boutons) et prend des décisions basées sur un programme logique pour actionner des sorties (moteurs, lampes, vannes). Ses principaux avantages sont : * **Fiabilité** : Conçu pour fonctionner dans des conditions industrielles difficiles (température, vibrations, poussière). * **Flexibilité** : Le programme peut être modifié facilement pour adapter le comportement de la machine. * **Vitesse** : Exécute les tâches de contrôle en temps réel. * **Facilité de diagnostic** : Permet une identification rapide des pannes. ##### Architecture générale d'un API Un API est généralement composé des éléments suivants : * **Unité Centrale (UC ou CPU)** : Le "cerveau" de l'API. Elle exécute le programme de l'utilisateur, gère la mémoire et les communications. * **Modules d'Entrées (E)** : Permettent à l'API de recevoir des informations du monde extérieur (état de capteurs, interrupteurs, etc.). Elles convertissent les signaux physiques en signaux numériques interprétables par l'UC. * **Modules de Sorties (S)** : Permettent à l'API d'agir sur le monde extérieur (allumer une lampe, démarrer un moteur, ouvrir une vanne). Elles convertissent les signaux numériques de l'UC en signaux physiques. * **Mémoire** : Stocke le programme utilisateur, les données d'entrées/sorties et d'autres variables de fonctionnement. * **Alimentation** : Fournit l'énergie nécessaire au fonctionnement de l'API et de ses modules. * **Interface de programmation** : Permet de connecter l'API à un ordinateur pour charger, modifier ou surveiller le programme. #### L'automate SLC100 d'Allen-Bradley (AB) ##### Présentation Le SLC100 (Small Logic Controller 100) d'Allen-Bradley (une marque de Rockwell Automation) est une série d'API monoblocs compacts, introduits dans les années 1980. Bien qu'obsolètes aujourd'hui, ils ont été très populaires pour les petites applications en raison de leur coût abordable et de leur simplicité. Ils intégraient l'unité centrale, la mémoire et un nombre fixe d'entrées/sorties dans un seul boîtier. ##### Caractéristiques principales * **Monobloc** : Toutes les fonctions sont intégrées. * **Compact** : Idéal pour les petits espaces. * **Langage de programmation** : Principalement le Ladder Diagram (LD), aussi appelé langage à contacts. * **Applications** : Petites machines, contrôle de processus simples. ##### Structure mémoire simplifiée La mémoire du SLC100 était organisée pour stocker : * **Images des entrées et sorties** : Les états des capteurs et des actionneurs. * **Bits internes (B)** : Des drapeaux ou relais internes virtuels utilisés dans le programme. * **Temporisateurs (T)** : Fonctions de temporisation. * **Compteurs (C)** : Fonctions de comptage. * **Données utilisateur** : Pour stocker des valeurs numériques. #### L'automate TSx27 de Telemecanique (Schneider Electric) ##### Présentation La désignation "TSx27" fait généralement référence à des gammes d'automates de Telemecanique (aujourd'hui Schneider Electric), comme les TSX Nano, TSX Micro, ou même des versions plus anciennes des TSX Premium. Ces API ont également été très répandus dans l'industrie européenne. Le TSX Micro, par exemple, était une gamme modulaire ou monobloc offrant une grande flexibilité pour des applications de taille moyenne. ##### Caractéristiques principales * **Modularité (pour certaines séries)** : Possibilité d'ajouter des modules d'entrées/sorties, de communication, ou de fonctions spécifiques selon les besoins. * **Compacité (pour les versions monobloc comme le TSX Nano)**. * **Langages de programmation** : Supporte souvent le Ladder Diagram (LD), la Liste d'Instructions (IL), et parfois le Grafcet (SFC). * **Applications** : Vastes, allant des petites machines aux lignes de production plus complexes. ##### Différences et similitudes avec le SLC100 * **Modularité** : Un avantage clé des TSx27 (notamment TSX Micro) est leur modularité, permettant d'adapter précisément le nombre et le type d'E/S, contrairement au SLC100 qui est monobloc. * **Langages de programmation** : Les TSx27 offrent souvent une palette plus large de langages (LD, IL, SFC) que le SLC100 (principalement LD). * **Environnement de développement** : Les logiciels de programmation des TSx27 (ex: PL7 Micro) étaient généralement plus évolués graphiquement que ceux du SLC100 (souvent des interfaces texte). * **Objectif commun** : Tous deux servent à automatiser des processus industriels en exécutant un programme logique. #### Principes de Programmation Communs (Ladder Diagram) Le Ladder Diagram (LD) est le langage le plus répandu pour la programmation des API. Il s'inspire des schémas électriques à relais. ##### Contacts (Normalement Ouvert - NO, Normalement Fermé - NF) * **Contact Normalement Ouvert (NO)** : Représente un interrupteur qui est ouvert (non conducteur) au repos et se ferme (devient conducteur) lorsque la condition associée est vraie (ex: bouton appuyé). * Symbole : `---] [`--- * **Contact Normalement Fermé (NF)** : Représente un interrupteur qui est fermé (conducteur) au repos et s'ouvre (devient non conducteur) lorsque la condition associée est vraie (ex: bouton appuyé). * Symbole : `---]/[`--- ##### Bobines * **Bobine** : Représente une sortie (physique ou interne) qui s'active (devient vraie) lorsque le chemin logique qui la précède est vrai (conducteur). * Symbole : `---( )--- ##### Temporisateurs (Timers) Les temporisateurs permettent de gérer des retards. Les plus courants sont : * **TON (Timer ON-Delay)** : Retarde l'activation d'une sortie. La sortie s'active après qu'un certain temps (temps préréglé) se soit écoulé et que l'entrée du timer soit restée vraie. * **TOF (Timer OFF-Delay)** : Retarde la désactivation d'une sortie. La sortie reste active pendant un certain temps après que l'entrée du timer soit devenue fausse. ##### Compteurs (Counters) Les compteurs permettent de compter des événements. * **CTU (Count UP)** : Compte les fronts montants d'une entrée. La sortie s'active lorsque le nombre compté atteint une valeur préréglée. * **CTD (Count DOWN)** : Décompte les fronts montants d'une entrée. La sortie s'active lorsque le nombre compté atteint zéro ou une valeur préréglée. ##### Fonctions logiques de base * **ET (AND)** : Une sortie est active si *toutes* les entrées sont actives (contacts en série). * **OU (OR)** : Une sortie est active si *au moins une* des entrées est active (contacts en parallèle). * **NON (NOT)** : Inverse l'état d'une entrée ou d'une condition (contact NF). ##### Le cycle de scan de l'API Un API ne fonctionne pas en continu, mais exécute son programme de manière cyclique. Un cycle de scan typique comprend les étapes suivantes : 1. **Lecture des entrées** : L'API lit l'état de toutes ses entrées et les stocke dans une mémoire image des entrées. 2. **Exécution du programme** : L'API exécute le programme logique ligne par ligne, en utilisant l'état des entrées lu précédemment et les valeurs des variables internes. 3. **Mise à jour des sorties** : L'API met à jour l'état de ses sorties en fonction des résultats de l'exécution du programme, en les écrivant dans la mémoire image des sorties. 4. **Tâches internes et communication** : L'API effectue d'autres tâches (diagnostic, communication) avant de recommencer le cycle. La vitesse à laquelle ce cycle s'exécute est appelée le temps de cycle. Un temps de cycle court est crucial pour un contrôle rapide et réactif. ### Vocabulaire * **API (Automate Programmable Industriel)** : Ordinateur industriel dédié au contrôle de processus. * **Ladder Diagram (LD)** : Langage de programmation graphique pour API, basé sur des schémas à relais. * **Entrée (Input)** : Signal reçu par l'API (ex: d'un capteur, bouton). * **Sortie (Output)** : Signal envoyé par l'API (ex: à un moteur, lampe). * **UC (Unité Centrale)** : Composant de l'API qui exécute le programme. * **Contact Normalement Ouvert (NO)** : Contact qui laisse passer le courant quand il est activé. * **Contact Normalement Fermé (NF)** : Contact qui bloque le courant quand il est activé. * **Bobine** : Représente une action ou une sortie dans un programme Ladder. * **Temporisateur (Timer)** : Fonction API pour gérer des délais (ex: TON, TOF). * **Compteur (Counter)** : Fonction API pour compter des événements (ex: CTU, CTD). * **Cycle de scan** : Processus cyclique d'un API (lecture E, exécution programme, écriture S). * **Monobloc** : API dont tous les composants sont intégrés dans un seul boîtier. * **Modulaire** : API composé de plusieurs modules enfichables. ### Exemples #### Exemple 1 : Allumer une lampe avec un bouton poussoir Supposons que nous voulions allumer une lampe (Sortie S1) lorsque nous appuyons sur un bouton poussoir (Entrée E1). ```ladder ----] [----( )---- E1 S1 ``` * Si E1 est activée (bouton appuyé), le contact E1 se ferme et la bobine S1 s'active, allumant la lampe. #### Exemple 2 : Démarrer un moteur avec deux conditions de sécurité Un moteur (Sortie S2) doit démarrer seulement si un interrupteur de sécurité (Entrée E2) est fermé ET qu'un niveau de liquide (Entrée E3) est détecté. ```ladder ----] [--] [----( )---- E2 E3 S2 ``` * S2 s'active seulement si E2 et E3 sont toutes deux activées. #### Exemple 3 : Retarder l'activation d'une alarme Une alarme (Sortie S4) doit s'activer 5 secondes après qu'un capteur de fumée (Entrée E4) soit activé. ```ladder ----] [----[TON]---- E4 T1 PT = 5s ----] [----( )---- T1.Q S4 ``` * Quand E4 s'active, le temporisateur T1 commence à compter. Après 5 secondes, la sortie de T1 (T1.Q) s'active, ce qui active à son tour la bobine S4 (l'alarme). ### Exercices 1. Expliquez en vos propres mots le rôle principal d'un Automate Programmable Industriel dans une usine. 2. Quelle est la différence fondamentale entre un contact Normalement Ouvert (NO) et un contact Normalement Fermé (NF) dans un programme Ladder ? 3. Décrivez les trois étapes principales du cycle de scan d'un API. 4. Dessinez un petit programme Ladder pour qu'une pompe (sortie P1) démarre quand deux interrupteurs (entrées I1 et I2) sont fermés et s'arrête si un troisième interrupteur (entrée I3) est ouvert. 5. Si vous avez un temporisateur TON configuré avec un temps préréglé de 10 secondes, quand sa sortie s'activera-t-elle par rapport à l'activation de son entrée ? ### Devoirs 1. Recherchez et décrivez brièvement le logiciel de programmation typiquement utilisé pour le SLC100 (par exemple, A.I. Series) et pour le TSX Micro (par exemple, PL7 Micro). Quelles étaient leurs principales caractéristiques ? 2. Proposez un programme Ladder pour un système de feu de circulation simple avec deux feux (Rouge R1, Vert V1) et un bouton poussoir de démarrage (BP_Start). Le feu vert reste allumé pendant 20 secondes, puis le feu rouge reste allumé pendant 25 secondes, et le cycle se répète. Utilisez des temporisateurs. Simplifiez en ignorant le feu orange pour le moment. 3. Identifiez au moins trois applications industrielles différentes (autres que les exemples donnés) où les API sont essentiels pour le contrôle des machines ou des processus. ### Résumé Cette leçon nous a introduit au monde des Automates Programmables Industriels (API), des dispositifs cruciaux pour l'automatisation. Nous avons vu l'architecture générale d'un API, composée d'une Unité Centrale, de modules d'entrées/sorties et de mémoire. Nous avons ensuite exploré deux familles d'API distinctes : le SLC100 d'Allen-Bradley, un API monobloc simple, et la série TSx27 de Telemecanique, souvent plus modulaire et offrant une plus grande flexibilité. Enfin, nous avons approfondi les principes fondamentaux de la programmation en Ladder Diagram, y compris l'utilisation des contacts, des bobines, des temporisateurs et des compteurs, ainsi que le concept vital du cycle de scan d'un API. Comprendre ces bases est essentiel pour quiconque souhaite travailler dans l'automatisation industrielle et la commande de machines. ## REVISION SUR LA PROGRAMMATION DES AUTOMATES PROGRAMMABLE INDUSTRIEL ### Introduction Bienvenue à cette séance de révision sur la programmation des Automates Programmables Industriels (API). Les API sont des composants essentiels dans l'automatisation des systèmes industriels. Ils permettent de contrôler des machines et des processus de manière fiable et flexible. Au cours de cette leçon, nous allons revoir les concepts fondamentaux des API, les principaux langages de programmation, et les bases de la logique séquentielle nécessaire à leur fonctionnement. L'objectif est de consolider vos connaissances et de vous préparer à des applications plus complexes. ### Concepts Clés #### Qu'est-ce qu'un Automate Programmable Industriel (API) ? Un API est un ordinateur industriel robuste, conçu pour contrôler des processus de fabrication ou tout autre processus automatisé, tel que le contrôle de l'éclairage, des lignes d'assemblage, des attractions, etc. * **Définition :** Un API est un dispositif électronique programmable qui mémorise des instructions pour implémenter des fonctions spécifiques telles que la logique, le séquençage, la temporisation, le comptage et l'arithmétique, afin de contrôler des machines ou des processus à travers des modules d'entrées/sorties numériques ou analogiques. * **Rôle et avantages :** * **Fiabilité :** Conçus pour fonctionner dans des environnements industriels difficiles. * **Flexibilité :** Le programme peut être modifié facilement sans changer le câblage physique. * **Coût-efficacité :** Réduit le nombre de relais et de câblage nécessaires par rapport aux systèmes logiques câblés traditionnels. * **Diagnostic :** Facilite la détection des pannes grâce aux outils de diagnostic intégrés. * **Structure générale d'un API :** * **Unité Centrale (CPU) :** Le cerveau de l'API, qui exécute le programme. * **Modules d'Entrées (Inputs) :** Reçoivent les signaux des capteurs (boutons poussoirs, détecteurs de présence, capteurs de température, etc.). * **Modules de Sorties (Outputs) :** Envoient des signaux aux actionneurs (moteurs, vérins, lampes, vannes, etc.). * **Module d'Alimentation :** Fournit l'énergie nécessaire au fonctionnement de l'API. * **Module de Communication :** Permet à l'API de communiquer avec d'autres API, des ordinateurs ou des interfaces homme-machine (IHM). #### Les Langages de Programmation des API (Norme CEI 61131-3) La norme internationale CEI 61131-3 définit les langages de programmation standard pour les API. Les plus courants sont : ##### 1. Langage à Contacts (LD - Ladder Diagram) * **Description :** Langage graphique basé sur la représentation des schémas électriques à relais. Il est facile à comprendre pour les électriciens. * **Éléments de base :** * **Contacts :** Représentent des entrées (capteurs, interrupteurs). Ils peuvent être Normalement Ouverts (NO) ou Normalement Fermés (NC). * **Bobines :** Représentent des sorties (actionneurs, lampes). * **Exemple :** Une ligne de commande typique ressemble à un circuit électrique. ##### 2. Liste d'Instructions (IL - Instruction List) * **Description :** Langage textuel, proche de l'assembleur. Il utilise des mnémoniques pour représenter les opérations logiques et arithmétiques. Il est souvent utilisé pour des optimisations ou des fonctions spécifiques. * **Opérations de base :** `LD` (Load), `ST` (Store), `AND`, `OR`, `NOT`, etc. * **Correspondance avec le LD :** Chaque ligne de LD peut généralement être convertie en une série d'instructions IL. ##### 3. Blocs Fonctionnels (FBD - Function Block Diagram) * **Description :** Langage graphique où les fonctions sont représentées par des blocs. Les entrées sont à gauche des blocs et les sorties à droite. Les blocs peuvent être des portes logiques, des temporisateurs, des compteurs, etc. * **Exemple :** Un bloc timer pour un temporisateur. ##### 4. Séquenceur Graphique de Fonctions (SFC - Sequential Function Chart ou Grafcet) * **Description :** Langage graphique pour décrire le comportement séquentiel d'un système automatisé. Il est particulièrement adapté pour la gestion des étapes et des transitions d'un processus. * **Éléments de base :** * **Étapes :** Représentent un état stable du système avec des actions associées. * **Transitions :** Représentent le passage d'une étape à une autre, conditionné par des réceptivités. * **Réceptivités :** Conditions logiques qui doivent être vraies pour qu'une transition soit validée. #### Notions de Base en Logique Séquentielle * **Logique combinatoire :** La sortie dépend uniquement de l'état actuel des entrées. Exemple : une lampe s'allume si deux interrupteurs sont fermés. * **Logique séquentielle :** La sortie dépend non seulement des entrées actuelles, mais aussi des états précédents du système (mémorisation). C'est le cœur de la programmation des API pour gérer des séquences d'événements. * **Notion d'état :** Un état représente une condition stable du système, caractérisée par les valeurs de ses variables internes et externes. * **Exemple de table de vérité pour une porte logique ET :** \[ \begin{array}{|c|c|c|} \hline A & B & A \land B \\ \hline 0 & 0 & 0 \\ 0 & 1 & 0 \\ 1 & 0 & 0 \\ 1 & 1 & 1 \\ \hline \end{array} \] Une expression logique simple pourrait être : \( Sortie = Entrée_1 \land Entrée_2 \). Si nous considérons la rétention (mémoire) pour un démarrage/arrêt, la logique devient séquentielle. ### Vocabulaire Important * **API (Automate Programmable Industriel) :** Dispositif électronique programmable pour le contrôle de processus industriels. * **LD (Ladder Diagram / Langage à Contacts) :** Langage graphique ressemblant à un schéma électrique à relais. * **IL (Instruction List / Liste d'Instructions) :** Langage textuel de bas niveau pour API. * **FBD (Function Block Diagram / Langage à Blocs Fonctionnels) :** Langage graphique utilisant des blocs pour représenter des fonctions. * **SFC (Sequential Function Chart / Grafcet) :** Langage graphique pour la description du comportement séquentiel. * **Entrée (Input) :** Signal provenant d'un capteur vers l'API. * **Sortie (Output) :** Signal de l'API vers un actionneur. * **Contact NO (Normalement Ouvert) :** Contact ouvert au repos, se ferme sous l'action. * **Contact NC (Normalement Fermé) :** Contact fermé au repos, s'ouvre sous l'action. * **Bobine (Coil) :** Représentation d'une sortie dans le langage LD. * **Temporisateur (Timer) :** Fonction permettant de déclencher une action après un certain délai. * **Compteur (Counter) :** Fonction permettant de compter des événements. * **Étape (Step) :** État d'un système dans un Grafcet, où des actions sont exécutées. * **Transition :** Condition de passage d'une étape à une autre dans un Grafcet. * **Réceptivité :** Condition logique associée à une transition, qui doit être vraie pour que la transition soit franchie. ### Exemples Pratiques #### 1. Démarrage et arrêt d'un moteur en LD Imaginez un moteur (Q1) contrôlé par un bouton de démarrage (I1) et un bouton d'arrêt (I2), et un bouton d'arrêt d'urgence (I3). ```ladder |--[ I1 ]--+--[ Q1 ]--+--[ Q1 ]-- | | | |--[ I2 ]--+ | | | | |--[ I3 ]--+----------| // Légende : // I1 : Bouton Démarrage (NO) // I2 : Bouton Arrêt (NC) // I3 : Arrêt d'Urgence (NC) // Q1 : Moteur ``` Dans ce programme, le moteur démarre quand I1 est activé et maintient son état grâce à l'auto-maintien (contact Q1). Il s'arrête si I2 est pressé (rupture du circuit) ou si l'arrêt d'urgence I3 est activé. #### 2. Traduction de l'exemple précédent en IL (Liste d'Instructions) ```il LD I1 // Charge l'état de l'entrée I1 OR Q1 // OU avec l'état actuel de la sortie Q1 (auto-maintien) ANDN I2 // ET NON l'entrée I2 (bouton arrêt NC) ANDN I3 // ET NON l'entrée I3 (arrêt d'urgence NC) ST Q1 // Stocke le résultat dans la sortie Q1 ``` #### 3. Utilisation d'un temporisateur en FBD Allumer une lampe (Q1) 5 secondes après l'activation d'un bouton poussoir (I1). ```fbd +-------------------+ I1 ----| | | TON |---- Q1 (Lampe) | (Timer On Delay) | | IN Q | | | | PT=T#5s | +-------------------+ ``` Quand `IN` (I1) passe à VRAI, le temporisateur `TON` commence à compter. Après 5 secondes (`PT=T#5s`), la sortie `Q` du temporisateur passe à VRAI, ce qui allume la lampe (Q1). ### Exercices 1. Décrivez le rôle de la CPU, des modules d'entrées et des modules de sorties dans un API. 2. Dessinez un programme en langage à contacts (LD) pour allumer une lampe (L1) si deux interrupteurs (S1 et S2) sont fermés simultanément. 3. Convertissez le programme LD de l'exercice 2 en Liste d'Instructions (IL). 4. Expliquez la différence fondamentale entre un contact Normalement Ouvert (NO) et un contact Normalement Fermé (NC) en donnant un exemple d'utilisation pour chacun. ### Devoirs 1. **Conception d'un programme LD :** Concevez un programme en langage à contacts (LD) pour un feu de circulation simple. Le feu doit avoir trois états (Vert, Orange, Rouge) avec les temporisations suivantes : Vert (10s), Orange (3s), Rouge (7s). Le cycle doit se répéter indéfiniment après un démarrage initial. 2. **Description de Grafcet :** Décrivez le fonctionnement d'un Grafcet pour une porte de garage automatisée. Les étapes clés sont : porte fermée, ouverture de la porte, porte ouverte, fermeture de la porte. Identifiez les réceptivités et les actions associées à chaque étape et transition. 3. **Recherche et Comparaison :** Effectuez une recherche sur les avantages et les inconvénients de l'utilisation du langage à contacts (LD) par rapport au langage à blocs fonctionnels (FBD) pour la programmation d'un système de contrôle de niveau de liquide dans une cuve. Expliquez dans quelles situations l'un pourrait être préférable à l'autre. ### Résumé Au cours de cette révision, nous avons exploré les fondamentaux des Automates Programmables Industriels, qui sont au cœur de l'automatisation moderne. Nous avons revu les principaux langages de programmation conformes à la norme CEI 61131-3 : le langage à contacts (LD) pour sa simplicité graphique, la liste d'instructions (IL) pour sa concision, et les blocs fonctionnels (FBD) pour leur modularité. Le Grafcet (SFC) a été mis en avant comme un outil puissant pour la conception de logiques séquentielles complexes. Une bonne maîtrise de ces concepts est cruciale pour la conception, la programmation et la maintenance des systèmes automatisés industriels. Continuez à pratiquer pour développer votre expertise dans ce domaine passionnant. ## REVISION SUR LA PROGRAMMATION DES AUTOMATES PROGRAMMABLE INDUSTRIEL ### Introduction Bienvenue à cette séance de révision sur la programmation des Automates Programmables Industriels (API). Les API sont des composants essentiels dans l'automatisation des systèmes industriels. Ils permettent de contrôler des machines et des processus complexes de manière fiable et efficace. Au cours de cette leçon, nous allons revoir les concepts fondamentaux de la programmation des API, les langages de programmation couramment utilisés, et quelques principes de base pour vous aider à consolider vos connaissances. ### Concepts Clés #### Qu'est-ce qu'un Automate Programmable Industriel (API) ? Un API est un ordinateur industriel qui est utilisé pour automatiser des processus électromécaniques dans des usines, sur des lignes d'assemblage, ou tout autre environnement industriel. Il est conçu pour être robuste, tolérant aux erreurs et facile à programmer. #### Architecture d'un API Un API typique se compose des éléments suivants : * **Unité Centrale de Traitement (UCT/CPU) :** C'est le cerveau de l'API. Elle exécute le programme de l'utilisateur, gère les communications et coordonne les modules d'entrée/sortie. * **Mémoire :** Stocke le programme utilisateur, les données et les paramètres de configuration. On distingue généralement : * **Mémoire programme :** Pour le code de l'application. * **Mémoire de données :** Pour les valeurs des entrées, sorties, compteurs, temporisateurs, etc. * **Modules d'Entrée (Inputs) :** Reçoivent des signaux des capteurs (boutons poussoirs, détecteurs de proximité, etc.) et les convertissent en signaux logiques compréhensibles par l'UCT. * **Modules de Sortie (Outputs) :** Convertissent les signaux logiques de l'UCT en signaux de commande pour les actionneurs (moteurs, vérins, voyants, contacteurs, etc.). * **Alimentation :** Fournit l'énergie nécessaire au fonctionnement de l'API. * **Module de Communication :** Permet à l'API de communiquer avec d'autres API, des ordinateurs (superviseurs SCADA) ou des interfaces homme-machine (IHM). #### Langages de Programmation des API (Norme CEI 61131-3) La norme internationale CEI 61131-3 définit les langages de programmation standardisés pour les API. Les plus courants sont : * **Ladder Diagram (LD) / Langage à contacts (LAD) :** * Ressemble aux schémas électriques à relais. * Idéal pour les automaticiens familiers avec l'électricité. * Utilise des contacts (normalement ouverts NO, normalement fermés NF) et des bobines (sorties). * **Instruction List (IL) / Liste d'instructions (LIT) :** * Langage textuel de bas niveau, proche de l'assembleur. * Chaque ligne est une instruction (ex: LD pour 'Load', AND pour 'ET logique', ST pour 'Store'). * Très compact mais moins lisible pour des programmes complexes. * **Structured Text (ST) / Texte structuré (ST) :** * Langage de haut niveau, similaire au Pascal ou au C. * Permet des structures de contrôle (IF-THEN-ELSE, FOR, WHILE) et des expressions arithmétiques. * Idéal pour des algorithmes complexes ou des calculs. * **Function Block Diagram (FBD) / Diagramme de blocs fonctionnels (FBD) :** * Représentation graphique de fonctions (blocs) avec des entrées et des sorties. * Chaque bloc représente une fonction (ex: temporisateur, compteur, porte logique). * Facilite la réutilisation de code et la compréhension visuelle des flux de données. * **Sequential Function Chart (SFC) / Grafcet (SFC) :** * Méthode graphique pour décrire le comportement séquentiel d'un système. * Utilise des étapes, des transitions et des actions. * Particulièrement adapté pour la modélisation et la programmation de systèmes séquentiels (ex: démarrer un moteur, attendre, puis ouvrir une vanne). #### Variables et Adressage Chaque entrée, sortie, ou donnée interne dans un API est associée à une adresse spécifique. Le format d'adressage varie selon le fabricant (ex: Siemens, Schneider, Rockwell). Par exemple : * `I0.0` ou `%IX0.0` : Entrée binaire 0, bit 0. * `Q0.0` ou `%QX0.0` : Sortie binaire 0, bit 0. * `DBW10` ou `%MW10` : Mot de donnée dans un bloc de données (16 bits). * `T1` : Temporisateur 1. * `C1` : Compteur 1. #### Fonctions de Base * **Logique booléenne :** AND (ET), OR (OU), NOT (NON), XOR (OU exclusif). * **Temporisateurs (Timers) :** Permettent de déclencher des actions après un certain délai. Types courants : TON (Temporisation à l'enclenchement), TOFF (Temporisation au déclenchement), TP (Pulse). * **Compteurs (Counters) :** Permettent de compter des événements. Types courants : CTU (Compteur incrémental), CTD (Compteur décrémental), CTUD (Compteur incrémental/décrémental). ### Vocabulaire * **API (Automate Programmable Industriel) :** Ordinateur industriel pour l'automatisation. * **UCT (Unité Centrale de Traitement) / CPU :** Le processeur de l'API qui exécute le programme. * **Module d'Entrée :** Circuit qui reçoit les signaux des capteurs. * **Module de Sortie :** Circuit qui commande les actionneurs. * **Capteur :** Dispositif qui détecte un événement physique (ex: présence, température) et le convertit en signal électrique. * **Actionneur :** Dispositif qui convertit un signal électrique en action physique (ex: moteur, vérin). * **Contact NO (Normalement Ouvert) :** Contact qui est ouvert au repos et se ferme lorsqu'il est activé. * **Contact NF (Normalement Fermé) :** Contact qui est fermé au repos et s'ouvre lorsqu'il est activé. * **Bobine :** Représente une sortie physique ou une variable interne (mémoire) dans un programme Ladder. * **Grafcet (SFC) :** Méthode graphique de description des séquences de fonctionnement. * **Cycle de scan :** Le processus par lequel l'API lit les entrées, exécute le programme et met à jour les sorties, puis se répète. ### Exemples #### Exemple 1: Démarrage direct d'un moteur (Ladder Diagram) Programmation en Ladder pour démarrer un moteur M1 via un bouton poussoir START (I0.0) et l'arrêter avec un bouton poussoir STOP (I0.1). Un contact d'auto-maintien (Q0.0) et un arrêt d'urgence (I0.2) normalement fermé sont inclus. ```ladder |--[I0.2]--+--[I0.0]--+--[Q0.0]--+--[Q0.0]--| | ARRET | START | AUTO-M | MOTEUR | | URG. | | | | | | | | | |----------+----------| +----------| | | | | | |--[I0.1]--| | | | STOP | | ``` * Si ARRET URG. (I0.2) est fermé (non activé) ET (START (I0.0) est activé OU (Q0.0) est activé), alors la sortie MOTEUR (Q0.0) est activée. * Si STOP (I0.1) est activé (donc contact ouvert), le circuit est coupé et le moteur s'arrête. #### Exemple 2: Compteur de pièces (FBD ou ST) Un capteur (I0.0) détecte des pièces. Quand 10 pièces sont détectées, une sortie (Q0.0) s'active pour signaliser la fin du lot. Un bouton (I0.1) réinitialise le compteur. **En FBD (logique simplifiée) :** ```fbd ┌───────┐ I0.0 --| CTU |-- CU | C_LOT |-- Q I0.1 --| R |-- R | PV=10 |-- └───────┘ |-- Q0.0 ``` **En ST :** ```st VAR Count_Lot : CTU; Capteur_Piece : BOOL; Reset_Compteur : BOOL; Lot_Fini : BOOL; END_VAR Capteur_Piece := %IX0.0; (* Assigner l'entrée physique au tag *) Reset_Compteur := %IX0.1; Count_Lot(CU := Capteur_Piece, R := Reset_Compteur, PV := 10); Lot_Fini := Count_Lot.Q; (* La sortie .Q du CTU s'active quand CV >= PV *) %QX0.0 := Lot_Fini; (* Assigner la sortie logique à la sortie physique *) ``` ### Exercices 1. **Question :** Citez les cinq langages de programmation des API définis par la norme CEI 61131-3. 2. **Question :** Expliquez la différence entre un contact normalement ouvert (NO) et un contact normalement fermé (NF) dans le contexte du Ladder Diagram. 3. **Exercice pratique (mini-projet) :** Décrivez, en utilisant le langage de votre choix (Ladder ou SFC), un système qui allume une lampe (Q0.0) 5 secondes après qu'un bouton poussoir (I0.0) ait été pressé. Un deuxième bouton poussoir (I0.1) doit arrêter la lampe immédiatement. ### Devoirs 1. **Recherche :** Faites une recherche sur les API modulaires et compacts. Donnez les avantages et les inconvénients de chaque type et citez deux exemples de modèles pour chaque type de la part de fabricants différents. 2. **Analyse de séquence :** Un système de convoyeur doit transporter des objets. Voici la séquence de fonctionnement : * Un capteur de présence (I0.0) détecte un objet. * Le convoyeur (Q0.0) démarre et avance pendant 10 secondes. * Après 10 secondes, le convoyeur s'arrête et une pince (Q0.1) se ferme pour saisir l'objet pendant 2 secondes. * Après 2 secondes, la pince s'ouvre et le cycle se termine, attendant un nouvel objet. * Un bouton d'arrêt d'urgence (I0.2, contact NF) doit arrêter l'intégralité du processus. Proposez une représentation de ce cycle sous forme de Grafcet (SFC) avec les étapes, transitions et actions associées. ### Résumé Dans cette révision, nous avons rappelé l'importance des Automates Programmables Industriels (API) dans l'automatisation industrielle. Nous avons examiné leur architecture de base, composé d'une UCT, de modules d'entrée/sortie, de mémoire et d'une alimentation. Nous avons également passé en revue les cinq langages de programmation standardisés par la norme CEI 61131-3 : Ladder Diagram (LD), Instruction List (IL), Structured Text (ST), Function Block Diagram (FBD) et Sequential Function Chart (SFC/Grafcet). Enfin, nous avons abordé les concepts de variables, d'adressage et les fonctions de base comme la logique booléenne, les temporisateurs et les compteurs, illustrés par des exemples concrets. Maîtriser ces concepts est essentiel pour la conception et la maintenance des systèmes automatisés. Continuer à pratiquer la programmation est la clé du succès dans ce domaine.