Download - CONTRIBUTION A LA REALISATION D’UN AUTOMATE
UNIVERSITE D’ANTANANARIVO
----------------------
ECOLE SUPERIEURE POLYTECHNIQUE
D’ANTANANARIVO
-----------------------
DEPARTEMENT GENIE MECANIQUE ET PRODUCTIQUE
DEPARTEMENT GENIE ELECTRIQUE
UFR : GENIE INDUSTRIEL
MEMOIRE DE FIN D’ETUDES EN VUE DE L’OBTENTION DU
DIPLOME D’INGENIEUR EN GENIE INDUSTRIEL
Présenté par : RAHARIMANANA Tsilavina Antonio
Directeur du mémoire : RAKOTONDRAINIBE Faniry Emile
CONTRIBUTION A LA REALISATION D’UN AUTOMATE
PROGRAMMABLE INDUSTRIEL : Partie logicielle
Date de soutenance : 13 Novembre 2014 Promotion 2013
UNIVERSITE D’ANTANANARIVO
----------------------
ECOLE SUPERIEURE POLYTECHNIQUE
D’ANTANANARIVO
-----------------------
DEPARTEMENT GENIE MECANIQUE ET PRODUCTIQUE
DEPARTEMENT GENIE ELECTRIQUE
UFR : GENIE INDUSTRIEL
MEMOIRE DE FIN D’ETUDES EN VUE DE L’OBTENTION DU
DIPLOME D’INGENIEUR EN GENIE INDUSTRIEL
Présenté par : RAHARIMANANA Tsilavina Antonio
Directeur du mémoire : RAKOTONDRAINIBE Faniry Emile
Président du juri : Monsieur ANDRIAMANOHISOA Hery Zo, Professeur à l’ESPA ;
Examinateurs :
Monsieur RAMELINA Lala Arimonjy, Enseignant Chercheur ;
Monsieur RAKOTONINDRINA Tahiry Fanantenana, Enseignant Chercheur.
CONTRIBUTION A LA REALISATION D’UN AUTOMATE
PROGRAMMABLE INDUSTRIEL : Partie logicielle
i
REMERCIEMENT
Nous tenons à remercier Le Bon Dieu de nous avoir donné la santé, la force, la patience et
le courage d’accomplir ce travail. Il convient de souligner que le présent ouvrage a pu être
réalisé non seulement par nos efforts personnels mais aussi grâce aux aides précieuses de toutes
les personnes qui de près ou de loin ont contribué à sa réalisation. Ainsi nous adressons notre
sincère remerciement et nos profondes reconnaissances à :
Monsieur ANDRIANARY Philippe Antoine, Directeur de l’Ecole Supérieur
Polytechnique d’Antananarivo qui a bien voulu autorisé cette soutenance ;
Monsieur RAKOTOMANANA Charles Rodin, Chef de Département Génie
Mécanique et Productique ;
Monsieur RAKOTONIAINA Solofohery, Chef de Département Génie
Electrique ;
Monsieur, RAKOTONDRAINIBE Faniry Emile, Directeur de ce mémoire qui
malgré ses lourdes responsabilités a bien voulu me guider et m’encadrer tout au long
de l’élaboration de mémoire ;
Nous ne saurions oublier de remercier les membres du jury qui ont pris leur temps et ont
accepté de siéger à notre soutenance :
Monsieur ANDRIAMANOHISOA Hery Zo,Enseignant à l’ESPA et président
du jury
Monsieur RAMELINA Lala Arimonjy, Enseignant à l’ESPA ;
Monsieur RAKOTONIRINA Tahiry Fanantenana, Enseignant à l’ESPA ;
Tous les professeurs qui nous ont enseigné et qui par leur compétences nous ont soutenu dans la
poursuite de nos études.
Un grand merci aussi à toute ma famille et mes amis qui m’ont soutenu et m’ont encouragé tout
au long de cet ouvrage.
ii
TABLE DES MATIERES
REMERCIEMENTS ……..…….……………………………………………………………..i
TABLE DES MATIERES …….………………………………………………………….ii
LISTE DES FIGURES …….……………………………………...………...……...…...vi
LISTE DES TABLEAUX …….………………………………………….………..….….viii
LISTE DES ABREVIATIONS …….………………..…………………………………...ix
INTRODUCTION …….……………………………………………………………………..1
PARTIE A : GENERALITES SUR LES AUTOMATES
PROGRAMMABLES INDUSTRIELS … .………………………………..……………….2
CHAPITRE I: LES AUTOMATES PROGRAMMABLES INDUSTRIELS ………….3
I-1) Définition ………………………………………………………………………………...3
I-2) Autre définition de l’API ……………………….……………….…………………......3
I-3) Fonctions de l’automate ………………..……………………………………….….....4
I-4) Exemples d’application des APIs …………..……...…………………………….……..4
I-5) Différences entre ordinateur et API …………..……………………..………….……...5
I-6) Les différents composants d’un API ……………..……………………………..….......7
I-6-1) Le processeur …………...…………………………..…………………………….…....7
I-6-2) Les modules d’entrées/sorties …………………………..…………………………….8
I-6-3) Les mémoires …………..……………………………..………………………….....8
I-6-4) L’interface de communication ………………………………………………………..8
I-7) Avantages et inconvénients ………………………………………….………………..9
I-8) Prix selon les différents constructeurs …………………………………….…………..10
CHAPITRE II: LES DIFFERENTS LANGAGES DANS LE
CEI 61131-3 …………………………………………………………………………………13
iii
II-1) Le CEI 61131-3 ………………………………………………………………..……..13
II-1-1) Définition d’un éditeur ……………………………………………………….…....13
II-1-2) Le langage FBD …………………………………………………………………..14
II-1-2) Le langage ST ……….…………………………………..…...…………………..15
II-1-3) Le langage IL (Instruction List) …………….………………..…………………..15
II-1-4) Le langage SFC ………………………………………………...…..……………..16
II-1-5) Le langage ladder ……………………..…………………………..……………..17
II-2) Notion sur le langage ladder ……………………..……………………….…………..17
II-3) composants du langage ladder ……………………..……………………….……….18
II-3- a) Les entrées ou contacts ……………………..……………………………..……..19
II-3-b) Les sorties ou bobines ……………………..……………………………………..20
II-3-c-) Les fonctions logiques ……………………..……………………………………….22
II-3-c-1) La fonction or (ou) ……………………..……………………………………….22
II-3-c-2) La fonction and (et) ……………………..……………………………...……….23
II-3-c-3) La fonction not (inversion) ……………………..…………………………...….23
II-3-c-4) La fonction xor (ou exclusif) ……………………..…………………………….24
PARTIE B : LANGAGE DE DEVELOPPEMENT ET IDE ……………………………25
CHAPITRE I : CHOIX DU LANGAGE DE DEVELOPPEMENT……………………..26
I-1) Choix du langage de programmation ……………………….………………….…..26
I-1-a) Initiation sur le C++ managée ……………………….………………………….…..26
I-1-b) Définition d’objet managée ………………..………………….…………………..26
I-1-c) Common Language Specification ou CLS ……..…………………….…………..26
I-1-d) Common Type System ou (CTS) ………………………..……….………………..27
I-1-e) Common Language Runtime ou (CLR) ……………….…….…………………..27
iv
I-1-f) Common Language Infrastructure ou (CLI) ………….…………….…………..27
I-1-g) Microsoft Intermediate Language ou (MSIL) ……….…………………………..27
I-1-h) Le JIT ou Just-In-Time ……………………….………………………….………....27
I-1-i) Les différentes couches du .NET Framework ……………………………….……..28
I-2) Le langage C++ managée ……………………….………………………..…………....29
I-3) Exemple de Création d’une fenêtre avec le C++ managée ………………………..…33
CHAPITRE II : CHOIX DU LOGICIEL DE DEVELOPPEMENT ……………………36
II-1) Choix du logiciel …………………………………………………………….…………36
II-2) Historique du logiciel ………………………………………………………….………36
II-3) Les avantages et inconvénients de Visual studio ……………………………..……36
II-4) Définition d’un IDE ………………………………………………………………...…36
II-5) Les outils proposés par Visual studio 2010 ……………………………………...…..37
II-5-a) Les winforms ………………………………………………….……………………..37
II-5-b) Les contrôles ……………………………………………………….………………..37
II-6) La classe graphique de Visual studio 2010 …………………………………………..38
II-6-a) Les noms d’espace de GDI+ …………………………………………….………..38
CHAPITRE III : METHODE EN V POUR LA REALISATION DE
L’EDITEUR ………………………………………………………………………………..40
III-1) définition ……………………………………………...……………………….……..41
III-2) Spécification …………………………………………………...……………………...41
III-3) conception préliminaire ……………………………………………...………..……..42
III-4) Codage …………………………………………………….………..……………..…..42
III-5) Tests unitaires ……………………………………………………….………..….…..42
III-6) Tests de validation ………………………………………………..…………………..42
PARTIE C : IMPLEMENTATIONS ET LES OUTILS
PROPOSEES PAR LE LOGICIEL ……………………………………….……………....43
CHAPITRE I : PROGRAMMATION DE L’INTERFACE
v
UTILISATEUR ………………………………………………..……………………..……..44
I-a) Programmation de l’interface utilisateur ………………………….…….…….……..44
I-b) Programmation du bouton pour le contact normalement ouvert ……..………...….46
I-c) Programmation du bouton pour le contact normalement fermé ……………………47
I-d) Programmation du bouton pour la bobine de sortie ……………………….……….49
I-e) Programmation du bouton pour le contact normalement fermé …………….……...50
CHAPITRE II : LES OUTILS DE L’EDITEUR ……………………………...……..…52
II-1) Les outils proposés par l’éditeur ………………………………………..…….….….52
II-2) Création d’un programme avec le logiciel ………………….…………...….………52
II-3) Fichier Texte en LADDER ……………………………………..……………….....…54
II-4) Les lettres réservées pour le texte ………………………………..………………….56
CONCLUSION ……………………………………………………………………………...57
REFERENCE BIBLIOGRAPHIQUE
ANNEXES
vi
LISTE DES FIGURES :
Figure n°1 : Commande des entrées sorties
Figure n° 2: structure du TSX 37 de SCHNEIDER
Figure n° 3 : Automate SCHNEIDER Micro
Figure n°4 : Architecture interne d’un API
Figure n°5 : Port série RS232
Figure n°6 : Quelques prix d’automate SIEMENS
Figure n°7 : Quelques prix du logiciel
Figure n° 8 : Quelques prix d’automate MITSUBISHI
Figure n°9 : éditeur de langage ladder sous STEP 7-Micro/Win32
Figure n°10 : langage FBD
Figure n° 11 : langage ST
Figure n°12 : langage IL
Figure n°13 : langage SFC
Figure n°14 : langage ladder
Figure n°15 : fonction OR sur le langage ladder
Figure n°16 : ordre de lecture dans un programme ladder
Figure n°17 : contact ouvert
Figure n°18 : contact fermé
Figure n°19 : contact normalement ouvert
Figure n°20 : contact normalement fermé
Figure n°21 : contact ouvert sur front descendant
Figure n°22 : contact ouvert sur front descendant
vii
Figure n°23 : bobine normalement ouvert
Figure n°24: bobine normalement fermé
Figure n°25 : bobine SET
Figure n°26 : bobine RESET
Figure n°27 : schéma ladder de la fonction OR
Figure n°28 : schéma ladder de la fonction AND
Figure n°29 : contact ouvert sur front descendant
Figure n°30 : contact ouvert sur front descendant
Figure n°31 : Cycle en V
Figure n° 32: LOGIGRAMME DU CONTACTEUR
Figure n°33 : contact normalement fermé
Figure n°34 : bobine de sortie
Figure n° 35: LOGIGRAMME DU FIN DE COURSE
Figure n° 36: le logiciel d’éditeur ladder
Figure n°37 : les boutons de commande du logiciel
Figure n°38: enregistrement d’un programme avec le logiciel
Figure n° 39: fonction XOR avec l’éditeur
Figure n° 40: ouverture d’un programme ladder avec le logiciel
Figure n° 41: outil pour transformer le programme ladder en texte
Figure n° 42: Ouverture d’un fichier texte
Figure n°43: fenêtre de filtrage
Figure n°44: Exemple de programme texte
viii
LISTE DES TABLEAUX :
Tableau n°1 : Entrée et sortie du contact ouvert
Tableau n°2 : Entrée et sortie du contact fermé
Tableau n° 3: Entrée et sortie du contact ouvert sur front descendant
Tableau n° 4: Entrée et sortie du contact ouvert sur front montant
Tableau n° 5: valeur binaire de l’entrée et valeur booléenne de sortie
Tableau n° 6: valeur binaire de l’entrée et valeur booléenne de sortie
Tableau n° 7: valeur binaire de l’entrée et valeur booléenne de sortie
Tableau n° 8: valeur binaire de l’entrée et valeur booléenne de sortie
Tableau n° 9: table de vérité de la fonction OR
Tableau n° 10: table de vérité de la fonction AND
Tableau n°11 : valeur binaire de l’entrée X et valeur binaire de sortie
Tableau n° 12: table de vérité de la fonction XOR
Tableau n°13 : Hiérarchie des couches du Net Framework
Tableau n°14 : les types de données en C++ managée
Tableau n° 15: les types de données en C++ pure
Tableau n° 16: Comparaison entre C++ managée et C++ pure
Tableau n° 17: nom d’espace de GDI+
Tableau n° 18: les classes dans GDI+
Tableau n°19: lettres réservés et symboles LADDER
ix
LISTE DES ABREVIATIONS :
API : Automate Programmable Industriel
CLS: Common Language Specification
CTS: Common Type System
CLR: Common Language Runtime
CLI : Common Language Infrastructure
CPU: Central Processing Unit
CEI: Commission Electrotechnique Internationale
DRAM: Dynamic Random Access Memory
EEPROM: Electrically Erasable Programmable Read Only Memory
EPROM: Erasable Programmable Read Only Memory
FBD: Fonctional Bloc Diagram
GUI: Graphical User Interface
GDI : Graphical Device Interface
IDE: Integrated Development Environment
IHM: Interface Homme-machine
JIT: Just-In-Time
MSIL: Microsoft Intermediate Language
OTP ROM: One-Time Programmable Read Only Memory
PC: Personal Computer
PROM: Programmable Read Only Memory
ROM: Read Only Memory
RAM: Random- Access Memory
SRAM: Static Random Access Memory
SFC : Sequential Function Chart
ST: Structured Text
UV EPROM: Ultra Violet Erasable Programmable Read Only Memory
USB: Universal Serial Bus
VB : Visual Basic
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
1
INTRODUCTION
Depuis quelques années le monde de l’industrie a connu un grand succès grâce à l’évolution de
l’électronique et de l’informatique industriel. La programmation fait partie des outils principaux
de l’informatique, or l’utilisation de l’informatique et de l’automatique participe au
développement économique d’un pays. Dans le secteur industriel pour minimiser le temps de
production et accroitre le taux de production il utilise les automates programmables industriels.
En effet, un automate est composé d’une partie matériel et d’une partie logiciel dont l’un est
destiné pour rédiger le programme et l’autre qui est le compilateur pour le convertir en instruction
exécutable pour l’automate.
Malgré les bienfaits des automates, à Madagascar seul les plus grandes entreprises ont
la possibilité de se les procurer puisqu’aucune société locale n’en fabrique ; par conséquent leur
coût est très élevé. En outre, les automates ne sont pas destinés non seulement pour les industries
mais aussi pour accélérer les recherches dans les Grandes Ecoles. À part cela réaliser l’automate
localement nous donne un avantage sur la facilité d’utilisation car nous connaitrons son principe
de fonctionnement et sa structure ainsi que les améliorations que nous pourrons lui apportés par
rapport à nos besoins. La présente mémoire qui s’intitule : « CONTRIBUTION
A LA REALISATION D’ UN AUTOMATE PROGRAMMABLE INDUSTRIEL »propose une
solution qui vise à atteindre ces objectifs.
Cette étude comporte trois grandes parties ; la première partie est consacrée sur les
automates programmables industriels ainsi que les notions de base des langages ladder. Dans la
deuxième on parlera du langage de programmation pour le développement du logiciel qui est le
C++ managé, ainsi que du logiciel Visual studio 2010. La troisième partie se focalisera sur
l’implémentation du programme et de l’outil proposé par notre logiciel.
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
2
PARTIE A : GENERALITES SUR LES AUTOMATES
PROGRAMMABLES INDUSTRIELS
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
3
CHAPITRE I: LES AUTOMATES PROGRAMMABLES INDUSTRIELS
I-1) Définition
Un Automate Programmable Industriel (API) est une machine électronique programmable par un
personnel non informaticien et destiné à piloter en ambiance industrielle et en temps réel des
procédés ou parties opératives.
I-2) Autre définition de l’API
Un automate programmable industriel, ou API, est un dispositif électronique programmable
destiné à la commande de processus industriels par un traitement séquentiel. Il envoie des
ordres vers les préactionneurs (partie opérative ou PO côté actionneur) à partir de données
d’entrées (capteurs) (partie commande ou PC côté capteur), de consignes et d’un programme
informatique. Lorsqu'un automate programmable remplit une fonction de sécurité, il est alors
appelé automate programmable de sécurité ou APS. Les APIs sont des circuits électroniques
à base de processeur.
Figure n°1 : Commande des entrées sorties [ 1 ]
AUTOMATE
Système à
commandé
Programme
pour la
commande
du système
Les entré es
et les sorties
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
4
À partir des informations que lui fournissent les capteurs et, suivant un algorithme déterminé par
programmation, un automate élabore les commandes transmises aux actionneurs. Il assure aussi
la communication avec l’opérateur et les autres processus qui gèrent la production ou qui
interviennent dans le même procédé. Il possède des entrées et des sorties analogiques et
numériques.
Dont les rôles sont les suivantes :
- Effectue des opérations logiques, arithmétiques, séquentielles, de comptage et de
temporisation
- Effectue ces opérations suivant des instructions sauvegardées dans une mémoire
programmable
I-4) Exemples d’application des APIs :
Un API :
Peut gérer un ou plusieurs ascenseurs.
I - Fonctions de l’automate 3)
Figure n° 2 : structure du TSX 37 de SCHNEIDER [ 6 ]
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
5
Est doté d'un programme simple peut maintenir un niveau de liquide dans un réservoir
entre deux niveaux (un mini et un maxi), en ouvrant et fermant une vanne. Un
programme légèrement plus complexe pourrait impliquer une mesure de niveau
(comme entrée) et un contrôleur d'écoulement (comme résultat) permettant à l'eau de
couler à un taux commandé. Un automatisme industriel typique pourrait commander
plusieurs réservoirs dans un processus tel que le traitement des eaux usées. Chaque
réservoir pourrait être observé pour une variété de conditions telles que : être ni trop
plein ou ni trop vide, avoir le pH dans une certaine fourchette, une température
adéquate....
peut également piloter un réacteur et commander en conséquence entrées de réactifs,
de catalyseurs ou de solvants, sorties de produits, réchauffement ou refroidissement
etc.
peut piloter un chariot automatique.
Les automates sont largement utilisés dans l'industrie, tant manufacturière (fabrication d'objets
finis ou de sous-ensembles) que de processus (élaboration de matières premières). On en trouve
aussi beaucoup dans la gestion de bâtiments, la logistique et le conditionnement, tel celui des
colis de la vente par correspondance. Ils conviennent parfaitement pour tout type d'activité
exigeant du réflexe plutôt que des calculs élaborés. Pour des systèmes exigeant une grande
sécurité (ferroviaire, machineries d'ascenseur, accès à des machines dangereuses), on utilise des
automates de sécurité (APIS) dont l'unité centrale est doublée et les procédures de test
renforcées. Pour la gestion des feux de circulation d'un carrefour, ce sont toutefois des automates
particuliers et totalement différents, qui sont utilisés et dédiés à cette tâche. Il s'agit de
contrôleurs de carrefours, qui doivent respecter des normes de sécurités particulières au
domaine.
I-5) Différences entre ordinateur et API
Les API se caractérisent par rapport aux ordinateurs par leur :
robustesse : conçus pour pouvoir travailler en milieu hostile, ils utilisent des circuits
durcis et sont prévus pour résister aux vibrations, aux températures des ateliers etc.
réactivité aux indications fournies par les capteurs (dispositifs anticollision,
alarmes diverses);
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
6
facilité de maintenance (bien que les ordinateurs industriels atteignent également
un très bon degré de fiabilité). Les modules peuvent être changés très facilement
et le redémarrage des API est très rapide.
L'absence d'Interface Homme-machine (IHM) permanent pour visualiser l'action et le
fonctionnement du programme sur la partie opérative font que les automates sont souvent reliés
à un pupitre opérateur, une interface graphique (écran d'affichage ou écran tactile) ou un PC.
Dans ce dernier cas, on parle de supervision.
Figur e n° 3 : Automate SCHNEIDER Micro
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
7
I-6) Les différents composants d’un API
Figure n°4 : Architecture interne d’un API
L’API comporte quatre constituants principaux qui sont :
Le processeur
La mémoire
Les modules d’entrées et de sorties
L’interface de communication
I-6-1) Le processeur
Il effectue les opérations logiques et arithmétiques suivant une séquence dictée par les
instructions stockées en mémoire. Il gère le trafic des données sur le bus interne c’est-à-dire le
transfert en mémoire. Il effectue aussi l’auto-diagnostique, c’est une mesure qui assure le bon
fonctionnement de toutes les composantes de l’automate. Un des critères de performance d’un
processeur est son temps de cycle qui est le temps pris par l’automate pour interroger les ports
d’entrée, exécuter le programme, mettre à jour les ports de sortie.
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
8
I-6-2) Les modules d’entrées/sorties
Ils traduisent les signaux industriels comme les tensions, les courants, les résistances, pulsations
en information logique ou numérique interprétable par le processeur. Inversement, les modules
de sorties traduisent les commandes du processeur en des signaux industriels.
Ces modules comportent 1, 4, 8,16 ou 32 voies (ports).
I-6-3) Les mémoires
Deux types de mémoire cohabitent :
La mémoire Langage où est stocké le langage de programmation. Elle est en général
figée, c'est à dire en lecture seulement. (ROM : mémoire morte).
La mémoire Travail utilisable en lecture-écriture pendant le fonctionnement c’est la
RAM (mémoire vive).
Pour le RAM (random-access memory) on a deux catégories :
mémoire volatile statique (SRAM): l'information est conservée tant que la tension
d'alimentation est présente.
mémoire volatile dynamique (DRAM): il faut recharger (rafraîchir) périodiquement les
cellules de mémoire pour conserver les données.
Il y a plusieurs types de ROM (read-only memory): mémoire non volatile
PROM (programmable ROM) ou OTP ROM (one-time programmable): le contenu peut
être modifié une fois par l'utilisateur, à l'aide d'un équipement spécialisé
EPROM (erasable PROM): le contenu peut être effacé et modifié plusieurs fois
UV EPROM: le contenu est effacé par des rayons ultra-violets (plusieurs minutes)
EEPROM (electrically EPROM) ou E2PROM: le contenu est effacé électriquement
(quelques millisecondes)
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
9
I-6-4) L’interface de communication
Communication série, l’information est communiquée, un bit à la fois, sur un seul fil) entre deux
dispositifs (un autre automate, une imprimante, …).
RS-232
RS-485
Réseau: lien de communication partagé par plusieurs dispositifs. Chacun d’eux est identifié par
une adresse unique. La communication se fait suivant des protocoles déterminés (DeviceNet,
Profibus, Ethernet, …)
Les API présentent de nombreux intérêts :
• Les éléments qui les composent sont particulièrement robustes (absence de mécanique
tournante pour le refroidissement et le stockage des données, matériaux renforcés) leur
permettant de fonctionner dans des environnements particulièrement hostiles (poussière
environnante, perturbations électromagnétiques, vibrations des supports, variations de
température...)
I - 7) Avantages et inconvénients
Figure n°5 : Port série RS 232
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
10
• Ils possèdent des circuits électroniques optimisés pour s'interfacer avec les entrées et les
sorties physiques du système, les envois et réceptions de signaux se font très rapidement
avec l'environnement. Avec de plus une exécution séquentielle cyclique sans
modification de mémoire, ils permettent d'assurer un temps d'exécution minimal,
respectant un déterminisme temporel et logique, garantissant un temps réel effectif (le
système réagit forcément dans le délai fixé).
En contrepartie, ils sont plus chers que des solutions informatiques classiques à base de
microcontrôleurs par exemple mais restent à l'heure actuelle les seules plateformes d'exécution
considérées comme fiables en milieu industriel (avec les ordinateurs industriels). Le prix est
notamment dépendant du nombre d'entrées/sorties nécessaires, de la mémoire dont on veut
disposer pour réaliser le programme, de la présence ou non de modules métier. De plus ils
nécessitent la maîtrise de langages spécifiques conformes à la norme CEI 61131-3 qui
reprennent dans leur forme la logique d'exécution interne de l'automate. Ces langages
apparaissent toutefois à beaucoup d'utilisateurs plus accessibles et plus visuels que les langages
informatiques classiques.
I-8) Prix selon les différents constructeurs :
Figure n°6 : Prix des automates SIEMENS
480.000 Ar
420.000 Ar
900.000 Ar
1.500.000 Ar
1.500.000 Ar
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
11
167.100 Ar
Figure n°7 : Prix logiciel
541.08 0 Ar
762.54 0 Ar
1.088.640 Ar
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
12
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
13
CHAPITRE II: LES DIFFERENTS LANGAGES DANS LE
CEI 61131-3
II-1) Le CEI 61131-3
La CEI 61131-3, intitulée Automates programmables - Partie 3 : Langages de programmation, est
une norme industrielle de la Commission électrotechnique internationale (CEI) définissant cinq
langages de programmation à utiliser pour les automates programmables :
Langage Ladder (schéma à relais) ;
Sequential function chart (SFC), proche du langage Grafcet ;
Boîtes fonctionnelles (FBD), sous forme de diagramme ;
Texte structuré (ST) ;
Liste d'instructions (IL), un pseudo-assembleur.
Elle a été publiée la première fois en 1993, et une seconde édition a vu le jour en 2003.
II-1-1) Définition d’un éditeur
Un éditeur est un logiciel destiné à la création et l'édition de fichiers contenant des données
spécifiques à l’éditeur.
Les fonctionnalités d'un éditeur sont:
Ouvrir un fichier (en proposant parfois une liste de fichiers récemment ouverts, ou
déjà existants, permettant de restreindre cette liste par un filtre)
Ajouter ou supprimer des données dans l’éditeur
Sauvegarder le fichier, ou au contraire sortir en renonçant aux modifications
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
14
Figure n°9 : éditeur de langage ladder sous STEP 7-Micro/Win32[6]
II-1-2) Le langage FBD
Sur le schéma ci-dessous se trouve un exemple sur le langage FBD :
Figure n°10 : langage FBD
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
15
Les blocs de fonction ressemblent beaucoup avec les blocs de fonction dans Simulink dans le
logiciel Matlab.
II - 1 - Le langage ST 2)
Figure n° 11 : langage ST
II - 1 - 3) Le langage IL (Instruction List)
Figure n°12 : langage IL
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
16
Figure n°13 : langage SFC
II - 1 - 4) Le langage SFC
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
17
des symboles graphiques qui sont plus simple à programmer.
II-2) Notion sur le langage ladder
Le diagramme ladder est un langage graphique ou langage à contact pour programmer les
Automates Programmables Industriels ou API .Le mots ladder vient du mot anglais qui veut dire
échelle .Voici un exemple de programme ladder :
Figure n°15 : fonction OR sur le langage ladder
Le langage ladder se lit de gauche à droite est de haut en bas ; par analogie à un schéma électrique
les valeurs correspondent à la présence ou non d’un potentiel électrique à chaque nœud de
connexion.
II - 1 - 5) Le langage ladder
Sur les cinq langages de programmation c’est le langage ladder qui est le plus utilisé, car il utilise
Figure n°14 : langage ladder
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
18
Le ladder est basé sur le principe d’une alimentation en tension représentées par deux traits
verticaux reliés horizontalement par des bobines, des contacts et des temporisateurs.
II-3) composants du langage ladder
Le logiciel pour l’édition du langage ladder est spécifique pour chaque API distribué par le
fabriquant .Les composants varient selon les constructeurs mais le plus commun d’entre eux sont
:
Les entrées ou contacts pour lire la valeur d’une variable booléenne:
Les sorties ou bobines pour écrire la valeur d’une variable booléenne :
Figure n°16 : ordre de lecture dans un programme ladder
Figure n°17 : contact ouvert
Figure n°18 : contact fermé
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
19
3- a) Les entrées ou contacts
Le contact normalement ouvert :
Bit X Etat
« 0 » True
« 1 » False
Tableau n°1 : Entrée et sortie du contact ouvert
Le contact normalement fermé :
Figure n°20 : contact normalement fermé
Bit X Etat
« 0 » False
« 1 » True
Tableau n°2 : Entrée et sortie du contact fermé Le
contact sur front descendant :
Figure n°19 : contact normalement ouvert
Figure n°21 : contact ouvert sur front descendant
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
20
Bit X Etat
1
0
True
Autre False
Tableau n° 3: Entrée et sortie du contact ouvert sur front descendant Le
contact sur front montant :
Figure n°22 : contact ouvert sur front montant
Bit X Etat
1
0
True
autre False
Tableau n° 4: Entrée et sortie du contact ouvert sur front montant
3-b) Les sorties ou bobines
La bobine normalement ouvert :
Figure n°23 : bobine normalement ouvert
Etat Bit X
False « 0 »
True « 1 »
Tableau n° 5: valeur binaire de l’entrée et valeur booléenne de sortie
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
21
La bobine normalement fermée :
Figure n°24: bobine normalement fermé
Etat Bit X
False « 1 »
True « 0 »
Tableau n° 6: valeur binaire de l’entrée et valeur booléenne de sortie La
bobine mise à un ou SET « S » :
Figure n°25 : bobine SET
Etat Bit X
False Inchangé
True « 1 »
Tableau n° 7: valeur binaire de l’entrée et valeur booléenne de sortie La
bobine mise à zéro ou RESET « R » :
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
22
Figure n°26 : bobine RESET
Etat Bit X
False inchangé
True « 0 »
Tableau n° 8: valeur binaire de l’entrée et valeur booléenne de sortie
3-c-) Les fonctions logiques
La valeur prit par les contacteurs sont des variables booléennes c’est-à-dire que les valeurs sont
mis à un ou à zéro.
II-3-c-1) La fonction or (ou)
Pour un contact nommé X et un contact nommé Y on a le programme ladder suivant pour réaliser
la fonction ou :
Figure n°27 : schéma ladder de la fonction OR
X Y Sortie
0 0 0
0 1 1
1 0 1
1 1 1
Tableau n° 9: table de vérité de la fonction OR
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
23
La fonction réalise une addition entre X et Y :
X OR Y= (X+Y)
II-3-c-2) La fonction and (et)
Pour deux contacts nommés X et Y le ladder correspondant est le suivant pour la fonction et :
Figure n°28 : schéma ladder de la fonction AND
X Y Sortie
0 0 0
0 1 0
1 0 0
1 1 1
Tableau n° 10: table de vérité de la fonction AND
La fonction effectue une multiplication entre X et Y :
X ET Y = (X*Y)
II-3-c-3) La fonction not (inversion)
Voici le programme ladder pour un contact nommé X :
Figure n°29 : contact ouvert sur front descendant
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
24
X Sortie
0 1
1 0
Tableau n°11 : valeur binaire de l’entrée X et valeur binaire de sortie La
fonction donne la valeur inverse du contact :
NOT X = (/X)
II-3-c-4) La fonction xor (ou exclusif)
Pour deux contacts nommé A et B on a le diagramme ladder suivant :
Voici le tableau de vérité de la fonction :
A XOR B = (A B)
A B Résultat
0 0 0
1 0 1
0 1 1
1 1 0
Tableau n° 12: table de vérité de la fonction XOR
Figure n°30 : contact ouvert sur front descendant
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
25
PARTIE B : LANGAGE DE DEVELOPPEMENT ET IDE
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
26
CHAPITRE I : CHOIX DU LANGAGE DE DEVELOPPEMENT
I-1) Choix du langage de programmation
On a choisi le langage C++ car il présente beaucoup d’avantage, premièrement c’est le langage
de programmation apprit à l’école. C’est avec le langage C++ que nous maitrisons l’utilisation
du port USB. Enfin le logiciel requit par le C++ est gratuit, et très léger par rapport à d’autres
logiciel pour d’autres langage. Voici quelques logiciels pour le développement avec le C++ :
devcpp
Codeblocks
Visual studio
Turbo C++
I-1-a) Initiation sur le C++ managé
Pour la création de l’éditeur nous avons choisis le langage C++, plus précisément le C++ managé
car il offre beaucoup de fonctions pour la programmation événementielle et les programmations
graphiques. En premier lieu nous allons découvrir quelques définitions, puis voir les différentes
fonctions proposées par le .net Framework. En suite voir des exemples de programmation avec
le C++ managé.
I-1-b) Définition d’objet managé
On appelle objet managé un objet dont la gestion de la mémoire est gérée par CLR ou
Common Language Runtime qui est le moteur d’exécution de programme du .net Framework.
Dans le langage C++ pure le programmeur doit toujours faire attention aux risques de fuite de
mémoire, grâce au langage managé on a plus à se soucié des fuites de mémoire. Le C++/CLI n’est
pas un programme portable sur les autres systèmes d’exploitation par exemple sur Linux ou sur
Mac, car le langage a été spécialement conçu pour les systèmes développés par Microsoft.
I-1-c) Common Language Specification ou CLS
Pour qu’il y ait interaction entre les objets dans lesquels ils ont été implantés, les objets managés
ne doivent exposer aux appelants que les fonctionnalités qui sont communes à tous les langages
avec lesquels ils doivent fonctionner. Pour cette raison, un ensemble de fonctionnalités de
langage appelé spécification CLS (Common Language Specification), qui comprend les
fonctionnalités de langage de base nécessaires à de nombreuses applications, a été défini. La
spécification CLS permet d'optimiser et d'assurer l'interopérabilité des langages en définissant
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
27
un ensemble de fonctionnalités sur lequel les développeurs peuvent compter dans de nombreux
langages. La spécification CLS établit également des exigences de conformité CLS ; elles
permettent de déterminer si le code managé est conforme à la spécification CLS et dans quelle
mesure un outil donné prend en charge le développement du code managé qui utilise des
fonctionnalités CLS. Si votre composant n'utilise que des fonctionnalités CLS dans des interfaces
API qu'il expose à un autre code (y compris des classes dérivées), le composant est assuré d'être
accessible à partir d'un langage de programmation prenant en charge la spécification CLS.
I-1-d) Common Type System ou (CTS)
Afin que des classes définies dans plusieurs langages puissent communiquer entres elles, elles
ont besoin d'un ensemble de types de données communs. C'est l'objet du CTS, il définit les types
de données que le Runtime .NET comprend et que les applications .NET peuvent utiliser.
I-1-e) Common Language Runtime ou (CLR)
On l'appelle aussi le runtime .NET. Le CLR est le moteur d'exécution du noyau .Net pour
exécuter des applications. Il apporte des services tels que la sécurité d'accès de code, la gestion
de la vie d'un objet, la gestion des ressources, la sûreté des types, etc.
I-1-f) Common Language Infrastructure ou (CLI)
Dans le contexte de C++/CLI, cela correspond à du C++ pouvant interagir avec le CLR.
I-1-g) Microsoft Intermediate Language ou (MSIL)
C'est un jeu d'instruction indépendant du CPU généré par les compilateurs .NET, à partir de
langages comme le J#, C# ou Visual Basic. Le langage MSIL est compilé avant ou pendant
l'exécution du programme par le VES (Virtual Execution System), qui fait partie intégrante du
CLR.
I-1-h) Le JIT ou Just-In-Time
L'interprétation et l'exécution du bytecode ligne par ligne pourrait prendre beaucoup de temps et
Microsoft a adopté une stratégie d'optimisation de la vitesse d'exécution du code MSIL en
utilisant la technique Just-in-time. JIT est une technique de traduction dynamique durant
l'interprétation. La machine virtuelle CLR contient un compilateur optimiseur qui recompile
localement le bytecode MSIL afin de n'avoir plus qu'à faire exécuter des instructions machines
de base. Le compilateur JIT du CLR compile une méthode en code natif dès qu'elle est appelée
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
28
dans le code MSIL, le processus recommence à chaque fois qu'un appel de méthode a lieu sur
une méthode non déjà compilée en code natif.
I-1-i) Les différentes couches du .NET Framework
VB net Delphi C++ C# Eiffel# J# J Script
COMMON LANGUAGE SP ECIFICATION (CLS)
SERVICE WEB IN TERFACE UTILISATEUR
DONNEES ET XML
LIBRAIRIE DE CLASSE FONDAMENTALE
COMMON LANGUAG E RUNTIME
Compilateur JIT du code MSIL
Garbage Collector
Contrôle de la Sécurité Gestionnaire de code
Contrôle de l'execution Chargeur de Classe
SYSTÈME D'EXPLOITATION
Tableau n°13 : Hiérarchie des couches du Net Framework
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
29
I-2) Le langage C++ managée
Le langage managé est un langage orienté objet, tout d’abord nous allons voir comment créer une
classe avec le C++ managé.
En C++ pure on crée une classe comme suit : class nom_de
_la_classe {
Private :
Les attributs
Public :
Les méthodes ainsi que le constructeur et le destructeur }
;
Pour le .Net on a :
ref class nom_de_la_classe {
private :
Les attributs
public :
Les méthodes
} ;
Dans la C++ managée nous n’avons pas besoin de destructeur car une fois que le programme n’a
plus besoin de l’objet il est automatiquement effacer de la mémoire.
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
30
L’exemple suivant montre un programme qui affiche « bonjour tout le monde » en C++ managé
et non managé :
#include <iostream> using namespace System; using namespace std; namespace Bonjour
{ void bonjour()
{
Console::WriteLine(L" Bonjour tout le monde "); // System::Console managée cout
<< "Bonjour tout le monde" << endl; // std::cout, std::endl non managée
} }
int main(array<System::String ^> ^args)
{
Bonjour ::bonjour(); return
0; }
On peut aussi écrire directement dans le programme principal sans passer par le namespace : int
main(array<System::String ^> ^args)
{
Console::WriteLine(L « Bonjour tout le monde » );
std ::cout<< « Bonjour tout le monde »<<std ::endl ; return
0;
}
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
31
Les différents types en C++ managé, les deux tableaux montrent la différence entre les
deux :
Types Descriptions Correspondances
C++/CLI
Bool Type booléenne System ::Boolean
Char 8-bit signé/non-signé System ::SByte
signed char 8-bit signé System ::SByte
unsigned char 8-bit non signé System ::Byte
Short 16-bit signé System ::Int16
unsigned short 16-bit non signé System ::UInt16
int 32-bit signé System ::Int32
unsigned int 32-bit non signé System ::UInt32
Long 32-bit signé System ::Int32
unsigned long 32-bit non signé System ::UInt32
long long int 64-bit signé System ::Int64
unsigned long long int 64-bit non signé System ::UInt64
Float Simple précision System ::Single
Double Double précision System ::Double
long double Extra-précision System ::Double
wchar_t 16-bit en Unicode System ::Char
Tableau n°14 : les types de données en C++ managée
Mais les types déjà présent dans le C++ pure existent encore voici quelques exemples de ces types
primitifs :
Types Descriptions
Bool Type booléenne (Vrai ou Faux)
Char Caractère
Int Entier
unsigned int entier positif ou nul
Double Nombre à virgule
String Chaine de caractère
Tableau n° 15: les types de données en C++ pure
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
32
L’éxemple suivant montre la declaration de tableau dans le C++/CLI:
int main(array<System ::String^>^ args){ array<int>^
tableau=gcnew array<int>(10);
//déclration d’un tableau de taille égal à 10 contenants des variables entiers for
(int i=0 ; i < tableau->Length;i++) { tableau[i]=i;
Console::WriteLine(L « {0}, » , i ) ;
} return
0 ;
}
L’exemple ci-dessus est un tableau à simple dimension, pour des tableaux à plusieurs dimensions
on aura :
array <[type],[dimension]>^ Nom=gcnew array<[type],[dimension]>(les valeurs) ;
Pour les chaines de caractère le « string » change en « String » à l’exception de la déclaration,
dans le .Net on n’a pas besoin d’inclure la bibliothèque « string.h » on le déclare seulement int
main(array<System::String ^> ^args)
{
String^ mot=”Toto”;
Console::WriteLine ( mot ); return
0;
}
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
33
Mais on peut aussi convertir des chaines de caractère écrit en C++ managé en chaine de caractère
native. Voici une fonction permettant de convertir du « String « managé en « string« natif : static
void ClrStringToStdString(std::string &outStr, String ^str) {
IntPtr ansiStr = System::Runtime::InteropServices::Marshal::StringToHGlobalAnsi(str); outStr = (const char*)ansiStr.ToPointer();
System::Runtime::InteropServices::Marshal::FreeHGlobal(ansiStr); }
Et le contraire aussi est possible, ceci pour dire que dans un même programme on peut voir du
code C++ managé et du C++ pure. Pour le cas contraire c’est plus simple car la conversion se fait
en une ligne :
Par exemple si nous avons un tableau de de chaine de caractère nommée tableau4 nous aurons:
String^ str2=gcnew String(tableau4[i].c_str());
Pour faire un programme mixte on utilise les directives suivantes :
Si c’est un programme managée on utilise le directive « #pragma managed «
Si c’est du code natif on utilise le directive « #pragma unmanaged »
Car c’est plus intéressant d’utiliser à la fois du code natif et du code managée.
On peut aussi convertir des types entiers en chaines de caractère en appelant la fonction
ToString() , comme cette exemple :
int i=10 ; // le nombre 10 est déclaré comme un nombre entier
String^ i_str=i.ToString(); // 10 est maintenant déclaré comme une chaine de caractère
String^ message=L”voici le nombre :”+ i_str;
Console ::WriteLine(message) ;
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
34
I-3) Exemple de Création d’une fenêtre avec le C++ managée
Pour la création d’une fenêtre en CLR nous pouvons créer un projet vide dans l’option «Fichier
» puis « Nouveau » ensuite dans le panneau « Projet » « C++ » et on choisit « projet vide CLR
». Le code minimal pour créer une fenêtre est la suivante :
#include "stdafx.h" #include
"Form1.h" namespace
Form_app {
Form1::Form1()
{
InitializeComponent();
}
Form1::~Form1()
{ if (components) delete
components;
}
Dans le programme principal on écrit :
#include « stdfax.h » #include « Form1.h
» int main(array<System::String ^> ^args)
{
Application::Run(gcnew Form1 ());
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
35
Application::EnableVisualStyles();
Application::SetCompatibleTextRenderingDefault(false); return
0 ;
}
Voici un tableau récapitulatif des opérations qui montre la différence entre le C++
managé et le non managé :
Opération C++ pure C++ managée
Pointeur pour le C++
référence pour le C++/CLI
* ^
Reference pour le C++
Adresse pour le C++/CLI
& %
Accès aux membres -> ->
Allocation New Gcnew
Désallocation Delete delete(en appelant Dispose)
Tableau n° 16: Comparaison entre C++ managé et C++ pure
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
36
CHAPITRE II : CHOIX DU LOGICIEL DE DEVELOPPEMENT
II-1) Choix du logiciel
L’IDE choisi pour le développement du logiciel est le logiciel de Microsoft qui est le Visual
Studio 2010. Notre choix s’est porté sur cet IDE parce que premièrement le logiciel est pour la
version express qui est fait pour les recherches. En plus le logiciel a beaucoup d’avantage sur
l’utilisation des ports USB, enfin c’est un logiciel qui peut utiliser le .Net Framework à part le
Visual C++.
II-2) Historique du logiciel
Le premier IDE Visual 6.0 date de 1998, Microsoft mais n’était pas très intéressant par
rapport à ces concurrents IDE connaissant un plus grand succès. Les versions qui lui succédèrent
: Visual 2002 (7.0) et Visual 2003 dot net (7.1) étaient toujours comme la version précédente.
Ses principaux concurrents étaient Borland, Eclipse, et les versions libre sur Linux qui étaient
plus avancés et plus faciles à utiliser que les produits Microsoft. Fin Octobre 2005,
Visual Studio .Net 2005 (8.0) arrivait et c’était un vrai succès. Une version allégée « Visual
2005 Express » fût éditée gratuitement. Assez restreinte, cette version contient les principaux
composants utiles pour développer des applications facilement. Mais il y avait un inconvénient
majeur sur sa portabilité car les projets créés sous la version complète seront incompatibles avec
la version Express. Ensuite, lui succéda, Visual 2008 (9.0) qui n’avait pas de réels changements,
et la version actuelle Visual 2010 (10.0).
II-3) Les avantages et inconvénients de Visual studio
C’est une application très intéressante étant donné que sa documentation est presque complète
mais aussi qu’elle a une interface facile à manipuler sans oublier l’éditeur de ressource intégré
pour décorer les fenêtres.
Malgré cela son inconvénient c’est qu’il n’est pas multiplateforme ce qui signifie qu’il ne
fonctionne qu’avec les systèmes d’exploitation de Microsoft.
II-4) Définition d’un IDE
Un Environnement de Développement Intégré ou IDE (Integrated Development Environment
) est un logiciel regroupant au minimum les fonctionnalités suivantes : un éditeur de texte, un
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
37
compilateur, des outils d’aide à la programmation et un débogueur. Un EDI fournit aussi des
outils et des bibliothèques propres permettant de créer des interfaces graphiques IHM
(Interface Homme Machine ) ou GUI(Graphical User Interface ).
II-5) Les outils proposés par Visual studio 2010
Les principaux outils sont les winforms et les contrôles qui composent ces winforms. Pour notre
projet ce sont les outils qu’on utilise beaucoup dans le programme mais il existe aussi d’autres
composants intéressants.
II-5-a) Les winforms
Microsoft Windows Forms (ou Winforms) est le nom donné à la partie du framework
.net responsable de l'interface graphique (GUI),donnant accès aux contrôles Windows
managés. Les Winforms se rapprochent beaucoup des forms comme on peut les connaître
en VB. Microsoft s'est basé sur le modèle de développement des interfaces graphiques en
VB, des forms, des contrôles et des propriétés pour créer un nouveau langage équivalent pour le
framework .net. Ainsi, il est très facile de créer une fenêtre, des boutons, d'écrire du texte,
d'associer un évènement à un clic sur un bouton, etc. Tout ceci est sans effort grâce à la volonté
de Microsoft de nous fournir un IDE puissant et performant où il suffit de cliquer, de
glisser/déposer pour créer une interface graphique.
Les winforms sont basées sur GDI+, un ensemble de classes et de fonctionnalités qui permettent
de créer et de gérer les IHMs. Les classes disponibles pour utiliser les Windows Forms se
trouvent dans le CLR (Common Language Runtime). La classe fondamentale est
System::Windows::Forms::Form. Et comme une Winform fait partie intégrante du CLR, elle est
sujette à l'héritage, c'est à dire que l'on peut construire une hiérarchie de classes dérivées de
Winforms dans une optique très orientée objet.
II-5-b) Les contrôles
A chaque contrôle, que ce soit la form ou bien ce qui la compose, correspondent une
liste de propriétés. Les plus communes sont les propriétés qui permettent de définir la taille
ou le positionnement du contrôle (location (x, y), Size (width, height), etc ...), le texte affiché d'un
contrôle (text, value), si le contrôle est visible, activé, etc ... (visible, enabled), ou encore les
couleurs et la font du contrôle (font, forecolor, backcolor, etc ...), et d'autres ...
Chaque contrôle dispose aussi de propriétés qui sont propres à son fonctionnement (par
exemple la propriété step de la barre de progression qui définit le pas de progression).
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
38
Le contrôle est associé à des événements comme cliqué sur le souris gauche ou droite ou encore
appui sur une touche particulière. La form est une fenêtre principale dans lesquels nous placerons
des contrôles comme des boutons ou des zones de texte, le point haut à gauche de cette fenêtre
principale est l’origine pour les coordonnées de tous les contrôles. II-6) La classe graphique
de Visual studio 2010
GDI+ (Graphical Device Interface) est la classe utilisée pour le dessin graphique, dans cette
deuxième partie nous allons nous intéresser sur cet outil car le langage LADDER est surtout un
langage graphique. Pour voir plus en détail les différents avantages de cette classe nous allons
explicités avec des exemples. Le GDI+ est un outil conçu pour le .net Framework donc
l’application utilisant cette classe ne marche qu’en présence de la dot net.
II-6-a) Les noms d’espace de GDI+
Pour résumé les noms d’espace ainsi que leur description voici un tableau récapitulatif :
Nom d’espace Description
System.Drawing
Utilisé pour des fonctionnalités graphiques basiques tel que dessiné sur une surface, affiché des images, ajouté des couleurs etc.
System.Drawing.Drawing2D
Utilisé pour des fonctionnalités avancées sur les rasters et les vecteurs
System.Drawing.Printing
Fourni les outils pour l’impression
System.Drawing.Text
Pour afficher des textes dans une surface
System.Drawing.Design
Pour personnaliser les fenêtres
Tableau n° 17: nom d’espace de GDI+
Pour ce premier exemple nous allons utiliser la classe DrawRectangle, voici un exemple de code
utilisant cette classe dans l’espace de nom Drawing :
private: System::Void button1_Click_1(System::Object^ sender, System::EventArgs^ e) {
Graphics^ test;
test=this->CreateGraphics(); Pen^ bluePen=gcnew Pen(Color::Red,3); test->DrawRectangle(bluePen,40,40,80,80); }
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
39
Lorsqu’on clique sur le bouton le programme dessine un rectangle sur la fenêtre placé au
coordonnée X=40 et Y=40 et la longueur est de 40 et la largeur de 40 en couleur rouge.
Pour dessiné une ellipse on appelle la classe DrawEllipse toujours dans l’espace de nom Drawing,
dont voici un exemple :
private: System::Void button1_Click_1(System::Object^ sender, System::EventArgs^ e) {
Graphics^ test; test=this->CreateGraphics(); Pen^ bluePen=gcnew Pen(Color::Red,3); test>DrawRectangle(bluePen,40,40,80,80); Pen^ redPen=gcnew Pen(Color::Blue,3);
test->DrawEllipse(redPen,80,80,100,120);
}
Le programme dessine une ellipse et un rectangle lorsqu’on clique sur le bouton, l’ellipse est
dessine aux coordonnées X=80 et Y=80. L’origine de la coordonnée est le point le plus à gauche
de la fenêtre en haut.
On a aussi l’outil Line qui permet de dessiner des lignes sur une surface défini, pour cela on
appelle la classe DrawLine dans l’espace de nom Drawing.
private: System::Void button1_Click_1(System::Object^ sender, System::EventArgs^ e) {
Graphics^ test;
test=this->CreateGraphics(); Pen^
bluePen=gcnew
Pen(Color::Red,3); test->DrawRectangle(bluePen,40,40,80,80); Pen^
redPen=gcnew Pen(Color::Blue,3); test- >DrawEllipse(redPen,80,80,100,120); Pen^ blackPen=gcnew Pen(Color::Black,3);
test->DrawLine(blackPen,120,120,160,120);
}
Le code ci-dessus dessine un rectangle coloré en rouge, une ellipse en bleu et une ligne en noir
lors d’un clic sur le bouton.
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
40
Methode
Dessin fournit
DrawLine
Dessine une ligne sur le formulaire
DrawRectangle
Dessine un rectangle dans la fenêtre
DrawEllipse
Dessine une ellipse dans une surface
DrawArc
Dessine un arc sur le formulaire
DrawCurve
Dessine une courbe dans une fenêtre
Tableau n° 18: les classes dans GDI+
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
41
CHAPITRE III : METHODE EN V POUR LA REALISATION DE
L’EDITEUR
III-1) définition
Le cycle en V est un paradigme du développement informatique. Il décrit les étapes essentielles
du développement d'un logiciel, le cycle de vie du projet. Il est représenté par un V dont la
branche descendante contient toutes les étapes de la conception du projet, et la branche montante
toutes les étapes de tests du projet. La pointe du V, quant à elle, représente la réalisation concrète
du projet, le codage; on pourrait donc en déduire, de manière simpliste, que les deux branches
montantes et descendantes ne sont que de la documentation. En effet, chaque étape d'une branche
a son pendant dans l'autre branche, c'est à dire qu'une étape de conception correspond à une étape
de test qui lui est spécifique. A tel point, d'ailleurs, qu'une étape de test peut être élaborée dès
que la phase de conception correspondante est terminée, indépendamment du reste du projet.
Figure n°31 : Cycle en V
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
42
III-2) Spécification
La spécification est souvent le document d'entrée du projet. Elle est même parfois rédigée en
commun avec le client. La spécification, bien rédigée, est une suite d'exigences, si possible
regroupées par thèmes, pour permettre d'esquisser un début d'architecture et aussi un plan de test.
III-3) conception préliminaire
La conception regroupe les activités d'étude qui suivent la spécification, et ce jusqu'au codage.
Le codage est la matérialisation de la conception.
La conception englobe:
la modélisation: facultative, assistée ou non d'un outil, elle permet de définir et
de visualiser le système ou une partie de celui-ci, aussi bien de manière statique
que dynamique. La modélisation n'est pas une étape en soi, elle peut être utilisée
à tout endroit du projet. Outre ses qualités techniques, l'aspect visuel de cette
pratique provoque un fort impact chez le client, qui peut plus facilement imaginer
son produit fini.
l'architecture, ou conception préliminaire: indispensable à partir d'une
certaine taille de projet, elle définit l'ensemble des briques constitutives de
l'application et leurs interfaces. C'est souvent le point faible d'un logiciel, car un
défaut à ce niveau, donc probablement détecté en phase d'intégration, sera
toujours pénible à corriger de par ses conséquences: débogage long, reprise
d'intégration dans un outil de gestion de configuration, régénération de
l'exécutable, traitement de la demande de correction, etc.
la conception détaillée: Tout d'abord, la conception détaillée consiste, souvent,
à écrire du pseudo-code pour définir chaque fonction logicielle, En toute rigueur,
on pourrait la placer dans un document dédié, au même titre que la conception
préliminaire ou l'architecture. Cependant, pour des raisons de maintenance, il est
plus efficace de la placer dans le code, en commentaire dans l'en-tête de la
fonction, ou dans un fichier séparé, cela éviterait de fournir en même temps le
code et la conception détaillée au client.
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
43
III-4) Codage
Le codage consiste à mettre en forme la conception détaillée, donc transformer du pseudocode en
code. La tâche parait simple et faire figure de parent pauvre du développement. Le codeur doit
savoir lire une conception détaillée, et surtout doit connaitre le langage utilisé. C’est la
programmation proprement dit en utilisant le langage approprié et en se servant des outils de
programmation comme les réservations/libérations de mémoire les constructeurs les destructeurs
les pointeurs et la mise à jour de la conception détaillée. Donc, une faille à ce niveau ne mettra
probablement pas le projet en péril, mais risque de ralentir la réalisation du logiciel.
III-5) Tests unitaires
Les tests unitaires semblent être à la phase de test, branche remontante du cycle en V, ce qu'est la
conception détaillée dans la branche descendante. Un test unitaire consiste à rédiger un scénario,
codé dans le langage de développement, qui peut être lancé, automatiquement ou non, à tout
moment. Dans sa conception même, ce test est très rapide à dérouler, sauf contrainte liée à la
spécification elle-même (par exemple: mettre A=10 et B=0, puis attendre 30 secondes avant de
vérifier B). De plus, il est très facile d'enchaîner les tests unitaires et de tracer leurs résultats. Seul
restera le temps à passer pour les dépouiller, et encore, cela peut aussi être automatisé. Le seul
problème est le temps mis pour développer un test unitaire, temps que l'on peut évaluer comme
étant pratiquement identique au temps mis pour développer la fonction testée. Les tests unitaires
sont ignorés pour gagner du temps. A charge du chef de projet d'évaluer s'il préfère gagner du
temps à court terme ou bien gagner du temps et beaucoup d'argent sur la maintenance.
III-6) Tests de validation
Les tests de validation consistent à dérouler les tests permettant d'affirmer que le logiciel répond
aux exigences de la spécification. Le test est souvent très longue, plusieurs heures voire plusieurs
jours. A ce stade, tout problème détecté est potentiellement catastrophique, car il est susceptible
de remettre en cause la spécification, donc tout le développement.
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
44
PARTIE C : IMPLEMENTATIONS ET LES OUTILS
PROPOSEES PAR LE LOGICIEL
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
45
CHAPITRE I : PROGRAMMATION DE L’INTERFACE
UTILISATEUR
I-a) Programmation de l’interface utilisateur
Dans cette partie nous allons voir la différente phase de la programmation de l’éditeur ainsi que
le résultat attendu, et enfin discuter ce résultat.
Le programme généré par la création d’une fenêtre principale est la suivante :
#pragma region Windows Form Designer generated code /// <summary> /// Méthode requise pour la prise en charge du concepteur - ne modifiez pas /// le contenu de cette méthode avec l'éditeur de code. /// </summary> void InitializeComponent(void) { this->button1 = (gcnew System::Windows::Forms::Button()); this->SuspendLayout(); // // button1 // this->button1->Location = System::Drawing::Point(239, 251); this->button1->Name = L"button1"; this->button1->Size = System::Drawing::Size(120, 65); this->button1->TabIndex = 0; this->button1->Text = L"button1"; this->button1- >UseVisualStyleBackColor = true; this->button1->Click += gcnew System::EventHandler(this, &Form1::button1_Click_1); // // Form1 // this->AutoScaleDimensions = System::Drawing::SizeF(6, 13); this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font; this->ClientSize = System::Drawing::Size(530, 328); this->Controls->Add(this->button1); this->Name = L"Form1"; this->Text = L"Form1"; this->Load += gcnew System::EventHandler(this, &Form1::Form1_Load); this->ResumeLayout(false);
} #pragma endregion
Ce code défini une région pour la fenêtre, qui sera la fenêtre principale de notre éditeur.
C’est dans cette région que tous les autres outils seront placés au fur et à mesure que la
programmation avance.
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
46
Mais avant la définition de cette région il y a la création du nom d’espace qui sera le nom du
projet crée auparavant. Voici le code pour la création de notre nom d’espace il y a plusieurs noms
d’espace utilisées dans notre programme mais le nom d’espace de base est : System
namespace exemple3 {
using namespace System; using namespace System::ComponentModel; using namespace System::Collections; using namespace System::Windows::Forms; using namespace System::Data; using namespace System::Drawing;
/// <summary> /// Description résumée de Form1 /// </summary> public ref class Form1 : public System::Windows::Forms::Form { public:
Form1(void) { InitializeComponent(); // //TODO: ajoutez ici le code du constructeur // }
protected: /// <summary> /// Nettoyage des ressources utilisées. /// </summary> ~Form1() { if (components) { delete components; } }
Dans la deuxième ligne du code nous avons le nom d’espace de base, après il y a le nom d’espace
qui contient tous les classes contenant les méthodes pour les composants par exemple les boutons
qui est le using namespace System::ComponentModel;
Il y a la création de la classe nommé Form1, et on initialise la fenêtre par la méthode :
InitializeComponent();
Pour la deuxième étape nous allons entrer dans la programmation de tous les outils utilisés dans
le logiciel comme les boutons pour faire les dessins composants le langage LADDER.
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
47
I-b) Programmation du bouton pour le contact normalement ouvert
Pour le premier bouton le schéma LADDER associé est contact normale dont voici le symbole :
Figure n°31 : contact normalement ouvert
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
48
private: System::Void toolStripButton1_Click(System::Object^ sender, System::EventArgs^ e) { Graphics^ g; Pen^ black=gcnew Pen(Color::White); Pen^ bleu=gcnew Pen(Color::Green,3); g=this->CreateGraphics(); tsila=true;
int x1,y1; int indice=0;
if(x>20){
tableau2.push_back(1); tableau2.push_back(x); tableau2.push_back(y); x1=x; y1=y; g->DrawLine(black,x1,y1,x1+20,y1); g->DrawLine(black,x1+20,y1-10,x1+20,y1+10); g- >DrawLine(black,x1+40,y1-10,x1+40,y1+10); g->DrawLine(black,x1+40,y1,x1+60,y1);
x=x1+60; y=y1; }
else if(x==20){ tableau2.push_back(1); tableau2.push_back(x); tableau2.push_back(y); x1=x; y1=y; g->DrawLine(bleu,x1,y1-10,x1,y1+40); g->DrawLine(black,x1,y1,x1+20,y1); g>DrawLine(black,x1+20,y1-10,x1+20,y1+10); g- >DrawLine(black,x1+40,y1-10,x1+40,y1+10); g->DrawLine(black,x1+40,y1,x1+60,y1);
x=x1+60; y=y1; } }
I-c) Programmation du bouton pour le contact normalement fermé
La démarche à suivre pour tous les composants est la même, seule l’outil pour le dessin est
différente. Par exemple pour le contact inverse on a besoin de ligne oblique sauf qu’il n’y a
pas de ligne oblique proposé donc on utilise toujours la ligne mais les coordonnées sont la clé
pour faire le schéma. Le symbole pour le schéma inverse est la suivante :
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
49
private: System::Void toolStripButton2_Click(System::Object^ sender, System::EventArgs^ e) {
tsila=true; Graphics^ g; int x1,y1;
Pen^ black=gcnew Pen(Color::White); Pen^ bleu=gcnew Pen(Color::Green,3); g=this->CreateGraphics(); if(x>20 && tableau2[tableau2.size()-3]!=3){
tableau2.push_back(2); tableau2.push_back(x); tableau2.push_back(y); x1=x; y1=y; g->DrawLine(black,x1,y1,x1+20,y1); g->DrawLine(black,x1+20,y1-10,x1+20,y1+10); g>DrawLine(black,x1+20,y1+10,x1+40,y1-10); g- >DrawLine(black,x1+40,y1-10,x1+40,y1+10); g->DrawLine(black,x1+40,y1,x1+60,y1);
x=x1+60; y=y1;
} else if(x==20){ tableau2.push_back(2); tableau2.push_back(x); tableau2.push_back(y); x1=x; y1=y; g->DrawLine(bleu,x1,y1-10,x1,y1+40); g->DrawLine(black,x1,y1,x1+20,y1); g>DrawLine(black,x1+20,y1-10,x1+20,y1+10); g- >DrawLine(black,x1+20,y1+10,x1+40,y1-10); g- >DrawLine(black,x1+40,y1-10,x1+40,y1+10); g->DrawLine(black,x1+40,y1,x1+60,y1);
x=x1+60; y=y1; }
}
Figure n° 33 : contact normalement fe rmé
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
50
I-d) Programmation du bouton pour la bobine de sortie Pour le symbole de sortie on utilise
la classe DrawCurve dans l’espace de nom System ::Drawing. Voici le symbole de sortie dans le
langage LADDER :
private: System::Void toolStripButton3_Click(System::Object^ sender, System::EventArgs^ e) { if(branche==false){ if(textBox1->TextLength>0){ TextBox^ textBox=gcnew TextBox; String^ text; string a; if(x>20){ tableau2.push_back(3); tableau2.push_back(x); tableau2.push_back(y); tsila=true;
Graphics^ g; int x1,y1;
y1=y; x1=x;
Controls->Add(textBox);
textBox->ReadOnly=true; textBox->Location = System::Drawing::Point(x1+15,y1-34); textBox->Size = System::Drawing::Size(30, 20); Pen^ black=gcnew Pen(Color::White); g=this- >CreateGraphics(); Point point1=Point(x1+25,y1-10); Point point2=Point(x1+20,y1); Point point3=Point(x1+25,y1+10); Point point4=Point(x1+35,y1-10); Point point5=Point(x1+40,y1); Point point6=Point(x1+35,y1+10); array<Point>^ curvePoints1 = {point1,point2,point3}; array<Point>^ curvePoints2 = {point4,point5,point6}; g->DrawLine(black,x1,y1,x1+20,y1); g->DrawCurve(black, curvePoints1 ); g->DrawCurve(black, curvePoints2 ); g->DrawLine(black,x1+40,y1,x1+60,y1) ; x=x1+60; y=y1; textBox->Text=textBox1->Text; textBox1->Clear();
text=textBox->Text; const char* chars = (const char*)(Marshal::StringToHGlobalAnsi(text)).ToPointer(); a= chars; Marshal::FreeHGlobal(IntPtr((void*)chars)); tableau4.push_back(a); textBox1->Clear();
Figure n°34 : bobine de sortie
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
51
} } } }
I-e) Programmation du bouton pour le contact normalement fermé
Pour le bouton fin de course voici son logigramme :
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
52
Voici un aperçu du logiciel après la programmation des composants terminés, ainsi qu’un
programme effectué avec l’éditeur :
Figure n° 36: le logiciel d’éd iteur ladder
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
53
CHAPITRE II : LES OUTILS DE L’EDITEUR
II-1) Les outils proposés par l’éditeur
Pour programmer avec l’éditeur on clique sur le bouton ayant une le symbole, le programme
s’exécute séquentiellement. Les symboles proposés par l’application sont les suivants :
pour ajouter des lignes sur le programme.
II-2) Création d’un programme avec le logiciel
On clique sur les différents images représentants les commandes voulues, une fois le programme
terminer on clique sur Fichier->Enregistrer sous pour enregistrer le programme. Le logiciel Voici
Il y a les contacts ouvert et fermé, ainsi que la sortie, la branche de condition et les outils lignes
Figure n° 37 : les bout ons de commande du logiciel
n’enregistre pas le programme par défaut, il faut l’enregistrer manuelle ment.
Figure n° 38 : enregistrement d’un programme avec le logiciel
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
54
un exemple de programme effectué avec le logiciel, ce programme effectue l’opérateur logique
XOR de l’algèbre booléenne :
On insère les variables grâce à la zone de texte en haut au centre une fois que l’on a cliqué sur le
bouton du symbole voulu la variable est automatiquement effacé de la zone de texte.
Pour l’ouverture d’un programme LADDER déjà enregistré on effectue les étapes suivantes :
Fichier->Ouvrir
Une fenêtre apparait sur l’écran :
On choisit l’emplacement du programme que l’on veut ouvrir, les programmes sont enregistrer
avec l’extension « .PRG » pour l’image LADDER, les variables qui correspondent à chaque
image sont enregistrer automatiquement avec l’extension « .PRGLAD ». Lors de la sélection du
programme seul l’image est utile pour ouvrir le fichier mais le fichier contenant les variables sont
automatiquement chargés.
Figure n° 39: fonction XOR avec l’éditeur
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
55
Dans le logiciel on a une option qui peut traduire le langage texte en dessin, sur les boutons
proposés on a le bouton qui transforme du texte en schémas LADDER.
L’opération inverse est aussi possible, c’est-à-dire que si on veut traduire le langage LADDER
Une fois le programme effectué on clique sur le bouton Ladder en Texte, le logiciel ouvre une
fenêtre pour l’enregistrement du texte. Le fichier ainsi enregistrer possède l’extension
« *. LADTXT ».
II - 3) Fichier Texte en LADDER
Figure n°
40 : ouverture d’un programme ladder avec le logiciel
en texte on le bouton qui exécute l’opération.
Figure n° 4 1: outil pour tranformer le programme ladder en texte
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
56
L’ouverture d’un fichier «*. LADTXT », sur l’onglet en haut à gauche dans le menu déroulant
Fichier->Ouvrir text ladder.
Après clique on a la fenêtre ci-dessous qui filtre directement les fichiers avec l’extension
«*. LADTXT »
Figure n° 42: Ouverture d’un fichier texte
Fig ure n°43 : fenêtre de filtrage
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
57
II-4) Les lettres réservées pour le texte
Chaque commande correspondent à une lettre le tableau ci-dessous montre cette correspondance
:
Lettre Correspondant Symbole LADDER
O
F
B
N
P
*
+
L
Tableau n°19: lettres réservés et symboles LADDER
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
58
Pour terminer avec le logiciel nous allons donner un exemple utilisant le langage texte et le
traduire en schéma LADDER.
Dans cet exemple nous allons montrer comment programmer le langage LADDER à l’aide du
langage textuel. On a les caractères correspondants à chaque symbole LADDER séparer de signe
« * » qui jouent le rôle de liaison en série.
On sauvegarde le fichier texte en « *.LADTXT », pour enregistrer on a les étapes suivantes :
Puis on a la fenêtre d’enregistrements, on fait glisser le type de fichier pour choisir tous les
fichiers. Après ces étapes effectués on peut maintenant ouvrir le fichier enregistrer à du logiciel.
Il est plus difficile de programmer du texte pour le transformer ensuite en schéma LADDER, car
il faut prendre en compte les différentes liaisons séries et parallèles. Les liaisons parallèles sont
équivalentes à des branches conditionnelles dans le schéma LADDER.
Pour les variables on l’insère après le caractère « [« puis on ferme le caractère « ] » lorsqu’on a
terminé d’entrer notre variable.
Pour transformer le texte en LADDER on effectue les étapes suivantes, on ouvre le logiciel sur le
menu déroulant Fichier on choisit texte en ladder puis on sélectionne notre fichier.
Pour ce faire on utilis e l’éditeur de texte de Windows comme « Notepad » ou « Notepad++ »
et on écrit not re programme textuel :
Fig ure n° 44 : Exemple de programme texte
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
59
La réalisation du projet se divise en trois parties, le premier est la conception de l’éditeur. La
deuxième partie et la réalisation du compilateur, la dernière partie est la réalisation de l’automate.
Nous recommandons de réaliser simultanément les deux dernières parties car elles sont
dépendants l’une de l’autre.
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
60
CONCLUSION
En guise de conclusion nous pouvons dire que la réalisation d’un automate programmable
industriel est un atout facilitant les taches dans l’univers industriel, grâce à sa rapidité et à sa
capacité d’adaptation dans les différentes situations. L’automate se divise en deux grandes parties
dont la partie logicielle et la partie matérielle constitué par les circuits électroniques et électriques.
Les APIs se distinguent des ordinateurs grâce à leur robustesse, leur portabilité et leur circuit
destiné pour des utilisations industriels.
La réalisation de l’éditeur passe par trois étapes principales. Premièrement la connaissance de
l’architecture de l’automate, les différents modules qui la compose et leurs rôles respectifs. Les
constituants du langage LADDER et les opérations correspondants à chaque symbole.
Ensuite le choix du langage de développement et du logiciel utilisé, ainsi que l’ajout des
bibliothèques graphiques pour les dessins. L’IDE de Microsoft est très intéressant grâce à ces
outils et à sa documentation très riche mais l’inconvénient c’est sa portabilité vers d’autres
plateformes. On recommande une bibliothèque graphique qui est à la fois libre et multiplateforme.
Enfin l’implémentation du programme se divise en deux, qui sont l’implémentation de la fenêtre
et implémentation des différents symboles graphiques. Ainsi que les fonctionnalités proposées
par le logiciel, le petit plus du logiciel dont la transformation du langage ladder en texte.
Les fonctionnalités proposés par l‘éditeur peut être enrichie, comme l’ajout d’un temporisateur et
des différentes fonctions mathématiques.
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
61
Bibliographie
[1] SIMATIC Automate programmable S7-200 Manuel système
[2] GPA-141 : AUTOMATES PROGRAMMABLES
[3] IEC61131_1
[4] Automate_lang
[5] La programmation ladder sur TSX 37
[6] https://cours.etsmtl.ca/gpa754/AutresCours/Lab1Gpa141.pdf
[7] https://isp.ljm.free.fr/manuels/num/fr/ladderfr.pdf
[8] https://installations-electriques.net/Apelm/Autoprog.html
[9] http://nico-pyright.developpez.com/tutoriel/vc2005/winforms
[10] http://msdn.microsoft.com/en-us/library
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
62
Annexe 1 : Implémentation de l’enregistrement du fichier ladder private: System::Void enregistrerSousToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e) { // System::IO::Stream^ FileStream; int i=0; String^ nom;
SaveFileDialog^ enregistrer=gcnew SaveFileDialog; SaveFileDialog^ enregistrer_text=gcnew SaveFileDialog;
enregistrer->Filter="Programme Ladder|*.PRG"; enregistrer_text- >InitialDirectory=Environment::GetFolderPath(Environment::SpecialFolder::MyDocuments); enregistrer- >InitialDirectory=Environment::GetFolderPath(Environment::SpecialFolder::MyDocuments); if(enregistrer- >ShowDialog(this)==Windows::Forms::DialogResult::OK){
BinaryWriter^ binWriter = gcnew BinaryWriter ( File::Open( enregistrer->FileName, FileMode::Create ) ); binWriter->BaseStream->Position=0; nom=enregistrer->FileName+"LAD"; binWriter- >Write(double(tableau2.size())); for(i=0;i<tableau2.size();i++){
System::Diagnostics::Debug::WriteLine(tableau2[i]); binWriter->Write(double(tableau2[i]));
} binWriter->Close();
} enregistrer_text->FileName= nom;
StreamWriter^ textWriter = gcnew StreamWriter ( enregistrer_text- >FileName); for(int j=0;j<tableau4.size();j++){ String^ str2 = gcnew String(tableau4[j].c_str()); textWriter->Write(str2); textWriter->Write(Environment::NewLine);
//} }
textWriter->Close();
}
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
63
Annexe 2 : Implémentation de l’ouverture du fichier ladder
private: System::Void ouvrirToolStripMenuItem_Click(System::Object^ sender, System::EventArgs^ e) { double i=0; double b;
String^ nom; String^ text;
string chaine; System::IO::Stream^ FileStream;
OpenFileDialog^ ouvrir=gcnew OpenFileDialog; OpenFileDialog^ ouvrir_text=gcnew OpenFileDialog; ouvrir->Filter="Programme Ladder|*.PRG"; ouvrir- >InitialDirectory=Environment::GetFolderPath(Environment::SpecialFolder::MyDocuments); if(ouvrir->ShowDialog(this)==Windows::Forms::DialogResult::OK){
BinaryReader^ binReader = gcnew BinaryReader( File::Open( ouvrir->FileName , FileMode::Open ) );
int a; nom=ouvrir->FileName+"LAD"; binReader->BaseStream->Position=0; b=binReader->ReadDouble(); if(b!=1){ tsila=true; } for(i=0;i<b;i++){ a=binReader->ReadDouble(); tableau2.push_back(a);
Invalidate();
}
binReader->Close();
if(tableau2[tableau2.size()-3]==4){ x=20; y=tableau2[tableau2.size()-1]+70;
} else if(tableau2[tableau2.size()-3]!=4){ x=tableau2[tableau2.size()-2]; y=tableau2[tableau2.size()-1]; }
}
ouvrir_text->FileName= nom;
StreamReader^ textReader = gcnew StreamReader ( ouvrir_text-
Ecole Supérieure Polytechnique d’Antananarivo
GENIE INDUSTRIEL PROMOTION 2013
64
>FileName); int j=0;
while( textReader->Peek() >=0){
text=textReader->ReadLine();
const char* chars =
(const char*)(Marshal::StringToHGlobalAnsi(text)).ToPointer(); chaine= chars; Marshal::FreeHGlobal(IntPtr((void*)chars)); tableau4.push_back(chaine);
} textReader->Close(); int over_text=0; int x1=0,y1=0; for(j=0;j<tableau2.size()-1;j+=3){ if(tableau2[j]==4){
}
else if(tableau2[j]==5){
} else if(tableau2[j]==6){
} else if(tableau2[j]==8){
} else { TextBox^ textBox=gcnew TextBox; x1=tableau2[j+1]; y1=tableau2[j+2]; String^ str2 = gcnew String(tableau4[over_text].c_str()); Controls->Add(textBox); textBox->Text=str2; textBox->ReadOnly=true; textBox->Location = System::Drawing::Point(x1+15,y1-34); textBox->Size = System::Drawing::Size(40, 20); over_text++; } } //}
}
Nom : RAHARIMANANA
Prénoms : Tsilavina Antonio
Titre : « CONTRIBUTION A LA REALISATION D’UN AUTOMATE
PROGRAMMABLE INDUSTRIEL » : Partie logicielle
Nombre de page : 63
Nombre de figure : 44
Nombre de tableau : 19
RESUME
Pour contribuer à la réalisation d’un automate programmable industriel qui est l’objectif
principal de ce mémoire, la mise en place d’un logiciel de programmation est indispensable.
Il s’agit d’un logiciel pour éditer un programme en langage ladder. Le présent projet applique
la méthode en v pour la création du logiciel qui consiste d’abord à faire le choix du langage de
développement, le C++ managé ensuite le codage du logiciel et enfin le test qui s’est avéré
efficace. Le logiciel ainsi créé accompagné d’un système embarqué liée par une interface de
communication formera un automate programmable industriel opérationnel.
Mots clès : C++ managé, langage ladder, API (Automate Programmable Industriel)
ABSTRACT
To contribute to the realization of a programmable logic controller which is the objective
the main memory, the development of software programming is essential.
It is a software to edit a program in ladder language. This project applies v in the method for the
creation of software which is to first make the selection of the language development, then the C
++ software managed coding and finally the test which has proven effective. The Software
created along with an embedded system connected by an interface to communication form a
programmable logic controller operational.
Keywords: C++ managed, ladder language, PLC (Programmable Language Controller)
Directeur du mémoire: RAKOTONDRAINIBE Faniry Emile, Enseignant chercheur à
l’ESPA.
Adresse de l’auteur : Lot ITH 47 ter A Amboatavo Itaosy
Contacts: 033 79 521 71 [email protected]