Du Grafcet au Ladder
Automates programmables Du Grafcet au Ladder
Anthony Juton - version 3.0
1
Du Grafcet au Ladder
Le but de ce guide est de vous permettre de programmer simplement un automate en langage ladder à partir d'un grafcet. Le langage ladder, un peu fastidieux parfois à écrire, reste le plus utilisé pour la programmation des systèmes automatisés industriels. Le guide s'appuie sur la programmation d'automates Omron, sur les parties opératives trIrobot. Cependant, nombre de notions générales sont valables pour tous les automates.
Ce guide ne comporte pas de tutorial spécifique vous guidant pas-à-pas dans la programmation de l'automate. Il propose simplement de suivre le guide d'introduction d'Omron-Cx-Programmer disponible sur le réseau (cf Bibliographie). Avant de lancer le logiciel, votre programme doit être formalisé proprement sous la forme d'un GRAFCET. Sur ce Grafcet, chaque étape aura un numéro bien sûr (1,2,3…) mais aussi chaque transition (t0_1 par exemple pour la transition de l'étape 0 vers l'étape 1).
A chaque fois que vous souhaitez faire une modification de votre programme, il faudra commencer par modifier votre Grafcet. Programme et Grafcet doivent se correspondent parfaitement. La méthode exposée ci-dessous pour transformer un Grafcet en Ladder doit être respectée strictement. 1
Du Grafcet au Ladder ............................................... ........................................................................ .............................................. ...................................... ................. 3 1.1
Création d'un nouveau projet .............................................. ....................................................................... .............................................. ....................... 3
Chargement de la table E/S .............................................. ....................................................................... .............................................. .............................. ......... 4 Création de la table des symboles ............................................. ..................................................................... .............................................. ........................ 4 1.2
Création des sections et programme................................................................. programme................................................................................... .................. 5
1ère étape : la section de calcul des transitions................................................................ transitions.......................................................................... .......... 6 2nde étape : la section d'évolution des états des étapes. ................................................. ............................................................ ........... 6 3ème étape : la section de calcul des sorties. ............................................... ................................................................... .............................. .......... 8 1.3
Compilation, téléchargement, exécution et débogage ............................................... .......................................................... ........... 8
1.4
variables internes et Timers ................................................ ......................................................................... .............................................. ....................... 8
Timers ............................................. ..................................................................... ................................................. ............................................. ..................................... ................. 8 Variables internes ............................................ ..................................................................... .............................................. .............................................. ......................... 9 2
Premiers exercices ............................................... ........................................................................ .............................................. .......................................... ..................... 9
3
Programmer sous Cx-Programmer des graphes hiérarchisés ............................................... .....................................................10 ......10
Bibliographie .............................................. ....................................................................... .............................................. .............................................. ....................................10 ...........10
2
Du Grafcet au Ladder
1 DU GRAFCET AU L ADDER
Pour être programmable en Ladder, votre Grafcet doit respecter scrupuleusement les règles du grafcet (cf cours II2). Votre Grafcet écrit, vous pouvez passer à la phase de programmation.
Le Ladder est aujourd'hui le langage le plus répandu pour la programmation des automates. Il consiste en un ensemble de réseaux de contacts, semblables à des schémas électriques. La barre de gauche représente VCC et celle de droite GND. Dans l'exemple présenté ci-dessous, la bobine S est alimenté si les interrupteurs a et (/b ou c) sont fermés. Ce réseau correspond donc à l'équation S=a.(/b+c).
a
b
S
c
Les réseaux sont exécutés du premier (celui du haut de la première section) vers le dernier (celui du bas de la dernière section), séquentiellement.
1.1
CREATION D'UN NOUVEAU PROJET
Se référer au guide Omron. Vous choisirez comme automate (PLC en anglais) un CJ1M (device type) connecté par Ethernet (Network type). Dans la configuration du réseau (Ethernet>settings), vous entrerez alors l'adresse IP de votre automate 192.192.xx.xx et le masque de sous-réseau (255.255.255.0) Cette adresse est l'identifiant de votre automate sur le réseau, elle est indiquée par une étiquette située sous l'automate.
3
Du Grafcet au Ladder
Votre nouveau projet comporte notamment
une table de symboles rassemblant les symboles communs à tous les programmes de votre projet.
Certains symboles sont présents d'office, ce sont les bits et variables auxquels est déjà affectée une fonction (mot indiquant le temps de cycle, bit de premier cycle…)
une table entrées/sorties correspondant aux modules et périphériques de votre automate.
une liste de programmes.
Dans un projet, vous pouvez avoir plusieurs programmes, correspondant chacun à un Grafcet. Ces programmes peuvent tourner en parallèle, être activés, désactivés selon les besoins. Nous verrons cela plus tard.
Chargement de la table E/S Si c'est votre premier projet, charger la table E/S de l'automate, API>Transfert>Transfert API>Transfert>Transfert depuis l'API ou grâce à l'icône
. Ne chargez que la table E/S.
Vous avez alors dans la table E/S de votre projet pr ojet les différents d ifférents modules de votre automate (Ethernet, bloc 16 entrées et bloc 16 sorties.)
Création de la table des symboles Un tableau appelé table des symboles vous permet d'entrer les noms de toutes les entrées et sorties que vous utiliserez. Vous le trouvez en cliquant sur Symboles, dans la partie programme de votre projet.
4
Du Grafcet au Ladder
L'automate CJ1M que vous programmez est un automate modulaire. Il est pourvu ici d'un bloc de 15 entrées Tout ou Rien à l'emplacement 0 et d'un bloc de 15 sorties Tout ou Rien à l'emplacement 1.
Bit associé à une entrée : 0.00 à 0.15
Bit associé à une sortie : 1.00 à 1.15
C'est aussi ici que vous matérialiserez les étapes en leur affectant un bit (H0.0 à H511.15) et un nom (X0, X1…). De même pour les transitions, vous leur affecterez un bit (A448.0 à A959.15) et un nom (t0_1, t1_2…). Vous pouvez enregistrer votre table des symboles pour la réutiliser ensuite dans tous vos projets. Pour cela, cliquez sur Symboles avec Symboles avec le bouton droit puis choisissez Fichiers réutilisables>Enregistrez sous.
1.2
CREATION DES SECTIONS ET PROGRAMME
Arrive maintenant la phase de programmation. Vous devez diviser votre ensemble de réseaux de contacts en plusieurs sections (voir page 1-11 du guide) Vous créerez trois sections : section1- calcul des transitions section2- évolution des états (active, inactive) des étapes section3- calcul des sorties
5
Du Grafcet au Ladder
La transposition d'un Grafcet en Ladder n'est pas une tâche complexe. Elle demande de travailler avec méthode et de respecter scrupuleusement les règles édictées. Pour un fonctionnement correct, il faut d'abord calculer toutes les transitions, ensuite faire évoluer les états des étapes et enfin calculer l'état des sorties.
1ère étape : la section de calcul des transitions. Dans cette section, vous devez avoir autant de réseaux de contacts que de transitions. Nous rappelons que pour être franchie (donc passage à 1 de la variable associée tx_y), toutes les étapes précédant la transition doivent être actives et la réceptivité doit être vraie. Dans l'exemple qui suit, la transition t0_1 est franchie si l'étape 0 est active (donc le bit X0 est à 1) et si la réceptivité a.(/b+c) est vraie, ce qui se traduit par le réseau de contacts ci-dessous.
X0
a
b
t0_1
0
t0_1
a.(/b+c) 1
t1_0
/a
c
Quand vous avez écrit les réseaux de toutes les transitions, vous pouvez passer à la section suivante.
2nde étape : la section d'évolution des états des étapes. Dans cette section, à chaque cycle, suivant les valeurs des transitions calculées dans la section précédente, on fait évoluer l'état des étapes. Une étape est active si le bit associé est à 1. Elle est inactive si le bit associé est à 0. Il doit y avoir ici autant de réseau que d'étapes. Une étape est active si
6
Du Grafcet au Ladder
elle était active dans le cycle précédent et que les transitions suivantes ne sont pas
franchie.
l'une des transitions précédentes est franchie actuellement. L'activation est prioritaire sur la
désactivation. On obtient le réseau suivant :
t0_1
0
t0_1
X1
a.(/b+c) 1
t1_0
/a
t1_0
X1
Si il y en a plusieurs, les conditions d'activation se mettront en parallèle (cas d'une convergence audessus de l'étape) et les conditions de désactivation en série (cas d'une divergence au-dessous de l'étape).
Lors du premier cycle de l'automate, il faut mettre à l'état actif les étapes initiales (cela rajoute une condition d'activation) et à l'état inactif toutes les autres. (cela rajoute une condition de désactivation mais qui cette fois est prioritaire.). On utilise le bit interne P_First_Cycle vrai seulement pendant le premier cycle automate pour assurer cette mise à l'état initial des états des étapes. On obtient les réseaux suivants : P_First_Cycle
0
t0_1
t1_0
X0
a.(/b+c) 1
t1_0
/a
t0_1
X0
P_First_Cycle X1
t0_1
t1_0
X1
7
Du Grafcet au Ladder
Désormais, les bits d'étapes (X0, X1…) nous donnent une image des étapes actives et inactives. Il reste juste à calculer l'état des sorties, suivant les actions associées aux étapes.
3ème étape : la section de calcul des sorties. Dans cette section, on calcule l'état de chaque sortie. Suite à cette section, la section nommée END provoquera la mise à jour des sorties sur le bornier de l'automate. On ne peut avoir qu'une bobine et donc qu'un réseau par sortie. Sinon, il pourrait y avoir un réseau demandant l'activation d'une sortie puis le réseau suivant demandant sa désactivation, ce qui ne serait pas simple à gérer. (En Ladder, les réseaux étant exécutés séquentiellement, c'est le dernier qui a parlé qui s'impose) A vous de lister l'ensemble l 'ensemble des étapes qui activent une sortie. Par exemple, si la lampe L est allumée pendant l'étape 1 et l'étape 3, on aura le réseau suivant :
L
X1
X3
Remarque : pensez à utiliser les raccourcis clavier pour le tracé des réseaux indiqué dans la fenêtre, plus CTrl+ pour les traits horizontaux. Les autres raccourcis sont indiqués dans le guide d'introduction d'Omron.
1.3
COMPILATION , TELECHARGEMENT , EXECUTION ET DEBOGAGE
Pour compiler et charger le programme, vous vous référerez au guide de mise en œuvre, à partir de la page 2-0. Ensuite, lancez l'exécution du programme en mode "monitor" et suivez le guide Omron pour utiliser les fonctions de debug : Watch Windows (à partir de la page 2-5) et Forçage (à partir de la page 211).
1.4 VARIABLES INTERNES ET TIMERS Timers A partir de la page 1-28 sont décrites les procédures pour insérer un timer (ou temporisateur) dans un programme. Attention, pour utiliser une temporisation dans un programme, il faut d'abord lancer le timer dans l'étape (c'est une action associée à l'étape) puis regarder l'état de la variable associé au 8
Du Grafcet au Ladder
timer dans la transition. Attention, le même terme est utilisé à la fois pour désigner la valeur actuelle du timer (T0000 (T000 0 à T4095 suivant le timer choisi, mot de 16 bits) et le drapeau indiquant la fin du décompte (simple bit indiquant si la temporisation est finie ou non). Suivant le contexte où vous l'utilisez, c'est l'un ou l'autre qui est pris en compte. Il ne peut y avoir d'ambiguïté.
Variables internes Dans votre automates, une large plage de mémoire est disponible pour vos variables internes. Pour les étapes et transitions, vous avez déjà utilisé les zones mémoires accessibles bit à bit (mots mémoires H000 à H511 et A660 à A959). Pour ces mots, on peut accéder à un seul bit de la manière suivante Hxxx.yy avec xxx allant de 000 à 511 et yy de 00 à 15. Par exemple pour accéder au bit numéro 4 du mot mémoire H211 : H211.04 Vous disposez aussi d'une mémoire de 512 mots (16 bits) nommés W000 à W511. Pour les utiliser, il vous suffit de créer dans la table des symboles une variable et de lui affecter un de ces mots.
2 PREMIERS EXERCICES Pour commencer à vous familiariser avec le ladder et Cx-programmer, vous ferez les exercices suivants : Exercice 1 Dans l'état initial, la lampe verte est allumée. Quand j'appuie sur le bouton blanc, la lampe verte s'éteint et la lampe blanche s'allume. Quand j'appuie sur le bouton vert, je reviens dans l'état initial.
Tracer le GRAFCET associé à ce cahier des charges.
Le programmer en ladder.
Exercice 2 Dans l'état initial, les deux lampes sont éteintes. Quand je tourne le sélecteur sur la position gauche, la lampe verte s'allume. Quand je tourne le sélecteur sur la position droite, la lampe blanche s'allume. Je reviens dans l'état initial après 4s.
Tracer le GRAFCET associé à ce cahier des charges.
Le programmer en ladder.
9
Du Grafcet au Ladder
3 PROGRAMMER SOUS C X -P -PROGRAMMER DES GRAPHES HIERARCHISES Une programmation propre, en Grafcet comme en C, passe par une division du programme en un ensemble de tâche ou de sous-programme testables de façon unitaire. Vous pouvez concevoir un programme comprenant plusieurs grafcet interagissant entre eux. Pour programmer cela, voici quelques conseils:
A chaque graphe, on associe un programme. Comme pour la programmation classique des grafcet, chaque programme est constitué de 3 sections :
Calculs des transitions
Evolution des étapes
Mise à jour des sorties
Une grande rigueur doit être apporté dans la répartition des variables internes. On peut attribuer les bits mémoire internes de la manière suivante par exemple : h0.0 à h0.15 et
A700.0 à A700.15
pour le graphe de production normale (étapes 0 et 1)
h2.0 à h2.15 et
et A702.0 à A702.15
pour le graphe de chargement (étapes 20 à 24)
et ainsi de suite… Remarque, pour les programmes, on commence à utiliser les bits de la zone mémoire auxiliaire (Axxx) à partir du bit A660.0. En effet, dans la zone auxiliaire, entre A000.0 et A459.15, nombre de bits sont utilisés par les fonctions de l'automate et ne sont donc pas libres pour le programme utilisateur. Les variables utilisés par tous les programmes (la position du plateau, le contenu des emplacements) sont définis en variables "globales", dans la table des symboles accessible à tous les programmes. Attention, il ne faut pas que deux programmes actifs a ctifs en même temps aient le droit de modifier une même variable, sans prendre de grandes précautions (le plus simple est de n'autoriser qu'un programme à modifier la variable et les autres à la lire). En variables locales, on définira les variables liées aux étapes et transitions, y compris celles que l'on utilise en lecture seule.
BIBLIOGRAPHIE API_du_Grafcet_au_Ladder_v3.pdf : le présent document cours_II2.pdf : le cours d'automatismes industriels de DUT 1ère année. R120-FR2-01+CX-Progr+IntroGuide.pdf : le guide d'introduction au logiciel OMRON CX-Programmer W340FR13_CJ_CS_Manuel_Programmation.pdf : le manuel regroupant l'ensemble des fonctions de l'automate OMRON CJ1. Ces quatres documents sont disponibles aux adresses suivantes :
http://iutcachanupsud.free.fr http://formation.u-psud.fr
10
