CIRCUITS PROGRAMMABLES (partie 3/3)

## Objectifs et prérequis À la fin de ce chapitre, l’élève sera capable de : - expliquer le principe de fonctionnement d’un automate programmable industriel (API), d’un microcontrôleur et d’une FPGA ; - rédiger un programme simple en langage Ladder, en C/C++ pour Arduino et en VHDL de base ; - réaliser le câblage de base d’une entrée/sortie numérique sur chaque plateforme en respectant les normes de sécurité électrique au Cameroun (NF C 15-100) ; - tester, déboguer et documenter un circuit programmable dans un contexte professionnel (atelier de maintenance industrielle, bureau d’études ou chantier de télécom). **Prérequis** : connaissances de base en électronique numérique (portes logiques, bascules, bus de données), notions de tension, courant et résistance, lecture de schémas électriques, utilisation d’un multimètre et d’une alimentation stabilisée. --- ## Introduction contextualisée Dans les entreprises camerounaises de production, de télécommunications et d’énergie, les systèmes programmables sont omniprésents : automatisation de lignes de montage, contrôle de pompes d’irrigation, gestion d’éclairage public, acquisition de données sur les réseaux électriques. La troisième partie du chapitre « Circuits programmables » vise à mettre l’élève en situation de remédiation : il consolide les acquis des parties 1 et 2 (logique combinatoire et séquentielle) en les appliquant à des plateformes réelles. Cette approche par compétences prépare directement aux épreuves pratiques du baccalauréat technique séries MIE, où le candidat doit programmer, câbler et dépanner un dispositif sous contrainte de temps et de sécurité. --- ## I. Programmation des automates programmables industriels (API) – langage Ladder ### 1. Notions fondamentales Un API (ou PLC) est un ordinateur industriel dédié à la logique de commande. Il possède des entrées discrètes (capteurs, boutons) et des sorties discrètes (relais, variateurs). Le langage Ladder représente le schéma de relais sous forme de barreaux horizontaux (contacts) et verticaux (bobines). > **>** Un contact normalement ouvert (NO) se ferme lorsque l’entrée est à l’état haut (1). > **>** Une bobine (coil) s’active lorsque le chemin logique qui la précède est continu. ### 2. Étapes de programmation 1. **Analyse du cahier des charges** : déterminer les entrées (ex. : bouton START, fin de course) et les sorties (ex. : moteur, voyant). 2. **Écriture du schéma Ladder** : chaque ligne représente une logique de commande. 3. **Transfert vers l’API** : via câble USB ou Ethernet, à l’aide du logiciel fourni par le constructeur (ex. : Siemens TIA Portal, Schneider EcoStruxure). 4. **Simulation hors ligne** : vérifier le comportement sans risque. 5. **Mise en service** : alimenter l’API, forcer les entrées, observer les sorties. ### 3. Exemple d’atelier : commande d’un convoyeur - **Entrées** : I0.0 = bouton START (NO), I0.1 = fin de course (NC). - **Sorties** : Q0.0 = moteur convoyeur. **Ladder** : ``` |----[ I0.0 ]----[/ I0.1 ]----( Q0.0 )----| ``` Interprétation : le moteur démarre si START est appuyé (I0.0 = 1) ET la fin de course n’est pas atteinte (I0.1 = 0). > **>** Formule de sécurité : toujours placer un arrêt d’urgence (E‑Stop) en série avec toutes les sorties critiques. ### 4. Normes et sécurité - Respecter la déconnexion de l’alimentation avant toute intervention (ISO 12100). - Utiliser des borniers à vis certifiés IEC 60947. - Vérifier le calibre des fusibles de protection (ex. : 2 A pour une sortie 24 V DC). --- ## II. Programmation des microcontrôleurs (Arduino) – langage C/C++ ### 1. Présentation du matériel Une carte Arduino Uno repose sur un microcontrôleur ATmega328P. Elle offre 14 broches E/S numériques (6 PWM), 6 entrées analogiques, une alimentation 5 V ou 7‑12 V via le connecteur VIN. ### 2. Structure d’un sketch Arduino ```cpp void setup() { // initialisation des broches } void loop() { // code répété indéfiniment } ``` > **>** `pinMode(numéro, INPUT);` configure une broche en entrée. > **>** `pinMode(numéro, OUTPUT);` configure une broche en sortie. > **>** `digitalRead(numéro);` retourne HIGH (1) ou LOW (0). > **>** `digitalWrite(numéro, valeur);` écrit HIGH ou LOW. ### 3. Exemple de projet : mesure de température avec capteur LM35 - **Branchement** : Vout du LM35 → A0, GND → GND, VCC → 5 V. - **Conversion** : 10 mV/°C → tension (V) = (analogRead(A0) * 5.0) / 1023.0. - **Température** : °C = tension / 0.01. **Sketch complet** : ```cpp const int pinLM35 = A0; void setup() { Serial.begin(9600); } void loop() { int raw = analogRead(pinLM35); float voltage = raw * (5.0 / 1023.0); float temperature = voltage / 0.01; Serial.print("Température : "); Serial.print(temperature); Serial.println(" °C"); delay(1000); } ``` > **>** Toujours ajouter une résistance de tirage‑up ou‑down si l’entrée est flottante. ### 4. Procédure de dépannage 1. Vérifier l’alimentation (LED ON). 2. Contrôler la continuité des fils avec un multimètre. 3. Utiliser le moniteur série pour afficher les valeurs intermédiaires. 4. Recharger le bootloader si le téléchargement échoue. ### 5. Sécurité électrostatique - Manipuler la carte avec un bracelet antistatique ou toucher régulièrement la masse du châssis. - Éviter les surtensions > 12 V sur le VIN (risque de endommager le régulateur). --- ## III. Programmation des FPGA – langage VHDL de base ### 1. Qu’est‑ce qu’une FPGA ? Une Field‑Programmable Gate Array est une matrice de blocs logiques configurables interconnectés par une matrice de commutation programmable. Elle permet d’implémenter des circuits numériques personnalisés sans fabriquer un ASIC. ### 2. Flux de conception VHDL 1. **Spécification** : définir les entrées/sorties et le comportement (ex. : compteur modulo‑16). 2. **Écriture du code VHDL** : entité (interface) + architecture (comportement). 3. **Simulation** : avec un testbench pour vérifier les waveforms. 4. **Synthèse** : génération du netlist adapté à la cible (ex. : Xilinx Artix‑7). 5. **Implémentation** : placement et routage, génération du bitstream. 6. **Chargement** : via JTAG ou configuration SPI sur la carte de développement. ### 3. Exemple VHDL : compteur binaire 4 bits avec remise à zéro asynchrone ```vhdl library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.NUMERIC_STD.ALL; entity compteur_4bits is Port ( clk : in STD_LOGIC; rst : in STD_LOGIC; -- remise à zéro asynchrone q : out STD_LOGIC_VECTOR (3 downto 0)); end compteur_4bits; architecture Behavioral of compteur_4bits is signal temp : unsigned(3 downto 0) := (others => '0'); begin process(clk, rst) begin if rst = '1' then temp <= (others => '0'); elsif rising_edge(clk) then temp <= temp + 1; end if; end process; q <= std_logic_vector(temp); end Behavioral; ``` > **>** Le signal `rst` est asynchrone : il agit immédiatement, indépendamment de l’horloge. > **>** Dans une FPGA, chaque bascule consomme environ 10 µW à 100 MHz ; estimer la puissance totale aide à dimensionner le refroidissement. ### 4. Atelier pratique : génération d’un signal PWM ```vhdl library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.NUMERIC_STD.ALL; entity pwm_generator is Port ( clk : in STD_LOGIC; led : out STD_LOGIC); end pwm_generator; architecture Behavioral of pwm_generator is signal cnt : unsigned(7 downto 0) := (others => '0'); begin process(clk) begin if rising_edge(clk) then cnt <= cnt + 1; end if; end process; led <= '1' when cnt < 128 else '0'; end Behavioral; ``` > **>** Toujours vérifier les contraintes de temporisation (setup/hold) après synthèse ; un violation entraîne un comportement imprévisible. ### 5. Sécurité et bonnes pratiques - Ne jamais alimenter une FPGA avec une tension dépassant celle spécifiée dans le datasheet (ex. : 3,3 V ± 5 %). - Utiliser des résistances de limitation de courant sur les sorties LED (typ. : 68 Ω pour 3,3 V, 20 mA, en supposant une tension directe de la LED ≈ 2 V). - Lors du reprogrammage, s’assurer que le design précédent ne laisse pas des sorties en état indéterminé qui pourraient endommager des périphériques connectés. --- ## Synthèse du chapitre - **API (PLC)** : logique en Ladder, entrées/sorties discrètes, arrêt d’urgence en série, normes IEC 61131‑3. - **Microcontrôleur (Arduino)** : programmation C/C++, fonctions `pinMode`, `digitalRead/Write`, gestion des entrées analogiques, précautions antistatiques. - **FPGA** : description matérielle en VHDL, flux conception → simulation → synthèse → implantation, respect des contraintes de temporisation et des tensions d’alimentation. - **Sécurité commune** : couper l’alimentation avant intervention, utiliser des protections (fusibles, disjoncteurs), respecter les limites de courant et de tension, porter un bracelet antistatique quand nécessaire. - **Méthodologie** : analyser le cahier des charges, écrire le schéma ou le code, simuler, transférer, tester en situation réelle, documenter les étapes. --- ## Glossaire | Terme | Définition | |-------|------------| | API / PLC | Automate programmable industriel, dispositif électronique dédié à la logique de commande en milieu industriel. | | Ladder | Langage de programmation graphique représentant des contacts et des bobines, dérivé des schémas de relais. | | Sketch | Programme destiné à une carte Arduino, écrit en langage C/C++ avec les fonctions `setup()` et `loop()`. | | PWM | Modulation de largeur d’impulsion, technique permettant de varier la puissance moyenne d’un signal numérique. | | FPGA | Field‑Programmable Gate Array, matrice de blocs logiques reconfigurables après fabrication. | | VHDL | VHSIC Hardware Description Language, langage utilisé pour décrire le comportement et la structure de circuits numériques. | | Testbench | Banc de test VHDL permettant d’appliquer des stimuli à un design et de vérifier ses réponses. | | Contrainte | Contrainte de temporisation (setup, hold, période d’horloge) imposée lors de la synthèse d’une FPGA pour garantir un fonctionnement correct. | --- ## Exercices d'application corrigés ### Exercice 1 – API : commande d’une pompe de relevage **Consigne** : Une pompe doit démarrer lorsque le niveau d’eau dépasse un seuil (capteur de niveau NiveauHaut = 1) et s’arrêter lorsque le niveau retombe sous un autre seuil (NiveauBas = 0). Un bouton d’arrêt d’urgence (EStop) doit couper immédiatement la pompe. Écrire le schéma Ladder correspondant. **Corrigé** : - Entrées : I0.0 = NiveauHaut, I0.1 = NiveauBas, I0.2 = EStop (normalement fermé). - Sortie : Q0.0 = Pompe. Ladder : ``` |----[ I0.0 ]----[/ I0.1 ]----[/ I0.2 ]----( Q0.0 )----| ``` Explication : la pompe est alimentée si le niveau est haut (I0.0=1), le niveau bas n’est pas atteint (I0.1=0 → contact fermé) et l’arrêt d’urgence n’est pas actionné (I0.2=0 → contact fermé). --- ### Exercice 2 – Microcontrôleur : régulation de la luminosité d’une LED via un potentiomètre **Consigne** : Utiliser une carte Arduino Uno. Le potentiomètre (connecté à A0) varie la tension de 0 à 5 V. La LED est reliée à la broche PWM 9. Écrire un sketch qui lit la valeur analogique et ajuste le rapport cyclique de la LED en temps réel. **Corrigé** : ```cpp const int potPin = A0; const int ledPin = 9; void setup() { pinMode(ledPin, OUTPUT); } void loop() { int valeur = analogRead(potPin); // 0‑1023 int pwm = map(valeur, 0, 1023, 0, 255); // conversion 0‑255 analogWrite(ledPin, pwm); delay(10); // stabilisation } ``` **Vérification** : tourner le potentiomètre à fond donne pwm=255 (LED pleine luminosité), à zéro donne pwm=0 (LED éteinte). --- ## Erreurs fréquentes et règles de sécurité | N° | Erreur fréquente | Conséquence | Règle de prévention / bonne pratique | |----|------------------|-------------|--------------------------------------| | 1 | Oublier de mettre un arrêt d’urgence en série avec toutes les sorties critiques d’un API. | Risque de mise en marche incontrôlée d’une machine en cas de défaut. | Toujours placer le contact E‑Stop en amont de chaque chaîne de puissance (norme IEC 60204‑1). | | 2 | Alimenter une Arduino avec une tension > 12 V sur le VIN sans régulateur adapté. | Surchauffe du régulateur linéaire, endommagement du ATmega328P. | Utiliser une alimentation 7‑12 V ou ajouter un régulateur externe (ex. : LM7805) si besoin. | | 3 | Négliger la résistance de limitation en série avec une LED connectée à une broche FPGA. | Courant excessif → dégradation de la broche ou de la LED. | Ajouter une résistance calculée par R = (Vcc – Vled) / Iled (ex. : 68 Ω pour 3,3 V, 20 mA, en supposant Vled ≈ 2 V). | | 4 | Effectuer un changement de broche d’entrée/sortie sans mettre le pin en haute impédance (tri‑state) avant la reconfiguration. | Court‑circuit temporaire pouvant endommager le périphérique connecté. | Toujours mettre la broche en mode `INPUT` (high‑Z) pendant le chargement du nouveau bitstream ou avant de modifier le schéma Ladder. | | 5 | Utiliser un multimètre en mode ampère‑mètre en parallèle avec une charge sous tension. | Création d’un court‑circuit, risque d’arc et de blessure. | Mesurer le courant en série uniquement, jamais en parallèle ; vérifier le positionnement du sélecteur avant chaque mesure. | | 6 | Ne pas décharger les condensateurs de filtrage avant d’intervenir sur l’alimentation d’une carte FPGA. | Choc électrique ou endommagement des composants par décharge soudaine. | Toujours utiliser une résistance de décharge ou un tournevis isolé pour court‑circuiter les bornes du condensateur sous tension nulle. | --- *Ce cours couvre l’ensemble des compétences attendues pour la partie 3/3 du chapitre « Circuits programmables » dans le cadre du baccalauréat technique séries MIE, conformément au programme officiel MINESEC/IGE du Cameroun.*