Logiciels de simulation (Automgen) (partie 1/2)

## Objectifs et prérequis **Objectifs** : à la fin de ce chapitre l’élève sera capable de 1. Télécharger, installer et vérifier le bon fonctionnement du logiciel de simulation **Automgen** sur une station de travail Windows 10/11. 2. Maîtriser la terminologie spécifique à Automgen (projet, bibliothèque, symbole, variable, adresse, séquence, organigramme, Ladder, Grafcet, fonction‑bloc, simulateur, débogueur). 3. Créer un projet complet, du schéma électrique à la génération de code, en passant par la simulation pas‑à‑pas et le débogage. 4. Appliquer les règles de sécurité informatique et d’hygiène de travail lors de l’installation et de l’utilisation du logiciel. **Prérequis** : - Notions de base en automatisme industriel (contacteurs, relais, logique booléenne, entrées/sorties discrètes). - Connaissances élémentaires du système d’exploitation Windows (gestion des fichiers, droits administrateur). - Notions de lecture de schémas électriques et de représentation IEC 61131‑3 (Ladder, Grafcet, STL). - Savoir manipuler une souris et un clavier, comprendre le concept de fichier exécutable (.exe). --- ## Introduction contextualisée Dans le contexte industriel camerounais, les entreprises agro‑alimentaires (ex. : Société Sucrière du Cameroun – SUCAM), les mines (ex. : exploitation de l’or à Batouri) et les usines de transformation du bois utilisent de plus en plus des automates programmables pour garantir la productivité, la sécurité et la conformité aux normes environnementales. Avant de mettre en service un automate sur une ligne de production, il est indispensable de valider son comportement grâce à un logiciel de simulation. **Automgen**, édité par la société française **Schneider Electric**, est largement présent dans les centres de formation technique du Cameroun (Lycée Technique de Yaoundé, IUT de Douala, etc.) grâce à sa licence éducative et à son interface conviviale. Maîtriser son installation, sa terminologie et son processus de création de projet permet à l’élève de passer de la théorie à la pratique professionnelle, réduisant les risques d’arrêt de ligne et les coûts de mise au point. --- ## I. Leçon 18 – Processus de démarrage et d’installation d’un logiciel de simulation ### 1.1 Présentation d’Automgen Automgen est un environnement de développement intégré (EDI) destiné à la conception, la simulation et la mise en service d’automates programmables industriels (API). Il supporte les langages IEC 61131‑3 (Ladder, Grafcet, Structured Text, Instruction List) et permet la génération de code C ou directement vers des automates Schneider (Modicon, Twido, etc.). > **>** Automgen intègre un simulateur temps réel qui reproduit le balayage de l’automate sans matériel physique. ### 1.2 Configuration minimale requise | Composant | Exigence minimale | Recommandé pour l’enseignement | |-----------|-------------------|--------------------------------| | Système d’exploitation | Windows 10 (64 bits) | Windows 11 (64 bits) | | Processeur | Intel Core i3 ou équivalent | Intel Core i5 ou supérieur | | Mémoire RAM | 4 Go | 8 Go ou plus | | Espace disque | 2 Go libres | 5 Go SSD | | Résolution écran | 1024 × 768 | 1920 × 1080 | | Carte graphique | Compatible DirectX 9 | Compatible DirectX 11 | | Autres | .NET Framework 4.8, accès Internet pour activation | Même chose + antivirus à jour | ### 1.3 Étapes d’installation 1. **Téléchargement** : depuis le portail éducatif Schneider Electric, récupérer le fichier `Automgen_Setup_XXXXX.exe`. 2. **Lancement du setup** : double‑clic → apparaît la boîte de dialogue d’accueil. 3. **Acceptation du contrat de licence** : cocher « J’accepte les termes du contrat de licence ». 4. **Choix du répertoire d’installation** : par défaut `C:\Program Files\Automgen` ; modifier si nécessaire (éviter les chemins contenant des espaces pour éviter certains problèmes de compatibilité). 5. **Sélection des composants** : - *Core Application* (obligatoire) - *Bibliothèques de symboles* (IEC, NEMA, spécifiques au Cameroun) - *Exemples et tutoriels* (recommandé pour l’auto‑formation) - *Pack de langue française* (si disponible) 6. **Installation** : cliquer sur « Installer ». Le programme copie les fichiers, enregistre les DLL et crée les entrées de registre. 7. **Redémarrage** : éventuellement demandé ; redémarrer l’ordinateur pour finaliser l’enregistrement des variables d’environnement. ### 1.4 Vérification de l’installation - Lancer Automgen depuis le menu Démarrer → apparaît la fenêtre d’accueil avec les options « Nouveau projet », « Ouvrir un projet », « Exemples ». - Dans le menu **Aide → À propos de Automgen**, vérifier le numéro de version (ex. : 7.5.2) et la présence de la licence éducative (date de validité). - Effectuer un **test de lancement du simulateur** : créer un nouveau projet vide, appuyez sur le bouton **Simuler** (icône triangle vert). Une fenêtre de simulation doit s’ouvrir sans message d’erreur. ### 1.5 Précautions de sécurité et d’hygiène - **Droits administrateur** : l’installation nécessite un compte avec privilèges d’administrateur ; ne jamais partager ce compte avec des élèves non supervisés. - **Antivirus** : désactiver temporairement l’antivirus uniquement pendant le téléchargement du setup si celui‑ci bloque à tort le fichier exécutable, puis le réactiver immédiatement après l’installation. - **Sauvegarde** : créer un point de restauration système avant l’installation ; conserver une copie du fichier d’installation sur un support externe (clé USB) pour réinstallation en cas de corruption. - **Sécurité réseau** : si l’installation se fait depuis un serveur interne, vérifier que le flux provient d’une source fiable (certificat SSL valide) afin d’éviter les attaques de type *man‑in‑the‑middle*. > **>** Toujours vérifier l’intégrité du fichier téléchargé en comparant son empreinte SHA‑256 avec celle publiée sur le site Schneider. --- ## II. Leçon 19 – Terminologie et processus de fonctionnement d’un logiciel de simulation ### 2.1 Vocabulaire clé | Terme | Définition (IEC 61131‑3 / Automgen) | |-------|--------------------------------------| | **Projet** | Ensemble de fichiers contenant le schéma, les variables, les programmes et les paramètres de simulation. | | **Bibliothèque** | Collection de symboles (contact, bobine, temporisateur, etc.) réutilisables dans plusieurs projets. | | **Symbole** | Représentation graphique d’un élément d’automatisme (ex. : contact normalement ouvert). | | **Variable** | Nom symbolique associé à une adresse mémoire de l’automate (ex. : `%IX0.0` pour une entrée discrète). | | **Adresse** | Emplacement physique ou logique dans la mémoire de l’automate (format IEC : `%IX`, `%QX`, `%MW`, etc.). | | **Séquence** | Suite d’étapes exécutées dans un ordre déterminé (utilisée en Grafcet). | | **Organigramme** | Représentation hiérarchique des blocs fonctionnels d’un programme. | | **Ladder** | Langage à contacts et bobines, proche du schéma électrique traditionnel. | | **Grafcet** | Langage basé sur les étapes et les transitions, adapté au contrôle séquentiel. | | **Fonction‑bloc** | Bloc réutilisable encapsulant un algorithme (ex. : PID, compteur). | | **Simulateur** | Module qui reproduit le cycle de balayage de l’automate en temps réel ou pas‑à‑pas. | | **Débogueur** | Outil permettant d’insérer des points d’arrêt, d’examiner les valeurs des variables et de suivre l’exécution ligne par ligne. | | **Générateur de code** | Produit du code source (C, Structured Text, etc.) ou le fichier de configuration destiné à l’automate cible. | > **>** En Automgen, chaque variable doit être déclarée avant d’être utilisée dans un schéma ou un programme. ### 2.2 Architecture logique d’Automgen 1. **Éditeur de schéma** : espace de travail où l’on glisse‑dépose des symboles pour créer le dessin électrique. 2. **Éditeur de langage** : trois onglets principaux – Ladder, Grafcet, Structured Text (ST). Chaque onglet possède sa propre barre d’outils (insertion de contacts, bobines, blocs fonctionnels, etc.). 3. **Simulateur** : fenêtre séparée qui affiche l’état des entrées/sorties en temps réel, avec possibilité de forcer des valeurs, d’avancer pas‑à‑pas (F10) ou d’exécuter jusqu’au prochain point d’arrêt (F5). 4. **Débogueur** : intégré au simulateur ; liste des points d’arrêt, espérances (watch) et pile d’appels. 5. **Générateur de code** : accessible via le menu **Projet → Générer le code** ; permet de choisir la cible (ex. : Schneider Twido, Siemens S7‑1200) et le langage de sortie. ### 2.3 Cycle de fonctionnement ``` Création du schéma → Déclaration des variables → Programmation (Ladder/Grafcet/ST) ↓ Compilation (vérification de syntaxe et de cohérence d’adresses) ↓ Simulation (exécution virtuelle du cycle de balayage) ↓ Débogage (observation, correction) ↓ Export / Génération de code vers l’automate cible ``` > **>** Le temps de cycle théorique d’un automate est donné par : > $$T_{\text{cycle}} = T_{\text{scan}} + T_{\text{process}}$$ > où $T_{\text{scan}}$ est le temps nécessaire au balayage des entrées et $T_{\text{process}}$ le temps d’exécution du logique utilisateur. ### 2.4 Notions de temps de cycle, balayage et mise à jour des E/S - **Balayage** : phase où l’automate lit l’état de toutes les entrées discrètes et analogiques, les stocke dans la mémoire d’image (%I, %AI). - **Exécution du logique** : le programme Ladder/Grafcet/ST est évalué à partir de l’image des entrées ; les résultats sont écrits dans la mémoire de sortie (%Q, %AQ). - **Mise à jour des sorties** : à la fin du cycle, les valeurs de la mémoire d’image de sortie sont transmises aux modules physiques. - En simulation, Automgen reproduit exactement ces trois phases ; l’utilisateur peut visualiser chaque étape grâce au mode **pas‑à‑pas**. ### 2.5 Sécurité logicielle - **Versionnage** : chaque enregistrement de projet crée une version incrémentée (ex. : `MonProjet_v1.agp`, `MonProjet_v2.agp`). - **Verrouillage** : possibilité de protéger le projet par un mot de passe afin d’empêcher la modification non autorisée. - **Sauvegarde automatique** : activer l’option *Enregistrement toutes les 5 minutes* dans les préférences pour limiter les pertes en cas de coupure de courant. --- ## III. Leçon 20 – Processus de création d’un projet dans un logiciel de simulation ### 3.1 Démarrage d’un nouveau projet 1. **Fichier → Nouveau projet** → choisir le type *Automatisme discret* (pour les exercices de niveau Terminale). 2. Saisir le **nom du projet** (ex. : `Convoyeur_Basique`). 3. Définir le **répertoire de travail** (ex. : `D:\Projets_Automgen\Convoyeur_Basique`). 4. Valider → Automgen crée la structure de dossiers : - `\Sources` (schémas, programmes) - `\Libraries` (bibliothèques de symboles utilisés) - `\Docs` (documentation, rapports de simulation) > **>** Toujours vérifier que le chemin ne contient pas de caractères accentués ni d’espaces pour éviter les problèmes de compilation sous certaines versions d’Automgen. ### 3.2 Création du schéma électrique - Ouvrir l’**éditeur de schéma** (icône crayon). - Depuis la **bibliothèque IEC**, glisser‑déposer : - Un **contact normalement ouvert** (symbole `─[ ]─`) pour le bouton de démarrage (`START`). - Un **contact normalement fermé** (symbole `─[/]─`) pour le bouton d’arrêt d’urgence (`STOP`). - Une **bobine** (symbole `─( )─`) représentant l’alimentation du moteur (`MOTEUR`). - Un **temporisateur ON‑Delay** (`TON`) pour gérer un délai de démarrage progressif (ex. : 2 s). - Relier les éléments avec des lignes de connexion (clic‑glisser). - Ajouter des **étiquettes** (double‑clic sur un fil) pour nommer les signaux (`%IX0.0` → `START`, `%IX0.1` → `STOP`, `%QX0.0` → `MOTEUR`). ### 3.3 Déclaration des variables - Menu **Projet → Variables** → ouvrir l’éditeur de variables. - Créer les variables suivantes (respectant la norme IEC 61131‑3) : | Nom logique | Type | Adresse IEC | Commentaire | |-------------|------|-------------|-------------| | `START` | BOOL | `%IX0.0` | Bouton de démarrage (NO) | | `STOP` | BOOL | `%IX0.1` | Bouton d’arrêt d’urgence (NF) | | `MOTEUR` | BOOL | `%QX0.0` | Sortie commande moteur | | `T_DELAY` | TON | `%T0` | Temporisateur ON‑Delay, PT = T#2s | | `MOTEUR_START` | BOOL | `%MX0.0` | Mémoire interne pour retenir l’état après relâchement du bouton START | > **>** Chaque adresse doit être unique ; le doublon entraîne une erreur de compilation « Adresse déjà utilisée ». ### 3.4 Programmation en Ladder Dans l’onglet **Ladder** : 1. **Réseau 1** – logique de démarrage/arrêt (auto‑maintenance) : - Contact `START` en parallèle avec la mémoire `MOTEUR_START`. - En série avec le contact `STOP` (NF). - Sortie bobine `MOTEUR_START`. ``` ----[ START ]----[/ STOP ]----( MOTEUR_START ) | | +----[ MOTEUR_START ]-+ ``` 2. **Réseau 2** – commande du moteur via temporisateur : - Contact `MOTEUR_START` en entrée du TON (`T_DELAY`). - Sortie du TON (`T_DELAY.Q`) commande la bobine `MOTEUR`. ``` ----[ MOTEUR_START ]----[ TON(T_DELAY) ]----( MOTEUR ) ``` 3. **Réseau 3** – réinitialisation du temporisateur à l’arrêt : - Le TON `T_DELAY` est réinitialisé automatiquement lorsque son entrée `MOTEUR_START` passe à `FALSE` ; aucun réseau supplémentaire n’est nécessaire. - (Alternativement, on peut utiliser un bloc `RES` déclenché par le contact `/MOTEUR_START`.) ``` ----[ /MOTEUR_START ]----[ RES(T_DELAY) ]---- ``` > **>** En Ladder, les contacts normalement fermés sont représentés par une barre oblique `[/]`. ### 3.5 Simulation - Cliquer sur l’icône **Simuler** (triangle vert). - La fenêtre de simulation apparaît ; on peut : - Forcer l’entrée `START` à `TRUE` (clic droit → *Forcer à TRUE*) → observer que `MOTEUR_START` se maintient après relâchement du bouton grâce à l’auto‑maintenance. - Voir le temporisateur `T_DELAY` commencer à compter ; après 2 s, sa sortie `Q` passe à `TRUE` et alimente la bobine `MOTEUR`. - Forcer `STOP` à `TRUE` → la bobine `MOTEUR_START` se désactive immédiatement, le moteur s’arrête et le temporisateur se réinitialise. - Utiliser le **pas‑à‑pas** (F10) pour suivre chaque réseau cycle par cycle. - Placer un **point d’arrêt** sur le réseau 2 (clic gauche → *Toggle Breakpoint*) pour inspecter la valeur de `T_DELAY.PT` et `T_DELAY.ET` à chaque étape. ### 3.6 Export du projet vers un automate cible - Menu **Projet → Générer le code** → choisir la cible *Schneider Twido* → langage *Ladder*. - Automgen produit un fichier `.twl` (format Twido) et un rapport de compilation. - Transférer le fichier `.twl` vers l’automate via le câble de programmation USB‑RS232 ou Ethernet, puis mettre en marche l’automate en mode *RUN*. - Vérifier sur le terrain que le comportement observé en simulation correspond au fonctionnement réel (démarrage progressif, arrêt d’urgence, auto‑maintenance). ### 3.7 Documentation et archivage - Générer un **rapport de projet** (menu *Outils → Rapport*) contenant : schéma, tableau des variables, liste des réseaux Ladder, journal de simulation. - Enregistrer le rapport au format PDF dans le dossier `\Docs`. - Archiver l’ensemble du projet sur un serveur de sauvegarde hebdomadaire (ex. : `\\ServeurSauvegarde\Projets\2025\Convoyeur_Basique.zip`). - Effectuer une **vérification de version** avant toute modification : comparer le hash SHA‑256 du fichier `.agp` avec celui stocké en base de données. > **>** Un bon archivage permet de retrouver rapidement la version fonctionnelle d’un projet en cas de régression après une modification. --- ## Synthèse du chapitre - **Installation** : téléchargement du setup, exécution avec droits administrateur, vérification de la licence et du simulateur. - **Terminologie** : projet, bibliothèque, symbole, variable, adresse, séquence, organigramme, Ladder, Grafcet, fonction‑bloc, simulateur, débogueur, générateur de code. - **Fonctionnement** : création → compilation → simulation → débogage → export ; cycle de balayage $T_{\text{cycle}} = T_{\text{scan}} + T_{\text{process}}$. - **Création de projet** : choix du type, schéma électrique, déclaration de variables IEC, programmation Ladder/Grafcet, simulation pas‑à‑pas, point d’arrêt, génération de code vers automate cible, documentation et archivage. - **Sécurité** : droits d’accès, antivirus, sauvegarde, vérification d’intégrité (SHA‑256), versionnage et verrouillage du projet. --- ## Glossaire | Terme | Définition | |-------|------------| | **Automgen** | Environnement de développement intégré pour la conception, la simulation et la mise en service d’automates programmables (Schneider Electric). | | **Projet** | Ensemble structuré de fichiers contenant schéma, variables, programmes et paramètres de simulation d’un automatisme. | | **Bibliothèque** | Collection réutilisable de symboles (contact, bobine, temporisateur, etc.) partagée entre plusieurs projets. | | **Symbole** | Représentation graphique normalisée d’un composant d’automatisme (ex. : contact NO). | | **Variable** | Nom symbolique associé à une adresse mémoire de l’automate (ex. : `%IX0.0`). | | **Adresse IEC** | Notation normalisée (%IX, %QX, %MW, %MD, etc.) définissant l’emplacement d’une variable dans la mémoire de l’automate. | | **Ladder** | Langage de programmation à contacts et bobines, proche du schéma électrique traditionnel. | | **Grafcet** | Langage basé sur étapes et transitions, adapté au contrôle séquentiel. | | **Simulateur** | Module qui reproduit le cycle de balayage de l’automate en temps réel ou pas‑à‑pas, permettant de tester le logique sans matériel. | | **Débogueur** | Outil permettant d’insérer des points d’arrêt, d’examiner et de modifier les valeurs des variables pendant la simulation. | | **Générateur de code** | Fonction qui produit le fichier de configuration ou le code source destiné à l’automate cible (ex. : Twido, S7‑1200). | | **Temporisateur ON‑Delay (TON)** | Bloc fonctionnel qui active sa sortie après un temps preset suivant une montée en logique de son entrée. | | **Point d’arrêt** | Instruction de débogage qui suspend l’exécution de la simulation à une instruction donnée pour inspection. | | **Versionnage** | Gestion automatique des versions successives d’un projet afin de permettre un retour en arrière ou une comparaison. | | **SHA‑256** | Algorithme de hachage cryptographique utilisé pour vérifier l’intégrité d’un fichier téléchargé. | --- ## Exercices d’applications corrigés ### Exercice 1 – Installation et vérification d’Automgen **Consigne** : Vous venez de recevoir une clé USB contenant le fichier `Automgen_Setup_7.5.2.exe`. Sur un poste de travail Windows 10 64 bits, réalisez l’installation d’Automgen, vérifiez son bon fonctionnement et produisez un rapport d’installation contenant : 1. La version installée. 2. La présence de la licence éducative. 3. Le résultat du test de lancement du simulateur (capture d’écran ou description). **Corrigé** : 1. Lancer le fichier `Automgen_Setup_7.5.2.exe` avec un clic droit → *Exécuter en tant qu’administrateur*. 2. Dans l’assistant d’installation : accepter le contrat, choisir le répertoire `C:\Program Files\Automgen`, sélectionner les composants *Core Application*, *Bibliothèques IEC*, *Exemples et tutoriels*, *Pack français*. 3. Cliquer sur *Installer* puis attendre la fin. Redémarrer l’ordinateur lorsqu’on le demande. 4. Après redémarrage, ouvrir le menu Démarrer → *Automgen*. Dans la fenêtre d’accueil, cliquer sur *Aide → À propos de Automgen*. La boîte de dialogue indique : - Version : **7.5.2** - Type de licence : **Éducative** (valide jusqu’au 30/06/2026) 5. Pour tester le simulateur : - *Fichier → Nouveau projet* → nommer `TestSimu`. - Dans l’éditeur de schéma, placer un contact NO (`%IX0.0`) et une bobine (`%QX0.0`) en série. - Cliquer sur l’icône **Simuler** (triangle vert). Une fenêtre de simulation apparaît montrant deux colonnes : *Entrées* et *Sorties*. Forcer l’entrée `%IX0.0` à `TRUE` (clic droit → *Forcer à TRUE*) ; la sortie `%QX0.0` passe immédiatement à `TRUE`. - Capturer l’écran (ou décrire) : la fenêtre affiche `Entrées : IX0.0 = 1` et `Sorties : QX0.0 = 1`. 6. Enregistrer le rapport d’installation sous `C:\Rapports\Installation_Automgen.txt` contenant les trois points ci‑dessus. --- ### Exercice 2 – Création d’un projet Ladder pour un convoyeur avec démarrage/arrêt et surveillance de surcharge **Consigne** : À l’aide d’Automgen, concevoir un projet nommé `Convoyeur_Surcharge` qui réalise les fonctions suivantes : - Un bouton de démarrage vert (`START`) et un bouton d’arrêt rouge (`STOP`) commandent l’alimentation du moteur du convoyeur (`MOTEUR`). - Le moteur démarre uniquement si le bouton `START` est maintenu enfoncé (auto‑maintenance) et s’arrête immédiatement lorsque `STOP` est actionné. - Un capteur de courant (`CURRENT`) fournit une entrée analogique `%IW0.0` (valeur en mA). Si le courant dépasse 500 mA, une alarme (`ALARME`) doit être activée et le moteur coupé, indépendamment de l’état de `START`/`STOP`. - Utiliser un temporisateur ON‑Delay (`TON`) de 1 s pour filtrer les à‑pics de courant avant de déclencher l’alarme. - Fournir le schéma Ladder complet, le tableau des variables, la description de la simulation pas‑à‑pas pour les scénarios suivants : a) Démarrage normal, arrêt par `STOP`. b) Surcharge transitoire (courant à 600 mA pendant 0,8 s) → aucune alarme. c) Surcharge soutenue (courant à 600 mA pendant 1,5 s) → alarme activée et moteur coupé. **Corrigé** : #### 2.1 Tableau des variables | Nom logique | Type | Adresse IEC | Commentaire | |-------------|------|-------------|-------------| | `START` | BOOL | `%IX0.0` | Bouton de démarrage (NO) | | `STOP` | BOOL | `%IX0.1` | Bouton d’arrêt (NF) | | `CURRENT` | INT | `%IW0.0` | Courant moteur en mA (entrée analogique) | | `MOTEUR` | BOOL | `%QX0.0` | Sortie commande moteur | | `ALARME` | BOOL | `%QX0.1` | Sortie alarme surcharge | | `T_FILTER` | TON | `%T0` | Temporisateur ON‑Delay, PT = T#1s | | `MOTEUR_LATCH` | BOOL | `%MX0.0` | Mémoire d’auto‑maintenance du moteur | | `OVERCURRENT` | BOOL | `%MX0.1` | Variable intermédiaire indiquant dépassement du seuil après filtrage | #### 2.2 Schéma Ladder (description texte) **Réseau 1 – Auto‑maintenance du moteur** ``` ----[ START ]----[/ STOP ]----( MOTEUR_LATCH ) | | +----[ MOTEUR_LATCH ]-+ ``` *Explication* : Le contact `START` en parallèle avec la mémoire `MOTEUR_LATCH` forme une boucle d’automaintenance ; le contact `STOP` (NF) la coupe lorsqu’il est actionné. **Réseau 2 – Commande du moteur** ``` ----[ MOTEUR_LATCH ]----[/ OVERCURRENT ]----( MOTEUR ) ``` *Explication* : Le moteur est alimenté seulement si la mémoire d’automaintenance est active **et** aucune surcharge filtrée n’est détectée. **Réseau 3 – Détection de surcharge avec filtrage** ``` ----[ %IW0.0 >= 500 ]----[ TON(T_FILTER) ]----( OVERCURRENT ) ``` *Explication* : Un contact de comparaison (implicite dans Automgen via un bloc de fonction `GE` ou un bloc de comparaison) vérifie si le courant `%IW0.0` est supérieur ou égal à 500 mA. Si la condition est vraie pendant au moins le preset du TON (1 s), la sortie du TON active `OVERCURRENT`. **Réseau 4 – Activation de l’alarme** ``` ----[ OVERCURRENT ]----( ALARME ) ``` *Explication* : Dès que `OVERCURRENT` est à TRUE, l’alarme est activée. **Réseau 5 – Réinitialisation du temporisateur à la fin de la surcharge** ``` ----[ /(%IW0.0 >= 500) ]----[ RES(T_FILTER) ]---- ``` *Explication* : Lorsque le courant repasse sous le seuil, l’entrée du TON est mise à FALSE, ce qui réinitialise le temporisateur (bloc `RES` disponible dans la bibliothèque de blocs fonctionnels d’Automgen). > **>** En Automgen, le bloc de comparaison s’insère depuis la barre d’outils *Fonctions → Comparaison → GE* (greater or equal). Le bloc `RES` se trouve sous *Fonctions → Temporisateurs → RESET*. #### 2.3 Simulation pas‑à‑pas **Scénario a) Démarrage normal, arrêt par `STOP`** 1. Au temps t=0 s : `START=0`, `STOP=0`, `CURRENT=100 mA`. 2. Forcer `START` à `TRUE` (clic droit → *Forcer à TRUE*) : - Réseau 1 : contact `START` fermé → bobine `MOTEUR_LATCH` s’active → `MOTEUR_LATCH=1`. - Réseau 2 : `MOTEUR_LATCH=1`, `OVERCURRENT=0` (pas encore de surcharge) → bobine `MOTEUR` s’active → `MOTEUR=1` (moteur en marche). - Réseau 3 : comparaison `%IW0.0 >= 500` est fausse → entrée du TON à `FALSE` → `OVERCURRENT=0`. - Réseau 4 : `ALARME=0`. 3. Relâcher `START` (forcer à `FALSE`) : - Le contact `START` s’ouvre, mais la mémoire `MOTEUR_LATCH` reste fermée grâce à l’automaintenance → `MOTEUR_LATCH` reste à `1`. - Le moteur reste alimenté. 4. Forcer `STOP` à `TRUE` : - Le contact `STOP` (NF) s’ouvre → la bobine `MOTEUR_LATCH` perd son alimentation → `MOTEUR_LATCH=0`. - Conséquence : `MOTEUR` passe à `0` (moteur arrêté). - `ALARME` reste à `0`. **Scénario b) Surcharge transitoire (0,8 s)** 1. Partir du état moteur en marche (`MOTEUR=1`, `MOTEUR_LATCH=1`). 2. À t=0 s, forcer le courant à `600 mA` (`%IW0.0 = 600`). - Comparaison `%IW0.0 >= 500` devient vraie → entrée du TON passe à `TRUE`. - Le TON commence à compter ; après 0,8 s, le temps écoulé (`ET`) est encore inférieur au preset (`PT=1s`). - Donc la sortie du TON (`OVERCURRENT`) reste à `FALSE`. - `ALARME` reste à `0`, `MOTEUR` reste alimenté. 3. À t=0,8 s, rétablir le courant à `100 mA`. - La comparaison redevient fausse → entrée du TON à `FALSE` → le TON se réinitialise immédiatement (`ET=0`). - Aucun changement sur les sorties. **Scénario c) Surcharge soutenue (1,5 s)** 1. Même départ que précédemment, moteur en marche. 2. À t=0 s, forcer le courant à `600 mA`. - Comparaison vraie → entrée du TON à `TRUE`. - Le TON compte ; après 1,0 s, `ET` atteint `PT`. - À ce instant, la sortie du TON passe à `TRUE` → `OVERCURRENT=1`. - Réseau 2 : le contact `/OVERCURRENT` s’ouvre → bobine `MOTEUR` perd son alimentation → `MOTEUR=0` (moteur coupé). - Réseau 4 : `OVERCURRENT=1` active la bobine `ALARME` → `ALARME=1` (alarme déclenchée). - Même si `START` reste enfoncé et `STOP` relâché, le moteur ne peut pas redémarrer tant que `OVERCURRENT` reste à `1`. 3. À t=1,5 s, rétablir le courant à `100 mA`. - La comparaison redevient fausse → entrée du TON à `FALSE` → le TON se réinitialise (`ET=0`, `OVERCURRENT=0`). - Conséquence immédiate : le contact `/OVERCURRENT` se referme, mais comme la mémoire `MOTEUR_LATCH` est toujours à `1` (puisque `START` est encore enfoncé et `STOP` relâché), le moteur peut redémarrer : - Réseau 1 maintient `MOTEUR_LATCH=1`. - Réseau 2 : `MOTEUR_LATCH=1`, `OVERCURRENT=0` → `MOTEUR` repasse à `1`. - L’alarme se désactive (`ALARME=0`) dès que `OVERCURRENT` retombe à `0`. > **>** Le filtrage par temporisateur évite les déclenchements intempestifs dus à des pointes de courant de courte durée (< 1 s). --- ## Erreurs fréquentes et règles de sécurité | N° | Erreur fréquente | Conséquence | Règle de prévention / bonne pratique | |----|------------------|-------------|--------------------------------------| | 1 | **Installation sans droits administrateur** | Le setup échoue ou crée une installation partielle ; le simulateur ne démarre pas. | Toujours lancer le fichier d’installation avec *Exécuter en tant qu’administrateur*. Vérifier que le compte utilisé appartient au groupe *Administrateurs*. | | 2 | **Oubli de déclarer une variable avant son utilisation** | Erreur de compilation : « Variable non déclarée » ou adresse par défaut entraînant des conflits. | Dans le menu *Projet → Variables*, créer toutes les entrées/sorties, mémoires et temporisateurs avant de les placer dans le schéma ou le langage Ladder. | | 3 | **Utilisation d’un contact NF mal représenté** (oubli de la barre oblique) | Le logique s’inverse : l’arrêt d’urgence ne coupe pas le moteur, risque de surcharge. | En Ladder, représenter un contact NF par `[/]` ; vérifier visuellement chaque symbole avant de valider le réseau. | | 4 | **Ne pas mettre à jour le preset d’un temporisateur** (laisser la valeur par défaut 0 s) | Le temporisateur déclenche immédiatement, provoquant des alarmes intempestives ou des arrêts prématurés. | Dans les propriétés du bloc TON, définir explicitement le preset (ex. : `PT = T#1s`) ; consulter toujours la fenêtre de propriétés après insertion du bloc. | | 5 | **Transfert du code vers l’automate sans vérifier la version du firmware** | Incompatibilité de langage ou d’adresses → le programme ne se charge pas ou provoque des erreurs d’exécution. | Avant le transfert, consulter la fiche technique de l’automate (version du firmware, adresses E/S disponibles) et choisir la bonne cible dans le menu *Générer le code*. | | 6 | **Sauvegarde irrégulière du projet** | Perte de travail en cas de coupure de courant ou de plantage du logiciel. | Activer l’option *Enregistrement automatique toutes les 5 minutes* dans les préférences ; effectuer également une sauvegarde manuelle sur un support externe après chaque séance de travail. | | 7 | **Utilisation d’un chemin d’accès contenant des espaces ou des caractères accentués** | Certains anciens versions d’Automgen génèrent des erreurs de chemin lors de la compilation ou du génération de code. | Utiliser des chemins simples sans espaces ni accents (ex. : `D:\Projets\Convoyeur`). | | 8 | **Ne pas vérifier l’intégrité du fichier d’installation** (absence de contrôle de hash) | Risque d’installer une version corrompue ou malveillante. | Après le téléchargement, calculer le SHA‑256 du fichier et le comparer à celui publié sur le site Schneider Electric ; ne poursuivre l’installation que si les valeurs correspondent. | --- *Fin du cours.*