tout savoir sur les automates programmables

Éditeur d'instructions ( LI )

Chaque ligne d'instruction doit comprendre une opération et une opérande ( le symbole et son texte long ne sont pas obligatoire). Lorsqu'on rentre une opérande déjà définie dans la table des variables, son symbole et son texte son directement inscrit dans le programme. On peut aussi entrer directement le symbole pré-défini dans la table des variables sans entrer l'opérande (le programme se chargeant de le faire). Si l'opérande n'a pas été définie dans la table des variables, le programme vous demande d'y mettre son symbole et son texte sans quitter l'éditeur LI (et complète automatiquement la table des variables).

exemple de programme:

Selectron PMC 2ø Éditeur liste d'instructions NOMPROG

_______________________________________________________________________________________

Phras Mot Comm.SF IOP GNR.KN Symboles Texte long

øøøøø øøøøø L I øø.ø1 niv ø Fin de course

øøøø1 A I øø.ø2 niv 1 encl. 1ère vitesse

øøøø2 = O ø1.øø

øøøø1 øøøø3 L I øø.ø1 niv ø Fin de course bas

øøøø4 = O ø1.ø1

øøøø5 EP

Attention, il est indispensable de terminer le programme par EP.

Ce programme correspond aux deux équations suivantes:

I øø.ø1 * I øø.ø2 = O ø1.øø I øø.ø1 = O ø1.ø1

ou aux fonctions logiques suivantes:

I øø.ø1 _______________________________O ø1.ø1

Exercice LI:

Faire un programme LI qui répond aux équations suivantes puis faire le schéma en portes logiques:

I øø.øø * I øø.ø1 = O ø1.øø

I øø.øø + I øø.ø1 = O ø1.ø1

I øø.ø5 * I øø.øø * I øø.ø1 = O ø1.ø2

I øø.øø + I øø.ø1 + I øø.ø2 = O ø1.ø3

I øø.øø * I øø.ø1 * (I øø.ø2 + I øø.ø3) = O ø1.ø4

Selectron PMC 2ø Éditeur liste d'instructions NOMPROG

________________________________________________________________________________

Phras Mot Comm.SF IOP GNR.KN Symboles Texte long

øøøøø øøøøø L I øø.øø

øøøø1 A I øø.ø1 niv ø Fin de course bas

øøøø2 = O

øøøø1 øøøø3

øøøø4

øøøø5

øøøø2 øøøø6

øøøø7

øøøø8

øøøø9 = O ø1.ø2

øøøø3 øøø1ø

øøø11

øøø12

øøø13 =

øøøø4 øøø14

øøø15

øøø16 L I

øøø17

øøø18 AB

øøø19

øøø2ø

Éditeur LI-MACRO

Avec cet éditeur, on a accès à une bibliothèque d'éléments fonctionnels - EF - prédéfinis, qu'il suffit de paramétrer selon les opérandes de notre programme.

Par exemple:

portes logiques

compteur

minuterie

Avec le logiciel CAP 4øø, on ne peut qu'utiliser les macros existantes alors qu'avec le CAP 4øø1, on peut créer ses propres EF

Par exemple:

minuterie de ventilation de toilettes
éclairage de rampes lumineuses (bureau) en fonction de l'éclairage extérieur,
vitesse d'avancement d'un tapis roulant en fonction du nombre de pièces posées dessus.

Il sera plus agréable d'utiliser ces EF dans l'éditeurs LOGSR. Dés que la fonction est appelée, une rectangle (avec ses entrées et sorties - à définir) représentant l'EF apparaît à l'écran. La structure du code LI existe déjà et il sera complété lors de la compilation.

exemple: appel d'un élément fonctionnel OR.

procédure d'accès: affichage écran (LI) affichage écran (LOGSR)

appel du menu : <espace>

choix: "menu EF"

choix: "insérer EF"

appel de OR: <return> (sur OR)

00000 00000 $

00001

00002

00003

00004

Définition des opérandes d'entrées - sorties (en mode LI)

amener le curseur sur la 1ère ligne

taper "I øø.ø1 <return>"

taper "I øø.ø2 <return>"

taper " O ø1.øø <return>"

00000 00000 $ OR

00001 I 00.01

00002 I 00.02

00003 O 01.00

00004

Pour le mode LOGSR voir le chapitre qui s'y rapporte.

Éditeur LOGSR

L'éditeur LOGSR comprend un éditeur SR et un éditeur LOG. On peut ainsi utiliser les deux types de programmation au sein d'un même programme ce qui permet l'emploi de la bibliothèque des blocs fonctionnels. On peut programmer soit avec les variables soit avec leur symbole. De même manière qu'en programmation LI, le logiciel complète la table des variables s'il y a lieu. Avec LOGSR il est indispensable de compiler (traduire en LI) votre programme.

Utilisation du schéma à relais:

exemple : commande d'un moteur K1,1 poussoir marche S1, 1 poussoir stop Sø

remarque : toujours laisser de la place au-dessus du contact pour la variable et son symbole sinon le logiciel ne vous autorisa pas son affichage et indique " colision ".

commande raccourci visualisation de écran

<espace> (appel du menu)

choix "Éditer"

choix "Contacts"

sélectionner le contact de départ (2ème) <ALT> F2 ]–––] [––––

placer le curseur après le premier contact ]–––] [–––I-–––

<espace>

sélectionner le contact série (3ème) <INS> ]–––] [–––] [–––

placer le curseur après le dernier contact ]–––] [-–––] [––I

<espace>

sélectionner le contact d'assignation (5ème) <ALT> F5 ]–––] [–––] [–––( )

placer le curseur entre les contacts ]–––] [–––]I[–––( )

<return> ]–––] [–––]/[–––( )

placer le curseur avant (avec <return>) <ALT> F6 ]–I–] [----I--]/[–––( )

et après le contact ]– ––] [––––]/[–––( )

––] [–––

Sø K1

I I øø.ø1 O ø1.øø

placer le curseur au-dessus du contact ]– ––] [––––]/[–––( )

entrer soit la variable, soit son symbole

––] [–––

Utilisation du Logigramme

On peut faire des programmes comprenant un ensemble d'EF (souvent des fonctions logiques) avec ou sans l'usage du SR.

Lorsqu'on utilise un EF (élément fonctionnel), il est indispensable de raccorder toutes ses entrées et sa sortie. Attention une entrée d'EF peut être un paramètre tel qu'une constante Kxxxx . Avant de connecter les EF entre eux, il faut les placer à leur place sur votre ordinogramme. Les connections entre EF se font de haut (sortie de l’une) en bas (entrée de l’autre).

Pour appeler un EF il faut :

placer le curseur à l'emplacement choisi
soit par le menu (<espace>,"Éditer", "Choix bibliothèque EF", choisir son EF)
soit taper au clavier le nom de l'EF choisi, puis <return>

Pour déplacer un EF (avant qu’il ne soit raccordé) , cliquer une fois dans l'EF puis à sa nouvelle place.

Pour connecter les EF, cliquer sur une entrée, puis sur la même ligne à gauche.

Pour connecter le sortie de l'EF, cliquer sur une sortie, puis sur la même ligne à droite

ou sur l'entrée d'un autre EF

Pour inverser une sortie ou une entrée, cliquer juste devant l'entrée ou derrière la sortie.

Pour assigner une variable, cliquer sur les points. Vous pouvez également compléter l'éditeur de variable si nécessaire.

Compilation:

(n'oubliez pas que le programme se termine par l'EF "EP" - end programm)

Chaque programme écrit en LOGSR doit être traduit en code LI avant d'être envoyé vers l'AP.

Pour compiler votre programme, il faut taper <espace> pour appeler le menu

choisir "Compilation", puis "Tout".

En cas d'erreur, vous pouvez appeler une liste d'erreur: taper <espace>

choisir "Recherche d'erreur".

Chaque erreur est affichée avec son éventuelle cause. (attention une compilation sans erreur n’est pas égale à un programme sans erreur...)

Éditeur GRA

L'éditeur GRA permet de programmer graphiquement des déroulements séquentiels. On peut programmer les LOUPES (les pas et les transitions) soit en LI soit en LOGSR. Une fois le programme terminé, il faut le compiler avant de le transmettre au PMC.

Une chaîne de pas commence par une " chaîne de pas de début " puis les séquences transitions - pas et fini toujours par un saut. Seule exception, les " chaînes de pas permanent " par exemple celle qui contient l’EF de fin de programme (EP). L’indication du pas se trouve affichée en haut à droite de la fenêtre. Dans un premier temps, il est inutile de tenir compte de la numérotation des pas et transitions. Il suffit de renuméroter lorsqu’on a fini de dessiner le programme.

remarques schéma Pas

Chaîne de pas de début : contient les conditions initiales

transition : contient la condition qui doit être satisfaite pour changer de pas

pas: un seul pas est actif à la fois dans une chaîne, contient les opérations à exécuter

embranchement alternatif :

pas

transition

embranchement simultané

pas

transition

Saut : renvois à un pas de programme (souvent øø1)

T

TA

S

SA

T

TA

S

SA

T

TA

S

La représentation écran peut être modifiée dans le menu "LAYOUT", ce qui permet d'agrandir l'image et de visualiser des commentaires (utilisez de préférence la valeur 13 signes/Tab).

Programmation :

pour cliquer sur puis

commencer choisir "Chaîne de pas de début" les 2 premiers pas apparaissent

ajouter un pas T puis cliquer juste en-dessous insère un pas + une transition

appeler un saut S choisir "saut" dans le menu

noter le pas d'arrivée S taper le numéro du pas d'arrivée

renuméroter <ALT> F9

embranch. altern. SA puis TA

effacer un embr. alt TA + 2* "return"

embranch. simultané TA SA

mettre un commentaire S entrer le texte au clavier - par exemple pompe 1 enc, vérin 2 hors

appeler une Loupe S ou T F1

Avant de commencer à écrire les loupes, il faut choisir le type programmation à utiliser (LI ou LOGSR) avec "définir loupe".

Pour programmer une transition en LI: placer le curseur en T puis presser F1. L'éditeur LI s'ouvre. Entrer la commande L I øø.øø <return><return> <ESC> .

Noter qu'à coté de la transition programmée, les lettres LI s'inscrivent. Le pas suivant ne pourra être exécuté que lorsque I øø.øø sera à "1".

Les 2 pressions sur <return> seront évitées si la variable est déjà déclarée dans l’éditeur de variable. L’on peut aussi remplir déclarer la variable à ce moment, l’editeur de variable sera alors automatiquement mis à jour.

Pour programmer un pas en LI: placer le curseur en S puis presser F1.

Entrer la commande LS <TAB> # <return> <return>

puis par exemple: S O ø1.øø <return> <ESC>.

Arrivé à ce pas la sortie O ø1.øø est activée (jusqu'à ce que le programme rencontre dans un autre pas l'instruction R O ø1.øø ). Le pas suivant ne sera exécuté que lorsque la condition de la transition suivante sera remplie.

Plan d'un programme :

Chaque programme peut contenir plusieurs mini-programmes (ou chaîne en GRA). En appelant le menu "GESTION", on peut créer de nouveau mini-programme. En GRA on créera obligatoirement un dernier mini-programme qui ne contiendra qu'un pas permanent "EP".

Récapitulation de quelques possibilités d'édition

commande:

raccourci clavier

VAR

LI

LOGRS

GRA

Tri par variables / par symboles

<F9>

x

Un champ d'entrée vers la gauche

<shift><TAB>

x

Représentation

Insérer une ligne

<CTRL> N

x

x

x

x

Effacer une ligne

<CTRL> Y

x

x

x

x

Effacer jusqu'à la fin

<CTRL> B

x

Curseur en début de projet

<CTRL> QR

x

Curseur en fin de projet

<CTRL> QC

x

Recherche / remplacement

Chercher des variables

<CTRL> QFA

x

x

x

Chercher des symboles

<CTRL> QFO

x

x

x

Répéter la recherche

<CTRL> L

x

x

x

Chercher des variables non utilisées

<CTRL> QFS

x

Chercher numéro de phrase

<CTRL> QFS

x

Chercher numéro de mot

<CTRL> QFW

x

Editer des blocs

Marquer début de bloc

<CTL> KB

x

x

x

x

Marquer la fin de bloc

<CTRL> KK

x

x

x

x

Décaler bloc

<CTRL> KV

x

x

Copier bloc

<CTRL> KC

x

x

Effacer marquage de bloc

<CTRL> KH

x

x

x

x

Sauvergarder bloc sur disque dur

<CTRL> KW

x

x

x

x

Récupérer bloc sur disque dur

<CTRL> KR

x

x

x

x

Effacer variables de blocs non utilisées

<CTRL>KY

x

x

Effacer bloc

<DEL>

CTRL KY

Divers

Menu

<espace>

x

x

x

x

Compiler

F3

-

-

x

x

Importer variables

<CTRL> KI

x

Exporter variables

<CTRL> KE

x

7 signes/TAB (2=F1; 5=F2; 13=F4)

<CTRL> F3

x

Effacer chaîne de pas

<ALT>

x

Renuméroter

<ALT> F8

x

Appeler loupe

F1

x

Effacer loupe

<ALT> F1ø

x

Pour commencer un programme.

Exercice LI:

Utilisation du schéma à relais:

Utilisation du Logigramme

Compilation:

Programmation :

Plan d'un programme :