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

http://fr.wikipedia.org/wiki/CEI_61131-3

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


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°31 : Cycle en V

Figure n° 32: LOGIGRAMME DU CONTACTEUR


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° 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

http://fr.wikipedia.org/wiki/Commission_%C3%A9lectrotechnique_internationale

http://fr.wikipedia.org/wiki/Sequential_function_chart


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.



2

PARTIE A : GENERALITES SUR LES AUTOMATES

PROGRAMMABLES INDUSTRIELS



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

http://fr.wikipedia.org/wiki/%C3%89lectronique

http://fr.wikipedia.org/wiki/%C3%89lectronique

http://fr.wikipedia.org/wiki/Commande_%28automatisme%29

http://fr.wikipedia.org/wiki/Proc%C3%A9dure_d%27entreprise

http://fr.wikipedia.org/wiki/Proc%C3%A9dure_d%27entreprise

http://fr.wikipedia.org/wiki/Donn%C3%A9e_%28informatique%29

http://fr.wikipedia.org/wiki/Donn%C3%A9e_%28informatique%29

http://fr.wikipedia.org/wiki/Capteur

http://fr.wikipedia.org/wiki/Consigne

http://fr.wikipedia.org/wiki/Programme_informatique





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 ]



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);

http://fr.wikipedia.org/wiki/Vanne

http://fr.wikipedia.org/wiki/Industriel

http://fr.wikipedia.org/wiki/Traitement_des_eaux_us%C3%A9es

http://fr.wikipedia.org/wiki/Potentiel_hydrog%C3%A8ne

http://fr.wikipedia.org/wiki/Potentiel_hydrog%C3%A8ne



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



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.



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)



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



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

http://fr.wikipedia.org/wiki/Informatique




11

167.100 Ar

Figure n°7 : Prix logiciel

541.08 0 Ar

762.54 0 Ar

1.088.640 Ar



12



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


http://fr.wikipedia.org/wiki/Normes_et_standards_industriels

http://fr.wikipedia.org/wiki/Commission_%C3%A9lectrotechnique_internationale

http://fr.wikipedia.org/wiki/Langage_de_programmation

http://fr.wikipedia.org/wiki/Automate_programmable_industriel

http://fr.wikipedia.org/wiki/Langage_Ladder


http://fr.wikipedia.org/wiki/Grafcet

http://fr.wikipedia.org/wiki/Bo%C3%AEtes_fonctionnelles

http://fr.wikipedia.org/wiki/Diagramme

http://fr.wikipedia.org/wiki/Texte_structur%C3%A9

http://fr.wikipedia.org/wiki/Liste_d%27instructions

http://fr.wikipedia.org/wiki/Assembleur

http://fr.wikipedia.org/wiki/1993

http://fr.wikipedia.org/wiki/2003

http://fr.wikipedia.org/wiki/Logiciel



http://fr.wikipedia.org/wiki/Fichier_texte





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



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



16

Figure n°13 : langage SFC

II - 1 - 4) Le langage SFC



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



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é



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é :


Bit X Etat

« 0 » False

« 1 » True

Tableau n°2 : Entrée et sortie du contact fermé Le

contact sur front descendant :





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 »




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 » :



22

Figure n°26 : bobine RESET

Etat Bit X

False inchangé

True « 0 »


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



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 :




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




25

PARTIE B : LANGAGE DE DEVELOPPEMENT ET IDE



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



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



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



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.



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;

}



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



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;

}



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) ;



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 ());



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



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



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).



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); }



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 :


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.


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.



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+



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



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.



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.



44

PARTIE C : IMPLEMENTATIONS ET LES OUTILS

PROPOSEES PAR LE LOGICIEL



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.



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.



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 :




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 :



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é



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



51

} } } }

I-e) Programmation du bouton pour le contact normalement fermé

Pour le bouton fin de course voici son logigramme :



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



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



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



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



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



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



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



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.



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.



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

https://cours.etsmtl.ca/gpa754/AutresCours/Lab1Gpa141.pdf

https://isp.ljm.free.fr/manuels/num/fr/ladderfr.pdf

https://installations-electriques.net/Apelm/Autoprog.html

http://nico-pyright.developpez.com/tutoriel/vc2005/winforms

http://msdn.microsoft.com/en-us/library



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();

}



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-



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]

mailto:[email protected]