Ces fonctions sont disponibles sur tous les automates, des plus simples aux plus évolués. Je vais définir un langage fictif (qui me servira pour la suite, dans la définition des méthodes). Ce chapitre continuera par une présentation succinte des instructions des différents matériels et langages utilisés dans la suite du document pour appliquer les méthodes présentées.
Je vais définir un automate ficitif (que j'apellerai par la suite AF), ainsi que son langage. Je fais ceci car les langages des automates sont très différents, pas très clairs, mais ils reviennent tous au même.
Un automate traite des variables booléennes (ne pouvant valoir que 0 ou 1). On distingue les entrées (en lecture seule), les sorties (en écriture mais généralement on peut les relire, au cas où on aurait oublié ce qu'on a allumé en sortie), et les variables internes (pour stocker les calculs intermédiaires) en lecture et écriture. Pour l'AF, je noterai les entrées Ei, les sorties Si, les variables internes Vi ou un nom en clair.
On dispose au moins des fonctions combinatoires ET, OU et NON, souvent plus (ou exclusif par exemple). Pour l'AF je supposerai pouvoir écrire une opération sous la forme : Résultat <= calcul, avec résultat pouvant être un sortie ou une variable interne, calcul une équation utilisant des entrées ou variables internes, les opérateurs ET, OU, / (complément) et parenthèses. Exemple : S3 <= (E1 ET /V3) OU V2 . On peut remarquer que dans la plupart des automates un tel calcul devrait se décomposer en plusieurs lignes de programme.
Pour gérer le séquentiel, on dispose de la bascule. Je la noterai : SI condition, résultat <= 1 ou 0. J'accepterai une condition complexe (comportant des opérateurs combinatoires), mais souvent dans la réalité il faudra passer par un calcul mémorisé dans une variable interne. Exemple : SI (E1 ET E2) ALORS S3 <= 1 .
La temporisation se notera : SI condition ALORS résultat <= 1 APRES n secondes. La temporisation est réinitialisée dès que la condition repasse à 0. Celle-ci doit donc rester validée tout le temps du comptage. Ce fonctionnement est admis sur tout les automates, mais souvent d'autres options sont possibles (déclenchement sur un front montant par exemple).
Certains automates autorisent des sauts (GOTO). Je les noterai SAUT. La destination du saut (en général un numéro de ligne) sera donné en AF par un label : un nom suivi du signe ":". Les automates qui n'acceptent pas les sauts bouclent continuellement sur l'ensemble du programme, mais certaines parties peuvent être invalidées suivant l'état de certaines variables, ce qui revient donc au même. Certains permettent également un saut conditionnel : SI condition SAUT. Exemple :
hors boucle label : dans boucle SI E1 SAUT label
Voyons quelques exemples d'automates réels :
Step 7 permet l'accès "de base" aux automates Siemens. Il permet de programmer individuellement un automate (en différents langages). Il prend également en compte le réseau des automates, ce qui permet d'accéder à tout automate du réseau (pour le programmer), et éventuellement aux automates de s'envoyer des messages entre eux. Vous pourrez trouver une documentation plus complète dans mes documents "programmation Siemens S7"
De base, les entrées ToR se notent E a.b (E=ein) avec a l'adresse du module, b étant le numéro du bit dans l'octet (entre 0 et 7). Exemple : E0.4 est la cinquième entrée du premier bloc d'entrées) les sorties se notent A a.b (A=Aus). Les entrées et les sorties peuvent utiliser les mêmes adresses, les 32 entrées du premier bloc s'appellent E0.0 à E3.7, les 32 sorties du second bloc s'appellent A0.0 à A3.7. On peut également accéder directement à un octet complet (B), un mot (W) de deux octets, un double mot (D) de 4 octets. Pour stocker des résultats intermédiaire, on dispose de mémoires internes (mémento) nommés en ToR M0.0 à M65535.7 (si on a assez de mémoire), ou MB, MW, MD. Pour l'arithmétique on dispose aussi des types int, dint, real, char, date, time...
Le programme sera placé dans l'automate (->programme->blocs). Le "programme principal" s'appelle obligatoirement OB1 (OB= Bloc d'Organisation, contient un bout de programme, on pourrait aussi appeler cela un sous-programme). Il faut avant tout choisir son langage préféré (dans "affichage" s'il ne le propose pas automatiquement) : CONT (langage à contacts), LIST (langage textuel), ou LOG (portes logiques). D'autres langages (optionnels) existent, les trois qui me semblent les plus intéressants sont SCL (langage proche du Pascal, permettant des algorithmes et calculs complexes), GRAPH (proche du Grafcet), HiGRAPH (proche des réseaux de Petri).
C'est une suite de réseaux qui seront parcourus séquentiellement. Les entrées sont représentées par des interrupteurs -| |- (ou -|/|- si entrée inversée), les sorties par des bobines -( ) ou des bascules -(S) -(R).Il y a également des opérations unaires (une entrée une sortie) : l'inverseur -|NOT|-, l'attente d'un front montant -(P)- ou descendant -(N)-. Les sorties sont obligatoirement à droite du réseau On doit évidemment définir nos E/S, soit directement par leur code (E a.b / A a.b), ou avec leur nom en clair défini dans la table des mnémoniques (entrez le nom entre guillemets). On relie les éléments en série pour la fonction ET, en parallèle pour le OU. On peut utiliser des bits internes (peuvent servir en bobines et interrupteurs), comme on utilise dans une calculatrice une mémoire pour stocker un résultat intermédiaire (M a.b). On peut aussi introduire des éléments plus complexes, en particulier les opérations sur bits comme par exemple une bascule SR (priorité déclenchement), RS (priorité enclenchement), POS et NEG pour la détection de fronts...
Le programme est en général décomposé en plusieurs réseaux, par exemple un réseau par sortie (2 parties du schéma non reliées entre elles doivent être dans deux réseaux différents). Les réseaux sont exécutés séquentiellement.
C'est un langage graphique, utilisant les symboles de l'électronique numérique (portes logiques). Il n'y a rien de spécial à dire, c'est très intuitif. On peut utiliser plusieurs entrées pour une même porte, placer des inverseurs sur les entrées.... Ici, on découpe son programme en plusieurs réseaux (en général quand un ensemble de blocs n'est pas relié au reste, ou un réseau par sortie...) Voici l'exemple correspondant au programme CONT montré plus haut :
C'est un langage textuel, qui est le plus proche du comportement interne de l'automate (correspond à peu près à l'assembleur dans un ordinateur). Le système sait toujours traduire du CONT ou du LOG en LIST, mais pas l'inverse. Le programme se compose d'une suite de lignes, chacune spécifiant un code opération suivi d'un opérande (et un seul). L'opérande peut être une adresse absolue (E0.0) ou un mnémonique entre guillemets (si les mnémoniques ont été définis, bien sûr). Comme on ne peut pas utiliser deux opérandes dans une même ligne, pour faire « x=a et b » on écrit :
U "a" U "b" = "x"
On utilise U pour ET (und), O pour OU (oder), X pour Ou Exclusif), UN, ON et même XN pour les entrées inversées, = pour stocker le résultat. L'opération (O ou U) pour le premier opérande n'a pas grande importance. Pour une bascule on utilisera :
U "a" S "x" U "b" R "x"
On peut également utiliser des parenthèses :
U(
U "bouton1"
S "bascule"
U "bouton2"
R "bascule"
)
UN "bouton3"
= "led1"
NOT inverse le résultat précédent, FP indique si le résultat précédent vient de passer de 0 à 1 (front montant), FN pour le front descendant. Ici aussi, on peut décomposer le programme en plusieurs réseaux, mais peut-être est-ce moins courant qu'en CONT ?
On peut, comme en programmation classique, faire des sauts (goto) : SPA label (inconditionnel), SPB (si dernier calcul = 1), SPBN (si 0). On saute à une ligne précédée de « label : »
En LIST, on peut aussi traiter des mots (peut-être plus facilement que dans les autres langages) : entiers de 16 bits (W) ou 32 bits (D), réels 32 bits).
Le PB100 fonctionne en hexadécimal. On peut possèder par exemple 24 entrées appelées 000 à 017 et 24 sorties appelées 018 à 02F. Ces entrées-sorties peuvent être modifiées par groupe de 8 par adjonction de cartes (64 E-S maxi). Il possède 512 variables internes binaires (pouvant donc valoir soit 0 soit 1) appelées A00 à BFF. Les programmes doivent être écrits à partir des lignes 0C30, et peuvent aller jusqu'à 0FFF (sauf ajout de modules mémoire).
Le PB 15 par contre, possède les entrées 000 à 017, les sorties 020 à 02F et les variables internes sont limitées de A00 à A3F. Tout le reste fonctionne de manière analogue.
Le langage est très simple : on peut simuler les fonctions ET, OU et les bascules bistables :
On désire allumer la sortie 020 si (l'entrée 000 est à 1 ET 001 est à 0) ou 002 est à 1 ou 003 est à 0. que je noterai en AF : S020<= (E000 ET /E001) OU E002 ou E003. Le programme correspondant sera :
0C30 SI 000
0C31 SI/ 001
0C32 ET A00
0C33 SI A00
0C34 SI 002
0C35 SI/ 003
0C36 OU 020
0C37 SAUT C30
La fonction ET possède ici 2 entrées : 000 et /001. Le
résultat (0 ou 1) est mis dans la variable interne A00. La fonction OU
possède ici 3 entrées : A00, 002, /003. Le résultat est
mis sur la sortie 020.Attention : un programme est une suite d'instructions, qui sont exécutées l'une après l'autre. Si une entrée change après le passage sur l'instruction qui la prend en compte et que l'on ne repasse plus sur les instructions, la sortie n'est pas modifiée. C'est la raison de la dernière ligne du programme : repasser sans arrêt sur l'ensemble du programme.
Par rapport à un câblage, on a donc deux désavantages : temps de réponse (un changement des entrées sera pris en compte au maximum après le temps d'un passage sur l'ensemble du programme, c'est ce qu'on appele le temps de scrutation, qui sera ici inférieur à la milliseconde) et non simultanéité (on n'effectue qu'un instruction à la fois). Mais ces temps étant en général très inférieurs aux temps de réaction des capteurs et actionneurs (inertie d'un moteur par exemple), ceci n'est que rarement gênant. L'avantage est que c'est programmable, donc facilement modifiable.
Les fonctions ET et OU acceptent autant d'entrées que l'on désire. Si on n'en utilise qu'une, on a une simple recopie de valeur (ex: SI A00 - OU A01).
Le SAUT peut être précédé de plusieurs SI ou SI/. si la conjonction (ET) des conditions est vraie, alors le saut est fait, sinon on continue sur la ligne suivante. Sur PB 15, seuls les sauts vers l'avant (SAUT Axx avec xx=nb de lignes à ne pas faire +1) sont possibles, seule la dernière ligne du programme peut contenir un saut en arrière (sans SI).
Les fonctions MU (mise à un) et MZ (mise à zéro) permettent de traiter les bistables. Il peuvent eux aussi être précédés par un ou plusieurs SI :
(1)
|
SI
A00
|
(2)
|
SI
A00
|
| SI
B0C
|
SI
B0C
| ||
| MU
AF3
|
ET
AF3
|
Une autre fonction utile est le DE :
DE A00 MZ BFFdonnera le même résultat que MZ A00 - MZ A01 - MZ A02 - ... - MZ BFE - MZ BFF
Il faut avant tout donner la condition qui déclenchera la tempo, par un ou plusieurs SI. Puis TP et le nom de la variable qui sera mise à 1 au bout de la tempo. Puis donner la base de temps (sur PB15 09FF, 09FE, 09FD pour 1 sec, 1/10è, 1/100è; sur PB100 BT F, BT E pour 1 sec, 1/10è). Puis donner l'adresse où l'on stocke la durée, et l'adresse réservée au compteur. Ces adresses sont n'importe quelle ligne de programme (mais sur laquelle on ne devra pas passer) sur PB100, et entre 0800 et 0817 sur PB15).
Exemple: 0C30
|
SI
000
|
si
appui sur le capteur 000
|
| TP
020
|
allumer
la sortie 020 après un certain délai
| |
| 09FF
|
le
délai sera donné en Secondes
| |
| 0800
|
adresse
durée
| |
| 0801
|
adresse
réservée compteur
| |
| SAUT
C30
|
||
|
0800
|
0005
|
la
durée sera de 5 secondes
|
|
0801
|
0000
|
En appuyant le contact, la sortie sera allumée 5 secondes après. Elle restera allumée jusqu'à ce qu'on lâche l'entrée. le compteur sera alors automatiquement remis à zero. Si on appuie moins de 5 secondes, rien ne se passe. Cetteinstruction n'arrête pas le programme, il faut constamment passer sur les lignes d'instruction pour que la sortie soit bien affectée en bout de tempo.
On peut trouver une documentation plus complète sur cet automate dans mon document "description du TSX"
Sur un TSX, les sorties peuvent être appelées O0,0 à O0,F, les entrées I1,0 à I1,F (si le rack de 16 sorties est positionné en position 0, les 16 entrées en 1). Les variables internes sont notées en décimal de B0 à B255.
Les schémas sont effectués l'un après l'autre, de haut en bas (et non suivant leur label). Chaque réseau est scruté par colonne de gauche à droite.
ex:
Dans ce cas l'entrée B12 est l'ancienne valeur de la bobine (variable interne) B12. Si l'on veut utiliser le résultat de ce réseau, il faut utiliser B12 dans le réseau suivant.
On note un capteur par le signe --| |--, un contact inverse par --|/|--.
Une bobine est notée --< >-- , une bobine inverse --< / >-- (commandée par un niveau 0).
Un bistable est allumé par --< S >-- , éteint par --< R >-- .
Un saut à un autre réseau est noté --< J >--. On a intérêt de n'utiliser que des sauts avants (vers la fin du programme). L'automate fixe automatiquement les entrées au début de cycle et n'affecte les sorties qu'en fin de cycle (les variables internes sont évidement immédiatement modifiées).
On représente la tempo par le signe :
E correspond à l'armement de la tempo, C au contrôle. D passe à 1 en fin de tempo, R est à 1 tant que la tempo est en cours. En appuyant la touche ZM, on peut donner : TB: la base de temps, PRESET: la durée.
On peut trouver une documentation plus complète sur cet automate dans mon document "description du Micro 1"
Cet automate est produit d'entrée de gamme : prix : environ 3000F, compact (environ 1 dm3), avec 6 sorties (numérotées 200 à 205) comportant chacune un relais (maxi 2A sous 220V), 8 entrées (24V) (numérotées 0 à 7). Les variables internes vont de à . Les opérations sont font via une pile (un peu comme une calculatrice HP) :
Pour effectuer S203 <= (E00 ET /E01) OU (/E02 ET E03) on écrit :
LOD 0
|
charger
0 sur le sommet de la pile
|
| AND
NOT 1
|
opération
ET entre le sommet de la pile et l'argument donné, le résultat
remplace le précédent sommet de la pile
|
| LOD
NOT 2
|
empiler
(au dessus du résultat précédent) une nouvelle valeur
|
| AND
3
|
faire
le calcul (le résultat remplace le sommet de la pile)
|
| OR
LOD
|
OU
entre le sommet de la pile et le précédent, le résultat
remplace le précédent et la pile a baissé d'un étage
|
| OUT
203
|
Copie
du sommet de la pile sur la sortie (sans changement dans la pile !!!)
|
| END
|
fin
du programme, saut automatique en première ligne
|
La bascule : si sommet de la pile (dernier calcul ou LOD) vaut 1, SET résultat ou RST résultat allumera ou éteindra le résultat, sinon il restera inchangé
le saut : si sommet de la pile (dernier calcul ou LOD) vaut 1, JMP sautera au prochain JEND (saut avant uniquement, pas d'imbrications)
L'assembleur sera utilisé soit sur un ordinateur (plutôt PC) mais surtout si l'on a choisi d'utiliser un micro-contrôleur. Ceux-ci sont des composants comportant un micro-processeur, de la RAM et PROM, des ports d'E/S, et souvent un CAN. Ces composants sont la solution idéale en cas de production en série de produits automatiques (même pour une petite série) : ils coutent à peine plus de 10 F pièce (si on en achète beaucoup, évidement). Un bon exemple est le ST62 :
Il possède trois ports d'E/S 8 bits, un compteur/timer 16 bits et un CNA 8 bits. L'EPROM est de 2 ou 4 Ko, la RAM utilisable est cependant limitée à 64 octets (256 adressables dont les 3/4 utilisés par le système). Le minimum à savoir sur son langage est simple :
- chargement d'un registre : LD A,adresse ou LDI A,valeur (on dispose aussi d'autres registres et d'autres adressages)
- comparaison avec une valeur : CPI A,valeur
- masquage : ANDI A,valeur
- ET, complément : AND A,adresse , COM A
Mais surtout des instructions avec accès direct à un bit donné , ce qui facilite la programmation et évite les problèmes de masquages et décalages :
- saut si un bit d'une mémoire est à 1 : JRS num_bit,adresse,destination_du_saut (JRR saut si bit=0)
- mise à 1 d'un bit d'une mémoire : SET num_bit,adresse
- mise à 0 d'un bit d'une mémoire : RST num_bit,adresse
Il possède bien évidement toutes les possibilités habituelles des micro-processeurs : interruptions (5 vecteurs, reset compris), sous- programmes (mais petite pile : 4 ou 6 imbrications maxi)...
L'assembleur ne sera que rarement utile : personellement je conseillerai plutôt C. Néanmoins ce n'est pas une possibilité à négliger, notament dans les cas nécessitant un traitement temps réel.
On trouvera un descriptif plus complet dans le document "mémento 8088"
On se limitera aux instructions suivantes :
LABEL: donne un nom à une ligne de programme
MOV reg,val met la valeur VAL dans le registre REG (ici DX ou AL)
OUT DX,reg envoie sur le port de sortie dont l'adresse est dans DX la valeur contenue dans le registre REG (ici AL)
IN reg,DX met dans le registre REG (ici AL) la valeur disponible sur le port d'entrée dont l'adresse est dans DX
TEST reg,val masque le contenu de REG par VAL (fonction ET) sans changer REG. Le(s) bit(s) de REG correspondant à un 1 de VAL seront inchangés, les autres sont mis à 0
JZ label saute à l'adresse LABEL si le résultat du test précédent était 0 (le bit non masqué valait 0)
JNZ label saute à LABEL si le résultat du test précédent était non nul.
JMP label saute à LABEL (sans condition)
Je pense que ces petites explications suffiront pour comprendre les programme que je donnerai plus bas
Vous pouvez consulter si nécéssaire mon livre sur le Language C ou mon document sur le Pascal.
Tous les langages conviennent : ils savent tous faire ET, OU et NON, mettre une mémoire à 1 ou à 0 sous condition (IF). Le Pascal permet un programme plus clair que tous les autres à condition d'utiliser la notion d'ensembles (est-ce que l'étape X appartient à l'ensemble des étapes actives ?). Dans les autres langages il faudra faire des boucles et des masquages, pour cela le C sera certainement le plus pratique (ainsi que pour gérer directement une carte d'entrées - sorties). Rappel : les sauts sont possibles dans tous les langages classiques, contrairement à ce que certains enseignants essayent de faire croire.
Ces fonctions de base sont présentes dans tous les automates (même si elles sont mises en oeuvre par des langages très différents, y compris graphiques), sauf les sauts qui peuvent être plus limités (au minimum bouclage automatique sur l'ensemble du programme, mais sans sauts dans le programme). Nous utiliserons ces seules fonctions pour voir comment programmer un grafcet, mais le principe reste valable quel que soit l'automate. Souvent, d'autres possibilités existent, en particulier temporisations, comptage, comparaisons,... Voir les documentations correspondantes si nécessaire.