Irai Automgen 7 Manuel utilisateur

Manuel de référence du langage
Exemples
Les aventures de Docteur R.
www.irai.com
Manuel de référence langage
1. Eléments communs........................................................................................................... 7
1.1. Les variables.......................................................................................................................... 7
1.1.1. Les variables booléennes ............................................................................................................... 7
1.1.2. Les variables numériques............................................................................................................... 8
1.1.3. Les temporisations ......................................................................................................................... 8
1.2. Les actions ........................................................................................................................... 10
1.2.1. Affectation d’une variable booléenne .......................................................................................... 10
Affectation complémentée d’une variable booléenne............................................................................ 11
1.2.2. Mise à un d’une variable booléenne............................................................................................. 12
1.2.3. Mise à zéro d’une variable booléenne.......................................................................................... 13
1.2.4. Inversion d’une variable booléenne ............................................................................................. 13
1.2.5. Mise à zéro d’un compteur, d’un mot ou d’un long..................................................................... 14
1.2.6. Incrémentation d’un compteur, d’un mot ou d’un long ............................................................... 15
1.2.7. Décrémentation d’un compteur, d’un mot ou d’un long .............................................................. 15
1.2.8. Temporisations............................................................................................................................. 16
1.2.9. Interférences entre les actions ...................................................................................................... 17
1.2.10. Actions de la norme CEI 1131-3................................................................................................ 17
1.2.11. Actions multiples ....................................................................................................................... 18
1.2.12. Code littéral................................................................................................................................ 19
1.3. Les tests................................................................................................................................ 19
1.3.1. Forme générale............................................................................................................................. 20
1.3.2. Modificateur de test ..................................................................................................................... 20
1.3.3. Temporisations............................................................................................................................. 21
1.3.4. Priorité des opérateurs booléens................................................................................................... 21
1.3.5. Test toujours vrai ......................................................................................................................... 22
1.3.6. Test sur variable numérique......................................................................................................... 22
1.3.7. Transitions sur plusieurs lignes.................................................................................................... 23
1.4. Utilisation de symboles ....................................................................................................... 23
1.4.1. Syntaxe des symboles .................................................................................................................. 23
1.4.2. Symboles automatiques................................................................................................................ 24
1.4.3. Syntaxe des symboles automatiques ............................................................................................ 24
1.4.4. Comment le compilateur gère-t-il les symboles automatiques ?.................................................. 24
1.4.5. Plage d’attribution des variables .................................................................................................. 25
1.5. A propos des exemples........................................................................................................ 26
1.6. Grafcet ................................................................................................................................. 28
1.6.1. Grafcet simple.............................................................................................................................. 28
1.6.2. Divergence et convergence en « Et »........................................................................................... 31
1.6.3. Divergence et convergence en « Ou ».......................................................................................... 33
1.6.4. Etapes puits et sources, transitions puits et sources ..................................................................... 36
AUTOMGEN7
3
(C)opyright 2002 IRAI
Manuel de référence langage
1.6.5. Actions multiples, actions conditionnées......................................................................................36
1.6.6. Synchronisation ............................................................................................................................38
1.6.7. Forçages de Grafcet ......................................................................................................................39
1.6.8. Macro-étapes ................................................................................................................................48
1.6.9. Compteurs.....................................................................................................................................51
1.7. Gemma ................................................................................................................................. 52
1.7.1. Création d’un Gemma ..................................................................................................................54
1.7.2. Contenu des rectangles du Gemma...............................................................................................54
1.7.3. Obtenir un Grafcet correspondant ................................................................................................54
1.7.4. Annuler les espaces vides dans le Grafcet ....................................................................................55
1.7.5. Imprimer le Gemma......................................................................................................................55
1.7.6. Exporter le Gemma.......................................................................................................................55
1.7.7. Exemple de Gemma......................................................................................................................55
1.8. Ladder.................................................................................................................................. 58
1.8.1. Exemple de Ladder.......................................................................................................................59
1.9. Logigramme......................................................................................................................... 60
1.9.1. Dessin des logigrammes ...............................................................................................................61
1.9.2. Exemple de logigramme ...............................................................................................................62
1.10. Langages littéraux............................................................................................................. 65
1.10.1. Comment utiliser le langage littéral ? .........................................................................................65
1.10.2. Définition d’une boîte de code ...................................................................................................66
1.10.3. Le langage littéral bas niveau .....................................................................................................67
1.10.4. Macro-instruction .....................................................................................................................120
1.10.5. Librairie ....................................................................................................................................121
1.10.6. Macro-instructions prédéfinies .................................................................................................121
1.10.7. Description des macro-instructions prédéfinies........................................................................121
1.10.8. Exemple en langage littéral bas niveau.....................................................................................123
1.11. Langage littéral étendu................................................................................................... 126
1.11.1. Ecriture d’équations booléennes...............................................................................................127
1.11.2. Ecriture d’équations numériques ..............................................................................................128
1.11.3. Structure de type IF ... THEN ... ELSE ... ................................................................................130
1.11.4. Structure de type WHILE ... ENDWHILE ...............................................................................130
1.11.5. Exemple de programme en langage littéral étendu...................................................................131
1.12. Langage littéral ST.......................................................................................................... 132
1.12.1. Généralités................................................................................................................................132
1.12.2. Equations booléennes ...............................................................................................................133
1.12.3. Equations numériques...............................................................................................................134
1.12.4. Structures de programmation....................................................................................................135
1.12.5. Exemple de programme en langage littéral étendu...................................................................137
AUTOMGEN7
4
(C)opyright 2002 IRAI
Manuel de référence langage
1.13. Organigramme ................................................................................................................ 137
1.13.1. Dessin d’un organigramme ...................................................................................................... 138
1.13.2. Contenu des rectangles............................................................................................................. 139
1.14. Illustration ....................................................................................................................... 139
1.15. Blocs fonctionnels............................................................................................................ 142
1.15.1. Création d’un bloc fonctionnel ................................................................................................ 142
1.15.2. Dessin du bloc et création du fichier « .ZON »........................................................................ 143
1.15.3. Création du fichier « .LIB » ..................................................................................................... 145
1.15.4. Exemple simple de bloc fonctionnel ........................................................................................ 145
1.15.5. Illustration................................................................................................................................ 146
1.15.6. Complément de syntaxe ........................................................................................................... 149
1.16. Blocs fonctionnels évolués .............................................................................................. 150
1.16.1. Syntaxe..................................................................................................................................... 150
1.16.2. Différencier anciens et nouveaux blocs fonctionnels............................................................... 150
1.16.3. Exemple ................................................................................................................................... 151
1.17. Blocs fonctionnels prédéfinis.......................................................................................... 152
1.17.1. Blocs de conversion ................................................................................................................. 152
1.17.2. Blocs de temporisation............................................................................................................. 153
1.17.3. Blocs de manipulations de chaîne de caractères ...................................................................... 153
1.17.4. Blocs de manipulation de table de mots................................................................................... 153
1.18. Techniques avancées....................................................................................................... 153
1.18.1. Code généré par le compilateur................................................................................................ 153
1.18.2. Optimisation du code généré.................................................................................................... 154
2. Exemples ....................................................................................................................... 157
2.1. A propos des exemples...................................................................................................... 157
2.1.1. Grafcet simple............................................................................................................................ 157
2.1.2. Grafcet avec divergence en OU ................................................................................................. 158
2.1.3. Grafcet avec divergence en ET .................................................................................................. 159
2.1.4. Grafcet et synchronisation ......................................................................................................... 160
2.1.5. Forçage d’étapes ........................................................................................................................ 161
2.1.6. Etapes puits et sources ............................................................................................................... 162
2.1.7. Etapes puits et sources ............................................................................................................... 163
2.1.8. Forçage de Grafcets ................................................................................................................... 164
2.1.9. Mémorisation de Grafcets.......................................................................................................... 164
2.1.10. Grafcet et macro-étapes ........................................................................................................... 166
2.1.11. Folios chaînés........................................................................................................................... 167
2.1.12. Logigramme............................................................................................................................. 169
2.1.13. Grafcet et Logigramme ............................................................................................................ 170
2.1.14. Boîte de langage littéral ........................................................................................................... 171
AUTOMGEN7
5
(C)opyright 2002 IRAI
Manuel de référence langage
2.1.15. Organigramme ..........................................................................................................................172
2.1.16. Organigramme ..........................................................................................................................173
2.1.17. Bloc fonctionnel .......................................................................................................................174
2.1.18. Bloc fonctionnel .......................................................................................................................175
2.1.19. Ladder.......................................................................................................................................176
2.1.20. Exemple développé sur une maquette de train .........................................................................177
Manuel pédagogique à l’usage des utilisateurs d’AUTOMGEN ............................... 183
AUTOMGEN7
6
(C)opyright 2002 IRAI
Manuel de référence langage
1. Eléments communs
Ce chapitre détaille les éléments communs à tous les langages utilisables dans
AUTOMGEN.
Le logo
repère les nouveautés utilisables dans la version 7 d’AUTOMGEN.
1.1. Les variables
Les types de variables suivants existent :
Ö le type booléen : la variable peut prendre la valeur vrai (1) ou faux (0).
Ö le type numérique : la variable peut prendre une valeur numérique, différents
sous types existent : variables 16 bits, 32 bits et virgule flottante.
Ö le type temporisation : type structuré, il est une combinaison du type booléen et
numérique.
A partir de la version 6 la syntaxe des noms de variables peut être celle propre à
AUTOMGEN ou la syntaxe de la norme CEI 1131-3.
1.1.1. Les variables booléennes
Le tableau suivant donne la liste exhaustive des variables booléennes utilisables.
Type
Syntaxe
Syntaxe
Commentaire
AUTOMGEN CEI 1131-3
Entrées
I0
%I0
Peut correspondre ou non à des entrées
à I9999
à %I9999
physiques (dépend de la configuration des
E/S de la cible).
Sorties
O0
%Q0
Peut correspondre ou non à des sorties
à O9999
à %Q9999
physiques (dépend de la configuration des
E/S de la cible).
Bits Système U0
%M0
Voir le manuel consacré à l’environnement
à U99
à %M99
pour le détail des bits Système.
Bits
U100
%M100
Bits internes à usage général.
Utilisateur
à U9999
à %M9999
AUTOMGEN7
7
(C)opyright 2002 IRAI
Manuel de référence langage
Etapes
X0
%X0
Grafcet
à X9999
à %X9999
Bits de mots M0#0
à M9999#15
Bits d’étapes Grafcet.
%MW0 :X0
Bits de mots : le numéro du bit est
à %MW9999 :X15 précisé en décimal et est compris
entre 0 (bit de poids faible) et 15 (bit
de poids fort).
1.1.2. Les variables numériques
Le tableau suivant donne la liste exhaustive des variables numériques.
Type
Compteurs
Syntaxe
Syntaxe CEI
AUTOMGEN
1131-3
C0
%C0
Compteur de 16 bits, peut être
à C9999
à %C9999
initialisé, incrémenté, décrémenté et
Commentaire
testé avec les langages booléens
sans utiliser le langage littéral.
Mots
M0
%MW0
Voir
le
manuel
consacré
à
Système
à M199
à %MW199
l’environnement pour le détail des
mots Système.
Mots
M200
%MW200
Utilisateur
à M9999
à %MW9999
Longs
L100
%MD100
à L4998
à %MD4998
F100
%MF100
Valeur réelle sur 32 bits (format
à F4998
à %MF4998
IEEE).
Flottants
Mot de 16 bits à usage général.
Valeur entière sur 32 bits.
1.1.3. Les temporisations
La temporisation est un type composé qui regroupe deux variables booléennes
(état de lancement, état de fin) et deux variables numériques sur 16 bits (la
consigne et le compteur).
AUTOMGEN7
8
(C)opyright 2002 IRAI
Manuel de référence langage
Le
schéma
suivant
donne
le
chronogramme
de
fonctionnement
d’une
temporisation :
1
état de lancement
0
1
état de fin
0
consigne
valeur de comptage
0
La valeur de consigne d’une temporisation est comprise entre 0 ms et
4294967295 ms (soit un peu plus de 49 jours)
La consigne de la temporisation peut être modifiée par programme, voir chapitre
1.10.3. Le langage littéral bas niveau (instruction STA).
Le compteur de la temporisation peut être lu par programme, voir chapitre 1.10.3.
Le langage littéral bas niveau (instruction LDA).
AUTOMGEN7
9
(C)opyright 2002 IRAI
Manuel de référence langage
1.2. Les actions
Les actions sont utilisées dans :
Ö les rectangles d’action du langage Grafcet,
Action
Ö les rectangles d’action du langage logigramme,
Action
Ö les bobines du langage ladder.
Action
1.2.1. Affectation d’une variable booléenne
La syntaxe de l’action « Affectation » est :
«variable booléenne»
Fonctionnement :
Ö si la commande du rectangle d’action ou de la bobine est à l’état vrai alors la
variable est mise à 1 (état vrai),
Ö si la commande du rectangle d’action ou de la bobine est à l’état faux alors la
variable est mise à 0 (état faux).
Table de vérité :
Commande
Etat de la variable (résultat)
0
0
1
1
Exemple :
Si l’étape 10 est active alors O0 prend la valeur 1, sinon O0 prend la valeur 0.
AUTOMGEN7
10
(C)opyright 2002 IRAI
Manuel de référence langage
Plusieurs actions « Affectation » peuvent être utilisées pour une même variable au
sein d’un programme. Dans ce cas, les différentes commandes sont combinées
en « Ou » logique.
Exemple :
Etat de X10 Etat de X50
Etat de O5
0
0
0
1
0
1
0
1
1
1
1
1
Affectation complémentée d’une variable booléenne
La syntaxe de l’action « Affectation complémentée » est :
«N variable booléenne»
Fonctionnement :
Ö si la commande du rectangle d’action ou de la bobine est à l’état vrai alors la
variable est mise à 0 (état faux),
Ö si la commande du rectangle d’action ou de la bobine est à l’état faux alors la
variable est mise à 1 (état vrai).
Table de vérité :
Commande
Etat de la variable (résultat)
0
1
1
0
Exemple :
Si l’étape 20 est active, alors U100 prend la valeur 0, sinon U100 prend la valeur
1.
AUTOMGEN7
11
(C)opyright 2002 IRAI
Manuel de référence langage
Plusieurs actions « Affectation complémentée» peuvent être utilisées pour une
même variable au sein d’un programme. Dans ce cas, les différentes commandes
sont combinées en « Ou » logique.
Exemple :
Etat de X100
Etat de X110
Etat de O20
0
0
1
1
0
0
0
1
0
1
1
0
1.2.2. Mise à un d’une variable booléenne
La syntaxe de l’action « Mise à un » est :
«S variable booléenne»
Fonctionnement :
Ö si la commande du rectangle d’action ou de la bobine est à l’état vrai alors la
variable est mise à 1 (état vrai),
Ö si la commande du rectangle d’action ou de la bobine est à l’état faux alors
l’état de la variable n’est pas modifié.
Table de vérité :
Commande
Etat de la variable (résultat)
0
inchangé
1
1
Exemple :
Si l’étape 5000 est active alors O2 prend la valeur 1, sinon O2 garde son état.
AUTOMGEN7
12
(C)opyright 2002 IRAI
Manuel de référence langage
1.2.3. Mise à zéro d’une variable booléenne
La syntaxe de l’action « Mise à zéro » est :
«R variable booléenne»
Fonctionnement :
Ö si la commande du rectangle d’action ou de la bobine est à l’état vrai alors la
variable est mise à 0 (état faux),
Ö si la commande du rectangle d’action ou de la bobine est à l’état faux alors
l’état de la variable n’est pas modifié.
Table de vérité :
Commande
Etat de la variable (résultat)
0
inchangé
1
0
Exemple :
Si l’étape 6000 est active alors O3 prend la valeur 0, sinon O3 garde son état.
1.2.4. Inversion d’une variable booléenne
La syntaxe de l’action « Inversion » est :
«I variable booléenne»
Fonctionnement :
Ö si la commande du rectangle d’action ou de la bobine est à l’état vrai alors
l’état de la variable est inversé à chaque cycle d’exécution,
Ö si la commande du rectangle d’action ou de la bobine est à l’état faux alors
l’état de la variable n’est pas modifié.
AUTOMGEN7
13
(C)opyright 2002 IRAI
Manuel de référence langage
Table de vérité :
Commande
Etat de la variable (résultat)
0
inchangé
1
inversé
Exemple :
Si l’étape 7000 est active alors l’état de O4 est inversé, sinon O4 garde son état.
1.2.5. Mise à zéro d’un compteur, d’un mot ou d’un long
La syntaxe de l’action « Mise à zéro d’un compteur, d’un mot ou d’un long» est :
«R compteur ou mot»
Fonctionnement :
Ö si la commande du rectangle d’action ou de la bobine est à l’état vrai alors le
compteur, le mot ou le long est remis à zéro,
Ö si la commande du rectangle d’action ou de la bobine est à l’état faux la valeur
du compteur, du mot, ou du long n’est pas modifiée.
Table de vérité :
Commande
Valeur du compteur du mot ou
du long (résultat)
0
Inchangé
1
0
Exemple :
Si l’étape 100 est active alors le compteur 25 est remis à zéro, sinon C25 garde sa
valeur.
AUTOMGEN7
14
(C)opyright 2002 IRAI
Manuel de référence langage
1.2.6. Incrémentation d’un compteur, d’un mot ou d’un long
La syntaxe de l’action « Incrémentation d’un compteur » est :
«+ compteur, mot ou long»
Fonctionnement :
Ö si la commande du rectangle d’action ou de la bobine est à l’état vrai alors le
compteur, le mot ou le long est incrémenté à chaque cycle d’exécution,
Ö si la commande du rectangle d’action ou de la bobine est à l’état faux la valeur
du compteur n’est pas modifiée.
Table de vérité :
Commande
Valeur du compteur, du
mot ou du long (résultat)
0
Inchangé
1
valeur actuelle +1
Exemple :
Si l’étape 100 est active alors le compteur 25 est incrémenté, sinon C25 garde sa
valeur.
1.2.7. Décrémentation d’un compteur, d’un mot ou d’un
long
La syntaxe de l’action « Décrémentation d’un compteur » est :
«- compteur, mot ou long»
Fonctionnement :
Ö si la commande du rectangle d’action ou de la bobine est à l’état vrai alors le
compteur, le mot ou le long est décrémenté à chaque cycle d’exécution,
Ö si la commande du rectangle d’action ou de la bobine est à l’état faux la valeur
du compteur n’est pas modifiée.
AUTOMGEN7
15
(C)opyright 2002 IRAI
Manuel de référence langage
Table de vérité :
Commande
Valeur du compteur, du mot
ou du long (résultat)
0
inchangé
1
valeur actuelle -1
Exemple :
Si l’étape 100 est active alors le compteur 25 est decrémenté, sinon C25 garde sa
valeur.
1.2.8. Temporisations
Les temporisations sont considérées comme des variables booléennes et sont
utilisables avec les actions « Affectation », « Affectation complémentée », « Mise à
un », « Mise à zéro », et « Inversion ». La consigne de la temporisation peut être
écrite à la suite de l’action. La syntaxe est :
« temporisation(durée) »
La durée est par défaut exprimée en dixièmes de seconde. Le caractère « S »
placé à la fin de la durée indique qu’elle est exprimée en secondes.
Exemples :
L’étape 10 lance une temporisation de 2 secondes qui restera active tant que
l’étape le sera. L’étape 20 arme une temporisation de 6 secondes qui restera
active même si l’étape 20 est désactivée.
Une même temporisation peut être utilisée à plusieurs endroits avec une même
consigne et à des instants différents. La consigne de la temporisation doit dans ce
cas être indiquée une seule fois.
Remarque : d’autres syntaxes existent pour les temporisations. Voir chapitre 1.3.3.
Temporisations
AUTOMGEN7
16
(C)opyright 2002 IRAI
Manuel de référence langage
1.2.9. Interférences entre les actions
Certains types d’action ne peuvent être utilisés simultanément sur une variable. Le
tableau ci-dessous résume les combinaisons interdites.
Affectation
Affectation
complémentée
Mise à un
Mise à zéro
Inversion
Affectation
OUI
NON
NON
NON
NON
Affectation
complémentée
NON
OUI
NON
NON
NON
Mise à un
NON
NON
OUI
OUI
OUI
Mise à zéro
NON
NON
OUI
OUI
OUI
Inversion
NON
NON
OUI
OUI
OUI
1.2.10. Actions de la norme CEI 1131-3
Le tableau ci-dessous donne la liste des actions de la norme CEI 1131-3
utilisables dans AUTOMGEN V>=6 par rapport à la syntaxe standard
d’AUTOMGEN. V5.
Nom
Nom
Syntaxe
Syntaxe
AUTOMGE
AUTOMGEN AUTOMGEN
d’équivalent
N V>=6
V5
AUTOMGEN V5
Néant
Néant
N1
Néant
N0
N
R
R
Exemple
V>=6
Exemple
mémorisé
Nom
mémorisé
Nom
mémorisé
complémenté
Mise à zéro
AUTOMGEN7
17
(C)opyright 2002 IRAI
Manuel de référence langage
Mise à 1
S
Limité dans le LTn/durée
S
Inexistant
temps
Temporisé
DTn/durée
Inexistant
Impulsion
P1
Inexistant
P0
Inexistant
SDTn/durée
Inexistant
Temporisé et DSTn/durée
Inexistant
sur front
montant
Impulsion
sur front
descendant
Mémorisé
et temporisé
mémorisé
Mémorisé et
SLTn/durée
Inexistant
limité dans
le temps
1.2.11. Actions multiples
Au sein d’un même rectangle d’action ou d’une bobine, plusieurs actions peuvent
être écrites en les séparant par le caractère « , » (virgule).
Exemple :
Plusieurs rectangles d’action (Grafcet et logigramme) ou bobines (ladder) peuvent
être juxtaposés. Reportez-vous aux chapitres correspondant à ces langages pour
plus de détails.
AUTOMGEN7
18
(C)opyright 2002 IRAI
Manuel de référence langage
1.2.12. Code littéral
Du code littéral peut être inséré dans un rectangle d’action ou une bobine.
La syntaxe est :
« { code littéral } »
Plusieurs lignes de langage littéral peuvent être écrites entre les accolades. Le
séparateur est ici aussi le caractère « , » (virgule).
Exemple :
Pour plus de détails, consultez les chapitres « Langage littéral bas niveau »,
« Langage littéral étendu » et « Langage littéral ST ».
1.3. Les tests
Les tests sont utilisés dans :
Ö les transitions du langage Grafcet,
Test
Ö les conditions sur action du langage Grafcet,
Test
Test
Ö les tests du langage logigramme,
Test
AUTOMGEN7
19
(C)opyright 2002 IRAI
Manuel de référence langage
Ö les tests du langage ladder.
Test
1.3.1. Forme générale
Un test est une équation booléenne composée de une ou de n variables séparées
par des opérateurs « + » (ou) ou « . » (et).
Exemple de test :
i0 (test l’entrée 0)
i0+i2 (test l’entrée 0 « ou » l’entrée 2)
i10.i11 (test l’entrée 10 « et » l’entrée 11)
1.3.2. Modificateur de test
Par défaut, si seul le nom d’une variable est spécifié, le test est « si égal à un» (si
vrai). Des modificateurs permettent de tester l’état complémenté, le front montant
et le front descendant :
Ö le caractère « / » placé devant une variable teste l’état complémenté,
Ö le caractère « u » ou le caractère « Ï* » placé devant une variable teste le
front montant,
Ö le caractère « d » ou le caractère « Ð** » placé devant une variable teste le
front descendant.
Les modificateurs de tests peuvent s’appliquer à une variable ou à une expression
entre parenthèses.
Exemples :
Ï i0
/i1
/(i2+i3)
Ð(i2+(i4./i5))
*
**
Pour obtenir ce caractère pendant l’édition d’un test pressez sur la touche [Ï].
Pour obtenir ce caractère pendant l’édition d’un test pressez sur la touche [Ð].
AUTOMGEN7
20
(C)opyright 2002 IRAI
Manuel de référence langage
1.3.3. Temporisations
Quatre syntaxes sont disponibles pour les temporisations.
Dans la première, on active la temporisation dans l’action et on mentionne
simplement la variable temporisation dans un test pour vérifier l’état de fin :
Pour les autres, tout est écrit dans le test. La forme générale est :
« temporisation / variable de lancement / durée »
ou
« durée / variable de lancement / temporisation »
ou
« durée / variable de lancement »
Dans ce cas, une temporisation est automatiquement attribuée. La plage
d’attribution est celle des symboles automatiques voir chapitre 1.4.2. Symboles
automatiques.
La durée est par défaut exprimée en dixièmes de seconde.
La durée peut être exprimée en jours, heures, minutes, secondes et
millisecondes avec les opérateurs « d », « h », « m », « s » et « ms ». Par
exemple : 1d30s = 1 jour et 30 secondes.
Exemple utilisant la deuxième syntaxe :
Exemple utilisant la syntaxe normalisée :
1.3.4. Priorité des opérateurs booléens
Par défaut l’opérateur booléen «. » (ET) à une priorité supérieure à l’opérateur ‘+’
(OU). Des parenthèses peuvent être utilisées pour définir une autre priorité.
AUTOMGEN7
21
(C)opyright 2002 IRAI
Manuel de référence langage
Exemples :
i0.(i1+i2)
((i0+i1).i2)+i5
1.3.5. Test toujours vrai
La syntaxe du test toujours vrai est :
« » (néant) ou « =1 »
1.3.6. Test sur variable numérique
Les tests sur variable numérique doivent utiliser la syntaxe suivante :
« variable numérique » « type de test » « constante ou variable numérique »
Le type de test peut être :
Ö « = » égal,
Ö « ! » ou « <> » différent,
Ö « < » inférieur (non signé),
Ö « > » supérieur (non signé),
Ö « << » inférieur (signé),
Ö « >> » supérieur (signé),
Ö « <= » inférieur ou égal (non signé),
Ö « >= » supérieur ou égal (non signé),
Ö « <<= » inférieur ou égal (signé),
Ö « >>= » supérieur ou égal (signé).
Un flottant ne peut comparé qu’avec un autre flottant ou une constante réelle.
Un long ne peut être comparé qu’avec un autre long ou une constante longue.
Un mot ou un compteur ne peut être comparé qu’avec un mot, un compteur ou
une constante 16 bits.
Les constantes réelles doivent être suivies du caractères « R ».
Les constantes longues (32 bits) doivent être suivies du caractère « L ».
Les constantes entières 16 ou 32 bits sont écrite en décimal par défaut. Elle
peuvent être écrites en hexadécimal (suffixe « $ » ou « 16# ») ou en binaire
(suffixe « % » ou « 2# »).
AUTOMGEN7
22
(C)opyright 2002 IRAI
Manuel de référence langage
Les tests sur variables numériques sont utilisés dans les équations comme les
tests sur variables booléennes. Ils peuvent être utilisés avec les modificateurs de
test à condition d’être encadrés par des parenthèses.
Exemples :
m200=100
%mw1000=16#abcd
c10>20.c10<100
f200=f201
m200=m203
%md100=%md102
f200=3.14r
l200=$12345678L
m200<<-100
m200>>1000
%mw500<=12
/(m200=4)
Ð(m200=100)
/(l200=100000+l200=-100000)
1.3.7. Transitions sur plusieurs lignes
Le texte des transitions peut être étendu sur plusieurs lignes. La fin d’une ligne de
transition doit obligatoirement être un opérateur « . » ou « + ». Les combinaisons
de touche [CTRL] + [Ð] et [CTRL] + [Ï] permettent de déplacer le curseur d’une
ligne à l’autre.
1.4. Utilisation de symboles
Les symboles permettent d’associer un texte à une variable.
Les symboles peuvent être utilisés avec tous les langages.
Un symbole doit être associé à une et une seule variable.
1.4.1. Syntaxe des symboles
Les symboles sont composés de :
Ö un caractère « _ »
optionnel (souligné, généralement associé à la touche [8]
sur les claviers) qui marque le début du symbole,
Ö le nom du symbole,
Ö un caractère « _ » optionnel (souligné) qui marque la fin du symbole.
AUTOMGEN7
23
(C)opyright 2002 IRAI
Manuel de référence langage
Les caractères « _ » encadrant les noms de symboles sont optionnels. Il
doivent être utilisés si le symbole commence par un chiffre ou un opérateur (+,-,
etc…).
1.4.2. Symboles automatiques
Il est parfois fastidieux de devoir définir l’attribution entre chaque symbole et une
variable, notamment si l’attribution précise d’un numéro de variable importe peu.
Les symboles automatiques sont une solution à ce problème, ils permettent de
laisser le soin au compilateur de générer automatiquement l’attribution d’un
symbole à un numéro de variable. Le type de variable à utiliser est, quant à lui,
fourni dans le nom du symbole.
1.4.3. Syntaxe des symboles automatiques
La syntaxe des symboles automatiques est la suivante :
_« nom du symbole » %« type de variable »_
« type de variable » peut être :
I , O ou Q, U ou M, T, C, M ou MW, L ou MD, F ou MF.
Il est possible de réserver plusieurs variables pour un symbole. Ceci est utile pour
définir des tableaux. Dans ce cas la syntaxe est :
_« nom du symbole » %« type de variable »« longueur »_
« longueur » représente le nombre de variables à réserver.
1.4.4. Comment le compilateur gère-t-il les symboles
automatiques ?
Au début de la compilation d’une application, le compilateur efface tous les
symboles automatiques qui se trouvent dans le fichier « .SYM » de l’application. A
chaque fois que le compilateur rencontre un symbole automatique, il crée une
attribution unique pour ce symbole en fonction du type de variable spécifié dans le
nom du symbole. Le symbole ainsi généré, est écrit dans le fichier « .SYM ». Si un
même symbole automatique est présent plusieurs fois dans une application, il fera
référence à la même variable.
AUTOMGEN7
24
(C)opyright 2002 IRAI
Manuel de référence langage
1.4.5. Plage d’attribution des variables
Par défaut, une plage d’attribution est définie pour chaque type de variable :
Type
Début
Fin
I ou %I
0
9999
O ou %Q
0
9999
U ou %M
100
9999
T ou %T
0
9999
C ou %C
0
9999
M ou %MW
200
9999
L ou %MD
100
4998
F ou %MF
100
4998
La plage d’attribution est modifiable pour chaque type de variable en utilisant la
directive de compilation #SR« type »=« début », « fin »
« type » désigne le type de variable, début et fin, les nouvelles bornes à utiliser.
Cette directive modifie l’attribution des variables automatiques pour la totalité du
folio où elle est écrite et jusqu’à une prochaine directive « #SR ».
AUTOMGEN7
25
(C)opyright 2002 IRAI
Manuel de référence langage
1.5. A propos des exemples
Pour mieux illustrer ce manuel, nous avons développé des exemples fonctionnant
avec une maquette de train dont voici le schéma :
S1I
T1I
1
S6I
T6I
S1D
T1D
MAQUETTE AT-850
S5D
T5D
voie 1
S6D
T6D
5
4
S5I
T5I
S4A
T4A
S2A
T2A
voie 2
S2B
T2B
voie 6
voie 5
voie 7
voie 8
S7I
T7I
2
S8I
T8I
S7D
T7D
voie 4
S4B
T4B
S8D
T8D
voie 3
S3I
T3I
S3D
T3D
Nous avons utilisé des cartes d’E/S sur PC pour piloter cette maquette. Les
symboles définis par le constructeur de la maquette ont été conservés.
AUTOMGEN7
26
(C)opyright 2002 IRAI
3
Manuel de référence langage
Le fichier de symboles suivant a été créé :
AUTOMGEN7
27
(C)opyright 2002 IRAI
Manuel de référence langage
1.6. Grafcet
AUTOMGEN supporte les éléments suivants :
Ö divergences et convergences en « Et » et en « Ou »,
Ö étapes puits et sources,
Ö transitions puits et sources,
Ö synchronisation,
Ö forçages de Grafcets,
Ö mémorisation de Grafcets,
Ö figeage,
Ö macro-étapes.
1.6.1. Grafcet simple
L’écriture de Grafcet en ligne se résume à la juxtaposition d’étapes et de
transitions.
Illustrons un Grafcet en ligne avec l’exemple suivant :
Cahier des charges :
La locomotive doit partir sur la voie 3 vers la droite, jusqu’au bout de la voie. Elle
revient ensuite dans le sens inverse jusqu’à l’autre bout et recommence.
AUTOMGEN7
28
(C)opyright 2002 IRAI
Manuel de référence langage
Solution 1 :
0
AV1
t1d
1
AV1 , DV1
t1i
exemples\grafcet\simple1.agn
Solution 2 :
0
S AV1 ,R DV1
Aller
t1d
1
S AV1 ,S DV1
Retour
t1i
exemple\grafcet\simple2.agn
La différence entre ces deux solutions réside dans l’utilisation des actions
« Affectation » pour le premier exemple et des actions « Mise à un » et « Mise à
zéro » pour le deuxième.
Modifions notre cahier des charges en imposant une attente de 10 secondes
lorsque la locomotive arrive à droite de la voie 1 et une attente de 4 secondes
lorsque la locomotive arrive à gauche de la voie 1.
AUTOMGEN7
29
(C)opyright 2002 IRAI
Manuel de référence langage
Solution 1 :
0
AV1
Aller
t1d
10
T0(10S)
t0
20
AV1 , DV1
Retour
t1i
30
T1(4S)
t1
exemple\grafcet\simple3.agn
Solution 2 :
0
AV1
Aller
t1d
10
10s/x10
20
AV1 , DV1
Retour
t1i
30
4s/x30
exemple\grafcet\simple4.agn
AUTOMGEN7
30
(C)opyright 2002 IRAI
Manuel de référence langage
La différence entre les exemples 3 et 4 réside dans le choix de la syntaxe utilisée
pour définir les temporisations. Le résultat au niveau du fonctionnement est
identique.
1.6.2. Divergence et convergence en « Et »
Les divergences en « Et » peuvent avoir n branches. L’important est de respecter
l’utilisation des blocs de fonction :
Obligatoirement
un bloc [K] et
pas un bloc [L]
Obligatoirement
un bloc [M] et
pas un bloc [L]
Obligatoirement
un bloc [Q] et
pas un bloc [P]
Obligatoirement
un bloc [O] et
pas un bloc [P]
Illustrons l’utilisation des divergences et convergences en « Et ».
Cahier des charges :
Nous allons utiliser deux locomotives : la première effectuera des allers et retours
sur la voie 1, la seconde sur la voie 3. Les deux locomotives seront synchronisées
(elles s’attendront en bout de voie).
AUTOMGEN7
31
(C)opyright 2002 IRAI
Manuel de référence langage
Solution 1 :
40
=1
0
AV1
50
t1d
AV3
t3i
10
60
=1
20
AV1 , DV1
70
t1i
AV3 , DV3
t3d
30
80
=1
exemple\grafcet\divergence et 1.agn
AUTOMGEN7
32
(C)opyright 2002 IRAI
Manuel de référence langage
Solution 2 :
t1d
0
t3i
AV1
10
AV3
t1d . t3i
t1i
20
t3d
AV1 , DV1
30
AV3 , DV3
t1i . t3d
exemple\grafcet\divergence et 2.agn
Ces deux solutions sont équivalentes au niveau du fonctionnement. La deuxième
est une version plus compacte qui utilise des actions conditionnées.
1.6.3. Divergence et convergence en « Ou »
Les divergences en « Ou » peuvent avoir n branches. L’important est de respecter
l’utilisation des blocs de fonction :
ou
AUTOMGEN7
33
(C)opyright 2002 IRAI
Manuel de référence langage
ou
Les divergences en « Ou » doivent obligatoirement se brancher sur des liaisons
descendantes. Par exemple :
incorrect, le bon dessin est :
AUTOMGEN7
34
(C)opyright 2002 IRAI
Manuel de référence langage
Si la largeur de la page vous interdit l’écriture d’un grand nombre de divergences,
vous pouvez adopter une structure du type:
Voyons un exemple pour illustrer l’utilisation des divergences et convergences en
« Ou » :
Cahier des charges :
Reprenons le cahier des charges du premier exemple de chapitre : aller et retour
d’une locomotive sur la voie 1.
Solution :
0
AV1
Ç t1d
1
Ç t1i
S DV1
2
=1
R DV1
=1
exemple\grafcet\divergence ou.agn
AUTOMGEN7
35
(C)opyright 2002 IRAI
Manuel de référence langage
Ce Grafcet pourrait se résumer à une étape en utilisant des actions conditionnées,
comme dans cet exemple :
Ç t1d
0
AV1
S DV1
Ç t1i
R DV1
exemple\grafcet\action conditionnée.agn
1.6.4. Etapes puits et sources, transitions puits et sources
Illustrons ces principes par des exemples :
Cahier des charges :
Traitons à nouveau le second exemple de ce chapitre : aller et retour d’une
locomotive sur la voie 1 avec attente en fin de voie.
Solution :
0
S AV1
Ç t1d
10
Ç t1i
R AV1
30
t0/x10/10s
20
S AV1
R AV1
t1/x30/4s
S DV1
40
=1
S AV1
R DV1
=1
exemple\grafcet\étapes puits et sources.agn
1.6.5. Actions multiples, actions conditionnées
Nous avons déjà utilisé dans ce chapitre des actions multiples et des actions
conditionnées. Détaillons ici ces deux principes.
AUTOMGEN7
36
(C)opyright 2002 IRAI
Manuel de référence langage
Comme il est dit dans le chapitre consacré au compilateur, plusieurs actions
peuvent être écrites dans un même rectangle, le caractère « , » (virgule) sert de
délimiteur dans ce cas.
Lorsqu’une condition est ajoutée sur un rectangle d’action, c’est l’ensemble des
actions contenues dans ce rectangle qui sont conditionnées.
Plusieurs rectangles d’action peuvent être associés à une étape :
autre possibilité :
Chacun des rectangles peut recevoir une condition différente :
Pour dessiner une action conditionnée, placez le curseur sur le rectangle d’action,
cliquez sur le bouton droit de la souris et choisissez « Action conditionnelle » dans
le menu. Pour documenter la condition sur action, cliquez sur l’élément
.
La syntaxe IF(condition) permet d’écrire une condition sur action dans le
rectangle d’action.
AUTOMGEN7
37
(C)opyright 2002 IRAI
Manuel de référence langage
1.6.6. Synchronisation
Reprenons un exemple déjà traité pour illustrer la synchronisation de Grafcets.
Cahier des charges:
Aller et retour de deux locomotives sur les voies 1 et 3 avec attente entre les
locomotives en bout de voie.
Cet exemple avait été traité avec une divergence en « Et ».
Solution 1 :
10
AV1
100
t1d
t3i
20
110
x110
30
AV3
x20
AV1 , DV1
120
t1i
AV3 , DV3
t3d
40
130
x130
x40
exemple\grafcet\synchro1.agn
AUTOMGEN7
38
(C)opyright 2002 IRAI
Manuel de référence langage
Solution 2 :
10
SX100,SX140
=1
20
x110.x150
30
SX120,SX160
=1
40
x130.x170
100
AV1
120
t1d
110
AV1 , DV1
140
t1i
160
t3i
130
x30
AV3
150
x10
AV3 , DV3
t3d
170
x30
x10
exemple\grafcet\synchro2.agn
Cette deuxième solution est un excellent exemple illustrant l’art de compliquer les
choses les plus simples à des fins pédagogiques.
1.6.7. Forçages de Grafcet
Le compilateur regroupe les étapes en fonction des liens qui sont établis entre
elles. Pour désigner un Grafcet, il suffit de faire référence à une des étapes
composant ce Grafcet.
On peut également désigner l’ensemble des Grafcets présents sur un folio
en mentionnant le nom du folio.
AUTOMGEN7
39
(C)opyright 2002 IRAI
Manuel de référence langage
Par exemple:
Pour désigner ce Grafcet nous parlerons du Grafcet 200, du Grafcet 201 ou
encore du Grafcet 202.
Le Grafcet en tant qu’ensemble d’étapes devient donc une variable de type
structurée, composée de n étapes, chacune de ces étapes, étant, soit active, soit
inactive.
Comme nous l’avons vu, AUTOMGEN divise les étapes en ensembles
indépendants. Ces ensembles peuvent être regroupés, ceci permet donc de les
considérer comme un seul Grafcet. Pour regrouper plusieurs Grafcets, il faut
utiliser la directive de compilation « #G:g1,g2 » (commande à inclure dans un
commentaire). Cette commande regroupe les Grafcets g1 et g2. Rappelons que la
désignation d’un Grafcet s’effectue en invoquant le numéro d’une de ses étapes.
Voyons un exemple :
#G:105,200
cette directive de compilation regroupe ces deux Grafcets :
Remarque : plusieurs directives « #G » peuvent être utilisées afin de regrouper
plus de deux Grafcets.
Nous allons maintenant détailler les ordres de forçage utilisables. Ils seront
simplement écrits dans des rectangles d’action comme des affectations
classiques. Ils supporteront également les opérateurs S(mise à un), R(mise à
AUTOMGEN7
40
(C)opyright 2002 IRAI
Manuel de référence langage
zéro), N(affectation complémentée) et I(inversion) ainsi que les actions
conditionnelles.
1.6.7.1. Forçage d’un Grafcet selon une liste d’étapes actives
Syntaxe:
« F<Grafcet>:{<liste d’étapes actives>} »
ou
« F/<nom de folio>:{<liste d’étapes actives>} »
Le ou les Grafcets ainsi désignés seront forcés à l’état défini par la liste des
étapes actives se trouvant entre accolades. Si plusieurs étapes doivent être
actives alors il faut les séparer par le caractère « , » (virgule). Si le ou les Grafcets
doivent être forcés à l’état vide (aucune étape active) alors aucune étape ne doit
être précisée entre les deux accolades.
Le numéro des étapes peut être précédé de « X ». On peut ainsi associer
un symbole au nom d’une étape.
Exemples :
« F10:{0} »
force toutes les étapes du Grafcet 10 à 0 sauf l’étape 0 qui sera forcée à 1.
« F0:{4,8,9,15} »
force toutes les étapes du Grafcet 0 à 0 sauf les étapes 4,8,9 et 15 qui seront
forcées à 1.
« F/marche normale :{} »
force tous les Grafcets se trouvant sur le folio « marche normale » à l’état vide.
1.6.7.2. Mémorisation de l’état d’un Grafcet
Etat actuel d’un Grafcet:
Syntaxe:
« G<Grafcet>:<N° de bit> »
ou
« G/<nom de folio>:<N° de bit> »
Cette commande mémorise l’état d’un ou plusieurs Grafcets dans une série de
bits. Il est nécessaire de réserver un espace au stockage de l’état du ou des
AUTOMGEN7
41
(C)opyright 2002 IRAI
Manuel de référence langage
Grafcets désignés (un bit par étape). Ces bits de stockage doivent être
consécutifs. Vous devez utiliser une commande #B pour réserver un espace
linéaire de bit.
Le numéro de l’étape désignant le Grafcet peut être précédé de « X » . On
peut ainsi associer un symbole au nom d’une étape. Le numéro du bit peut être
précédé de « U » ou de « B ». On peut ainsi associer un symbole au premier bit
de la zone de stockage d’état.
Etat particulier d’un Grafcet :
Syntaxe:
« G<Grafcet>:<N° de bit> {liste d’étapes actives} »
ou
« G/<nom de folio> :<N° de bit> {liste d’étapes actives} »
Cette commande mémorise l’état défini par la liste d’étapes actives appliquées
aux Grafcets spécifiés à partir du bit indiqué. Il est nécessaire ici aussi de réserver
un nombre suffisant de bits. Si une situation vide doit être mémorisée alors
aucune étape ne doit apparaître entre les deux accolades.
Le numéro des étapes peut être précédé de « X ». On peut ainsi associer
un symbole au nom d’une étape. Le numéro du bit peut être précédé de « U » ou
de « B ». On peut ainsi associer un symbole au premier bit de la zone de stockage
d’état.
Exemples:
« G0:100 »
mémorise l’état actuel du Grafcet 0 à partir de U100.
« G0:U200 »
mémorise l’état vide du Grafcet 0 à partir de U200.
« G10:150{1,2} »
mémorise l’état du Grafcet 10, dans lequel seules les étapes 1 et 2 sont actives, à
partir de U150.
« G/PRODUCTION :_SAUVE ETAT PRODUCTION_ »
mémorisé l’état des Grafcets se trouvant sur le folio « PRODUCTION » dans la
variable _SAUVE ETAT PRODUCTION_.
AUTOMGEN7
42
(C)opyright 2002 IRAI
Manuel de référence langage
1.6.7.3. Forçage d’un Grafcet à partir d’un état mémorisé
Syntaxe:
« F<Grafcet>:<N° de bit> »
ou
« F/<Nom de folio>:<N° de bit> »
Force le ou les Grafcets avec l’état mémorisé à partir du bit précisé.
Le numéro de l’étape désignant le Grafcet peut être précédé de ‘X’. On peut ainsi
associer un symbole au nom d’une étape. Le numéro du bit peut être précédé de
« U » ou de « B ». On peut ainsi associer un symbole au premier bit de la zone de
stockage d’état.
Exemple:
« G0:100 »
mémorise l’état actuel du Grafcet 0
« F0:100 »
et restaure cet état
1.6.7.4. Figeage d’un Grafcet
Syntaxe:
« F<Grafcet> »
ou
« F/<Nom de folio> »
Fige un ou des Grafcets : interdit toute évolution de ceux-ci.
Exemple :
« F100 »
fige le Grafcet 100
« F/production »
fige les Grafcets contenus dans le folio « production »
Illustrons les forçages par un exemple.
AUTOMGEN7
43
(C)opyright 2002 IRAI
Manuel de référence langage
Cahier des charges :
Reprenons un exemple déjà traité : aller et retour de deux locomotives sur les
voies 1 et 3 (cette fois sans attente entre les locomotives) et ajoutons le traitement
d’un arrêt d’urgence. Lorsque l’arrêt d’urgence est détecté toutes les sorties sont
remises à zéro. A la disparition de l’arrêt d’urgence le programme doit reprendre là
ou il s’était arrêté.
AUTOMGEN7
44
(C)opyright 2002 IRAI
Manuel de référence langage
Solution 1 :
#B104
réserve 4 bits pour la mémorisation de l'état des Grafcets
locomotive 1
locomotive 2
10
AV1
30
t1d
20
AV3
t3i
AV1 , DV1
40
t1i
AV3 , DV3
t3d
gestion de l'arrêt d'urgence
1000
arret urgence
1010
G10:100,G30:102
=1
1020
F10:{},F30:{}
arret urgence
1030
F10:100,F30:102
=1
exemple\grafcet\forçage1.agn
Notez l’utilisation de la directive #B104 qui permet de réserver quatre bits
consécutifs (U100 à U103) pour la mémorisation de l’état des deux Grafcets.
AUTOMGEN7
45
(C)opyright 2002 IRAI
Manuel de référence langage
« _arret urgence_ » a été associé à un bit (U1000). Son état peut donc être
modifié à partir de l’environnement en cliquant dessus lorsque la visualisation
dynamique est activée.
AUTOMGEN7
46
(C)opyright 2002 IRAI
Manuel de référence langage
Solution 2 :
#B104
réserve 4 bits pour la mémorisation de l'état des Grafcets
locomotive 1
locomotive 2
10
AV1
30
t1d
20
AV3
t3i
AV1 , DV1
40
t1i
AV3 , DV3
t3d
#G:10,30
gestion de l'arrêt d'urgence
1000
arret urgence
1010
G10:100
=1
1020
F10:{}
arret urgence
1030
F10:100
=1
exemple\grafcet\forçage2.agn
AUTOMGEN7
47
(C)opyright 2002 IRAI
Manuel de référence langage
Cette deuxième solution montre l’utilisation de la directive de compilation « #G »
qui permet de regrouper les Grafcets pour les commandes de forçages.
1.6.8. Macro-étapes
AUTOMGEN implémente les macro-étapes.
Donnons quelques rappels à ce sujet :
Une macro-étape ME est l’unique représentation d’un ensemble unique d’étapes
et de transitions nommé « expansion de ME ».
Une macro-étape obéit aux règles suivantes :
Ö l’expansion de ME comporte une étape particulière dite étape d’entrée et une
étape particulière dite étape de sortie.
Ö l’étape d’entrée a la propriété suivante : tout franchissement d’une transition
amont de la macro-étape, active l’étape d’entrée de son expansion.
Ö l’étape
de sortie a la propriété suivante : elle participe à la validation des
transitions aval de la macro-étape.
Ö en
dehors des transitions amont et aval de ME, il n’existe aucune liaison
structurale entre, d’une part une étape ou une transition de l’expansion ME, et
d’autre part, une étape ou une transition n’appartenant pas à ME.
L’utilisation des macro-étapes sous AUTOMGEN a été définie comme suit :
Ö l’expansion d’une macro-étape est un Grafcet se trouvant dans un folio distinct,
Ö l’étape d’entrée de l’expansion d’une macro-étape devra porter le numéro 0 ou
le repère Exxx, (avec xxx = un numéro quelconque),
Ö l’étape
de sortie de l’expansion d’une macro-étape devra porter le numéro
9999 ou le repère Sxxx, avec xxx = un numéro quelconque,
Ö en dehors de ces deux dernières obligations, l’expansion d’une macro-étape
peut être un Grafcet quelconque et pourra à ce titre contenir des macro-étapes
(l’imbrication de macro-étapes est possible).
1.6.8.1. Comment définir une macro-étape ?
Le symbole
doît être utilisé. Pour poser ce symbole, cliquez sur un
emplacement vide du folio et choisissez « Plus …/Macro-étape » dans le menu
contextuel. Pour ouvrir le menu contextuel, cliquez avec le bouton droit de la
souris sur le fond du folio.
AUTOMGEN7
48
(C)opyright 2002 IRAI
Manuel de référence langage
Pour définir l’expansion de la macro-étape, créez un folio, dessinez l’expansion et
modifier les propriétés du folio (en cliquant avec le bouton droit de la souris sur le
nom du folio dans le navigateur). Réglez le type du folio sur « Expansion de
macro-étapes » ainsi que le numéro de la macro-étape.
En mode exécution, il est possible de visualiser une expansion de macro-étape.
Pour cela, il faut placer le curseur sur la macro-étape et cliquer sur le bouton
gauche de la souris.
Remarques :
Ö les étapes et les bits Utilisateur utilisés dans une expansion de macro-étape
sont locaux, c’est à dire qu’ils n’ont aucun rapport avec les étapes et les bits
d’autres Grafcets. Tous les autres types de variables n’ont pas cette
caractéristique : ils sont communs à tous les niveaux.
Ö si une zone de bits doit être utilisée de façon globale alors il faut la déclarer
avec la directive de compilation « #B ».
Ö l’affectation
de variables non locales par différents niveaux ou différentes
expansions n’est pas gérée par le système. En d’autres termes, il faut utiliser
les affectations « S » « R » ou « I » afin de garantir un fonctionnement
cohérent du système.
Illustrons l’utilisation des macro-étapes par un exemple déjà traité : aller et retour
d’une locomotive sur la voie 1 avec attente en bout de voie. Nous décomposerons
l’aller et le retour en deux macro-étapes distinctes.
AUTOMGEN7
49
(C)opyright 2002 IRAI
Manuel de référence langage
Solution :
macro-étape aller voie 1
E1
10
S AV1 ,R DV1
t1d
20
R AV1
t0/x20/10s
S1
macro-étape retour voie 1
E2
10
S AV1 ,S DV1
t1i
20
R AV1
t1/x20/4s
S2
AUTOMGEN7
50
(C)opyright 2002 IRAI
Manuel de référence langage
0
=1
M1
=1
M2
=1
exemple\grafcet\macro-étape.agn
1.6.9. Compteurs
Illustrons l’utilisation des compteurs par un exemple.
Cahier des charges :
Une locomotive doit effectuer 10 allers et retours sur la voie 1, s’immobiliser
pendant quinze secondes et recommencer.
AUTOMGEN7
51
(C)opyright 2002 IRAI
Manuel de référence langage
Solution :
0
RC0
=1
1
AV1
t1d
2
AV1 , DV1
t1i
3
+C0
c0<10
c0=10
4
15s/x4
exemple\grafcet\compteur.agn
1.7. Gemma
AUTOMGEN implémente la description de Grafcet de gestion des modes de
marche sous forme de Gemma. Le principe retenu est un mode d’édition
transparent au mode Grafcet. Il est possible de passer du mode d’édition Grafcet
au mode d’édition Gemma. La traduction d’un Gemma en Grafcet de gestion des
modes de marche est donc automatique et immédiate.
C’est la commande « Editer sous la forme d’un Gemma » du menu « Boîte à
outils » qui permet de passer d’un mode à l’autre.
AUTOMGEN7
52
(C)opyright 2002 IRAI
Manuel de référence langage
P.C. HORS
ENERGIE
remise en route
A6 <Mise P.O. dans état initial>
_AV1_,_DV1_
ramÞne la locomotiv e Ó
gauche
_t1i _
PZ
arrêt
mise en ou hors serv ice
f onctionnement normal
A1 <Arrêt dans état initial>
_VOYANT INIT_
ArrÛt dans Útat initial
essais et v érif ications
F4 <Marches de v érif ication
dans le désordre>
_depart cycle_
=1
_fin de cycle obtenu_
A7 <Mise P.O. dans état
déterminé>
A4 <Arrêt obtenu>
F2 <Marches de
préparation>
F3 <Marches de
clôture>
PRODUCTION
A5 <Préparation pour remise en
route après déf aillance>
rien pour l'instant
A2 <Arrêt
demandé en
f in de
cy cle>
_FIN_
ArrÛt du
Graf cet de
production
F5 <Marches de v érif ication
dans l'ordre>
A3 <Arrêt
demandé
dans état
déterminé>
_fi n de cycl e_
/_arret urgence_
D2 <Diagnostic et/ou
traitement de
déf aillance>
F1 <Production normale>
_DEPART_
Lancement du Graf cet de productio
D3 <Production tout de même>
F6 <Marches de test>
PRODUCTION
PRODUCTION
_arret urgence_
D1 <Marche ou arrêt en v ue d'assurer la sécurité>
F_GFN_:{}
RAZ du Graf cet de production
f onctionnement normal
essais et v érif ications
P.C. HORS
ENERGIE
Arrêt dans état initial
0
#L"gemma2"
VOYANT INIT
gemma1.gr7
Ç depart cycle
exemple de la notice d'AUTOMGEN
(C)opyright 1997 IRAI
05/03/1994
Lancement du Grafcet de productio
1
DEPART
RAZ du Grafcet de production
fin de cycle
5
F GFN :{}
Arrêt du Grafcet de production
2
FIN
arret urgence
fin de cycle obtenu
rien pour l'instant
6
=1
ramène la locomotive à gauche
7
AV1 , DV1
t1i
AUTOMGEN7
53
(C)opyright 2002 IRAI
Manuel de référence langage
1.7.1. Création d’un Gemma
Pour créer un Gemma il faut :
Ö cliquez sur l’élément « Folio » du navigateur avec le bouton droit de la souris
sélectionner la commande « Ajouter un nouveau folio »,
Ö dans la liste des tailles choisir « Gemma »,
Ö cliquer sur le bouton poussoir « OK »,
Ö cliquez avec le bouton droit de la souris sur le nom du folio ainsi créé dans le
navigateur,
Ö choisissez « Propriétés » dans le menu,
Ö cochez la case « Afficher sous la forme d’un Gemma ».
La fenêtre contient alors un Gemma dont tous les rectangles et tous les liens sont
grisés. Pour valider un rectangle ou une liaison il faut cliquer dessus avec le
bouton droit de la souris.
Pour modifier le contenu d’un rectangle ou la nature d’une liaison il faut cliquer
dessus avec le bouton gauche de la souris.
Le contenu des rectangles du Gemma sera placé dans des rectangles d’action du
Grafcet. La nature des liaisons sera placée dans les transitions du Grafcet.
Un commentaire peut être associé à chaque rectangle du Gemma, il apparaîtra à
proximité du rectangle d’action correspondant dans le Grafcet.
1.7.2. Contenu des rectangles du Gemma
Les rectangles du Gemma peuvent recevoir n’importe quelle action utilisable dans
le Grafcet. Comme il s’agit de définir une structure de gestion des modes d’arrêt et
de marche, il parait judicieux d’utiliser des ordres de forçage vers des Grafcets de
plus bas niveau voir le chapitre 1.6.7. Forçages de Grafcet.
1.7.3. Obtenir un Grafcet correspondant
C’est encore la case à cocher « Afficher sous la forme d’un Gemma » dans les
propriétés du folio qui permet de revenir à une représentation Grafcet. Il est
possible de revenir à tout moment à une représentation Gemma tant que la
structure du Grafcet n’a pas été modifiée. Les transitions, le contenu des
AUTOMGEN7
54
(C)opyright 2002 IRAI
Manuel de référence langage
rectangles d’action et les commentaires peuvent être modifiés avec une mise à
jour automatique du Gemma.
1.7.4. Annuler les espaces vides dans le Grafcet
Il est possible que le Grafcet obtenu occupe plus d’espace que nécessaire sur la
page. La commande « Réorganiser la page » du menu « Outils » permet de
supprimer tous les espaces non utilisés.
1.7.5. Imprimer le Gemma
Quand l’édition est en mode Gemma c’est la commande « Imprimer » qui permet
d’imprimer le Gemma.
1.7.6. Exporter le Gemma
La commande « Copier au format EMF » du menu « Edition » permet d’exporter
un Gemma au format vectoriel.
1.7.7. Exemple de Gemma
Illustrons l’utilisation du Gemma.
Cahier des charges :
Imaginons un pupitre composé des boutons poussoirs suivants : « départ cycle »,
« fin de cycle » et « arrêt d’urgence » et d’un voyant « INIT ».
Le programme principal consistera à faire effectuer des allers et retours à une
locomotive sur la voie 1.
AUTOMGEN7
55
(C)opyright 2002 IRAI
Manuel de référence langage
Solution :
P.C. HORS
ENERGIE
remise en route
A6 <Mise P.O. dans état initial>
_AV1_,_DV1_
ramÞne la locomotiv e Ó
gauche
_t1i _
PZ
arrêt
essais et v érif ications
mise en ou hors serv ice
f onctionnement normal
A1 <Arrêt dans état initial>
_VOYANT INIT_
ArrÛt dans Útat initial
F4 <Marches de v érif ication
dans le désordre>
_depart cycle_
=1
_fin de cycle obtenu_
A7 <Mise P.O. dans état
déterminé>
A4 <Arrêt obtenu>
F2 <Marches de
préparation>
F3 <Marches de
clôture>
PRODUCTION
A5 <Préparation pour remise en
route après déf aillance>
rien pour l'instant
A2 <Arrêt
demandé en
f in de
cy cle>
_FIN_
ArrÛt du
Graf cet de
production
F5 <Marches de v érif ication
dans l'ordre>
A3 <Arrêt
demandé
dans état
déterminé>
F1 <Production normale>
_DEPART_
Lancement du Graf cet de productio
_fi n de cycl e_
/_arret urgence_
D2 <Diagnostic et/ou
traitement de
déf aillance>
D3 <Production tout de même>
F6 <Marches de test>
PRODUCTION
PRODUCTION
_arret urgence_
D1 <Marche ou arrêt en v ue d'assurer la sécurité>
F_GFN_:{}
RAZ du Graf cet de production
f onctionnement normal
essais et v érif ications
P.C. HORS
ENERGIE
AUTOMGEN7
56
(C)opyright 2002 IRAI
Manuel de référence langage
Arrêt dans état initial
0
VOYANT INIT
Ç depart cycle
Lancement du Grafcet de produ
1
ctio
DEPART
RAZ du Grafcet de production
fin de cycle
Arrêt du Grafcet de productio
2
5
F GFN :{}
n
FIN
arret urgence
fin de cycle obtenu
rien pour l'instant
6
=1
ramène la locomotive à gauche
7
AV1 , DV1
t1i
arret urgence
22
F5:(5)
(édité sous la forme d’un Grafcet)
AUTOMGEN7
57
(C)opyright 2002 IRAI
Manuel de référence langage
Ç depart
100
AV1
t1d
110
AV1 , DV1
t1i .
fin
t1i . fin
120
FIN DE CYCLE OBTENU
fin de cycle obtenu
exemple\gemma\gemma.agn
1.8. Ladder
Le langage Ladder, également appelé « schéma à contact », permet de décrire
graphiquement des équations booléennes. Pour réaliser une fonction logique
« Et », il faut écrire des contacts en série. Pour écrire une fonction « Ou », il faut
écrire des contacts en parallèle.
Fonction « Et »
Fonction « Ou »
Le contenu des contacts doit respecter la syntaxe définie pour les tests et détaillée
dans le chapitre « Eléments communs » de ce manuel.
AUTOMGEN7
58
(C)opyright 2002 IRAI
Manuel de référence langage
Le contenu des bobines doit respecter la syntaxe définie pour les actions, elle
aussi détaillée dans le chapitre « Eléments communs » de ce manuel.
1.8.1. Exemple de Ladder
Commençons par l’exemple le plus simple.
Cahier des charges :
Aller et retour d’une locomotive sur la voie 1.
Solution 1 :
AV1
Ç t1i
R DV1
Ç t1d
S DV1
exemple\ladder\ladder1.agn
Solution 2 :
AV1
t1i
dv1
DV1
t1d
exemple\ladder\ladder2.agn
Cette deuxième solution est identique d’un point de vue fonctionnel. Son intérêt
est de montrer l’utilisation d’une variable en auto maintien.
Enrichissons notre exemple.
Cahier des charges :
La locomotive devra s’arrêter 10 secondes à droite de la voie 1 et 4 secondes à
gauche.
AUTOMGEN7
59
(C)opyright 2002 IRAI
Manuel de référence langage
Solution :
t1d
T0(10S)
S DV1
t1i
T1(4S)
R DV1
t1i
t1d
AV1
t0
t1
exemple\ladder\ladder3.agn
Un dernier exemple un peu plus complexe.
Cahier des charges :
Toujours une locomotive qui fait des allers et retours sur la voie 1. Tous les 10
allers et retours elle devra marquer un temps d’arrêt de 15 secondes.
Solution :
b0
RC0
t0
t1d
dv1
+C0
S DV1
t1i
R DV1
c0<10
AV1
t0
c0=10
T0(15S)
exemple\ladder\ladder4.agn
1.9. Logigramme
AUTOMGEN implémente le langage logigramme de la façon suivante :
AUTOMGEN7
60
(C)opyright 2002 IRAI
Manuel de référence langage
Ö utilisation
d’un bloc spécial nommé « bloc d’affectation », ce bloc sépare la
zone d’action de la zone test, il a la forme suivante
et est associé à la
touche [0] (zéro),
Ö utilisation des fonctions « Pas », « Et » et « Ou »,
Ö utilisation de rectangles d’action à droite du bloc d’action.
Le langage logigramme permet d’écrire graphiquement des équations booléennes.
Le contenu des tests doit respecter la syntaxe définie dans le chapitre « Eléments
communs » de ce manuel.
Le contenu des rectangles d’action doit respecter la syntaxe définie pour les
actions et détaillée dans le chapitre « Eléments communs » de ce manuel.
Zone « test »
Bloc
d’affectation
pour délimiter la
zone test de la
zone action
Zone « action »
1.9.1. Dessin des logigrammes
1.9.1.1. Nombre d’entrées des fonctions « Et » et « Ou »
Les fonctions « Et » et « Ou » se composent respectivement d’un bloc
(touche [2]) ou d’un bloc
(touche [3]), éventuellement de blocs
[4]) pour ajouter des entrées aux blocs et en fin d’un bloc
(touche
(touche [5]).
Les fonctions « Et » et « Ou » comportent donc un minimum de deux entrées.
AUTOMGEN7
61
(C)opyright 2002 IRAI
Manuel de référence langage
1.9.1.2. Enchaînement des fonctions
Les fonctions peuvent être chaînées.
1.9.1.3. Actions multiples
Plusieurs rectangles d’action peuvent être associés à un logigramme après le bloc
d’affectation.
ou
1.9.2. Exemple de logigramme
Commençons par l’exemple le plus simple.
Cahier des charges :
Aller et retour d’une locomotive sur la voie 1.
Solution 1 :
=1
AV1
Ç t1d
S DV1
Ç t1i
R DV1
exemple\logigramme\logigramme1.agn
AUTOMGEN7
62
(C)opyright 2002 IRAI
Manuel de référence langage
Solution 2 :
=1
AV1
t1d
DV1
dv1
t1i
&
O
exemple\logigramme\logigramme2.agn
Cette deuxième solution est identique d’un point de vue fonctionnel. Son intérêt
consiste à montrer l’utilisation d’une variable en auto maintien.
Enrichissons notre exemple.
Cahier des charges :
La locomotive devra s’arrêter 10 secondes à droite de la voie 1et 4 secondes à
gauche.
Solution :
t1d
T0(10S)
S DV1
t1i
T1(4S)
R DV1
t0
AV1
t1
O &
O
exemple\logigramme\logigramme3.agn
Notez le repiquage du bloc « Et » du bas de l’exemple vers les entrées « _t1d_ »
et « _t1i_ ». Cela évite d’avoir à écrire une deuxième fois ces deux tests.
AUTOMGEN7
63
(C)opyright 2002 IRAI
Manuel de référence langage
Un dernier exemple un peu plus complexe.
Cahier des charges :
Toujours une locomotive qui fait des allers et retours sur la voie 1. Tous les 10
allers et retours, elle devra marquer un temps d’arrêt de 15 secondes.
Solution :
b0
RC0
t0
t1d
dv1
&
+C0
O
S DV1
t1i
R DV1
c0<10
AV1
t0
c0=10
T0(15S)
exemple\logigramme\logigramme4.agn
AUTOMGEN7
64
(C)opyright 2002 IRAI
Manuel de référence langage
1.10. Langages littéraux
Ce chapitre décrit l’utilisation les trois formes de langages littéraux disponibles
dans AUTOMGEN :
Ö le langage littéral bas niveau,
Ö le langage littéral étendu,
Ö le langage littéral ST de la norme CEI 1131-3.
1.10.1. Comment utiliser le langage littéral ?
Le langage littéral peut être utilisé sous la forme suivante :
Ö fichier de code associé à une action (Grafcet, Ladder, logigramme),
Ö boîte de code associée à une action (Grafcet, logigramme),
Ö code littéral dans un rectangle d’action ou une bobine (Grafcet,
Ladder,
logigramme),
Ö boîte
de code utilisée sous forme d’organigramme (consultez le chapitre
« Organigramme »),
Ö fichier de code régissant le fonctionnement d’un bloc fonctionnel (consultez le
chapitre « Blocs fonctionnels »),
Ö fichier
de code régissant le fonctionnement d’une macro-instruction voir
chapitre 1.10.4. Macro-instruction.
1.10.1.1. Boîte de code associée à une étape ou un logigramme
Une boîte de code associée à une action permet d’écrire quelques lignes de
langage littéral au sein d’une page de l’application.
Exemples :
AUTOMGEN7
65
(C)opyright 2002 IRAI
Manuel de référence langage
Le code ainsi utilisé est scruté tant que l’action est vraie.
Il est possible d’utiliser conjointement des rectangles d’action et des boîtes de
code.
Exemple :
1.10.1.2. Code littéral dans un rectangle d’action ou une bobine
Les caractères « { » et « } » permettent d’insérer directement des instructions en
langage littéral dans un rectangle d’action (langages Grafcet et logigramme) ou
une bobine (langage ladder). Le caractère « , » (virgule) est utilisé comme
séparateur si plusieurs instructions sont présentes entre « { » et « } ».
Ce type d’insertion peut être utilisé avec des ordres conditionnés.
Exemples :
1.10.2. Définition d’une boîte de code
Pour dessiner une boîte de code, suivez les étapes suivantes :
Ö cliquez avec le bouton droit de la souris sur un emplacement vide du folio,
AUTOMGEN7
66
(C)opyright 2002 IRAI
Manuel de référence langage
Ö choisissez dans le menu « Plus … / Boîte de code »,
Ö cliquez sur le bord de la boîte de code pour modifier son contenu.
Pour sortir de la boîte après modification, utilisez la touche [Enter] ou cliquez à
l’extérieur.
1.10.3. Le langage littéral bas niveau
Ce chapitre détaille l’utilisation du langage littéral bas niveau. Ce langage est un
code intermédiaire entre les langages évolués Grafcet, logigramme, ladder,
organigramme, blocs fonctionnels, littéral étendu, littéral ST et les langages
exécutables. Il est également connu sous le nom de code pivot. Ce sont les postprocesseurs qui traduisent le langage littéral bas niveau en code exécutable pour
PC, automate ou carte à microprocesseur.
Le langage littéral peut également être utilisé au sein d’une application pour
effectuer divers traitements booléens, numériques ou algorithmiques.
Le langage littéral bas niveau est un langage de type assembleur. Il utilise une
notion d’accumulateur pour les traitements numériques.
Le langage littéral étendu et le langage littéral ST décrits dans les chapitres
suivants, offrent une alternative simplifiée et de plus haut niveau pour l’écriture de
programmes en langage littéral.
Syntaxe générale d’une ligne de langage littéral bas niveau :
«action » [[ [« Test »] « Test » ]...]
Les actions et les tests du langage littéral bas niveau sont représentés par des
mnémoniques formés de trois caractères alphabétiques. Une instruction est
toujours suivie d’une expression : variable, constante, etc...
Une ligne est composée d’une seule action et éventuellement d’un test. Si une
ligne comporte uniquement une action, alors par convention l’instruction sera
toujours exécutée.
1.10.3.1. Les variables
Les variables utilisables sont les mêmes que celles définies dans le chapitre
« Eléments communs ».
AUTOMGEN7
67
(C)opyright 2002 IRAI
Manuel de référence langage
1.10.3.2. Les accumulateurs
Certaines instructions utilisent la notion d’accumulateur. Les accumulateurs sont
des registres internes au système qui exécute le programme final et permettent
d’accueillir temporairement des valeurs.
Il existe trois accumulateurs : un accumulateur entier 16 bits noté AAA, un
accumulateur entier 32 bits noté AAL et un accumulateur flottant noté AAF.
1.10.3.3. Les drapeaux
Les drapeaux sont des variables booléennes positionnées en fonction du résultat
des opérations numériques.
Il y a quatre drapeaux permettant de tester le résultat d’un calcul. Ces quatre
indicateurs sont :
Ö indicateur de retenue C : il indique si une opération a engendré une retenue (1)
ou n’a pas engendré de retenue (0),
Ö indicateur de zéro Z : il indique si une opération a engendré un résultat nul (1)
ou non nul (0),
Ö indicateur de signe S : il indique si une opération a engendré un résultat négatif
(1) ou positif (0),
Ö indicateur
de débordement O : il indique si une opération a généré un
dépassement de capacité (1).
1.10.3.4. Modes d’adressage
Le langage littéral bas niveau possède 5 modes d’adressage. Un mode
d’adressage est une caractéristique associée à chacune des instructions du
langage littéral.
Les modes d’adressage utilisables sont :
TYPE
SYNTAXE
EXEMPLE
Immédiat 16 bits
{constante}
100
Immédiat 32 bits
{constante}L
100000L
Immédiat flottant
{constante}R
3.14R
Absolu
{variable} {repère de variable}
O540
Accumulateur 16 bits
AAA
AAA
Accumulateur 32 bits
AAL
AAL
AUTOMGEN7
68
(C)opyright 2002 IRAI
Manuel de référence langage
Accumulateur flottant
AAF
AAF
Indirect
{variable}{(repère de mot)}
O(220)
Label
:{nom de label} :
:boucle:
Une instruction possède donc deux caractéristiques : le type de variable et le
mode d’adressage. Certaines instructions supportent ou ne supportent pas
certains modes d’adressage ou certains types de variables. Par exemple une
instruction pourra s’appliquer uniquement à des mots et pas aux autres types de
variables.
Remarque : Les variables X et U ne peuvent être associées à un adressage
indirect du fait de la non linéarité de leurs affectations. Si toutefois il est nécessaire
d’accéder à un tableau de variables U, alors il faut utiliser une directive de
compilation #B pour déclarer une table de bits linéaires.
1.10.3.5. Les tests
Les tests pouvant être associés aux instructions sont composés d’un
mnémonique, d’un type de test et d’une variable.
Les mnémoniques de tests permettent de définir des tests combinatoires sur
plusieurs variables (et, ou). Si un test est composé d’une seule variable, un
opérateur AND doit quand même lui être associé.
Il existe seulement trois mnémoniques de test :
AND et
ORR ou
EOR fin de ou
Voici quelques exemples d’équivalences entre des équations booléennes et le
langage littéral bas niveau :
o0=i1
: and i1
o0=i1.i2
: and i1 and i2
o0=i1+i2
: orr i1 eor i2
o0=i1+i2+i3+i4
: orr i1 orr i2 orr i3 eor i4
o0=(i1+i2).(i3+i4)
: orr i1 eor i2 orr i3 eor i4
o0=i1.(i2+i3+i4)
: and i1 orr i2 orr i3 eor i4
o0=(i1.i2)+(i3.i4)
; impossible à traduire directement,
; il faut utiliser des
; variables intermédiaires :
AUTOMGEN7
69
(C)opyright 2002 IRAI
Manuel de référence langage
equ u100 and i1 and i2
equ u101 and i3 and i4
equ o0 orr u100 eor u101
Les modificateurs de tests permettent de tester autre chose que l’état vrai d’une
variable :
Ö
Ö
Ö
Ö
/
pas
#
front montant
*
front descendant
@
état immédiat
Remarques :
Ö les variables booléennes sont rafraîchies après chaque cycle d’exécution. En
d’autres termes, si une variable binaire est positionnée à un état au cours d’un
cycle, alors son nouvel état sera réellement reconnu au cycle suivant. Le
modificateur de test @ permet d’obtenir l’état réel d’une variable booléenne
sans attendre le cycle suivant.
Ö les modificateurs de tests ne sont pas utilisables avec les tests numériques.
Exemples:
set o100
equ o0 and @o100
; test vrai dès le premier cycle
equ o1 and o100
; test vrai au deuxième cycle
Pour les tests, seuls deux modes d’adressage sont disponibles : le mode absolu et
le mode indirect.
Un test sur compteurs, sur mots, sur longs et sur flottants est disponible :
Syntaxe :
« {variable} {=, !, <, >, << , >>} {constante ou variable} »
= signifie égal,
! signifie différent,
< signifie inférieur non signé,
> signifie supérieur non signé,
AUTOMGEN7
70
(C)opyright 2002 IRAI
Manuel de référence langage
<< signifie inférieur signé,
>> signifie supérieur signé,
Les constantes sont écrites par défaut en décimal. Les suffixes « $ » et « % »
permettent de les écrire en hexadécimal ou en binaire. Les guillemets permettent
de les écrire en ASCII.
Les constantes 32 bits doivent être suivies du caractère « L ».
Les constantes réelles doivent être suivies du caractère « R ».
Un mot ou un compteur peut être comparé avec un mot, un compteur ou une
constante 16 bits.
Un long peut être comparé avec un long ou une constante 32 bits.
Un flottant peut être comparé avec un flottant ou une constante réelle.
Exemples :
and c0>100 and m225=10
orr m200=m201 eor m202=m203 and f100=f101 and f200<f203
orr m200<<-100 eor m200>>200
and f200=3.14r
and l200=$12345678L
and m200=%1111111100000000
1.10.3.6. Commentaires
Les commentaires doivent débuter par le caractère « ; » (point virgule), tous les
caractères venant à la suite sont ignorés.
1.10.3.7. Base de numérotation
Les valeurs (repères de variables ou constantes) peuvent être écrites en décimal,
hexadécimal, binaire ou en ASCII.
La syntaxe suivante doit être appliquée pour les constantes 16 bits :
Ö décimal : éventuellement le caractère « - » puis 1 à 5 digits « 0123456789 »,
Ö hexadécimal : le préfixe « $ » ou « 16# » suivi de 1 à 4 digits
« 0123456789ABCDEF »,
Ö binaire : le préfixe « % » ou « 2# » suivi de 1 à 16 digits « 01 »,
Ö ASCII : le caractère « " » suivi de 1 ou 2 caractères suivis de « " ».
La syntaxe suivante doit être appliquée pour les constantes 32 bits :
AUTOMGEN7
71
(C)opyright 2002 IRAI
Manuel de référence langage
Ö Décimal : éventuellement le caractère « - » puis 1 à 10 digits « 0123456789 »,
Ö Hexadécimal : le préfixe « $ » ou « 16# » suivi de 1 à 8 digits
« 0123456789ABCDEF »,
Ö Binaire : le préfixe « % » ou « 2# » suivi de 1 à 32 digits « 01 »,
Ö ASCII : le caractère « " » suivi de 1 à 4 caractères suivis de « " ».
La syntaxe suivante doit être appliquée pour les constantes réelles :
[-] i [[.d] Esx]
i est la partie entière
d une éventuelle partie décimale
s éventuellement le signe de l’exposant
x éventuellement l’exposant
1.10.3.8. Prédispositions
Une prédisposition permet de fixer la valeur d’une variable au démarrage de
l’application.
Les variables T ou %T, M ou %MW, L ou %MD et F ou %F peuvent être
prédisposées.
La syntaxe est la suivante :
« $(variable)=constante{,constante{,constante...}} »
Pour les temporisations la valeur doit être écrite en décimal et comprise entre 0 et
65535.
Pour les mots la syntaxe suivante doit être utilisée :
Ö Décimal
: éventuellement le caractère « - » puis 1 à 5 digits
« 0123456789 »,
Ö Hexadécimal
: le préfixe « $ » ou « 16# » suivi de 1 à 4 digits
« 0123456789ABCDEF »,
Ö Binaire : le préfixe « % »
AUTOMGEN7
ou « 2# » suivi de 1 à 16 digits « 01 »,
72
(C)opyright 2002 IRAI
Manuel de référence langage
Ö ASCII
: (deux caractères par mot) le caractère « " » suivi de n
caractères suivis de « " »,
Ö ASCII : (un caractère par mot) le caractère « ’ » suivi de n caractères
suivis de « ’ ».
Pour les longs la syntaxe suivante doit être utilisée :
Ö Décimal : éventuellement le caractère « - » puis 1 à 10 digits « 0123456789 »,
Ö Hexadécimal : le préfixe « $ » ou « 16# » suivi de 1 à 8 digits
« 0123456789ABCDEF »,
Ö Binaire : le caractère « % » ou « 2# » suivi de 1 à 32 digits « 01 »,
Ö ASCII : (quatre caractères par long) le caractère « " » suivi de n
caractères
suivis de « " »,
Ö ASCII : (un caractère par long) le caractère « ’ » suivi de n caractères suivis de
«’»
Pour les flottants, la valeur doit être écrite sous la forme :
[-] i [[.d] Esx]
i est la partie entière
d une éventuelle partie décimale
s éventuellement le signe de l’exposant
x éventuellement l’exposant
Exemples :
$t25=100
fixe la consigne de la temporisation 25 à 10 s
$MW200=100,200,300,400
place les valeurs 100,200,300,400 dans les mots 200, 201, 202, 203
$m200="ABCDEF"
place la chaîne de caractères « ABCDEF » à partir de m200 (« AB » dans m200,
« CD » dans m201, « EF » dans m202)
$m200=‘ABCDEF’
place la chaîne de caractères « ABCDEF » à partir de m200, chaque mot reçoit un
caractère.
$f1000=3.14
place la valeur 3,14 dans f1000
AUTOMGEN7
73
(C)opyright 2002 IRAI
Manuel de référence langage
$%mf100=5.1E-15
place la valeur 5,1 * 10 exposant -15 dans %mf100
$l200=16#12345678
place la valeur 12345678 (hexa) dans le long l200
Il est possible d’écrire plus facilement du texte dans les prédispositions.
Exemple :
$m200=" Arrêt de la vanne N°10 "
Place le message à partir du mot 200 en plaçant deux caractères dans chaque
mot.
$m400=‘ Défaut moteur ‘
Place le message à partir du mot 400 en plaçant un caractère dans l’octet de
poids faibles de chaque mot, l’octet de poids fort contient 0.
La syntaxe « $...= » permet de poursuivre une table de prédispositions à la suite
de la précédente.
Par exemple :
#$m200=1,2,3,4,5
#$...=6,7,8,9
Place les valeurs de 1 à 9 dans les mots m200 à m208.
Les prédispositions peuvent être écrites de la même façon que le langage littéral
bas niveau ou dans une directive de compilation dans un folio. Dans ce cas, la
prédisposition commence par le caractère « # ».
Exemple de prédisposition écrite dans une boîte de code :
Exemple de prédisposition écrite dans une directive de compilation :
AUTOMGEN7
74
(C)opyright 2002 IRAI
Manuel de référence langage
1.10.3.9. Adressage indirect
L’adressage indirect permet d’effectuer une opération sur une variable pointée par
un index.
Ce sont les variables M (les mots) qui servent d’index.
Syntaxe :
« variable ( index ) »
Exemple :
lda 10
; charge 10 dans l’accumulateur
sta m200
; le place dans le mot 200
set o(200)
; mise à un de la sortie pointée par le mot 200 (o10)
1.10.3.10. Adresse d’une variable
Le caractère « ? » permet de spécifier l’adresse d’une variable.
Exemple :
lda ?o10
; place la valeur 10 dans l’accumulateur
Cette syntaxe est surtout intéressante si des symboles sont utilisés.
Exemple :
lda ?_vanne_
; place dans l’accumulateur le numéro de la variable
; associée au symbole « _vanne_ »
Cette syntaxe peut également être utilisée dans les prédispositions pour créer des
tables d’adresses de variables.
Exemple :
$m200=?_vanne1_,?_vanne2_,?_vanne3_
1.10.3.11. Sauts et labels
Les sauts doivent faire référence à un label. La syntaxe d’un label est :
« :nom du label: »
Exemple :
jmp :suite:
...
:suite:
AUTOMGEN7
75
(C)opyright 2002 IRAI
Manuel de référence langage
1.10.3.12. Liste des fonctions par type
1.10.3.12.1. Fonctions booléennes
SET
mise à un
RES
mise à zéro
INV
inversion
EQU
équivalence
NEQ
non-équivalence
1.10.3.12.2. Fonctions de chargement et de stockage sur entiers et flottants
LDA
chargement
STA
stockage
1.10.3.12.3. Fonctions arithmétiques sur entiers et flottants
ADA
addition
SBA
soustraction
MLA
multiplication
DVA
division
CPA
comparaison
1.10.3.12.4. Fonctions arithmétiques sur flottants
ABS
valeur absolue
SQR
racine carrée
1.10.3.12.5. Fonctions d’accès aux ports d’entrées/sorties sur PC
AIN
lecture d’un port
AOU
écriture d’un port
1.10.3.12.6. Fonctions d’accès à la mémoire sur PC
ATM
lecture d’une adresse mémoire
MTA
écriture d’une adresse mémoire
1.10.3.12.7. Fonctions binaires sur entiers
ANA
et bit à bit
ORA
ou bit à bit
XRA
ou exclusif bit à bit
TSA
test bit à bit
AUTOMGEN7
76
(C)opyright 2002 IRAI
Manuel de référence langage
SET
mise à un de tous les bits
RES
mise à zéro de tous les bits
RRA
décalage à droite
RLA
décalage à gauche
1.10.3.12.8. Autres fonctions sur entiers
INC
incrémentation
DEC
décrémentation
1.10.3.12.9. Fonctions de conversion
ATB
entier vers booléens
BTA
booléens vers entier
FTI
flottant vers entier
ITF
entier vers flottant
LTI
entier 32 bits vers entier 16 bits
ITL
entier 16 bits vers entier 32 bits
AUTOMGEN7
77
(C)opyright 2002 IRAI
Manuel de référence langage
1.10.3.12.10. Fonctions de branchement
JMP
saut
JSR
saut à un sous-programme
RET
retour de sous-programme
1.10.3.12.11. Fonctions de test
RFZ
flag de résultat nul
RFS
flag de signe
RFO
flag de débordement
RFC
flag de retenue
1.10.3.12.12. Fonctions d’accès asynchrones aux entrées sorties
RIN
lecture des entrées
WOU
écriture des sorties
1.10.3.12.13. Informations contenues dans la liste des fonctions
Pour chaque instruction sont donnés :
Ö Nom : le mnémonique.
Ö Fonction : une description de la fonction réalisée par l’instruction.
Ö Variables : les types de variables utilisables avec l’instruction.
Ö Adressage : les types d’adressages utilisables.
Ö Voir aussi : les autres instructions ayant un rapport avec ce mnémonique.
Ö Exemple : un exemple d’utilisation.
Les post-processeurs qui génèrent des langages constructeurs sont soumis à
certaines restrictions. Consultez les notices relatives à ces post-processeurs pour
avoir le détail de ces restrictions.
AUTOMGEN7
78
(C)opyright 2002 IRAI
Manuel de référence langage
ABS
Nom
:
ABS - abs accumulator
Fonction
:
calcule la valeur absolue de l’accumulateur flottant
Variables
:
aucune
Adressage
:
accumulateur
Voir aussi
:
SQR
Exemple
:
lda f200
abs aaf
sta f201
; laisse dans f201 la valeur absolue de f200
AUTOMGEN7
79
(C)opyright 2002 IRAI
Manuel de référence langage
ADA
Nom
:
ADA - adds accumulator
Fonction
:
ajoute une valeur à l’accumulateur
Variables
:
M ou %MW, L ou %MD, F ou %MF
Adressage
:
absolu, indirect, immédiat
Voir aussi
:
SBA
Exemple
:
ada 200
; ajoute 200 à l’accumulateur 16 bits
ada f124
; ajoute le contenu de f124 à l’accumulateur flottant
ada l200
; ajoute le contenu de l200 à l’accumulateur 32 bits
ada 200L
; ajoute 200 à l’accumulateur 32 bits
ada 3.14R
; ajoute 3.14 à l’accumulateur flottant
AUTOMGEN7
80
(C)opyright 2002 IRAI
Manuel de référence langage
AIN
Nom
:
AIN - accumulator input
Fonction
:
lecture d’un port d’entrée (8 bits) et stockage dans
la partie basse de l’accumulateur 16 bits ;
lecture d’un port d’entrée 16 bits et stockage dans
l’accumulateur 16 bits (dans ce cas l’adresse du port doit être
écrite sous la forme d’une constante 32 bits)
utilisable seulement avec l’exécuteur PC
Variables
:
M ou %MW
Adressage
:
indirect, immédiat
Voir aussi
:
AOU
Exemple
:
ain $3f8
; lecture du port $3f8 (8 bits)
ain $3f8l
; lecture du port $3f8 (16 bits)
AUTOMGEN7
81
(C)opyright 2002 IRAI
Manuel de référence langage
ANA
Nom
:
ANA - and accumulator
Fonction
:
effectue un ET logique entre l’accumulateur 16 bits
et un mot ou une constante ou l’accumulateur 32 bits et
un long ou une constante
Variables
:
M ou %MW, L ou %MD
Adressage
:
absolu, indirect, immédiat
Voir aussi
:
ORA, XRA
Exemple
:
ana %1111111100000000
; masque les 8 bits de poids faible de
; l’accumulateur 16 bits
ana $ffff0000L
; masque les 16 bits de poids faibles de l’accumulateur 32 bits
AUTOMGEN7
82
(C)opyright 2002 IRAI
Manuel de référence langage
AOU
Nom
:
AOU - accumulator output
Fonction
:
transfère la partie basse (8 bits) du contenu de
l’accumulateur 16 bits sur un port de sortie ;
transfère les 16 bits de l’accumulateur 16 bits
sur un port de sortie (sans ce cas l’adresse du port doit être
écrite sous la forme d’une constante 32 bits)
utilisable seulement avec l’exécuteur PC
Variables
:
M ou %MW
Adressage
:
indirect, immédiat
Voir aussi
:
AIN
Exemple
:
lda "A"
aou $3f8
; place le caractère « A » sur le port de sortie $3f8
lda $3f8
sta m200
lda "z"
aou m(200)
; place le caractère « z » sur le port de sortie $3f8
lda $1234
aou $300l
; place la valeur 16 bits 1234 sur le port de sortie $300
AUTOMGEN7
83
(C)opyright 2002 IRAI
Manuel de référence langage
ATB
Nom
:
ATB - accumulator to bit
Fonction
:
transfère les 16 bits de l’accumulateur 16 bits
vers 16 variables booléennes successives ; le
bit de poids faible correspond à la première
variable booléenne
Variables
:
I ou %I, O ou %Q, B ou %M, T ou %T, U*
Adressage
:
absolu
Voir aussi
:
BTA
Exemple
:
lda m200
atb o0
; recopie les 16 bits de m200 dans les variables
; o0 à o15
*
Attention : pour pouvoir utiliser les bits U avec cette fonction il faut réaliser une table linéaire de
bits avec la directive de compilation #B.
AUTOMGEN7
84
(C)opyright 2002 IRAI
Manuel de référence langage
ATM
Nom
:
ATM - accumulator to memory
Fonction
:
transfère l’accumulateur 16 bits à une adresse
mémoire ; le mot ou la constante spécifié
défini l’offset de l’adresse mémoire à
atteindre, le mot m0 doit être chargé avec la
valeur du segment de l’adresse mémoire à
atteindre ; utilisable seulement avec l’exécuteur PC
Variables
:
M ou %MW
Adressage
:
indirect, immédiat
Voir aussi
:
MTA
Exemple
:
lda $b800
sta m0
lda 64258
atm $10
; place la valeur 64258 à l’adresse $b800:$0010
AUTOMGEN7
85
(C)opyright 2002 IRAI
Manuel de référence langage
BTA
Nom
:
BTA - bit to accumulator
Fonction
:
transfère 16 variables booléennes successives
vers les 16 bits de l’accumulateur 16 bits ;
le bit de poids faible correspond à la première
variable booléenne
Variables
:
I ou %I, O ou %Q, B ou %M, T ou %T, U*
Adressage
:
absolu
Voir aussi
:
ATB
Exemple
:
bta i0
sta m200
; recopie les 16 entrées i0 à i15 dans le mot m200
*
Attention : pour pouvoir utiliser les bits U avec cette fonction il faut réaliser une table linéaire de
bits avec la directive de compilation #B.
AUTOMGEN7
86
(C)opyright 2002 IRAI
Manuel de référence langage
CPA
Nom
:
CPA - compares accumulator
Fonction
:
compare une valeur à l’accumulateur 16 bits ou 32 bits
ou flottant ; effectue la même opération que SBA
mais sans modifier le contenu de l’accumulateur
Variables
:
M ou %MW, L ou %MD, F ou %MF
Adressage
:
absolu, indirect, immédiat
Voir aussi
:
SBA
Exemple
:
lda m200
cpa 4
rfz o0
; met o0 à 1 si m200 est égal à 4, autrement o0
; est mis à 0
lda f200
cpa f201
rfz o1
; met o1 à 1 si f200 est égal à f201, autrement o1
; est mis à 0
AUTOMGEN7
87
(C)opyright 2002 IRAI
Manuel de référence langage
D EC
Nom
:
DEC – decrement
Fonction
:
décrémente un mot, un compteur, un long, l’accumulateur 16
bits ou 32 bits
Variables
:
M ou %MW, C ou %C, L ou %MD
Adressage
:
absolu, indirect, accumulateur
Voir aussi
:
INC
Exemple
:
dec m200
; décrémente m200
dec aal
; décrémente l’accumulateur 32 bits
dec m200
dec m201 and m200=-1
; décrémente une valeur 32 bits composée de
; m200 (poids faibles)
; et m201 (poids forts)
AUTOMGEN7
88
(C)opyright 2002 IRAI
Manuel de référence langage
DVA
Nom
:
DVA - divides accumulator
Fonction
:
division de l’accumulateur 16 bits par un mot ou
une constante ; division de l’accumulateur flottant
par un flottant ou une constante ; division de l’accumulateur
32 bits par un long ou une constante, pour l’accumulateur 16
bits le reste est placé dans le mot m0 ; en cas de division par
0
le bit système 56 passe à 1
Variables
:
M ou %MW, L ou %MD, F ou %MF
Adressage
:
absolu, indirect, immédiat
Voir aussi
:
MLA
Exemple
:
lda m200
dva 10
sta m201
; m201 est égal à m200 divisé par 10, m0 contient le
; reste de la division
lda l200
dva $10000L
sta l201
AUTOMGEN7
89
(C)opyright 2002 IRAI
Manuel de référence langage
EQU
Nom
:
EQU - equal
Fonction
:
force une variable à 1 si le test est vrai,
dans le cas contraire la variable est forcée
à0
Variables
:
I ou %I, O ou %Q, B ou %M, T ou %T, X ou %X, U
Adressage
:
absolu, indirect (sauf sur les variables X)
Voir aussi
:
NEQ, SET, RES, INV
Exemple
:
equ o0 and i10
; force la sortie o0 au même état que l’entrée i10
lda 10
sta m200
equ o(200) and i0
; force o10 au même état que l’entrée i0
$t0=100
equ t0 and i0
equ o0 and t0
; force o0 à l’état de i0 avec un retard à l’activation
; de 10 secondes
AUTOMGEN7
90
(C)opyright 2002 IRAI
Manuel de référence langage
FTI
Nom
:
FTI - float to integer
Fonction
:
transfère l’accumulateur flottant vers l’accumulateur
16 bits
Variables
:
aucune
Adressage
:
accumulateur
Voir aussi
:
ITF
Exemple
:
lda f200
fti aaa
sta m1000
; laisse la partie entière de f200 dans m1000
AUTOMGEN7
91
(C)opyright 2002 IRAI
Manuel de référence langage
INC
Nom
:
INC - increment
Fonction
:
incrémente un mot, un compteur, un long, l’accumulateur 16
bits ou 32 bits
Variables
:
M ou %MW, C ou %C, L ou %MD
Adressage
:
absolu, indirect, accumulateur
Voir aussi
:
DEC
Exemple
:
inc m200
; ajoute 1 à m200
inc m200
inc m201 and m201=0
; incrémente une valeur sur 32 bits, m200
; représente les
; poids faibles, et m201 les poids forts
inc l200
; incrémente le long l200
AUTOMGEN7
92
(C)opyright 2002 IRAI
Manuel de référence langage
INV
Nom
:
INV - inverse
Fonction
:
inverse l’état d’une variable booléenne, ou inverse
tous les bits d’un mot, d’un long ou de l’accumulateur 16 bits
ou 32 bits
Variables
:
I ou %I, O ou %Q, B ou %M, T ou %T, X ou %X, U,
M ou %MW, L ou %MD
Adressage
:
absolu, indirect, accumulateur
Voir aussi
:
EQU, NEQ, SET, RES
Exemple
:
inv o0
; inverse l’état de la sortie 0
inv aaa
; inverse tous les bits de l’accumulateur 16 bits
inv m200 and i0
; inverse tous les bits de m200 si i0 est à l’état 1
AUTOMGEN7
93
(C)opyright 2002 IRAI
Manuel de référence langage
I TF
Nom
:
ITF - integer to float
Fonction
:
transfère l’accumulateur 16 bits vers l’accumulateur flottant
Variables
:
aucune
Adressage
:
accumulateur
Voir aussi
:
FTI
Exemple
:
lda 1000
itf aaa
sta f200
; laisse la constante 1000 dans f200
AUTOMGEN7
94
(C)opyright 2002 IRAI
Manuel de référence langage
ITL
Nom
:
ITL - integer to long
Fonction
:
transfère l’accumulateur 16 bits vers l’accumulateur 32 bits
Variables
:
aucune
Adressage
:
accumulateur
Voir aussi
:
LTI
Exemple
:
lda 1000
itl aaa
sta f200
; laisse la constante 1000 dans l200
AUTOMGEN7
95
(C)opyright 2002 IRAI
Manuel de référence langage
JMP
Nom
:
JMP - jump
Fonction
:
saut à un label
Variables
:
label
Adressage
:
label
Voir aussi
:
JSR
Exemple
:
jmp :fin de programme:
; branchement inconditionnel au label :fin
; de programme:
jmp :suite: and i0
set o0
set o1
:suite:
; branchement conditionnel au label :suite:
; suivant l’état de i0
AUTOMGEN7
96
(C)opyright 2002 IRAI
Manuel de référence langage
JSR
Nom
:
JSR - jump sub routine
Fonction
:
effectue un branchement à un sous-programme
Variables
:
label
Adressage
:
label
Voir aussi
:
RET
Exemple
:
lda m200
jsr :carre:
sta m201
jmp :fin:
:carre:
sta m53
mla m53
sta m53
ret m53
:fin:
; le sous-programme « carre » élève le contenu de
; l’accumulateur au carré
AUTOMGEN7
97
(C)opyright 2002 IRAI
Manuel de référence langage
LDA
Nom
:
LDA - load accumulator
Fonction
:
charge dans l’accumulateur 16 bits une constante, un mot
ou un compteur ; charge dans l’accumulateur 32 bits un long
ou une constante, charge dans l’accumulateur flottant un
flottant ou une constante, charge un compteur de
temporisation dans l’accumulateur 16 bits
Variables
:
M ou %MW, C ou %C, L ou %MD, F ou %MF, T ou %T
Adressage
:
absolu, indirect, immédiat
Voir aussi
:
STA
Exemple
:
lda 200
; charge la constante 200 dans l’accumulateur 16 bits
lda 0.01R
; charge la constante réelle 0.01 dans l’accumulateur flottant
lda t10
; charge le compteur de la temporisation 10 dans
; l’accumulateur
AUTOMGEN7
98
(C)opyright 2002 IRAI
Manuel de référence langage
LTI
Nom
:
LTI - long to integer
Fonction
:
transfère l’accumulateur 32 bits vers l’accumulateur
16 bits
Variables
:
aucune
Adressage
:
accumulateur
Voir aussi
:
ITL
Exemple
:
lda l200
lti aaa
sta m1000
; laisse les 16 bits de poids faibles de l200 dans m1000
AUTOMGEN7
99
(C)opyright 2002 IRAI
Manuel de référence langage
MLA
Nom
:
MLA - multiples accumulator
Fonction
:
multiplication de l’accumulateur 16 bits par un mot ou
une constante ; multiplication de l’accumulateur 32 bits par
un long ou une constante, multiplication de l’accumulateur
flottant par un flottant ou une constante ; pour l’accumulateur
16 bits, les 16 bits de poids forts du résultat de la
multiplication sont transférés dans m0
Variables
:
M ou %MW, L ou %MD, F ou %MF
Adressage
:
absolu, indirect, immédiat
Voir aussi
:
DVA
Exemple
:
lda m200
mla 10
sta m201
; multiplie m200 par 10, m201 est chargé avec les
; 16 bits de poids faibles, et m0 avec les 16 bits de
; poids forts
AUTOMGEN7
100
(C)opyright 2002 IRAI
Manuel de référence langage
MTA
Nom
:
MTA - memory to accumulator
Fonction
:
transfère le contenu d’une adresse mémoire dans
l’accumulateur 16 bits ; le mot ou la constante spécifié
défini l’offset de l’adresse mémoire à atteindre, le mot m0
doit être chargé avec la valeur du segment de l’adresse
mémoire à atteindre ; utilisable seulement avec l’exécuteur
PC
Variables
:
M ou %MW
Adressage
:
indirect, immédiat
Voir aussi
:
ATM
Exemple
:
lda $b800
sta m0
mta $10
; place la valeur contenue à l’adresse $b800:$0010
; dans l’accumulateur 16 bits
AUTOMGEN7
101
(C)opyright 2002 IRAI
Manuel de référence langage
NEQ
Nom
:
NEQ - not equal
Fonction
:
force une variable à 0 si le test est vrai,
dans le cas contraire la variable est forcée
à1
Variables
:
I ou %I, O ou %Q, B ou %M, T ou %T, X ou %X, U
Adressage
:
absolu, indirect (sauf sur les variables X)
Voir aussi
:
EQU, SET, RES, INV
Exemple
:
neq o0 and i00
; force la sortie o0 à l’état complémenté de l’entrée
; i10
lda 10
sta m200
neq o(200) and i0
; force o10 à l’état complémenté de l’entrée i0
$t0=100
neq t0 and i0
neq o0 and t0
; force o0 à l’état de i0 avec un retard à la
; désactivation de 10 secondes
AUTOMGEN7
102
(C)opyright 2002 IRAI
Manuel de référence langage
ORA
Nom
:
ORA - or accumulator
Fonction
:
effectue un OU logique entre l’accumulateur 16 bits
et un mot ou une constante, ou entre l’accumulateur 32 bits et
un long ou une constante
Variables
:
M ou %M, L ou %MD
Adressage
:
absolu, indirect, immédiat
Voir aussi
:
ANA, XRA
Exemple
:
ora %1111111100000000
; force les 8 bits de poids forts de
; l’accumulateur 16 bits à 1
ora $ffff0000L
; force les 16 bits de poids forts de l’accumulateur 32 bits
;à1
AUTOMGEN7
103
(C)opyright 2002 IRAI
Manuel de référence langage
RES
Nom
:
RES - reset
Fonction
:
force une variable booléenne, un mot,
un compteur, un long, l’accumulateur 16 bits
ou l’accumulateur 32 bits à 0
Variables
:
I ou %I, O ou %Q, B ou %M, T ou %T, X ou %X, U,
M ou %MW, C ou %C, L ou %MD
Adressage
:
absolu, indirect (sauf sur les variables X), accumulateur
Voir aussi
:
NEQ, SET, EQU, INV
Exemple
:
res o0
; force la sortie o0 à 0
lda 10
sta m200
res o(200) and i0
; force o10 à 0 si l’entrée i0 est à 1
res c0
; force le compteur 0 à 0
AUTOMGEN7
104
(C)opyright 2002 IRAI
Manuel de référence langage
RET
Nom
:
RET - return
Fonction
:
marque le retour d’un sous-programme et
place dans l’accumulateur 16 bits un mot ou
une constante ; ou place dans l’accumulateur 32 bits un long
ou une constante, ou place dans l’accumulateur
flottant un flottant ou une constante
Variables
:
M ou %MW, L ou %MD, F ou %MF
Adressage
:
absolu, indirect, immédiat
Voir aussi
:
JSR
Exemple
:
ret 0
; retour de sous-programme en plaçant 0 dans
; l’accumulateur 16 bits
ret f200
; retour de sous-programme en plaçant le contenu
; de f200 dans l’accumulateur flottant
AUTOMGEN7
105
(C)opyright 2002 IRAI
Manuel de référence langage
RFC
Nom
:
RFC - read flag : carry
Fonction
:
transfère le contenu de l’indicateur de retenue dans
une variable booléenne
Variables
:
I ou %I, O ou %Q, B ou %M, T ou %T, X ou %X, U
Adressage
:
absolu
Voir aussi
:
RFZ, RFS, RFO
Exemple
:
rfc o0
; transfère l’indicateur de retenue dans o0
lda m200
ada m300
sta m400
rfc b99
lda m201
ada m301
sta m401
inc m401 and b99
; effectue une addition sur 32 bits
; (m400,401)=(m200,201)+(m300,301)
; m200, m300 et m400 sont les poids faibles
; m201, m301 et m401 sont les poids forts
AUTOMGEN7
106
(C)opyright 2002 IRAI
Manuel de référence langage
RFO
Nom
:
RFO - read flag : overflow
Fonction
:
transfère le contenu de l’indicateur de débordement
dans une variable booléenne
Variables
:
I ou %I, O ou %Q, B ou %M, T ou %T, X ou %X, U
Adressage
:
absolu
Voir aussi
:
RFZ, RFS, RFC
Exemple
:
rfo o0
; transfère l’indicateur de débordement dans o0
AUTOMGEN7
107
(C)opyright 2002 IRAI
Manuel de référence langage
RFS
Nom
:
RFS - read flag : signe
Fonction
:
transfère le contenu de l’indicateur de signe dans une
variable booléenne
Variables
:
I ou %I, O ou %Q, B ou %M, T ou %T, X ou %X, U
Adressage
:
absolu
Voir aussi
:
RFZ, RFC, RFO
Exemple
:
rfs o0
; transfère l’indicateur de signe dans o0
AUTOMGEN7
108
(C)opyright 2002 IRAI
Manuel de référence langage
RFZ
Nom
:
RFZ - read flag : zero
Fonction
:
transfère le contenu de l’indicateur de résultat nul
dans une variable booléenne
Variables
:
I ou %I, O ou %Q, B ou %M, T ou %T, X ou %X, U
Adressage
:
absolu
Voir aussi
:
RFC, RFS, RFO
Exemple
:
rfz o0
; transfère l’indicateur de résultat nul dans o0
lda m200
cpa m201
rfz o0
; positionne o0 à 1 si m200 est égal à m201
; ou à 0 dans le cas contraire
AUTOMGEN7
109
(C)opyright 2002 IRAI
Manuel de référence langage
RIN
Nom
:
RIN - read input
Fonction
:
effectue une lecture des entrées physiques. Cette fonction est
uniquement implémentée sur cibles Z et varie suivant la
cible. Consultez la documentation relative à chaque
éxécuteur pour plus de détails.
Variables
:
aucune
Adressage
:
immédiat
Voir aussi
:
WOU
AUTOMGEN7
110
(C)opyright 2002 IRAI
Manuel de référence langage
RLA
Nom
Fonction
:
:
RLA - rotate left accumulator
effectue une rotation à gauche des bits de
l’accumulateur 16 bits ou 32 bits ; le bit évacué à gauche
entre à droite ; l’argument de cette fonction est une
constante qui précise le nombre de décalages à effectuer, la
taille de l’argument (16 ou 32 bits) détermine quel est
l’accumulateur qui doit subir la rotation
Variables
:
aucune
Adressage
:
immédiat
Voir aussi
:
RRA
Exemple
:
ana $f000
; isole le digit de poids fort de l’accumulateur 16 bits
rla 4
; et le ramène à droite
rla 8L
; effectue 8 rotations à gauche des bits de l’accumlateur
; 32 bits
AUTOMGEN7
111
(C)opyright 2002 IRAI
Manuel de référence langage
RRA
Nom
:
RRA - rotate right accumulator
Fonction
:
effectue une rotation à droite des bits de
l’accumulateur 16 bits ou 32 bits ; le bit évacué à droite entre
à gauche ; l’argument de cette fonction est une constante qui
précise le nombre de décalages à effectuer, la taille de
l’argument (16 ou 32 bits) détermine si c’est l’accumulateur
16 ou 32 bits qui doit subir la rotation
Variables
:
aucune
Adressage
:
immédiat
Voir aussi
:
RLA
Exemple
:
ana $f000
; isole le digit de poids fort de l’accumulateur 16 bits
rra 12
; et le ramène à droite
rra 1L
; effectue une rotation des bits de l’accumulateur 32 bits
; d’une position vers la droite
AUTOMGEN7
112
(C)opyright 2002 IRAI
Manuel de référence langage
SBA
Nom
:
SBA - substacts accumulator
Fonction
:
enlève le contenu d’un mot ou une constante à
l’accumulateur 16 bits ; enlève le contenu d’un long ou d’une
constante à l’accumulateur 32 bits, enlève le contenu d’un
flottant ou d’une constante à l’accumulateur flottant
Variables
:
M ou %MW, L ou %MD, F ou %MF
Adressage
:
absolu, indirect, immédiat
Voir aussi
:
ADA
Exemple
:
sba 200
; enlève 200 à l’accumulateur 16 bits
sba f(421)
; enlève le contenu du flottant dont le numéro est
; contenu dans le mot 421 à l’accumulateur flottant
AUTOMGEN7
113
(C)opyright 2002 IRAI
Manuel de référence langage
SET
Nom
:
SET - set
Fonction
:
force une variable booléenne à 1; force tous les bits d’un mot,
d’un compteur, d’un long, de l’accumulateur 16 bits ou de
l’accumulateur 32 bits à 1
Variables
:
I ou %I, O ou %Q, B ou %M, T ou %T, X ou %X, U,
M ou %MW, C ou %C, L ou %MD
Adressage
:
absolu, indirect (sauf sur les variables X), accumulateur
Voir aussi
:
NEQ, RES, EQU, INV
Exemple
:
set o0
; force la sortie o0 à 1
lda 10
sta m200
set o(200) and i0
; force o10 à 1 si l’entrée i0 est à 1
set m200
; force m200 à la valeur -1
set aal
; force tous les bits de l’accumulateur 32 bits à 1
AUTOMGEN7
114
(C)opyright 2002 IRAI
Manuel de référence langage
SQR
Nom
:
SQR - square root
Fonction
:
calcule la racine carrée de l’accumulateur flottant
Variables
:
aucune
Adressage
:
accumulateur
Voir aussi
:
ABS
Exemple
:
lda 9
itf aaa
sqr aaf
fti aaa
sta m200
; laisse la valeur 3 dans m200
AUTOMGEN7
115
(C)opyright 2002 IRAI
Manuel de référence langage
STA
Nom
:
STA - store accumulator
Fonction
:
stocke l’accumulateur 16 bits dans un compteur ou un mot;
stocke l’accumulateur 32 bits dans un long, stocke
l’accumulateur flottant dans un flottant, stocke
l’accumulateur 16 bits dans une consigne de temporisation
Variables
:
M ou %MW, C ou %C, L ou %MD, F ou %MF, T ou %T
Adressage
:
absolu, indirect
Voir aussi
:
LDA
Exemple
:
sta m200
; transfère le contenu de l’accumulateur 16 bits
; dans le mot 200
sta f200
; transfère le contenu de l’accumulateur flottant
; dans le flottant 200
sta l200
; transfère l’accumulateur 32 bits dans le long l200
AUTOMGEN7
116
(C)opyright 2002 IRAI
Manuel de référence langage
TSA
Nom
:
TSA - test accumulator
Fonction
:
effectue un ET logique entre l’accumulateur 16 bits et un mot
ou une constante ; effectue un ET logique entre
l’accumulateur 32 bits et un long ou une constante, opère de
façon similaire à l’instruction ANA, mais sans modifier le
contenu de l’accumulateur
Variables
:
M ou %MW, L ou %MD
Adressage
:
absolu, indirect, immédiat
Voir aussi
:
ANA
Exemple
:
tsa %10
rfz b99
jmp :suite: and b99
; branchement au label :suite: si le bit 1
; de l’accumulateur 16 bits est à 0
AUTOMGEN7
117
(C)opyright 2002 IRAI
Manuel de référence langage
WOU
Nom
:
WOU - write output
Fonction
:
effectue une écriture des sorties physiques. Cette fonction est
uniquement implémentée sur cibles Z (et varie suivant la
cible). Consultez la documentation relative à chaque
exécuteur pour plus de détails.
Variables
:
aucune
Adressage
:
immédiat
Voir aussi
:
RIN
AUTOMGEN7
118
(C)opyright 2002 IRAI
Manuel de référence langage
XRA
Nom
:
XRA - xor accumulator
Fonction
:
effectue un OU EXCLUSIF entre l’accumulateur 16 bits et
un mot ou une constante, effectue un OU EXCLUSIF entre
l’accumulateur 32 bits et un long ou une constante
Variables
:
M ou %MW, L ou %MD
Adressage
:
absolu, indirect, immédiat
Voir aussi
:
ORA, ANA,
Exemple
:
xra %1111111100000000
; inverse les 8 bits de poids fort de l’accumulateur 16 bits
xra 1L
; inverse le bit de poids faible de l’accumulateur 32 bits
AUTOMGEN7
119
(C)opyright 2002 IRAI
Manuel de référence langage
1.10.4. Macro-instruction
Les macro-instructions sont des nouvelles instructions du langage littéral derrière
lesquelles se cache un ensemble d’instructions de base.
Syntaxe d’appel d’une macro-instruction :
« %<nom de la macro-instruction*> {paramètres ...} »
Syntaxe de déclaration d’une macro-instruction :
#MACRO
<programme>
#ENDM
Cette déclaration se trouve dans un fichier portant le nom de la macro-instruction
et possédant l’extension « .M ».
Le fichier .M peut être placé dans sous-répertoire « lib » du répertoire d’installation
d’AUTOMGEN ou dans les ressources du projet.
Dix paramètres peuvent être passés à la macro-instruction. A l’appel, ces
paramètres seront placés sur la même ligne que la macro-instruction et seront
séparés par un espace.
Dans le programme de la macro-instruction la syntaxe « {?n} » fait référence au
paramètre n.
Exemple :
Réalisons la macro-instruction « carre » qui élève le premier paramètre de la
macro-instruction au carré et range le résultat dans le deuxième paramètre.
Appel de la macro-instruction :
lda 3
sta m200
%carre m200 m201
; m201 contiendra 9 ici
*
Le nom de la macro-instruction peut être un chemin d’accès complet vers le fichier « .M », il peut
contenir une désignation de lecteur et de répertoire.
AUTOMGEN7
120
(C)opyright 2002 IRAI
Manuel de référence langage
Fichier « CARRE.M » :
#MACRO
lda {?0}
mla {?0}
sta {?1}
#ENDM
1.10.5. Librairie
La notion de librairie permet la définition de ressources qui seront compilées une
seule fois dans une application, quel que soit le nombre d’appels à ces
ressources.
Syntaxe de définition d’une librairie :
#LIBRARY <nom de la librairie>
<programme>
#ENDL
<nom de la librairie> est le nom de la fonction qui sera appelée par une instruction
jsr :<nom de la librairie>:
Au premier appel rencontré par le compilateur, le code de la librairie est compilé.
Pour les suivants, l’appel est simplement dirigé vers la routine existante.
Ce mécanisme est particulièrement adapté à l’utilisation des blocs fonctionnels et
des macro-instructions pour limiter la génération de code dans le cas de
l’utilisation multiple de mêmes ressources programmes.
Les mots m120 à m129 sont réservés aux librairies et peuvent être utilisés pour le
passage des paramètres.
1.10.6. Macro-instructions prédéfinies
Des macro-instructions de conversion se trouvent dans le sous répertoire « LIB »
du répertoire où a été installé AUTOMGEN.
Les équivalents en blocs fonctionnels sont également présents.
1.10.7. Description des macro-instructions prédéfinies
1.10.7.1. Conversions
%ASCTOBIN <deux premiers digits> <deux derniers digits> <résultat en binaire>
AUTOMGEN7
121
(C)opyright 2002 IRAI
Manuel de référence langage
Effectue une conversion ASCII hexadécimal (deux premiers paramètres) vers
binaire (troisième paramètre), en sortie l’accumulateur contient $FFFF si les deux
premiers paramètres ne sont pas des nombres ASCII valides, 0 autrement. Tous
les paramètres sont des mots de 16 bits.
%BCDTOBIN <valeur en BCD> <valeur en binaire>
Effectue une conversion BCD vers binaire. En sortie l’accumulateur contient
$FFFF si le premier paramètre n’est pas un nombre bcd valide, 0 autrement. Les
deux paramètres sont des mots de 16 bits.
%BINTOASC <valeur en binaire> <résultat partie haute> <résultat partie basse>
Effectue une conversion binaire (premier paramètre) vers ASCII hexadécimal
(deuxième et troisième paramètres). Tous les paramètres sont des mots de 16
bits.
%BINTOBCD <valeur en binaire> <valeur en BCD>
Effectue une conversion BCD (premier paramètre) vers binaire (deuxième
paramètre). En sortie l’accumulateur contient $FFFF si le nombre binaire ne peut
être converti en BCD, 0 autrement.
%GRAYTOB <valeur en code GRAY> <valeur en binaire>
Effectue une conversion code Gray (premier paramètre) vers binaire (deuxième
paramètre).
1.10.7.2. Traitement sur table de mots
%COPY <premier mot table source> <premier mot table destination> <nombre de mots>
Copie une table de mots source vers une table de mots destination. La longueur
est donnée en nombre de mots.
%COMP <premier mot table 1> <premier mot table 2> <nombre de mots> <résultat>
Compare deux tables de mots. Le résultat est une variable binaire qui prend la
valeur 1 si tous les éléments de la table 1 sont identiques à la table 2.
%FILL <premier mot table> <valeur> <nombre de mots>
Remplit une table de mots avec une valeur.
AUTOMGEN7
122
(C)opyright 2002 IRAI
Manuel de référence langage
1.10.7.3. Traitement sur chaîne de caractères
Le codage des chaînes de caractères est le suivant : un caractère par mot, un mot
contenant la valeur 0 marque la fin de la chaîne. Dans les macro-instructions, les
chaînes sont passées en paramètres en désignant le premier mot qui les
compose.
%STRCPY <chaîne source> <chaîne destination>
Copie une chaîne vers une autre.
%STRCAT <chaîne source> <chaîne destination>
Ajoute la chaîne source à la fin de la chaîne destination.
%STRCMP <chaîne 1> <chaîne 2> <résultat>
Compare deux chaînes. Le résultat est une variable booléenne qui passe à 1 si
les deux chaînes sont identiques.
%STRLEN <chaîne> <résultat>
Place la longueur de la chaîne dans le mot résultat.
%STRUPR <chaîne>
Transforme tous les caractères de la chaîne en majuscules.
%STRLWR <chaîne>
Transforme tous les caractères de la chaîne en minuscules.
Exemple:
Conversion de m200 (binaire) vers m202, m203 en 4 digits (ASCII bcd)
%bintobcd m200 m201
%bintoasc m201 m202 m203
1.10.8. Exemple en langage littéral bas niveau
Cahier des charges : commençons par l’exemple le plus simple : aller et retour
d’une locomotive sur la voie 1.
AUTOMGEN7
123
(C)opyright 2002 IRAI
Manuel de référence langage
Solution :
0
set _av1_
set _dv1_ and _t1d_
res _dv1_ and _t1i_
exemple\lit\littéral bas niveau1.agn
Un exemple un peu plus évolué.
Cahier des charges :
La locomotive devra maintenant marquer une attente de 10 secondes à l’extrémité
droite de la voie et une attente de 4 secondes à l’extrémité gauche.
Solution :
0
$t0=100,40
equ u100 and
_t1i_ and
_t1d_
equ u101 orr t0 eor t1
equ _av1_ orr u100 eor u101
set _dv1_ and _t1d_
equ t0 and _t1d_
res _dv1_ and _t1i_
equ t1 and _t1i_
exemple\lit\littéral bas niveau 2.agn
Autre exemple :
Cahier des charges :
Faire clignoter tous les feux de la maquette.
AUTOMGEN7
124
(C)opyright 2002 IRAI
Manuel de référence langage
Solution :
0
; table contenant l'adresse de tous les feux
$_table_=123,?_s1d_,?_s1i_,?_s2a_,?_s2b_
$...=?_s3d_,?_s3i_,?_s4a_,?_s4b_
$...=?_s5i_,?_s5d_,?_s6d_,?_s6i_
$...=?_s7i_,?_s7d_,?_s8d_,?_s8i_
$...=-1
; initialise l'index sur le debut de la table
lda ?_table_
sta _index_
:boucle:
; la valeur -1 marque la fin de la table
jmp :fin: and m(_index_)=-1
; inverser la sortie
lda m(_index_)
sta _index2_
inv o(_index2_)
inc _index_
jmp :boucle:
:fin:
exemple\lit\littéral bas niveau 3.agn
Cet exemple montre l’utilisation des prédispositions. Elles sont utilisées ici pour
créer une table d’adresses de variables. La table contient l’adresse de toutes les
sorties qui pilotent les feux de la maquette.
A chaque cycle d’exécution, l’état de tous les feux est inversé.
Un problème se pose, les feux clignotent très vite et l’on ne voit pas grand chose.
Modifions notre exemple.
Cahier des charges :
Il faut maintenant inverser un par un l’état des feux tous les dixièmes de seconde.
AUTOMGEN7
125
(C)opyright 2002 IRAI
Manuel de référence langage
Solution :
10
; ta b le c o nt en an t l 'a d re ss e d e to u s le s f eu x
$_ ta b le _= 1 23 ,? _s 1 d_ ,? _ s1 i_ ,? _ s2 a_ , ?_ s2 b _
$. .. = ?_ s3 d _, ?_ s3 i _, ?_ s 4a _, ?_ s 4b _
$. .. = ?_ s5 i _, ?_ s5 d _, ?_ s 6d _, ?_ s 6i _
$. .. = ?_ s7 i _, ?_ s7 d _, ?_ s 8d _, ?_ s 8i _
$. .. = -1
$_ in d ex _= ? _t ab le _
:b ou c le :
; la va le u r -1 m a rq ue la f in de l a t ab l e
jm p : fi n d e ta bl e : an d m (_ in d ex _) = -1
; in v er se r l a so r ti e
ld a m (_ in d ex _)
st a _ in de x 2_
in v o (_ in d ex 2_ )
in c _ in de x _
jm p : fi n:
:f in de t a bl e:
ld a ? _t ab l e_
st a _ in de x _
:f in :
=1
20
t 0/ x2 0 /1
exemple\lit\littéral bas niveau 4.agn
1.11. Langage littéral étendu
Le langage littéral étendu est un « sur ensemble » du langage littéral bas niveau.
Il permet d’écrire plus simplement et sous une forme plus concise des équations
booléennes et numériques.
Il permet également d’écrire des structures de type IF ... THEN ... ELSE et WHILE
... ENDWHILE (boucle).
AUTOMGEN7
126
(C)opyright 2002 IRAI
Manuel de référence langage
L’utilisation du langage littéral étendu est soumise aux mêmes règles que le
langage littéral bas niveau, il utilise la même syntaxe pour les variables, les
mnémoniques, les types de test (fronts, état complémenté, état immédiat) et les
modes d’adressage.
Il est possible de « mixer » le langage littéral bas niveau et le langage littéral
étendu.
Lorsque le compilateur de langage littéral détecte une ligne écrite en langage
littéral étendu, il la décompose en instructions du langage littéral bas niveau, puis
la compile.
1.11.1. Ecriture d’équations booléennes
Syntaxe générale :
« variable bool.=(type d’affectation) (variable bool.
2 opérateur 1
variable
bool. 3... opérateur n -1 variable bool. n ) »
Le type d’affectation doit être précisé s’il est autre que « Affectation ».
Il peut être :
Ö « (/) » : affectation complémentée,
Ö « (0) » : mise à zéro,
Ö « (1) » : mise à un.
Les opérateurs peuvent être :
Ö « . » : et,
Ö « + » : ou.
Les équations peuvent contenir plusieurs niveaux de parenthèses pour préciser
l’ordre d’évaluation. Par défaut, les équations sont évaluées de la gauche vers la
droite.
Exemples et équivalences avec le langage littéral bas niveau:
o0=(i0)
equ o0 and i0
o0=(i0.i1)
equ o0 and i0 and i1
o0=(i0+i1)
equ o0 orr i0 eor i1
o0=(1)
set o0
o0=(0)
res o0
AUTOMGEN7
127
(C)opyright 2002 IRAI
Manuel de référence langage
o0=(1)(i0)
set o0 and i0
o0=(0)(i0)
res o0 and i0
o0=(1)(i0.i1)
set o0 and i0 and i1
o0=(0)(i0+i1)
res o0 orr o0 eor i1
o0=(/)(i0)
neq o0 and i0
o0=(/)(i0.i1)
neq o0 and i0 and i1
o0=(/i0)
equ o0 and /i0
o0=(/i0./i1)
equ o0 and /i0 and /i1
o0=(c0=10)
equ o0 and c0=10
o0=(m200<100+m200>200)
equ o0 orr m200<100 eor m200>200
1.11.2. Ecriture d’équations numériques
Syntaxe générale pour les entiers :
« variable num.1=[variable num.2 opérateur 1 ... opérateur n-1 variable num.n] »
Les équations peuvent contenir plusieurs niveaux de crochets pour préciser l’ordre
d’évaluation. Par défaut, les équations sont évaluées de la gauche vers la droite.
Les opérateurs pour les entiers 16 et 32 bits peuvent être :
« + » : addition (équivalent à l’instruction ADA),
« - » : soustraction (équivalent à l’instruction SBA),
« * » : multiplication (équivalent à l’instruction MLA),
« / » : division (équivalent à l’instruction DVA),
« < » : décalage à gauche (équivalent à l’instruction RLA),
« > » : décalage à droite (équivalent à l’instruction RRA),
« & » : « Et » binaire (équivalent à l’instruction ANA),
« | »* : « Ou » binaire (équivalent à l’instruction ORA),
« ^ » : « Ou exclusif » binaire (équivalent à l’instruction XRA).
Les opérateurs pour les flottants peuvent être :
Ö « + » : addition (équivalent à l’instruction ADA),
Ö « - » : soustraction (équivalent à l’instruction SBA),
Ö « * » : multiplication (équivalent à l’instruction MLA),
Ö « / » : division (équivalent à l’instruction DVA).
On ne peut pas préciser de constante dans les équations sur les flottants. Si cela
est nécessaire, il faut utiliser des prédispositions sur des flottants.
*
Ce caractère est généralement associé à la combinaison de touches [ALT] + [6] sur les claviers.
AUTOMGEN7
128
(C)opyright 2002 IRAI
Manuel de référence langage
Les équations sur les flottants peuvent faire appeler les fonctions « SQR » et
« ABS ».
Remarque : suivant la complexité des équations, le compilateur peut utiliser des
variables intermédiaires. Ces variables sont les mots m53 à m59 pour les entiers
16 bits, les longs l53 à l59 pour les entiers 32 bits et les flottants f53 à f59.
Exemples et équivalences avec le langage littéral bas niveau :
m200=[10]
lda 10
m200=[m201]
lda m201
sta m200
sta m200
m200=[m201+100]
lda m201
ada 100
sta m200
m200=[m200+m201-m202]
lda m200
ada m201
sba m202
sta m200
m200=[m200&$ff00]
lda m200
ana $ff00
sta m200
f200=[f201]
lda f201
sta f200
f200=[f201+f202]
lda f201
ada f202
sta f200
f200=[sqr[f201]]
lda f201
sqr aaa
sta f200
f200=[sqr[abs[f201*100R]]]
lda f201
mla 100R
abs aaa
sqr aaa
sta f200
l200=[l201+$12345678L]
lda l201
ada $12345678L
sta l200
AUTOMGEN7
129
(C)opyright 2002 IRAI
Manuel de référence langage
1.11.3. Structure de type IF ... THEN ... ELSE ...
Syntaxe générale :
IF(test)
THEN
action si test vrai
ENDIF
ELSE
action si test faux
ENDIF
Le test doit respecter la syntaxe décrite au chapitre consacré aux équations
booléennes dans ce chapitre.
Seule une action si test vrai ou une action si test faux peut figurer.
Il est possible d’imbriquer plusieurs structures de ce type.
Les bits Système u90 à u99 sont utilisés comme variables temporaires pour la
gestion de ce type de structure.
Exemples :
IF(i0)
THEN
inc m200
; incrémenter le mot 200 si i0
ENDIF
IF(i1+i2)
THEN
m200=[m200+10]
; ajouter 10 au mot 200 si i1 ou i2
ENDIF
ELSE
res m200
; sinon effacer m200
ENDIF
1.11.4. Structure de type WHILE ... ENDWHILE
Syntaxe générale :
WHILE(test)
action à répéter tant que le test est vrai
ENDWHILE
AUTOMGEN7
130
(C)opyright 2002 IRAI
Manuel de référence langage
Le test doit respecter la syntaxe décrite au chapitre consacré aux équations
booléennes dans ce chapitre.
Il est possible d’imbriquer plusieurs structures de ce type.
Les bits Système u90 à u99 sont utilisés comme variables temporaires pour la
gestion de ce type de structure.
Exemples :
m200=[0]
WHILE(m200<10)
set o(200)
inc m200
; incrémenter le mot 200
ENDWHILE
Cet exemple effectue une mise à un des sorties o0 à o9.
1.11.5. Exemple de programme en langage littéral étendu
Reprenons le premier exemple du chapitre précédent.
Solution :
0
_ a v 1_ = ( 1 )
_ d v 1_ = ( 1 )( _ t 1 d_ )
_ d v 1_ = ( 0 )( _ t 1 i_ )
exemple\lit\littéral étendu 1.agn
Enrichissons notre exemple avec des calculs.
Cahier des charges :
Calculer la vitesse en millimètres par seconde et en mètres par heure de la
locomotive sur le trajet gauche vers droite.
AUTOMGEN7
131
(C)opyright 2002 IRAI
Manuel de référence langage
Solution :
0
_av1_=(1)
_dv1_=(1)(_t1d_)
_dv1_=(0)(_t1i_)
È dv1
_temps aller_=[m32]
Ç dv1
$_longueur_=300 ; en mm
$_mille_=1000;
$_dixdansh_=36000;
$_dix_=10;
_temps mis_=[m32-_temps aller_]
IF(_temps mis_<0)
THEN
_temps mis_=[_temps mis_+100]
ENDIF
lda _temps mis_
itf aaa
sta _dixieme_
_vitesse mm par s_=[_longueur_/[_dixieme_/_dix_]]
_vitesse m par h_=[[_longueur_/_mille_]/[_dixieme_/_dixdansh_]]
exemple\lit\littéral étendu 2.agn
Le mot 32 est utilisé pour lire le temps Système. La valeur est ensuite transférée
dans des flottants pour pouvoir effectuer les calculs sans perte de précision.
1.12. Langage littéral ST
Le langage littéral ST est le langage littéral structuré défini par la norme CEI11313. Ce langage permet d’écrire des équations booléennes et numériques ainsi que
des structures de programmation.
1.12.1. Généralités
Le langage littéral ST s’utilise aux mêmes endroits que le langage littéral bas
niveau et le langage littéral étendu.
AUTOMGEN7
132
(C)opyright 2002 IRAI
Manuel de référence langage
Des directives permettent de définir des sections en langage littéral ST :
« #BEGIN_ST » marque le début d’une section en langage ST.
« #END_ST » marque la fin d'une section en langage ST.
Exemple :
m200=[50]
; langage littéral étendu
#BEGIN_ST
m201:=4;
(* langage ST *)
#END_ST
Il est également possible de choisir l’utilisation du langage ST pour tout un folio.
Le choix s’effectue dans la boîte de dialogue de propriétés de chaque folio.
Dans un folio ou le langage ST est le langage par défaut il est possible d'insérer
du langage littéral bas niveau et étendu en encadrant les lignes par deux
directives « #END_ST » et « #BEGIN_ST ».
Pour le langage ST les commentaires doivent débuter par « (* » et se terminer par
« *) ».
Les instructions du langage ST sont terminées par le caractère « ; ». Plusieurs
instructions peuvent être écrites sur une même ligne.
Exemple :
o0:=1; m200:=m200+1;
1.12.2. Equations booléennes
La syntaxe générale est :
variable := équation booléenne;
L’équation booléenne peut être composée d’une constante, d’une variable ou de
plusieurs variables séparées par des opérateurs.
Les constantes peuvent être : 0, 1, FALSE ou TRUE.
AUTOMGEN7
133
(C)opyright 2002 IRAI
Manuel de référence langage
Exemples :
o0:=1;
o1:=FALSE;
Les opérateurs permettant de séparer plusieurs variables sont : + (ou), . (et), OR
ou AND.
Le « Et » est prioritaire sur le « Ou ».
Exemple :
o0:=i0+i1.i2+i3;
Sera traité comme :
o0:=i0+(i1.i2)+i3;
Les parenthèses peuvent être utilisées dans les équations pour spécifier les
priorités.
Exemple :
o0:=(i0+i1).(i2+i3);
Des tests numériques peuvent êtres utilisés.
Exemple :
o0:=m200>5.m200<100;
1.12.3. Equations numériques
La syntaxe générale est :
variable := équation numérique;
L’équation numérique peut être composée d’une constante, d’une variable ou de
plusieurs variables et constantes séparées par des opérateurs.
Les constantes peuvent être des valeurs exprimées en décimal, hexadécimal
(préfixe 16#) ou binaire (préfixe 2#).
AUTOMGEN7
134
(C)opyright 2002 IRAI
Manuel de référence langage
Exemples :
m200:=1234;
m201:=16#aa55;
m202:=2#100000011101;
Les opérateurs permettant de séparer plusieurs variables ou constantes sont dans
l’ordre de leurs priorités:
* (multiplication),/ (division), + (addition), - (soustraction), & ou AND (et binaire),
XOR (ou exclusif binaire), OR (ou binaire).
Exemples :
m200:=1000*m201;
m200:=m202-m204*m203;
(* équivalent à m200:=m202-(m204*m203) *)
Les parenthèses peuvent être utilisées dans les équations pour spécifier les
priorités.
Exemple :
m200:=(m202-m204)*m203;
1.12.4. Structures de programmation
1.12.4.1. Test SI ALORS SINON
Syntaxe :
IF condition THEN action ENDIF;
et
IF condition THEN action ELSE action ENDIF;
Exemple :
if i0
then o0:=TRUE;
else
o0:=FALSE;
if i1 then m200:=4; endif;
AUTOMGEN7
135
(C)opyright 2002 IRAI
Manuel de référence langage
endif ;
1.12.4.2. Boucle TANT QUE
Syntaxe :
WHILE condition DO action ENDWHILE;
Exemple :
while m200<1000
do
m200:=m200+1;
endwhile;
1.12.4.3. Boucle JUSQU'A CE QUE
Syntaxe :
REPEAT action UNTIL condition; ENDREPEAT;
Exemple :
repeat
m200:=m200+1;
until m200=500
endrepeat;
1.12.4.4. Boucle DEPUIS JUSQU'A
Syntaxe :
FOR variable:=valeur de départ TO valeur de fin DO action ENDFOR;
ou
FOR variable:=valeur de départ TO valeur de fin BY pas DO action ENDFOR;
Exemple :
for m200:=0 to 100 by 2
do
m201:=m202*m201;
endfor;
AUTOMGEN7
136
(C)opyright 2002 IRAI
Manuel de référence langage
1.12.4.5. Sortie de boucle
Le mot clé « EXIT » permet de sortir d’une boucle.
Exemple :
while i0
m200:=m200+1;
if m200>1000 then exit; endif;
endwhile;
1.12.5. Exemple de programme en langage littéral étendu
Reprenons le premier exemple du chapitre précédent.
Solution :
0
_ a v 1 _ : = T RU E ;
i f _ t 1 d _ t h e n _ d v1 _ : = T R U E ; e n d i f ;
i f _ t 1 i _ t h e n _ d v1 _ : = F A L S E; e n d i f ;
exemple\lit\littéral ST 1.agn
1.13. Organigramme
AUTOMGEN implémente une programmation de type « organigramme ».
Pour utiliser ce type de programmation il faut utiliser les langages littéraux Veuillez
consulter les chapitres précédents pour apprendre à utiliser ces langages.
L’intérêt de la programmation sous forme d’organigramme est la représentation
graphique d’un traitement algorithmique.
Contrairement au langage Grafcet, la programmation sous forme d’organigramme
génère un code qui sera exécuté une fois par cycle de scrutation. Cela signifie que
l’on ne peut rester en attente dans un rectangle d’organigramme, il faut
obligatoirement que l’exécution sorte de l’organigramme pour pouvoir continuer à
exécuter la suite du programme.
AUTOMGEN7
137
(C)opyright 2002 IRAI
Manuel de référence langage
C’est un point très important à ne pas oublier lorsqu’on choisit ce langage.
Seuls des rectangles peuvent être dessinés. C’est le contenu des rectangles et les
liaisons qui en partent qui déterminent si le rectangle est une action ou un test.
1.13.1. Dessin d’un organigramme
Les rectangles sont dessinés en choisissant la commande « Plus … / Boîte de
code » du menu contextuel (cliquez sur le bouton droit de la souris sur le fond du
folio pour ouvrir le menu contextuel).
Il faut placer un bloc
(touche [<]) à l’entrée de chacun des rectangles, cette
entrée doit être placée sur la partie supérieure du rectangle.
Si le rectangle représente une action, il y aura une seule sortie matérialisée par un
bloc
(touche [E]) en bas et à gauche du rectangle.
Un rectangle d’action :
Si le rectangle représente un test, il y aura obligatoirement deux sorties. La
première, matérialisée par un bloc
(touche [E]) en bas et à gauche
représente la sortie si le test est vrai, la deuxième, matérialisée par un bloc
(touche [=]) se trouvant immédiatement à droite de l’autre sortie représente la
sortie si le test est faux.
AUTOMGEN7
138
(C)opyright 2002 IRAI
Manuel de référence langage
Un rectangle de test :
Les branches d’organigrammes doivent toujours se terminer par un rectangle sans
sortie qui peut éventuellement rester vide.
1.13.2. Contenu des rectangles
1.13.2.1. Contenu des rectangles d’action
Les rectangles d’action peuvent contenir n’importe quelles instructions du langage
littéral.
1.13.2.2. Contenu des rectangles de test
Les rectangles de test doivent contenir un test respectant la syntaxe de la partie
test de la structure de type IF...THEN...ELSE... du langage littéral étendu.
Par exemple :
IF (i0)
Il est possible d’écrire avant ce test des actions dans le rectangle de test.
Cela permet par exemple d’effectuer certains calculs avant le test.
Si par exemple nous voulons tester si le mot 200 est égal au mot 201 plus 4 :
m202=[m201+4]
IF(m200=m202)
1.14. Illustration
Notre premier exemple désormais classique, consistera à faire effectuer des allers
et retours à une locomotive sur la voie 1 de la maquette.
AUTOMGEN7
139
(C)opyright 2002 IRAI
Manuel de référence langage
Solution :
s et _ a v1 _
i f( _t 1 d_ )
s et _ d v1 _
if (_ t1 i _)
re s _d v 1_
exemple\organigramme\organigramme 1.agn
Deuxième exemple
Cahier des charges :
Faire clignoter tous les feux de la maquette. Les feux changeront d’état toutes les
secondes.
AUTOMGEN7
140
(C)opyright 2002 IRAI
Manuel de référence langage
Solution :
$t0=10
t0=( t0)
_ i n d e x % m _ = [ ? _ s 1d _ ]
i n v o ( _ i n d e x % m _) a n d t 0
inc _index%m_
_ c a l c u l % m _ = [ ? _ s8 i _ + 1 ]
I F ( _ i n d e x % m _ = _ ca l c u l % m _ )
exemple\organigramme\organigramme 2.agn
Notez l’utilisation de symboles automatiques dans cet exemple.
AUTOMGEN7
141
(C)opyright 2002 IRAI
Manuel de référence langage
1.15. Blocs fonctionnels
AUTOMGEN implémente la notion de blocs fonctionnels.
Cette méthode de programmation modulaire permet d’associer à un élément
graphique un ensemble d’instructions écrites en langage littéral.
Les blocs fonctionnels sont définissables par le programmeur. Leur nombre n’est
pas limité. Il est ainsi possible de constituer des ensembles de blocs fonctionnels
permettant une conception modulaire et standardisée des applications.
Les blocs fonctionnels s’utilisent à l’intérieur de schémas de types logigramme ou
ladder, ils possèdent de une à n entrées booléennes et de une à n sorties
booléennes. Si le bloc doit traiter des variables autres que booléennes, alors
celles-ci seront mentionnées dans le dessin du bloc fonctionnel. L’intérieur du bloc
peut recevoir des paramètres : constantes ou variables.
Entrées
booléennes du
bloc (maximum
16)
Paramètres du
bloc (maximum
16)
Sorties
booléennes du
bloc (maximum
16)
1.15.1. Création d’un bloc fonctionnel
Un bloc fonctionnel est composé de deux fichiers distincts. Un fichier portant
l’extension « .ZON » qui contient le dessin du bloc fonctionnel et un fichier portant
l’extension « .LIB » qui contient une suite d’instructions écrites en langage littéral
définissant le fonctionnement du bloc fonctionnel.
Les fichiers « .ZON » et « .LIB » doivent porter le nom du bloc fonctionnel. Par
exemple si nous décidons de créer un bloc fonctionnel « MEMOIRE », nous
AUTOMGEN7
142
(C)opyright 2002 IRAI
Manuel de référence langage
devrons créer les fichiers « MEMOIRE.ZON » (pour le dessin du bloc) et
« MEMOIRE.LIB » (pour le fonctionnement du bloc).
1.15.2. Dessin du bloc et création du fichier « .ZON »
L’enveloppe d’un bloc fonctionnel est constituée d’une boîte de code à laquelle il
faut ajouter des blocs dédiés aux blocs fonctionnels.
Pour dessiner un bloc fonctionnel il faut effectuer les opérations suivantes :
Ö utilisez l’assistant (conseillé)
Ou :
Ö dessiner une boîte de code (utilisez la commande « Plus …/Boîte de code » du
menu contectuel) :
Ö poser
un bloc
(touche [8]) sur le coin supérieur gauche de la boîte de
code :
Ö poser un bloc
(touche [9]) sur le coin supérieur droit de la boîte de code :
Ö effacer la ligne qui reste en haut du bloc (la touche [A] permet de poser des
blocs blancs) :
AUTOMGEN7
143
(C)opyright 2002 IRAI
Manuel de référence langage
Ö cliquez avec le bouton gauche de la souris sur le coin supérieur gauche du
bloc fonctionnel, entrer alors le nom du bloc fonctionnel qui ne doit pas
dépasser 8 caractères (les fichiers « .ZON » et « .LIB » devront porter ce nom),
presser ensuite [ENTER].
Ö si des entrées booléennes supplémentaires sont nécessaires, il faut utiliser un
bloc
(touche [;]) ou
(touche [:]), les entrées ainsi ajoutées doivent se
trouver immédiatement en dessous de la première entrée, aucun espace libre
ne doit être laissé,
Ö si des sorties booléennes supplémentaires sont nécessaires il faut ajouter un
bloc
(touche [>]) ou
(touche [?]), les sorties ainsi ajoutées doivent
se trouver immédiatement en dessous de la première sortie, aucun espace
libre ne doit être laissé,
Ö l’intérieur
du bloc peut contenir des commentaires ou des paramètres, les
paramètres sont écrits entre accolades « {...} ». Tout ce qui n’est pas écrit
entre accolades est ignoré par le compilateur. Il est intéressant de repérer
l’usage des entrées et des sorties booléennes à l’intérieur du bloc.
Ö lorsque
le bloc est terminé, il faut utiliser la commande « Sélectionner » du
menu « Edition » pour sélectionner le dessin du bloc fonctionnel, puis le
sauvegarder dans un fichier « .ZON » avec la commande « Copier vers » du
menu « Edition ».
AUTOMGEN7
144
(C)opyright 2002 IRAI
Manuel de référence langage
1.15.3. Création du fichier « .LIB »
Le fichier « .LIB » est un fichier texte contenant des instructions en langage littéral
(bas niveau ou étendu). Ces instructions définissent le fonctionnement du bloc
fonctionnel.
Une syntaxe spéciale permet de faire référence aux entrées booléennes du bloc,
aux sorties booléennes du bloc et aux paramètres du bloc.
Pour faire référence à une entrée booléenne du bloc, il faut utiliser la syntaxe
« {Ix} » ou x est le numéro de l’entrée booléenne exprimé en hexadécimal (0 à f).
Pour faire référence à une sortie booléenne du bloc, il faut utiliser la syntaxe
« {Ox} » ou x est le numéro de la sortie booléenne exprimé en hexadécimal (0 à f).
Pour faire référence à un paramètre du bloc, il faut utiliser la syntaxe « {?x} » ou x
est le numéro du paramètre en hexadécimal (0 à f).
Le fichier .LIB peut être placé dans sous-répertoire « lib » du répertoire
d’installation d’AUTOMGEN ou dans les ressources du projet.
1.15.4. Exemple simple de bloc fonctionnel
Créons le bloc fonctionnel « MEMOIRE » qui possède deux entrées booléennes
(mise à un et mise à zéro) et une sortie booléenne (l’état de la mémoire).
Le dessin du bloc contenu dans le fichier « MEMOIRE.ZON » est :
Le fonctionnement du bloc contenu dans le fichier « MEMOIRE.LIB » est :
{O0}=(1)({I0})
{O0}=(0)({I1})
Le bloc peut ensuite être utilisé de la façon suivante :
ou
AUTOMGEN7
145
(C)opyright 2002 IRAI
Manuel de référence langage
Pour utiliser un bloc fonctionnel dans une application il faut choisir la commande
« Coller à partir de » du menu « Edition » et choisir le fichier « .ZON »
correspondant au bloc fonctionnel à utiliser.
1.15.5. Illustration
Reprenons un exemple désormais classique.
Cahier des charges :
Aller et retour d’une locomotive sur la voie 1 de la maquette.
Solution :
t1d
ALLERRET
capteur droit
t1i
capteur gauche
alimentation
AV1
direction
DV1
BF aller/retour
exemple\bf\bloc-fonctionnel 1.agn
; bloc fonctionnel ALLERRET
; aller retour d’une locomotive sur une voie
; les entrées booléennes sont les fins de course
; les sorties booléennes sont l’alimentation de la voie (0) et la
direction (1)
; toujours alimenter la voie
set {O0}
; piloter la direction en fonction des fins de course
{O1}=(1)({I0})
{O1}=(0)({I1})
Pour illustrer l’intérêt de l’utilisation des blocs fonctionnels, complétons notre
exemple.
Cahier des charges :
Aller et retour de deux locomotives sur les voies 1 et 3.
AUTOMGEN7
146
(C)opyright 2002 IRAI
Manuel de référence langage
Solution :
t1d
A L L ER R E T
c a p t eu r d r o i t
t1i
c a p t eu r g a u c h e
a l i m e nt a t i o n
AV1
d i re c t i o n
DV1
a l i m e nt a t i o n
AV3
B F a ll e r / r e t o ur
t3d
A L L ER R E T
c a p t eu r d r o i t
t3i
c a p t eu r g a u c h e
d i re c t i o n
N D V3
B F a ll e r / r e t o ur
exemple\bf\bloc-fonctionnel 2.agn
Cet exemple montre qu’avec le même bloc fonctionnel, il est aisé de faire
fonctionner de façon identique différents modules d’une partie opérative.
Complétons notre exemple pour illustrer l’utilisation de paramètres.
Cahier des charges :
Les deux locomotives devront maintenant marquer une attente en bout de voie.
Pour la locomotive 1: 10 secondes à droite et 4 secondes à gauche, pour la
locomotive 2 : 20 secondes à droite et 8 secondes à gauche.
AUTOMGEN7
147
(C)opyright 2002 IRAI
Manuel de référence langage
Solution :
t1d
A R A TT
c a p t eu r d r o i t
t1i
c a p t eu r g a u c h e
a l i m e nt a t i o n
AV1
d i re c t i o n
DV1
t e m p or i s a t i o n 1 { t 0 }
a t t e nt e a d r o it e : { 1 00 }
t e m p or i s a t i o n 2 { t 1 }
a t t e nt e a g a u ch e : { 4 0}
B F a ll e r / r e t o ur a v e c at t e n t e
t3d
A R A TT
c a p t eu r d r o i t
t3i
c a p t eu r g a u c h e
a l i m e nt a t i o n
d i re c t i o n
AV3
N D V3
t e m p or i s a t i o n 1 { t 2 }
a t t e nt e a d r o it e : { 2 00 }
t e m p or i s a t i o n 2 { t 3 }
a t t e nt e a g a u ch e : { 8 0}
B F a ll e r / r e t o ur a v e c at t e n t e
AUTOMGEN7
148
(C)opyright 2002 IRAI
Manuel de référence langage
; bloc fonctionnel ARATT
; aller retour d'une locomotive sur une voie avec attente
; les entrées booléennes sont les fins de course
; les sorties booléennes sont l'alimentation de la voie (0) et la
direction (1)
; les paramètres sont :
;
0 : première temporisation
;
1 : durée de la première temporisation
;
2 : deuxième temporisation
;
3 : durée de la deuxième temporisation
; prédisposition des deux temporisations
${?0}={?1}
${?2}={?3}
; alimenter la voie si pas les fins de course ou si tempo. terminées
set {O0}
res {O0} orr {I0} eor {I1}
set {O0} orr {?0} eor {?2}
; gestion des temporisations
{?0}=({I0})
{?2}=({I1})
; piloter la direction en fonction des fins de course
{O1}=(1)({I0})
{O1}=(0)({I1})
exemple\bf\bloc-fonctionnel 3.agn
1.15.6. Complément de syntaxe
Une syntaxe complémentaire permet d’effectuer un calcul sur les numéros de
variables référencées dans le fichier « .LIB ».
La syntaxe « ~+n » ajoutée à la suite d’une référence à une variable ou un
paramètre, ajoute n.
La syntaxe « ~-n » ajoutée à la suite d’une référence à une variable ou un
paramètre, soustrait n.
La syntaxe « ~*n » ajoutée à la suite d’une référence à une variable ou un
paramètre, multiplie par n.
On peut écrire plusieurs de ces commandes à la suite, elles sont évaluées de la
gauche vers la droite.
Ce mécanisme est utile lorsqu’un paramètre du bloc fonctionnel doit permettre de
faire référence à une table de variables.
Exemples :
{?0}~+1
AUTOMGEN7
149
(C)opyright 2002 IRAI
Manuel de référence langage
fait référence à l’élément suivant le premier paramètre, par exemple si le premier
paramètre est m200 cette syntaxe fait référence à m201.
M{?2}~*100~+200
fait référence au troisième paramètre multiplié par 100 plus 200, par exemple si le
troisième paramètre est 1 cette syntaxe fait référence à M 1*100 + 200 donc
M300.
1.16. Blocs fonctionnels évolués
Cette fonctionnalité permet de créer des blocs fonctionnels très puissants avec
plus de simplicité que les blocs fonctionnels gérés par des fichiers écrits en
langage littéral. Cette méthode de programmation permet une approche de type
analyse fonctionnelle.
N’importe quel folio ou ensemble de folios peut devenir un bloc fonctionnel (on
parle parfois d’encapsuler un programme).
Le ou les folios décrivant le fonctionnement d’un bloc fonctionnel peuvent accéder
aux variables externes du bloc fonctionnel : les entrées booléennes du bloc, les
sorties booléennes et les paramètres.
Le principe d’utilisation et notamment l’utilisation des variables externes reste
identique aux anciens blocs fonctionnels.
1.16.1. Syntaxe
Pour référencer une variable externe d’un bloc fonctionnel il faut utiliser un
mnémonique incluant le texte suivant : {In} pour référencer l’entrée booléenne n,
{On} pour référencer la sortie booléenne n, {?n} pour référencer le paramètre n. Le
mnémonique doit commencer par une lettre.
1.16.2. Différencier anciens et nouveaux blocs fonctionnels
Le nom de fichier inscrit sur le dessin bloc fonctionnel indique s’il s’agit d’un
ancien (géré par un fichier .LIB) ou d’un nouveau bloc fonctionnel (géré par un
folio .GR7). Pour un ancien bloc fonctionnel le nom ne porte pas d’extension, pour
un nouveau l’extension .GR7 doit être ajoutée. Le folio contenant le code qui gère
le fonctionnement du bloc fonctionnel doit être intégré dans la liste des folios du
projet. Dans les propriétés du folio, le type « Bloc-fonctionnel » doit être choisi.
AUTOMGEN7
150
(C)opyright 2002 IRAI
Manuel de référence langage
1.16.3. Exemple
Contenu du folio VERINB :
BF vérin bistable
10
cde ouverture{i0} .
20
OUVRIR{O0}
o u ve r t { i 2 }
cde fermeture{i1} .
30
ouvert{i2}
ferme{i3} .
cde ouverture{i0}
FERMER{O1}
ferme{i3}
40
d u r e e {? 0 } / x 4 0 / t e m p o { ? 1 }
AUTOMGEN7
151
(C)opyright 2002 IRAI
Manuel de référence langage
Appel du bloc fonctionnel :
u100
V ER I N B . G R 7
CDE O
O
O0
u101
CDE F
F
O1
i1
O
i0
F
D u ré e
{ 1 0s }
T e mp o r i s a t i on
{ T 0}
V E RI N B I S T A BL E
exemple\bf\bloc-fonctionnel 3.agn
1.17. Blocs fonctionnels prédéfinis
Des blocs fonctionnels de conversion se trouvent dans le sous-répertoire « \LIB »
du répertoire où a été installé AUTOMGEN.
Les équivalents en macro-instructions sont également présents voir le chapitre
1.10.3. Le langage littéral bas niveau.
Pour insérer et paramétrer un bloc fonctionnel dans une application, sélectionnez
la commande « Insérer un bloc fonctionnel » du menu « Outils ».
1.17.1. Blocs de conversion
ASCTOBIN : conversion ASCII vers binaire
BCDTOBIN : conversion BCD vers binaire
BINTOASC : conversion binaire vers ASCII
BINTOBCD : conversion binaire vers BCD
GRAYTOB : conversion code gra vers binaire
16BINTOM : transfert de 16 variables booléennes dans un mot
AUTOMGEN7
152
(C)opyright 2002 IRAI
Manuel de référence langage
MTO16 BIN : transfert d’un mot vers 16 variables booléennes
1.17.2. Blocs de temporisation
TEMPO : temporisation à la montée
PULSOR : sortie à créneau
PULSE : impulsion temporisée
1.17.3. Blocs de manipulations de chaîne de caractères
STRCMP : comparaison
STRCAT : concaténation
STRCPY : copie
STRLEN : calcul de la longueur
STRUPR : mise en minuscules
STRLWR : mise en majuscules
1.17.4. Blocs de manipulation de table de mots
COMP : comparaison
COPY : copie
FILL : remplissage
1.18. Techniques avancées
1.18.1. Code généré par le compilateur
Nous allons aborder dans ce chapitre, la forme du code généré par la compilation
de tel ou tel type de programme.
L’utilitaire « CODELIST.EXE »* permet de traduire « en clair » un fichier de code
intermédiaire « .EQU » (aussi appelé langage pivot).
Faisons l’expérience suivante : chargeons et compilons le premier exemple de
programme
du
chapitre
« Grafcet »
:
« simple1.agn »
du
répertoire
« exemple\grafcet » :
*
Cet utilitaire doit être exécuté à partir de la ligne de commande DOS.
AUTOMGEN7
153
(C)opyright 2002 IRAI
Manuel de référence langage
0
A V1
t1 d
1
A V1 , DV1
t1 i
Double cliquez sur l’élément « Fichiers générés/Code pivot » dans le navigateur.
Vous obtenez la liste d’instructions suivantes :
; Le code qui suit a été généré par la compilation de : 'Folio : GRAF1'
:00000000: RES x0 AND i0
:00000002: SET x0 AND b0
:00000004: SET x0 AND x1
AND i1
:00000007: RES x1 AND i1
:00000009: SET x1 AND x0
AND i0
; Le code qui suit a été généré par la compilation de : 'affectations
(actions Grafcet, logigrammes et ladder)'
:0000000C: EQU o0 ORR @x0 EOR @x1
:0000000F: EQU o23 AND @x1
Elle représente la traduction de l’application « simple1.agn » en instructions du
langage littéral bas niveau.
Les commentaires indiquent la provenance des portions de code, cela est utile si
une application est composée de plusieurs folios.
Obtenir cette liste d’instructions peut être utile pour répondre aux questions
concernant le code généré par telle ou telle forme de programme ou l’utilisation de
tel ou tel langage.
Dans certains cas « critiques », pour lesquels il est important de connaître des
informations comme « au bout de combien de cycles cette action devient-elle
vraie ? » le mode pas à pas et l’examen approfondi du code généré s’avèrent
indispensables.
1.18.2. Optimisation du code généré
Plusieurs niveaux d’optimisation sont possibles.
AUTOMGEN7
154
(C)opyright 2002 IRAI
Manuel de référence langage
1.18.2.1. Optimisation du code généré par le compilateur
L’option d’optimisation du compilateur permet de réduire sensiblement la taille du
code généré. Cette directive demande au compilateur de générer moins de lignes
de langage littéral bas niveau, ce qui a pour conséquence d’augmenter le temps
de compilation.
Suivant les post-processeurs utilisés, cette option entraîne un gain sur la taille du
code et ou le temps d’exécution. Il convient d’effectuer des essais pour déterminer
si cette directive est intéressante ou pas suivant la nature du programme et le type
de cible utilisée.
Il est en général intéressant de l’utiliser avec les post-processeurs pour cibles Z.
1.18.2.2. Optimisation du code généré par les post-processeurs
Chaque post-processeur peut posséder des options pour optimiser le code
généré. Pour les post-processeurs qui génèrent du code constructeur veuillez
consulter la notice correspondante.
1.18.2.3. Optimisation du temps de cycle : réduire le nombre de
temporisations sur cibles Z
Pour les cibles Z, le nombre de temporisations déclarées influe directement sur le
temps de cycle. Veillez à déclarer le minimum de temporisations en fonction des
besoins de l’application.
1.18.2.4. Optimisation du temps de cycle : annuler la scrutation de
certaines parties du programme
Seules les cibles acceptant les instructions JSR et RET supportent cette
technique.
Des directives de compilation spéciales permettent de valider ou de « dévalider »
la scrutation de certaines parties du programme.
Ce sont les folios qui définissent ces portions d’application.
Si une application est décomposée en quatre folios alors chacun d’eux pourra être
indépendamment « validé » ou « dévalidé ».
Une directive « #C(condition) » placée sur un folio conditionne la scrutation du
folio jusqu’au folio contenant une directive « #R ».
AUTOMGEN7
155
(C)opyright 2002 IRAI
Manuel de référence langage
Cette condition doit utiliser la syntaxe définie pour les tests voir le chapitre 1.3. Les
tests
Exemple :
Si un folio contient les deux directives :
#C(m200=4)
#R
Alors tout ce qu’il contient ne sera exécuté que si le mot 200 contient 4.
AUTOMGEN7
156
(C)opyright 2002 IRAI
Manuel de référence langage
2. Exemples
2.1. A propos des exemples
Cette partie regroupe une série d’exemples donnant une illustration des différentes
possibilités de programmation offertes par AUTOMGEN.
Tous ces exemples se trouvent dans le sous répertoire « exemple » du répertoire où
a été installé AUTOMGEN.
Cette partie contient également des exemples plus complets et plus complexes
développés pour une maquette de train. La description de cette maquette se trouve
au début du manuel de référence langage.
2.1.1. Grafcet simple
Ce premier exemple est un Grafcet simple en ligne :
100
i0
110
T0 (100 )
t0
120
O0 ,O1, O2
i0
exemple\grafcet\sample1.agn
Ö la
transition entre l’étape 100 et l’étape 110 est constituée du test sur
l’entrée 0,
AUTOMGEN7
157
(C)opyright 2002 IRAI
Manuel de référence langage
Ö l’étape
110 active la temporisation 0 d’une durée de 10 secondes, cette
temporisation est utilisée comme transition entre l’étape 110 et l’étape 120,
Ö l’étape 120 active les sorties 0, 1 et 2,
Ö le complément de l’entrée 0 sert de transition entre l’étape 120 et 100.
2.1.2. Grafcet avec divergence en OU
100
i0
11 0
O1
i4
11 1
O0
i1
1 20
i2
O2
130
i5
i6
O5
131
i8
11 2
O3
i3
1 40
O4
i7
O6
i9
O7
i10
exemple\grafcet\sample2.agn
Cet exemple illustre l’utilisation des divergences et convergences en « Ou ». Le
nombre de branches n’est limité que par la taille du folio. Il s’agit comme le prévoit la
norme, d’un « Ou » non exclusif. Si par exemple, les entrées 1 et 2 sont actives,
alors les étapes 120 et 130 seront mises à un.
AUTOMGEN7
158
(C)opyright 2002 IRAI
Manuel de référence langage
2.1.3. Grafcet avec divergence en ET
100
i0
110
O0
130
i1
120
O1
160
SO2
170
O4
190
O3
i2
140
i2
150
i4
O5
180
RO2
i7
exemple\grafcet\sample3.agn
Cet exemple illustre l’utilisation des divergences et convergences en « Et ». Le
nombre de branches n’est limité que par la taille du folio. Notons également au
passage les points suivants :
Ö une étape peut ne pas comporter d’action (cas des étapes 100, 120, et 140),
Ö les ordres « S » et « R » ont été utilisés avec la sortie o2 (étapes 160 et
180),
Ö la
transition entre l’étape 160 et 170 est laissée blanche, elle est donc
toujours vraie, la syntaxe « =1 » aurait pu aussi être utilisée.
AUTOMGEN7
159
(C)opyright 2002 IRAI
Manuel de référence langage
2.1.4. Grafcet et synchronisation
0
100
i0
1
Çx1
110
Èx110
i10
O0
i1
i14
O4
i11
O1
i12
O2
i13
O3
exemple\grafcet\sample4.agn
Cet exemple illustre une des possibilités offertes par AUTOMGEN pour synchroniser
plusieurs Grafcets. La transition entre l’étape 100 et 110 « Ïx1 » signifie « attendre
un front montant sur l’étape 1 ». La transition « Ðx110 » signifie « attendre un front
descendant sur l’étape 110 ». L’exécution pas à pas de ce programme montre
l’évolution exacte des variables et de leur front à chaque cycle. Ceci permet de
comprendre exactement ce qu’il se passe lors de l’exécution. Notons également
l’utilisation d’actions multiples associées à l’étape 110, qui sont ici conditionnées
individuellement.
AUTOMGEN7
160
(C)opyright 2002 IRAI
Manuel de référence langage
2.1.5. Forçage d’étapes
10
RC0
i0
20
100
SX100
Çi4
110
30
+C0
i1
x120
120
exemple\grafcet\sample5.agn
Dans cet exemple, un ordre « S » (mise à un) a été utilisé pour forcer une étape.
AUTOMGEN autorise également le forçage d’un Grafcet entier (voir exemples 8 et 9)
Le mode d’exécution pas à pas permet, pour cet exemple aussi, de comprendre de
façon précise l’évolution du programme dans le temps. Notons également :
Ö l’utilisation d’un Grafcet non rebouclé (100, 110, 120),
Ö l’utilisation de l’ordre « RC0 » (mise à zéro du compteur 0),
Ö l’utilisation de l’ordre « +C0 » (incrémenter le compteur 0), conditionné par le
front montant de l’entrée 4, pour exécuter l’incrémentation du compteur, il
faut donc que l’étape 110 soit active et qu’un front montant soit détecté sur
l’entrée 4.
AUTOMGEN7
161
(C)opyright 2002 IRAI
Manuel de référence langage
2.1.6. Etapes puits et sources
Çi 0. i 1
100
O0
Çi 0
110
O1
Çi 0
120
O2
Çi 0
130
O3
Çi 0
exemple\grafcet\sample6.agn
Nous avons déjà rencontré des formes similaires, dont la première étape était activée
par un autre Grafcet. Ici l’activation de l’étape 100 est réalisée par la transition « Ïi0
. i1 » (front montant de l’entrée 0 et l’entrée 1). Cet exemple représente un registre à
décalage. « i1 » est l’information à mémoriser dans le registre et « i0 » est l’horloge
qui fait progresser le décalage. L’exemple 7 est une variante qui utilise une
temporisation comme horloge.
AUTOMGEN7
162
(C)opyright 2002 IRAI
Manuel de référence langage
2.1.7. Etapes puits et sources
Çt 0 . i 1
100
O0
Çt 0
110
O1
Çt 0
120
O2
Çt 0
130
O3
t0
1000
T0(10)
Çt 0
exemple\grafcet\sample7.agn
Nous retrouvons la structure de registre à décalage utilisé dans l’exemple 6.
L’information de décalage est cette fois générée par une temporisation (t0). « Ït0 »
représente le front montant de la temporisation, cette information est vraie pendant
un cycle lorsque la temporisation a fini de décompter. L’étape 1000 gère le
lancement de la temporisation. On peut résumer l’action de cette étape par la phrase
suivante : « activer le décomptage si celui-ci n’est pas terminé, dans le cas contraire,
réarmer la temporisation ». Le diagramme de fonctionnement des temporisations de
ce manuel vous aidera à comprendre le fonctionnement de ce programme.
AUTOMGEN7
163
(C)opyright 2002 IRAI
Manuel de référence langage
2.1.8. Forçage de Grafcets
0
100
arret urgence
1
Ç bp depart de cycle
F100:{}
110
arret urgence
2
VOYANT INIT
MOTEUR
bp fin de cycle
F100:{100}
exemple\grafcet\sample8.agn
Cet exemple illustre l’utilisation d’une commande de forçage de Grafcet. L’ordre
« F100:{} » signifie « forcer toutes les étapes du Grafcet dont une des étapes porte le
numéro 100 à zéro ». L’ordre « F100:{100} » est identique mais force l’étape 100 à 1.
Pour cet exemple, nous avons utilisé des symboles :
AUTOMGEN7
164
(C)opyright 2002 IRAI
Manuel de référence langage
2.1.9. Mémorisation de Grafcets
# B2 0 0
0
100
a r r et u rg e n c e
1
V O YA N T I N I T
Ç b p d e p ar t d e c y c le
G 1 0 0: 1 0 0
110
M O TE U R
b p fi n de c y cl e
2
F 1 0 0: ( )
a r re t ur g e n ce
3
F 1 0 0: 1 0 0
exemple\grafcet\sample9.agn
Cet exemple est une variante du programme précédent. L’ordre « G100:100 » de
l’étape 1 mémorise l’état du Grafcet de production avant qu’il ne soit forcé à zéro. A
la reprise, le Grafcet de production sera replacé dans l’état où il était avant la
coupure, avec l’ordre « F100:100 ». L’état du Grafcet de production est mémorisé à
partir du bit 100 (c’est le deuxième paramètre des ordres « F » et « G » qui précise
cet emplacement), la directive de compilation « #B200 » réserve les bits u100 à u199
pour ce type d’utilisation. Notons qu’une directive « #B102 » aurait suffit ici puisque
le Grafcet de production ne nécessite que deux bits pour être mémorisé (un bit par
étape).
AUTOMGEN7
165
(C)opyright 2002 IRAI
Manuel de référence langage
2.1.10. Grafcet et macro-étapes
0
O0
i0
1
i1
2
O1
i2
3
i3
E
10
SO10
i10
20
RO10
S
exemple\grafcet\sample11.agn
AUTOMGEN7
166
(C)opyright 2002 IRAI
Manuel de référence langage
Cet exemple illustre l’utilisation des macro-étapes. Les folio « Macro étape 1 » et
« Macro étape 3 » représentent l’expansion des macro-étapes avec les étapes
d’entrées et de sorties. Les étapes 1 et 3 du folio « Programme principal » sont
définies comme macro-étapes. L’accès aux expansions de macro-étapes en
visualisation est réalisé en cliquant avec le bouton gauche de la souris sur les macroétapes.
2.1.11. Folios chaînés
0
O0
i0
1
O1
i1
2
O2
i2
3
SUITE
c o n t i n ue
AUTOMGEN7
167
(C)opyright 2002 IRAI
Manuel de référence langage
4
O3
suite
5
O4
i3
6
O5
i4
7
C O N T I NU E
exemple\grafcet\sample12.agn
Dans cet exemple, deux folios ont été utilisés pour écrire le programme. Les
symboles « _SUITE_ » et « _CONTINUE_ » ont été déclarés comme bits (voir le
fichier des symboles) et permettent de faire le lien entre les deux Grafcets (c’est une
autre technique de synchronisation utilisable avec AUTOMGEN).
AUTOMGEN7
168
(C)opyright 2002 IRAI
Manuel de référence langage
2.1.12. Logigramme
i0
O
O0
i1
i2
&
O
i3
i4
i5
i6
&
i7
i8
i9
i1 0
exemple\logigramme\sample14.agn
Cet exemple développé en logigrammes montre l’utilisation des différents blocs : le
bloc d’affectation associé à la touche [0] à gauche du rectangle d’action, le bloc
« pas » associé à la touche [1] qui complémente un signal, ainsi que les blocs
d’ancrage de tests et les fonctions « Et » et « Ou ».
AUTOMGEN7
169
(C)opyright 2002 IRAI
Manuel de référence langage
2.1.13. Grafcet et Logigramme
0
Ç bp depart de cycle
1
fin de cycle
bp manuel
MOTEUR
étape 1
&
sécurité 1
O
sécutité 2
O
exemple\logigramme\exempl15.agn
Dans cet exemple un Grafcet et un Logigramme sont utilisés conjointement. Le
symbole « _étape 1_ » utilisé dans le logigramme est associé à la variable « x1 ».
Ce type de programmation laisse apparaître clairement les conditions d’activation
d’une sortie.
AUTOMGEN7
170
(C)opyright 2002 IRAI
Manuel de référence langage
2.1.14. Boîte de langage littéral
0
SO0
1
m200=[0]
; m200 est utilisé comme index
res _flag une entrée est à un_
WHILE( _flag une entrée est à un_.m200<100)
IF(i(200))
THEN
set _flag une entrée est à un_
ENDIF
inc m200
ENDWHILE
flag une entrée est à un
flag une entrée est à u
2
RO0
exemple\lit\sample16.agn
Ce programme qui associe Grafcet et boîte de langage littéral a pour objet de tester
les entrées i0 à i99. Si une de ces entrées est à un, alors l’étape 2 est activée et le
Grafcet se retrouve dans un état ou toute évolution est interdite. Le symbole « _flag
une entrée est à un_ » est associé au bit u500. Un adressage indexé a été utilisé
pour balayer les 100 entrées. Notons également l’emploi simultané du langage littéral
bas niveau et étendu.
AUTOMGEN7
171
(C)opyright 2002 IRAI
Manuel de référence langage
2.1.15. Organigramme
IF(_bp validation_)
bta _entrée roue codeuse_
ana %0000000000000111
sta _valeur roue codeuse_
; fin
exemple\organigramme\sample18.agn
Cet exemple illustre l’utilisation d’un organigramme pour effectuer un traitement
algorithmique et numérique. Ici trois entrées provenant d’une roue codeuse sont lues
et stockées dans un mot si une entrée de validation est active.
AUTOMGEN7
172
(C)opyright 2002 IRAI
Manuel de référence langage
2.1.16. Organigramme
m200=[10]
o(200)=(1)
m200=[m200+1]
IF(m200=30)
; Fin de la
; boucle
exemple\organigramme\sample19.agn
Ce deuxième exemple d’organigramme réalise une structure de boucle qui permet de
forcer à un une série de sorties (o10 à o29) avec un adressage indirect (« o(200) »).
AUTOMGEN7
173
(C)opyright 2002 IRAI
Manuel de référence langage
2.1.17. Bloc fonctionnel
i16
RO0
i17
&
i0
C O M P T A GE
R.A.Z.
i1
COMPTAGE
SO0
V A L . I N IT
{100}
B O R N E M AX
{110}
VARIABLE
{m200}
exemple\bf\sample20.agn
; Gestion de l'entrée de RAZ
IF({I0})
THEN
{?2}=[{?0}]
ENDIF
; Gestion de l'entrée de comptage
IF(#{I1})
THEN
{?2}=[{?2}+1]
ENDIF
; Teste la borne maxi
IF({?2}={?1})
THEN
{O0}=(1)
{?2}=[{?0}]
ENDIF
ELSE
{O0}=(0)
ENDIF
comptage.lib (inclus dans les ressources du projet)
AUTOMGEN7
174
(C)opyright 2002 IRAI
Manuel de référence langage
Cet exemple illustre l’utilisation d’un bloc fonctionnel. Les fonctions du bloc
« COMPTAGE » que nous avons définies ici sont les suivantes :
Ö le
comptage se fera en partant d’une valeur d’init et se terminera à une
valeur de borne maximale,
Ö lorsque la variable de comptage atteindra la borne maximale elle sera forcée
à la valeur d’init et la sortie du bloc passera à un pendant un cycle
programme,
Ö le bloc possédera une entrée booléenne de RAZ et une entrée de comptage
sur front montant.
2.1.18. Bloc fonctionnel
O U _ E X C LU
O U _ E X CL U
=1
=1
i0
i1
O U _ E X C LU
i2
=1
i3
O U _ E X C LU
O U _ E X CL U
=1
=1
i4
O0
i5
exemple\bf\sample21.agn
; Ou exclusif
neq {o0} orr /{i0} eor {i1} orr {i0} eor /{i1}
ou_exclu.lib (inclus dans les ressources du projet)
Ce deuxième exemple de bloc fonctionnel illustre l’utilisation multiple d’un même
bloc. Le bloc « OU_EXCLU » réalise un ou exclusif entre les deux entrées
booléennes. Cet exemple utilise 5 blocs pour réaliser un ou exclusif entre 6 entrées
(i0 à i5). Le fichier « OU_EXCLU.LIB » listé dessous régit le fonctionnement du bloc.
AUTOMGEN7
175
(C)opyright 2002 IRAI
Manuel de référence langage
L’équation booléenne du ou exclusif est la suivante : « (i0./i1)+(/i0.i1) ». La forme
équivalente utilisée ici permet de coder l’équation sur une seule ligne de langage
littéral bas niveau sans utiliser de variables intermédiaires.
2.1.19. Ladder
i0
i7
i1
i8
i2
i9
O0
i3
i10
O1
i4
i11
O2
i5
i12
O3
i6
i13
O4
exemple\laddersample22.agn
Cet exemple illustre l’utilisation de la programmation en ladder.
AUTOMGEN7
176
(C)opyright 2002 IRAI
Manuel de référence langage
2.1.20. Exemple développé sur une maquette de train
AUTOMGEN7
177
(C)opyright 2002 IRAI
Manuel de référence langage
AUTOMGEN7
178
(C)opyright 2002 IRAI
Manuel de référence langage
AUTOMGEN7
179
(C)opyright 2002 IRAI
Manuel de référence langage
AUTOMGEN7
180
(C)opyright 2002 IRAI
Manuel de référence langage
AUTOMGEN7
181
(C)opyright 2002 IRAI
Manuel de référence langage
AUTOMGEN7
182
(C)opyright 2002 IRAI
Manuel de référence langage
Les aventures de Docteur R.
Manuel pédagogique à l’usage des utilisateurs d’AUTOMGEN
AUTOMGEN7
183
(C)opyright 2002 IRAI
Manuel de référence langage
Distribution
Docteur R. ………………………………………………… Monsieur R.
C’est délicat comme ça tout
le monde sait que je ne suis
pas vraiment docteur.
Docteur R. au royaume de la domotique
Nous allons aborder différents exemples pouvant directement s’appliquer dans un
projet de domotique. D’un premier abord simple, ces exemples nous permettront
d’appréhender différents aspects de la base des automatismes et de
l’apprentissage d’AUTOMGEN et d’IRIS.
Rien entre domino et doryphore.
Peuvent pas parler comme tout le
monde les gens d'IRAI.
AUTOMGEN7
185
(C)opyright 2002 IRAI
Manuel de référence langage
Ce symbole évoquera dans ce qui suit une partie commande (un automate
programmable par exemple.
Est-il besoin de préciser que ceci
évoquera une ampoule,
un bouton poussoir
et cela un interrupteur ?
Premier exemple : « qui de l’interrupteur ou de
l’ampoule était le premier … »
Un simple interrupteur et une simple ampoule : l’interrupteur est câblé sur l’entrée
i0, l’ampoule sur la sortie o0. Si l’interrupteur est fermé alors l’ampoule s’allume, si
l’interrupteur est ouvert l’ampoule s’éteint. Difficile de faire plus simple.
Se torturer pareillement l’esprit
pour allumer une ampoule. Faut
être sacrément tordu ! ! !
AUTOMGEN7
186
(C)opyright 2002 IRAI
Manuel de référence langage
Solution 1 : le langage naturel de l’électricien : le ladder
Le contact
La bobine
Le ladder est la transcription la plus directe du schéma électrique. Le contact
reçoit le nom de l’entrée où est câblé l’interrupteur, la bobine le nom de la sortie
où est câblée l’ampoule.
Solution 2 : le langage séquentiel de l’automaticien : le
Grafcet
Une étape
0
Une transition
i0
Une autre étape
1
O0
Un rectangle
d’action
/i0
Une autre transition
Le Grafcet est basé sur la notion d’état. Pour notre problème nous pouvons dire
qu’il y a deux états : l’état allumé et l’état éteint. Chaque étape représente un état :
ici l’étape 0 représente l'état éteint et l’étape 1 l’état allumé. Reste à déterminer la
AUTOMGEN7
187
(C)opyright 2002 IRAI
Manuel de référence langage
condition qui fait évoluer de l’état éteint à l’état allumé : ici l’interrupteur fermé
(noté i0) puis la condition qui fait passer de l’état allumé à l’état éteint : ici
l’interrupteur ouvert (noté / i0). Les conditions sont écrites à droite de l’élément
noté transition. Le rectangle associé à l’étape 1 nommé rectangle d’action contient
le nom de la sortie O0 (sortie où est câblée notre ampoule). Ainsi, à tout instant
l’état de l’ampoule est le même que celui de l’étape 1.
AUTOMGEN7
188
(C)opyright 2002 IRAI
Manuel de référence langage
Les heureux possesseurs d’IRIS peuvent utiliser deux objets BPVOYANT pour
simuler ce premier exemple.
Peuvent pas
s’empêcher de faire
de la promotion.
AUTOMGEN7
189
(C)opyright 2002 IRAI
Manuel de référence langage
A vous de jouer …
L’interrupteur 1 allume l’ampoule 1, l’interrupteur 2 l’ampoule numéro 2. Une
solution Grafcet vous est proposée à la fin de ce document.
Je me demande si c’est deux fois
plus compliqué ou deux fois moins
simple que le premier exemple.
Deuxième exemple : « temporisations, minuteries et
autres amusements temporels… »
A propos il est
gruyère moins dix
minutes.
AUTOMGEN7
190
(C)opyright 2002 IRAI
Manuel de référence langage
Comme vous vous en doutez certainement, la notion de temporisation est utilisée
lorsqu’un programme doit, d’une façon ou d’une autre, effectuer des actions en
tenant compte d’une donnée relative au temps. Attendre un certain temps avant
de faire une action ou faire une action pendant un certain temps par exemple.
Notre deuxième exemple est le suivant : un couloir est équipé d’une ampoule et
de deux boutons poussoirs. L’appui sur un des deux boutons poussoirs provoque
l’allumage de l’ampoule pendant 2 minutes (d’après Dr R. c’est largement suffisant
pour traverser le couloir).
Solution 1 : la simplicité
0
i0+i1
1
O0
Allumer l’ampoule si le bouton
poussoir 1 est pressé ou si le
bouton poussoir 2 est pressé.
« Ou » s’écrit « + » dans une
transition.
t0/x1/120s
Attendre 2 minutes (120 secondes) en utilisant la
temporisation 0, c’est l’étape 1 qui lance la
temporisation.
AUTOMGEN7
191
(C)opyright 2002 IRAI
Manuel de référence langage
Solution 2 : amélioration
Un problème posé par cette solution est que si l’on appuie sur un bouton poussoir
pendant que l’ampoule est allumée, alors on ne réarme pas la temporisation. Ainsi
Dr R. croyant avoir réarmé la minuterie s’est retrouvé dans le noir la semaine
dernière.
0
↑(i0+i1)
1
O0
↑(i0+i1)
t0/x1/120s
2
=1
Et si vous vous lanciez dans l’écriture d’un vrai programme …
AUTOMGEN7
192
(C)opyright 2002 IRAI
Manuel de référence langage
Une gestion intelligente de l’éclairage du couloir : une ampoule a
été placée à chaque extrémité. Lorsqu’on appuie sur un
interrupteur : les deux ampoules s’allument, puis l’ampoule se
trouvant du côté de l’interrupteur pressé s’éteint au bout de 30
secondes et enfin l’autre ampoule au bout d’une minute.
Troisième exemple : « variation sur le thème du va et
vient… »
Rappelons le principe au combien génial du va et vient : deux interrupteurs
permettent d’allumer ou d‘éteindre la même ampoule.
AUTOMGEN7
193
(C)opyright 2002 IRAI
Manuel de référence langage
Voici une solution en logigramme :
i0
O &
O0
i1
O &
Les puristes auront reconnu l’équation booléenne du ou exclusif.
Les choses deviennent réellement intéressantes si l’on souhaite conserver les
propriétés du va et vient avec un nombre d’interrupteurs supérieur à 2.
AUTOMGEN7
194
(C)opyright 2002 IRAI
Manuel de référence langage
Une solution utilisant le langage littéral d’AUTOMGEN.
bta i0
sta m203 ; le mot m203 contiendra l'état de 16 entrées
m200=[0] ; ce mot contiendra le nombre d'interrupteurs
; allumés
m201=[4] ; compteur pour quatre interrupteurs
m202=[1] ; pour tester les bits de m203
while (m201>0)
m204=[m202&m203]
if(m204>0)
then
inc m200
endif
dec m201
m202=[m202<1]
endwhile
; arrivé ici, m200 contient le nombre d'interrupteurs à 1
; il suffit de transférer le bit de poids faible de m200
; vers la sortie
o0=(m200#0)
AUTOMGEN7
195
(C)opyright 2002 IRAI
Manuel de référence langage
Une autre plus astucieuse :
0
↑i0+ ↓i0+ ↑i1+ ↓i1+ ↑i2+ ↓i2+ ↑i3+ ↓i3
1
IO0
=1
« IO0 » signifie « inverser l’état de la sortie 0 ».
Essayez ceci :
Une grande pièce avec 6 interrupteurs et 10 ampoules. Chaque
interrupteur permet d’éclairer plus ou moins la pièce (en clair de
passer d’un état où tout est éteint à un état où une ampoule est
allumée, puis deux, etc …).
AUTOMGEN7
196
(C)opyright 2002 IRAI
Manuel de référence langage
Quatrième exemple : « Et le bouton poussoir devint
intelligent … »
Dans tous les exemples précédents, les boutons poussoirs n’ont réalisés qu’une
seule fonction. Entendez par là que la personne qui les manipule n’a que deux
choix : ne pas appuyer dessus ou appuyer dessus pour obtenir une fonction
(allumer ou éteindre). Imaginons un bouton poussoir « plus performant » capable
de recevoir deux types de pression : une pression courte (arbitrairement moins de
1 seconde) ou une pression longue (arbitrairement au moins une seconde).
Dans cinq minutes vont nous
faire croire qu’ils ont inventé
le morse.
Pour cet exemple quatre boutons poussoirs et quatre ampoules. Par défaut, en
utilisation normale chacun des boutons poussoirs est associé à une ampoule. Une
pression courte sur un bouton poussoir allume ou éteint l’ampoule associée.
Chaque bouton poussoir doit permettre de piloter chaque ampoule ou la totalité
des ampoules. Le tableau ci-dessous résume le fonctionnement.
Type d’action sur les boutons poussoirs
Résultat
Une pression courte
L’ampoule associée change d’état
Une pression longue et une pression courte
L’ampoule numéro 1 change d’état
Une pression longue et deux pressions courtes
L’ampoule numéro 2 change d’état
Une pression longue et trois pressions courtes
L’ampoule numéro 3 change d’état
Une pression longue et quatre pressions courtes
L’ampoule numéro 4 change d’état
Deux pressions longues et une pression courte
Toutes les ampoules s’éteignent
Deux pressions longues et deux pressions courtes
Toutes les ampoules s’allument
AUTOMGEN7
197
(C)opyright 2002 IRAI
Manuel de référence langage
AUTOMGEN7
198
(C)opyright 2002 IRAI
i0
M200#0
i1./i0
M200#1
i2./i0./i1
M200#2
i3./i0./i1./i2
M200#3
Manuel de référence langage
Attendre qu'un bouton poussoir soit enfoncé
0
{M201=[M200]}
m200<>0
10
m200=0
Relâché rapidement
Inverser l'état de l'ampoule associée
30
t0/x10/1s.m200<>0
Toujours enfoncé au bout d'une seconde
40
{BTA O0,XRA M201,ATB O0}
RM210,RM211
RAZ compteur nombre d'appuis longs et nombre d'appuis courts
m200=0
Attendre que le bp soit relâchée
=1
50
m200=0.t2/x50/1s
Suivant le nombre de pressions ...
{M201=[M200]}
m200<>0
60
m210=1.m211=0
100
IO0
m200=0
Relâché rapidement
m210=2.m211=0
IO1
70
+M210
t1/x60/1s.m200<>0
Toujours enfoncé au bout d'une seconde
80
=1
m210=3.m211=0
+M211
=1
90
IO2
m200=0
Attendre que le bp soit relâché
m210=4.m211=0
IO3
m210=1.m211=1
RO0,RO1,RO2,RO3
m210=2.m211=1
SO0,SO1,SO2,SO3
=1
AUTOMGEN7
199
(C)opyright 2002 IRAI
Manuel de référence langage
Ceci termine ce manuel pédagogique. Nous espérons qu’il vous
aura permis de découvrir les possibilités d’AUTOMGEN.
Nous vous proposons un ultime exercice.
Automatiser l’appartement de votre tante Hortense en respectant son goût
immodéré pour les interrupteurs nickelés.
Il était temps que cette
notice touche à sa fin.
AUTOMGEN7
200
(C)opyright 2002 IRAI
Manuel de référence langage
Les solutions …
« qui de l’interrupteur ou de l’ampoule était le premier … »
0
D’habitude il
faut toujours
un miroir pour
lire les
solutions.
2
i0
1
i1
O0
3
/i0
O1
/i1
Il suffit d’écrire deux Grafcets identiques. Chacun s’occupe indépendamment d’un
interrupteur et d’une ampoule.
« temporisations,
minuteries
et
autres
amusements
temporels… »
0
↑i0
10
O0,O1
↑i1
50
t0/x10/30s
30
O1
t1/x30/30s
O0,O1
t2/x50/30s
70
O0
t3/x70/30s
Une version simple sans la gestion du réarmement de la minuterie.
AUTOMGEN7
201
(C)opyright 2002 IRAI
Manuel de référence langage
0
↑i0
10
↑i1
↑i0
↑i1
O0,O1
50
t0/x10/30s
20
30
O1
O0,O1
↑i1
t2/x50/30s
70
O0
60
=1
↑i1
↑i0
=1
↑i0
t1/x30/30s
↑i1
t3/x70/30s
40
↑i0
80
=1
=1
Le réarmement de la minuterie rend le programme très complexe.
↑i0
0
x10
RT0
x30
F0:{10}
x50
↑i0
10
O0,O1
↑i1
50
t0/x10/30s
30
O1
x70
O0,O1
↑i1
t2/x50/30s
70
t1/x30/30s
O0
x50
RT2
x10
F0:{50}
x30
t3/x70/30s
x70
Une troisième solution utilisant Grafcet, langage ladder et forçages de Grafcet. Le
programme reste lisible.
AUTOMGEN7
202
(C)opyright 2002 IRAI
Manuel de référence langage
« variation sur le thème du va et vient …»
0
{BTA I0,ANA %11111,STA M200}
m200<>m201
1
{LDA M200,STA M201}
o0
SO0
=1
SO1
o4
SO5
o1
SO2
o5
SO6
o2
SO3
o6
SO7
o3
SO4
o7
SO8
o8
SO9
o9
RO0,RO1,RO2,RO3,RO4,RO5,RO6,RO7,RO8,RO9
AUTOMGEN7
203
(C)opyright 2002 IRAI
">