Tous les outils pour le développement et la maintenance des systèmes automatisés

Un Automate Programmable Industriel, API (en anglais Programmable Logic Controller, PLC) est un petit ordinateur utilisé pour automatiser des processus réels, tels que la commande des machines sur des chaînes de montage dans les usines. Là où les systèmes automatisés plus anciens emploieraient des centaines ou des milliers de relais et de cames, un simple automate suffit.

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 appelle le temps de scrutation, qui sera souvent de l'ordre de 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.

Tout automate programmable possède :

• des entrées, des sorties, des mémoires internes : toutes sont binaires (0 ou 1), on peut les lire (c.a.d connaître leur état) (même les sorties), mais on ne peut écrire (modifier l'état) que sur les sorties et les mémoires internes. Les mémoires internes servent pour stocker des résultats temporaires, et s'en resservir plus tard.
• des fonctions combinatoires : ET, OU, NON (mais aussi quelquefois XOR, NAND,...)
• des fonctions séquentielles : bascules RS (ou du moins Set et Reset des bascules), temporisations, compteurs/décompteurs mais aussi quelquefois registres à décalage, etc...
• des fonctions algorithmiques : sauts (vers l'avant mais aussi quelquefois saut généralisés), boucles, instructions conditionnelles...
• de plus il permet de créer, essayer, modifier, sauver un programme, quelquefois par l'intermédiaire d'une console séparable et utilisable pour plusieurs automates. Désormais cette fonctionnalité est également possible sur PC, permettant une plus grande souplesse, une assistance automatique, des simulations graphiques,... mais pour un prix supérieur.

Ce qui différencie les automates, c'est la capacité (entrées, sorties, mémoires internes, taille de programme, nombre de compteurs, nombre de temporisations), la vitesse mais surtout son adaptabilité (possibilité d'augmenter les capacités, de prendre en compte de l'analogique et numérique, de converser via un réseau (DeviceNet, Control Net, DH+, RIO, Profibus, Modbus…)

Lorsqu'on fait un programme, on peut choisir un langage évolué ( Ladder, Grafcet, Logigramme). Les API ne comprenant que les langages en liste d'instructions, il faut compiler votre programme (si le logiciel de programmation ne le fait pas automatiquement) avant de la transférer dans l'API.

On cherche également à documenter ( joindre des commentaires)  au maximum le programme pour qu'une autre personne puisse le comprendre et le modifier facilement. On peut également déclarer les entrées, sorties, etc.. par des nom court et/ou des textes plus long - par exemple : sur la sortie O00.01 est raccordé le relais K1 sur lequel commande la ventilation : O00.01 - K1 - ventilation 1.

Toutes ces adjonctions au programme de base ne sont pas prises en charge par l'AP. L'ordinateur va créer pour ces données des fichiers spécifiques qui resteront dans la mémoire d'archivage (disque dur) de votre choix. Sans ces fichiers, un rappel de votre programme de l'AP vers l'ordinateur ne donnera que la liste d'instructions et le reste des données peut être considéré comme perdu.

LANGAGES DE PROGRAMMATION

Le langage à contacts : exemple du TSX

C'est le langage de base des TSX. Il est nécessaire de le connaître même pour utiliser le langage PL7-2 (proche du Grafcet).

Sur le TSX, les sorties sont appelées Oi,0 à Oi,23 (i=numéro de carte d'entrée), les entrées Ii,0 à Ii,24. Les variables internes sont notées en décimal de B0 à B255 (B pour Bit interne ou Bobine).

La programmation se fait à l'aide de programmes graphiques : les réseaux. Ce sont des schémas qui sont exécuté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

exemple :

Dans ce cas l'entrée B12 est l'ancienne valeur du bit interne (bobine) B12. Si l'on veut utiliser le résultat B12 de ce réseau, il faut utiliser B12 dans le réseau suivant.

On note un capteur par le signe  , un contact complémenté (vrai si 0) par.

Un bit interne est noté  , un bit interne inverse (commandée par un niveau 0).

Une bascule bistable est allumée par  , éteinte par.

Un saut à un autre réseau est noté. Un saut est effectué immédiatement lors de son évaluation (les bobines en sortie dans le même réseau mais sur les lignes suivantes ne seront donc pas évaluées en cas de saut). On a intérêt de n'utiliser que des sauts avants (vers la fin du programme). L'exécution du dernier réseau sera automatiquement suivie de l'exécution du premier (sauf si sauts). 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). Il est nécessaire de refaire un cycle (c'est à dire passer du dernier réseau au premier) fréquemment (tous les 150 ms maximum).

Programmation directe en Grafcet

Certains automates sont prévus pour être programmés plus facilement à partir d'un Grafcet. C'est le cas du TSX (à l'aide d'une cartouche ROM) mais pas du MICRO1.

Il faut tout d'abord dessiner le Grafcet. Analysons le cas du Grafcet suivant :

Une fois le grafcet entré, on définit les transitions et les actions correspondant aux étapes. Pour ceci, placer le curseur sur une transition à définir, appuyer la touche ZM (zoom). Un réseau à contacts apparaît, avec un bit interne représentant la transition. Il faut alors représenter le schéma qui, en fonction des capteurs, "allumera" la réceptivité. On valide le réseau par ENT (touche ENTER). Pour les actions, on peut (mais je ne le conseille pas) pointer une étape, appuyer ZM, donner le schéma qui allumera les bobines de sortie. Sur nos TSX, les sorties ne peuvent être activées que par un bit interne <S>, ce qui force à désactiver la sortie par un bit interne <R> l'étape suivante.

Soient : Capteurs m=I1,0, a=I2,0 Sortie L=O0,0. Les réseaux à entrer sont donc:

Une bien meilleure solution est de regrouper toutes les actions dans le "traitement postérieur". Attention, du fait que le TSX fige les entrées-sorties le temps d'un cycle, il ne faut mettre en place qu'une seule "équation" par sortie (sinon seule la dernière sera prise en compte). On n'oubliera donc pas de regrouper (en parallèle) les Xi allumant une sortie.

Une tempo (en secondes) est automatiquement liée à chaque étape, et permet de tester la durée depuis l'activation de l'étape par un opérateur de type -[ < ]- (comparaison) par la variable interne Xi,V (i numéro d'étape)

Pour plus de détails sur la mise en route du TSX-17  suivez le lien : Mise en Route TSX.

On peut également trouver d’autres langages dont : le langage LIST  que je ne développerais pas ici  pour le moment.