ISSATKr API A.U.

2019/2020
Master CSI1-AII

Chapitre 2

Programmation des API

Chapitre 2 ........................................................................................................................................................... 1
Programmation des API...................................................................................................................................... 1
1. Introduction ............................................................................................................................................... 2
2. Identification des entrées/sorties et bit d’adresses : ................................................................................. 4
2.1. Rangés, cartes et signaux ................................................................................................................... 4
2.2. Bits de sauvegarde internes. .............................................................................................................. 6
3. Programmation en langage Ladder : .......................................................................................................... 6
3.1. Eléments de base d’un réseau Ladder ................................................................................................ 6
3.2. Appelle de fonctions ou blocs fonctionnels (FB): ............................................................................... 7
3.3. Variables en boucle de retour (feedback)........................................................................................... 7
4. Programmation en liste d’instruction (IL) ................................................................................................... 8
4.1. Syntaxe ............................................................................................................................................... 8
4.2. Accumulateur universel (Résultat courant) ...................................................................................... 10
4.3. Utilisation des fonctions ou blocs fonctionnels (FB): ....................................................................... 10
5. Programmation en FBD (Logigramme) ..................................................................................................... 12
6. Programmation en texte structuré (ST) .................................................................................................... 13
Expressions en ST ......................................................................................................................................... 13
7. Programmation SFC (Grafcet)................................................................................................................... 14
7.1. Rappel sur le grafcet : ....................................................................................................................... 14
7.2. Identification des étapes et transissions en SFC ............................................................................... 17
7.3. Description des actions :................................................................................................................... 18
8. Types de données et déclaration des variables ........................................................................................ 20
8.1. Types de données ............................................................................................................................. 20
8.2. Déclaration de variable : ................................................................................................................... 22
9. Fonctions standards ................................................................................................................................. 23
9.1. Fonctions de conversions de types: .................................................................................................. 23
9.2. Fonctions numériques : .................................................................................................................... 23
9.3. Fonctions arithmétiques : ................................................................................................................. 23
9.4. Opérations sur les bits : .................................................................................................................... 24
9.5. Opérations bit à bit ........................................................................................................................... 24

S. MARAOUI Page 1
ISSATKr API A.U. 2019/2020
Master CSI1-AII

9.6. Fonction sélection ............................................................................................................................ 24

9.7. Fonctions SEL et Mux : ...................................................................................................................... 24
9.8. Fonctions pour variable de type date : ............................................................................................. 25
10. Fonctions blocs standard : .................................................................................................................... 25

1. Introduction
Les langages de programmation utilisées pour les API ont évolué depuis l’introduction des automates à la fin
des années 60. Actuellement la norme CEI 61131-3 (la partie 3 sur 8 de la norme notée précédemment 1131,
apparue en 1993 et en deuxième édition en 2003 et spécifiant les langages de programmation), spécifie 5
langages qui sont :

• Langages graphiques :
o Langage LADDER (à relais), LD
o Boîtes fonctionnelles, ou Functional Block Diagram (FBD).
• Langages textuels :
o Texte structuré (ST)
o Liste d’instructions (IL)
• Diagramme de fonctions séquentielles (Sequential Chart function, SFC) :
o Version graphique (proche du grafcet)
o Version textuelle.

Le cycle de fonctionnement d’un automate peut être simplifié comme suit :

Lecture des entrées et

sauvegarde en mémoire

Lecture des entrées de la

mémoire, exécution des
instructions du
programme et
mémorisations des
sorties

Mise à jour des sorties

S. MARAOUI Page 2
ISSATKr API A.U. 2019/2020
Master CSI1-AII

Le temps d’un cycle dépend de la taille du programme à exécuter et la vitesse du processeur avec une
moyenne de 2-5ms/K de programme. Le scan du programme limite les vitesses (fréquences) des signaux
auxquels un API peut réagir. La figure suivante illustre le cas où l’automate compte le nombre d’impulsions
d’un signal : le premier est moins rapide que la vitesse de scan du programme, le comptage est correct. Le
deuxième signal est plus rapide et l’automate peut rater quelques impulsions. Le troisième est encore plus
rapide et l’automate peut rater plusieurs impulsions. Pour que la lecture des entrées se fait correctement,
théoriquement il faut que le temps d’une impulsion en entrée dure plus que 1/(2*période de scan). Par
exemple si le temps de scan est de 20ms, l’automate peut lire des impulsions d’une largeur de
1/(2*0.01)=0.02s soit une fréquence de 50Hz. En pratique, d’autres facteurs, tel que le filtrage sur les
entrées, ont un effet considérable sur la vitesse de lecture et doivent être pris en compte.

Signal 1

Signal 2

Signal 3

Un autre problème moins évident peut apparaitre lorsque le changement d’une entrée parvient juste après
sa lecture, ce qui va retarder l’activation (ou désactivation) de la sortie concernée un cycle (voir figure)
Lecture de Mise à jour Lecture de Mise à jour de la
l’entrée de la sortie l’entrée sortie

Entrée
Entrée processus
processus
Sortie
Sortie processus
processus
Scan du Scan du Scan du
programme programme programme

Par exemple considérant un processus ou la matière d’ouvre est déplacée avec la vitesse de 15m/s (par
exemple barre de fer de construction), et qui doit être découpé sous la commande d’un API avec un temps
de scan de 30ms, après un signal d’une photocellule. La marge d’erreur est donc de 15000*0.03=450mm.

Les constructeurs peuvent proposer des cartes spéciales (avec leur propre µP) pour traiter ces signaux
rapides.

S. MARAOUI Page 3
ISSATKr API A.U. 2019/2020
Master CSI1-AII

2. Identification des entrées/sorties et bit d’adresses :

2.1. Rangés, cartes et signaux

Le programme d’API concerne les connections avec le processus et les modules des entrées et sorties
doivent être identifié dans le programme. Les constructeurs ont différentes façons d’identifier ces E/S (voir
exemple figure ci-dessous)

Notation: (a) Mitsubishi, (b) Siemens, (c) Allen-Bradley, and (d) Schneider (Télémécanique).

Généralement les apis contiennent des rangés (racks) locales ou éloigné. Chacune contient des cartes (ou
modules) d’entrées sorties avec 8, 16 ou 32 connections. L’idée est d’adresser ces E/S en utilisant la notion
de rack/module/bit.

Exemple 1 Allen Bradley PLC-5:

L’Allen Bradley PLC-5 peut avoir jusqu’à 8 racks dans sa version 5/25. Le rack 0 contient automatiquement le
processeur, et l’utilisateur peut attribuer des adresses dans les autres racks (de 1 à 7) en positionnant des
switchers. Ses racks (outre le n°0) se connectent au processeur via un câble de communication série des E/S
lointaines. Il y a trois façons avec laquelle un rack peut être configuré pour ce constructeur mais seule la plus
simple est présentée.

Chaque rack contient une carte à 16 voies d’entrées et une carte à 16 voies de sortie, ou bien deux cartes de
8 voies généralement (mais pas nécessairement du même type. Dans la figure suivante par exemple le slot 1
contient une carte d’entrée à 16 voies et une carte de sortie à 16 voies. Le slot 2 contient 2 cartes de sorties
de 8 voies chacune.

L’adressage des entrées est comme suit : I : Rack Slot/bit, où bit est sur deux digits.

S. MARAOUI Page 4
ISSATKr API A.U. 2019/2020
Master CSI1-AII

Allen Bradley utilise un système d’adressage octal pour les bits, donc les nombres autorisés sont0-7 et 10-17.
Par exemple l’adresse I :27/14 désigne l’entrée 14 sur le slot 7 dans le rack 2. Les sorties sont adressées de
manière analogue : O:Rack Slot/Bit. Donc l’adresse O:35/06 est la sortie 6 sur le slot 5 du rack 2.

Exemple 2 Siemens SIMATIC S5 :

Les E/S numérique des API de Siemens sont organisées en groupes de 8 bits (appelés Byte). Un signal est
identifié utilisant son numéro de bit (0-7) et son numéro de byte (0-127). Les entrées sont notées
I<byte>.<bit>, et les sorties Q<byte>.<bit>, exemple l’entrée I9.4 et la sortie Q52.7.

Comme pour l’Allen Bradley, siemens utilise des slots pour les cartes dans un ou plusieurs racks. Les cartes
sont disponibles en 16 bits (2-bytes) ou 32 bits (4-bytes). Un système peut être construit à partir de racks
locaux connectés via un câble de bus parallèle, des racks éloignés avec une connexion série. Les racks locaux
sont plus rapides et peuvent résoudre quelques problèmes liés aux processus rapides et aux connections
séries, mais ne peuvent pas être qu’à quelques mètres de distance du processeur.

La forme la plus simple d’adressage est les slots fixes (figure ci-dessous). Quatre bytes sont attribués
séquentiellement à chaque slot (0-3 pour le premier slot, 4-7 pour le deuxième, …). L’entrée I2.4 est donc le
bit d’entrée numéro 4 du premier byte de la carte dans le slot 3 du premier rack.

L’utilisateur a la possibilité d’affecter l’adressage par byte (appelé adressage de slots variable). Le numéro du
premier byte et le nombre de bytes (2 pour les cartes à 16 bites et 4 pour les cartes à 32 bites) peuvent être
fixé pour chaque slot indépendamment avec des switchers dans le module adaptateur pour chaque rack.
N’importe quelle combinaison est possible, toutefois il est recommandé d’utiliser une numérotation
séquentielle (figure suivante).

A noter finalement que siemens utilise différentes notations dans différents pays avec des terminaux de
programmation multilingues (par exemple E pour l’entrée et a pour la sortie en Allemagne).

S. MARAOUI Page 5
ISSATKr API A.U. 2019/2020
Master CSI1-AII

2.2. Bits de sauvegarde internes.

Comme pour les entrées et sorties, l’automate nécessite de sauvegarder des signaux internes de données
concernant par exemple le bon fonctionnement du système, mise en attente, défaillance détectée, …

L’automate permet d’allouer des bits internes pour ces signaux. Ces bits ont des appellations qui varient
d’un constructeur à un autre, par exemple relais auxiliaires pour Mitsubishi, drapeaux (flags) pour Siemens,
bit de sauvegarde pour Allen Bradley…, de même la notation varie, Mitsubishi utilise Mnnn, avec nnn est un
nombre dans une zone prédéfinie de M100 à M377 (octal), Siemens utilise la notation FByte.bit (e.g. F27.06),
pour le PLC-5 de Allen Bradley, le bit de sauvegarde (bit storage) est noté B3/n où n est le numéro du signal
(e.g. B3/100). Dans cette notation B est pour Bit storage, 3 vient du fait que le PLC-5 maintient les données
en fichiers (fichier 3 pour ces bits, fichier 4 pour les timers (T4), fichier 5 pour les compteurs (C5), …).

3. Programmation en langage Ladder :

Le langage Ladder (LD) est issu du domaine des relais électromécaniques et décrit le flux d’énergie à travers
un réseau d’une unité organisée du programme, de gauche à droite. Initialement ce langage est destiné à
commander des signaux booléens. Ces réseaux sont organisés du haut vers le bas sauf spécification de
l’utilisateur.

En LD l’évaluation du réseau dépend de sa forme graphique (noms des variables et types de connections).
Les éléments sont connectés soit en série soit e parallèle.

3.1. Eléments de base d’un réseau Ladder

Un réseau LD consiste en les éléments suivants :

- Connections
- Contacts et bobines.
- Eléments graphiques pour contrôler l’exécution de la séquence (sauts)
- Eléments graphiques pour appelés des fonctions blocs (FB)
- Connecteurs.

Le tableau suivant donne les principaux éléments (contacts et bobines) d’un réseau LD :

Objet graphique nom

-| |- Contact normalement ouvert
-|/|- Contact normalement fermé
-|P|- Contact fermé au front montant
-|N|- Contact fermé au front descendant
-( )- Bobine normalement ouverte
-( / )- Bobine normalement fermée
-( S )- (ou –( L)- Bobine Latch (maintenu à 1 une fois actionné)
-( R )- (ou –( U )- Bobine Reset (remise à 0 de la bobine latch)
-( P )- Bobine active au front montant de son entrée

S. MARAOUI Page 6
ISSATKr API A.U. 2019/2020
Master CSI1-AII

-( N )- Bobine active au front descendant de son entrée

|-<return> Retour inconditionnel (vers le sous-programme appelant)
|-cond-<return> Retour conditionnel
|->>Label Saut inconditionnel
|-cond->>Label Saut conditionnel

3.2. Appelle de fonctions ou blocs fonctionnels (FB):

Les fonctions et les FB, représentés par des rectangles, peuvent avoir plusieurs paramètres et variables
d’entrées et de sorties. Les fonctions peuvent avoir un ou plusieurs paramètres à retourner. Les noms
formels des paramètres d’entrées et de sortie doivent apparaître à l’intérieur du bloc. Le paramètre
approprié ‘actuel’ (variables, constantes sont écrites en dehors du bloc, sur le fils adjacent au paramètre
formel, il est aussi possible de connecter les entrées/sorties d’un bloc avec celle d’un autre bloc.

Les paramètres d’une (FB) peuvent être des données de n’importe quel type, mais au moins une seule
entrée et une seule sortie doivent être de type booléen et doivent avoir des connections directe ou indirecte
aux lignes de puissance gauche et droite. Une FB standard à une sortie Q pour répondre à cette exigence.

Les fonctions doivent avoir un paramètre d’entrée et un de sortie spéciaux appelé EN et ENO
respectivement, qui contrôlent l’exécution de la fonction. Si EN est évalué à faux (= 0), la fonction n’est pas
exécutée et ENO est aussi mis à 0. Il est possible d’utiliser ENO comme un paramètre d’erreur. Les autres
états pour lesquelles ENO est 0, sont déterminés par le constructeur et doivent être documentés.

3.3. Variables en boucle de retour (feedback)

Si une variable est utilisée pour sauvegarder une valeur (sortie) dans un cycle et lue comme une entrée dans
le cycle suivant dans le même réseau, elle est appelée variable en feedback

S. MARAOUI Page 7
ISSATKr API A.U. 2019/2020
Master CSI1-AII

Seules les connections implicites en feedback (en répétant le nom de la variable) sont possibles en LD et
donc pas de connexions explicites (de droite vers la gauche) ne sont autorisées.

Si un FB et une variable en feedback font partie du même réseau, ceci peut conduire à des comportements
différents selon les systèmes d’API.

Considérant par exemple le réseau donné par la figure suivante :

Dans cet exemple il n’est pas clair si le contact var2 sera attribué la valeur du paramètre FBname O2 du cycle
d’automate en cours ou celle du cycle précèdent. La norme 61131-3 ne discute pas en détails cette
ambiguïté. Pour résoudre ce problème le FB doit être considéré comme un réseau LD à part. S’il y a besoin
d’utiliser des parties du réseau pour prédéfinir un paramètre d’entrée, ou d’utiliser un paramètre de sortie
dans le même réseau, alors cette variable ne doit pas être affectée à un contact ou une bobine dans le
même réseau.

4. Programmation en liste d’instruction (IL)

4.1. Syntaxe
Le langage IL est un langage simple, semblable au langage assembleur, largement utilisé pour la
programmation de l’api et souvent comme langage intermédiaire vers lequel les programmes écrits en
autres langages sont traduits.

Un programme en IL se présente comme une série d’instructions avec une instruction par ligne. Chaque
instruction consiste en un opérateur suivit par un ou plusieurs opérandes. D’une façon générale, une
instruction en IL a la syntaxe suivante :

S. MARAOUI Page 8
ISSATKr API A.U. 2019/2020
Master CSI1-AII

Label : Opérateur/Fonction Opérande (list) (*Commentaire*)

Par exemple :

LD A

Qui indique que l’opérande A est à charger, ou bien : OUT Q

Les opérandes utilisent un code mnémonique qui varie de constructeur à un autre, bien que la norme
indique les instructions à utiliser (et qui sont largement adoptées), le tableau suivant donne quelques
instructions selon cette norme et son équivalent pour certains constructeurs :

CEI 61131-3 Mitsubishi Omron Siemens Description

LD LD LD A Charger l’opérande
dans le registre
résultat
LDN LDI LD NOT AN Charger le
complément de
l’opérande
AND AND AND A ET logique
ANDN ANI AND NOT AN ET logique avec le
complément de
l’opérande
OR OR OR O OU logique
ORN ORI OR NOT ON Ou logique avec le
complément de
l’opérande
ST OUT OUT = Sauvegarder le
registre de résultat
dans l’opérande

Exemple 1 : programmation de l’équation Q = A.B utilisant la notation de Siemens :

A A (* charger A*)
AN B (*Charger le complément de B*)
= Q (*sauvegarderle résultat en Q*)

Exemple 2:

A(
A I0.0
AN I1.1
O(
AN I0.0
A I0.1
)
= Q2.0

S. MARAOUI Page 9
ISSATKr API A.U. 2019/2020
Master CSI1-AII

4.2. Accumulateur universel (Résultat courant)

Les langages assembleurs standards se basent sur une architecture matérielle dans laquelle un accumulateur
est utilisé pour sauvegarder les résultats des différentes opérations effectuées par le processeur. Le langage
IL offre cette possibilité d’accumulateur appelé résultat courant (Current Result, CR). Toutefois le CR n’a pas
un nombre de bits fixes comme pour un accumulateur, le compilateur IL assure qu’un accumulateur virtuel
(incluant une pile accumulateur) est toujours disponible pour n’importe quelle largeur de mémoire. Le
nombre de bits dépond de type de donnée de l’opérande, et elle varie d’instruction à autre pour s’adapter à
l’instruction la plus récente.

Les types de données dans le CR peuvent être :

- Élémentaires
- Composées (structure, array, …)
- Fonction bloc.

Exemple :

VAR_INPUT
FirstOperand: INT;
END_VAR
VAR
SecondOperand, ThirdOperand: INT := 10;
WordVar: WORD;
END_VAR

LD 1 (* 1 {INT} *)
ADD FirstOperand (* 11 {INT} *)
ST SecondOperand (* 11 {INT} *)
LT ThirdOperand (* Faux {BOOL} *)
AND WordVar (* Erreur: WordVar est de type WORD, pas BOOL comme CR *)
(* type de donnée non compatible *)
ST Exam43

4.3. Utilisation des fonctions ou blocs fonctionnels (FB):

• Appelle d’une fonction
Une fonction est appelée en IL en écrivant son nom. Les paramètres de cette fonction suivent séparé par des
virgules. Les paramètres formels peuvent aussi prendre les valeurs actuelles en ligne par ligne utilisant le
signe « := ». Le premier paramètre de la fonction est le CR, il faut donc qu’il soit chargé juste avant l’appel de
la fonction. Le premier opérande dans l’appelle de la fonction est le deuxième paramètre, ainsi de suite.

Exemple : soit la fonction LIMIT ayant trois paramètres d’appel, MN, MX et IN, l’appel de cette fonction peut
se faire comme suit :

Utilisant les paramètres actuels Utilisant les paramètres formels Utilisant les paramètres formels
LD 1 LIMIT( LIMIT(
Limit 2,3 MN :=1 MX :=2
MX :=2 MX :=1
IN :=3 IN :=3
) )

Une fonction doit retourner au moins une sortie, dont le type est spécifié dans la déclaration de la fonction,
et qui sera sauvegarder dans CR.

S. MARAOUI Page 10
ISSATKr API A.U. 2019/2020
Master CSI1-AII

Exemple d’appel et de déclaration de fonction :

Dans cet exemple on fait deux appels à UserFun. Dans le premier appel Funpar1 est égale à 10, dans le
deuxième il est égal à 60. A la fin des deux appels la valeur 110 est sauvegardée dans la variable Sum.

• Appelle d’un bloc fonctionnel (FB)

Un FB peut être activé par l’opérateur CAL (ou CALC pour l’appel conditionnel, ou CALCN pour l’appel
conditionnel avec négation). La norme 61131-3 décrit trois méthodes pour passer les paramètres à un FB en
langage IL :

1- Utilisant un appel incluant la liste des instances actuelles des paramètres d’entrée et sortie entre
parenthèses.
2- Charger et sauvegarder les paramètres d’entrée avant l’appel de la FB
3- Appeler implicitement e utilisant les paramètres d’entrée comme opérateur. Cette méthode n’est
valable que pour les FB standard et non pour celle définies par l’utilisateur, et elle est rarement
utilisée en pratique.

Exemple : considérant le bloc suivant (temporisation) qui sera appelé par les trois méthodes :

(*Declarations des variables*)

VAR
Rel, Out: BOOL := 0; (* Release - Input; Output *)
Time1: TON; (* FB TON standard a les paramètres formels… *)
(* …IN, PT (entrées) et Q, ET (sorties *)
Value TIME; (* entrée –mise à 1 *)
END_VAR

S. MARAOUI Page 11
ISSATKr API A.U. 2019/2020
Master CSI1-AII

(*méthode 1*) (*donner les (* Appel: *)

CAL Time1 (
paramètres*) IN:=Rel,
PT:= t#500ms,
Q=>Out, (* Output p. 1 *)
ET=>VALUE (* Output p. 2 *)
)
(*méthode 2*) LD t#500ms CAL Time1 (*Utilisation des paramètres de
ST Time1.PT
LD Rel sortie*)
ST Time1.IN LD Time1.Q
LD t#500ms ST Out
(*méthode 3*) IN time1 LD Time1.ET
PT Time1
LD Rel ST Value

5. Programmation en FBD (Logigramme)

Un programme (ou partie de programme) écrit en langage FBD (Function Block Diagram) comporte trois
parties : départ en fin du programme, partie déclaration et partie code.

La partie déclaration peut être textuelle ou graphique. La partie code est divisée en réseaux. Un réseau est
constitué de :

- Label du réseau
- Commentaire
- Graphique du réseau

Dans ce langage on utilise des fonctions logiques comme ET, OU, NAND, NOR, XOR ou des combinaisons de
ces fonctions. L’utilisateur peut aussi définir ses propres fonctions ou FB, comme pour le langage LD.

Exemple :

S. MARAOUI Page 12
ISSATKr API A.U. 2019/2020
Master CSI1-AII

6. Programmation en texte structuré (ST)

Comme le IL, le langage ST est un langage textuel. Il est dit de haut niveau. Il offre un ensemble
d’instructions abstraites décrivant des fonctions plus ou moins complexes d’une façon condensée. Les
avantages du langage ST par rapport à celui de l’IL sont nombreuses, parmi lesquelles :

- Formulation très condensée des fonctions à réaliser.

- Construction claire du programme en blocs fonctionnels.
- Possibilité poussée de commande de processus.

Les inconvénients de ce langage sont liés principalement à sa compilation, puisque généralement les
programmes compilés sont plus longs et plus lents à l’exécution.

Expressions en ST
Un programme écrit en ST est formé par un ensemble d’expressions, séparées par un “;” (le retour à la ligne
est interprété comme un simple espace). Les commentaires sont de la forme (*Commentaire*) et peuvent
être dans l’expression même comme : A := B (* élongation *) + C (* température *);

Les expressions du langage sont résumées dans le tableau suivant :

Mot clé Description Exemple

:= Affectation D :=10 ;
Appel de fonction FBName(
Par1:=10,
Par2:=20,
Par3:=>Res);
Return Retour Return ;
If Sélection IF d < e THEN f:=1;
ELSIF d=e THEN f:=2;
ELSE f:= 3;
END_IF;
Case Choix multiple CASE f OF
1: g:=11;
2: g:=12;
ELSE g:=FunName();
END_CASE;
For FOR h:=1 TO 10 BY 2 DO
f[h/2] := h;
Itération END_FOR;
While WHILE m > 1 DO
n := n / 2;
END_WHILE;
Repeat REPEAT
i := i*j;
UNTIL i < 10000
END_REPEAT;
Exit Fin de boucle exit;

N.B : différents opérateurs sont utilisés pour effectuer les opérations logiques et arithmétiques (&, and, or,
<,>, parenthèses,) , comme par exemple pour le langage C, l’ordre de priorité est aussi semblable.

S. MARAOUI Page 13
ISSATKr API A.U. 2019/2020
Master CSI1-AII

7. Programmation SFC (Grafcet)

Le langage SFC (Sequentiel Function Chart) de la norme CEI 61131-3 a été défini pour pouvoir diviser un
problème complexe en des unités plus petites et plus manipulable, et aussi pour décrire le flux de
commande entre ces unités. La séquence d’exécution de ces unités dépond des conditions statiques définies
par le programme et des conditions dynamiques définies par les E/S. Les unités peuvent elles même être
programmées utilisant les autres langages de programmations des API.

Le premier langage largement adopté décrivant un processus par un ensemble d’états et de conditions
transitoires est le Grafcet, qui est par la suite largement intégré dans le langage SFC.

Les processus pouvant être décris par un comportement séquentiels caractérisé par des étapes, sont
particulièrement adaptés pour que leur fonctionnement soit décrit avec ce langage.

7.1. Rappel sur le grafcet :

Le GRAFCET (GRAphe Fonctionnel de Commande par Etape Transition) est un outil graphique qui permet la
description du fonctionnement du système automatisé au cours du temps d'une façon claire et sans
ambiguïté.

Un grafcet est un ensemble d’étapes, des transitions et des liaisons orientées.

Etape : Une étape correspond à une phase durant laquelle on effectue une action pendant
une certaine durée (même faible mais jamais nulle). L'action doit être stable, c'est à dire que
l'on fait la même chose pendant toute la durée de l'étape.
A chaque étape on associe une ou plusieurs actions.

2 Marche Montée 3* 3
avant

Etape Etape inactive

Une étape peut être active on effectue l'action qui lui est associée, active

ou désactive.
Les actions peuvent :
 Commander des actions extérieures : Déplacement d’un chariot, mise en marche d’un moteur,
allumage d’un voyant…
 Effectuer des relations intérieures : lancer une temporisation, activer un autre cycle…
Transition : Une transition est une condition de passage d'une étape à une autre. Elle définit
la fin de l’étape qui la précède. A chaque transition on associe une condition logique appelée
réceptivité qui définit la condition de passage d'une étape à la suivante.
Les liaisons orientées
Les liaisons orientées indiquent les voies d’évolution du grafcet. Elles sont horizontales ou verticales. Le sens
général d’évolution du grafcet est du haut vers le bas. Des flèches doivent être utilisées dans le cas contraire
ou lorsqu’une meilleure compréhension pourra en résulter.

S. MARAOUI Page 14
ISSATKr API A.U. 2019/2020
Master CSI1-AII

La figure suivante illustre les différentes composantes d’un grafcet :

Règles d’évolution d’un GRAFCET

La modification de l'état de l'automatisme est appelée évolution, et est régie par 5 règles :
Règle 1 : Situation initiale : Un grafcet doit contenir au moins une étape qui soit active au début
du fonctionnement du système et à partir du quelle le grafcet va évoluer. Cette étape est
appelée étape initiale.

Règle 2 : Franchissement d'une transition : Une transition est franchissable si toutes les étapes
immédiatement précédentes sont actives et la réceptivité associée à cette transition est vraie. Si
une transition est franchissable, elle est forcément franchie.

Règle 3 : Activation et désactivation d'une étape :Le franchissement d'une transition entraîne
l'activation de toutes les étapes immédiatement suivantes et la désactivation de toutes les
étapes immédiatement précédentes.

Règle 4 : Plusieurs transitions simultanément franchissables sont simultanément franchies.

Règle 5 : Si au cours du fonctionnement d’une même étape doit être active et désactivée simultanément,
alors elle reste activée.

Différentes structures d'un grafcet

Un cycle d’automatisme peut être linéaire, ou ramifié. Les cycles simples ne comportent qu’une seule
séquence, c’est à dire un ensemble d’étapes les unes à la suite des autres.

Les cycles ramifiés comportent plusieurs séquences, le rôle des aiguillages dans un GRAFCET est soit de
sélectionner une séquence : Aiguillage en OU (on parle dans ce cas de cycle à plusieurs branches avec
sélection de séquence), soit d’exécuter simultanément plusieurs séquences : Aiguillage en ET (on parle dans
ce cas de cycle à plusieurs séquences à séquences simultanées).

Grafcet à séquence unique : C’est un grafcet constitué d’une suite d’étapes et transitions sans ramifications.
Le cycle de poinçonnage traité précédemment en est un exemple.

S. MARAOUI Page 15
ISSATKr API A.U. 2019/2020
Master CSI1-AII

Aiguillage en OU : Dans ce cas, le grafcet possède une structure à plusieurs branches à exécution exclusive
c'est-à-dire une seule séquence (branche) est exécuté à la fois lors d’un cycle.

D’autres structures d’aiguillage en OU sont aussi possibles comme le saut d’étapes ou la reprise de
séquence:

Aiguillage en Et (séquences simultanées) : C’est un grafcet qui possède plusieurs séquences (branches) qui
vont se dérouler simultanément (en parallèle).

S. MARAOUI Page 16
ISSATKr API A.U. 2019/2020
Master CSI1-AII

7.2. Identification des étapes et transissions en SFC

En SFC, une étape peut être identifiée graphiquement par un rectangle et un nom d’étape (ou double
rectangle pour l’étape initiale) ou textuellement via une déclaration :

Ou : Step Identifiant
Identifiant
(* Corps de l’étape pour décrire les actions *)
End_step

Initial_step identifiant ;
Initiale
(*Corps de l’étape *)
End_step

Une réceptivité associée à une transition peut être écrite en l’un des langages ST, LD ou FBD, mais pas en IL
dans la version graphique du SFC.

Langage LD Langage ST Langage FBD

²

On peut aussi utiliser des connecteurs pour lier une réceptivité à une transition.

Dans ce cas les langages ST et IL ne sont pas autorisés.

S. MARAOUI Page 17
ISSATKr API A.U. 2019/2020
Master CSI1-AII

Une troisième méthode consiste à utiliser le nom de la réceptivité associé à la transition, écrite
indépendamment du diagramme SFC, les langages textuels peuvent être utilisés dans ce cas. Cette méthode
a l’avantage de pouvoir utiliser le nom de la réceptivité pour différentes transitions auxquelles sont
associées la même condition logique.

Exemple :
Déclaration de la réceptivité :

Appel de la transition :

7.3. Description des actions :

Une action est utilisée pour décrire les instructions à exécuter en association avec une étape active. Ces
instructions peuvent être une action booléenne ou une séquence d’instructions programmées en LD, IL, FBD,
ST ou un sous-programme en SFC.

Un bloc action est constitué d’une action avec une condition d’exécution (appelée qualificateur d’action) et
un indicateur booléen variable (optionnel). Un bloc d’action peut être définit en version graphique ou
textuelle.

Qualificateur d’action Nom d’action Indicateur booléen variable

Instruction en LD, IL, ST ou SFC

S. MARAOUI Page 18
ISSATKr API A.U. 2019/2020
Master CSI1-AII

Exemples :

S. MARAOUI Page 19
ISSATKr API A.U. 2019/2020
Master CSI1-AII

8. Types de données et déclaration des variables

8.1. Types de données

Types de données élémentaires :
Les types de données élémentaires spécifiés par la norme 61131-3, sont donnés par le tableau suivant :

Booléenne/string Entiers signés Entiers non signés Réels (FP) Temps, durée et
date
BOOL INT UINT REAL TIME
BYTE SINT USINT LREAL DATE
WORD DINT UDINT TIME_OF_DAY
DWORD LINT ULINT DATE_AND_TIME
LWORD STRING
Avec : D= double, L= long, S = Short et U = unsigned.

Ces types ont caractérisé par leurs largeurs (nombres de bits) ainsi que par leur étendus (ou intervalles de
valeurs). Ceci ne s’applique pas aux types de temps et dates qui ont leurs propres spécifications.

Ces grandeurs sont résumées dans les tableaux suivants pour les différents types élémentaires.

Type de variable Bits Intervalle Initiale

BOOL 1 [0,1] 0
BYTE 8 [0,…,16#FF] 0
WORD 16 [0,…,16#FFFF] 0
DWORD 32 [0,…,16#FFFF FFFF] 0
LWORD 64 [0,…,16#FFFF FFFF FFFF FFFF] 0
SINT 8 [-127,…,128] 0
INT 16 [-32768,…,32767] 0
DINT 32 [-231,…,231-1] 0
LINT 64 [-263,…,263-1] 0
USINT 8 [0 … 255] 0
UINT 16 [0… 65535] 0
UDINT 32 [0… 231-1] 0
ULINT 64 [0 …264-1] 0
REAL 32 Spécifié par la norme IEEE 754-2008 0.0
LREAL 64 0.0

Type dtae Description Initiale

DATE Date (seulement) D#0001-01-01
TOD Temps durant la journée Tod#00 :00 :00
DT Temps et date Dt#0001-01-01-00 :00 :00
Time Durée t#0s

Types de données dérivées (ou définition de type)

L’utilisateur peut définir ses propres types de données à partir des types élémentaires. Ceci est appelé
dérivation ou définition de type. Ceci permet à l’utilisateur de définir les types les plus appropriés à ses

S. MARAOUI Page 20
ISSATKr API A.U. 2019/2020
Master CSI1-AII

besoins. Ses définitions sont globales pour un projet API. La définition de type de variables utilise les mots
clés Type … END_TYPE.

Exemple :
TYPE
LongFloatNum : LREAL; (*dérivation depuis la norme *)
FloatingPoint : LongFloatNum; (* derivation depuis un type définit par l’utilisateur *)
InitFloatNum : LREAL := 1.0; (* derivation avec une nouvelle valeur initiale *)
tControl : BOOL := TRUE; (* derivation avec nouvelle valeur initiale *)

END_TYPE

On peut aussi déclarer des types de données de type array (vecteur) ou structure.

Un array est une suite d’éléments de même type consécutifs en la mémoire et peuvent être accédé via un
index, alors que la structure est formée de sous-éléments qui peuvent être de type élémentaire ou dérivés.

Exemples:
1)

TYPE
Colour : (red, yellow, green); (* enumeration *)
Sensor : INT (-56..128); (* range *)
Measure : ARRAY [1..45] OF Sensor; (* array *)
TestBench : (* structure *)
STRUCT
Place : UINT; (* elementary data type *)
Light : Colour:= red; (* enumerated data type with initial value *)
Meas1 : Measure; (* array type *)
Meas2 : Measure; (* array type *)
Meas3 : Measure; (* array type *)
END_STRUCT;
END_TYPE

2) définition de structure relative au fonctionnement d’un moteur

TYPE
LimitedRevol : UINT (0..230);
TypLevel : (Idling, SpeedUp1, SpeedUp2, MaxPower);
MotorState :
STRUCT
Revolutions : LimitedRevol; (* limites *)
Level : TypLevel; (*type enumeration*)
MaxReached : BOOL; (*type elementaire *)
Failure : BOOL; (*type elementaire *)
Brake : BYTE; (*type elementaire *)
END_STRUCT;
END_TYPE

S. MARAOUI Page 21
ISSATKr API A.U. 2019/2020
Master CSI1-AII

8.2. Déclaration de variable :

Forme générale de déclaration :
Les variables sont déclarées avec le type de donnée et des propriétés. Ces propriétés peuvent être définies
dans la déclaration utilisant :

- Les propriétés du type de données spécifiques.

- Informations (optionnelles) sur les valeurs initiales
- Informations (optionnelles) sur les valeurs limites
- Type de variable du bloc de déclaration dans lequel la variable a été déclarée (avec
qualificateur/attribue)

Exemple:

Type de variable Attribue

VAR_OUTPUT RETAIN

Var1 : Byte := 10;

Nom de variable Valeur initiale

END_VAR Type de donnée

Fin du type de variable

Attribues de types de variables :

La norme CEI 61131-3 définie des attribues (ou qualificateurs) avec lesquelles des propriétés
supplémentaires peuvent être ajoutées aux variables :

- RETAIN : variable retenu (peut être récupérer après coupure de courant grâce à la batterie).
- NON_RETAIN : non récupérable.
- CONSTANT : variable constante, ne peut pas être modifiée
- R_EDGE : à front montant
- F_EDGE : à front descendant
- READY_ONLY : protéger en écriture
- READ_WRITE : peut-être accédée pour l’écriture et la lecture

S. MARAOUI Page 22
ISSATKr API A.U. 2019/2020
Master CSI1-AII

9. Fonctions standards
Les fonctions standards ont des variables d’entrée (paramètres formels) ainsi que la valeur retournée par la
fonction.

9.1. Fonctions de conversions de types:

Ces fonctions standards convertie la variable d’entrée en le type de donnée retournée par la fonction. Ces
fonctions sont résumées par la figure suivante :

9.2. Fonctions numériques :

Permettent de réaliser des fonctions mathématiques de base (abs, sqrt, Ln, Log, sin, cos, tan, asin,…)

9.3. Fonctions arithmétiques :

Permettent de réaliser des opérations arithmétiques (add, sub, mult, div)

Addition et multiplication :

Soustraction et division :

MOD :

S. MARAOUI Page 23
ISSATKr API A.U. 2019/2020
Master CSI1-AII

9.4. Opérations sur les bits :

Permettent de manipuler des bit (shift droite/gauche, rotation droite/gauche : SHR, SHL, ROR et ROL)

9.5. Opérations bit à bit

Permettent de réaliser des opérations de type fonctions logique de base (not, and, or, xor)

9.6. Fonction sélection

Les fonctions MAX, MIN et LIMIT permettent de faire une sélection selon la valeur de l’entrée

Pour Max ou Min :

Pour limit :

Pour cette fonction : F :=MIN(MAX(IN,MN),MX) ;

9.7. Fonctions SEL et Mux :

Sel : sélection binaire.

F := IN0 si G=1 sinon F :=IN1

S. MARAOUI Page 24
ISSATKr API A.U. 2019/2020
Master CSI1-AII

Mux : multiplexeur.

F :=INi, si K=i avec K=0…n-1

9.8. Fonctions pour variable de type date :

Dans ces figure (***)= ADD ou SUB

(***)=Mul ou Div

Conversion :

10. Fonctions blocs standard :

Bascules :
Bascule à set dominant Bascule à reset dominant

S. MARAOUI Page 25
ISSATKr API A.U. 2019/2020
Master CSI1-AII

Détection de front :
Détection front montant Détection front descendant

Compteurs :
Trois types de compteurs : incrémentation (CTU), décrémentation (CTD) et incrémentation-décrémentation
(CTUD)

CTU CTD CTUD

FUNCTION_BLOCK CTU (* up counter *) FUNCTION_BLOCK CTD (* down counter*) FUNCTION_BLOCK CTUD

VAR_INPUT VAR_INPUT VAR_INPUT
CU : BOOL R_EDGE; (* CU front montant*) CD : BOOL R_EDGE; CU : BOOL R_EDGE;
R : BOOL; LD : BOOL; CD : BOOL R_EDGE;
PV : INT; PV : INT; R : BOOL;
END_VAR END_VAR LD : BOOL;
VAR_OUTPUT VAR_OUTPUT PV : INT;
Q : BOOL; Q : BOOL; END_VAR
CV : INT; CV : INT; VAR_OUTPUT
END_VAR END_VAR QU : BOOL;
IF R THEN (* reset compteur *) IF LD THEN (* reset compteur*) QD : BOOL;
CV := 0; CV := PV; CV : INT;
ELSIF CU AND ( CV < PV) THEN ELSIF CD AND ( CV > 0) THEN END_VAR
CV := CV + 1; (* count up *) CV := CV - 1; (* count down *) IF R THEN (*reset counter(reset dominant)*)
ENDIF; ENDIF; CV := 0;
Q := (CV >= PV); (* limite attainte*) Q := (CV <= 0); (* zero reached *) ELSIF LD THEN
END_FUNCTION_BLOCK END_FUNCTION_BLOCK CV := PV; (* valeur à compter value *)
ELSE
IF NOT (CU AND CD) THEN
IF CU AND ( CV < PV) THEN
CV := CV + 1; (* count up *)
ELSIF CD AND ( CV > 0) THEN
CV := CV - 1; (* count down *)
ENDIF;
ENDIF;
ENDIF;
QU := (CV >= PV); (* limit reached *)
QD := (CV <= 0); (* zero reached *)
END_FUNCTION_BLOCK

Temporisation :
Trois types de temporisations sont disponible TON (décompte T…0), TOF (comptage 0…T) et à impulsion

*** = TON ou TOF ou TP

S. MARAOUI Page 26
ISSATKr API A.U. 2019/2020
Master CSI1-AII

Temporisation à impulsions TP
Le diagramme ci-après montre le comportement des sortie ET Q selon les valeurs des entrées IN et PT

La fonction bloc standard TP fonctionne comme générateur d’impulsions, qui fournit une impulsion de
largeur fixe (TP) à la sortie Q lorsqu’un front montant est détecté sur l’entrée IN. Le temps qui s’est passé
peut-être lu sur ET (Elapsed Time). A noter que l’impulsion ne peut pas réinitialiser avant sa fin (voir
intervalle entre t2 et t2+PT).

Temporisation TON (On delay timer)

Le timer TON fournit la valeur de l’entrée IN à la sortie Q avec un délai lors qu’un front montant est détecté
sur IN. Si IN est 0 un pour une durée plus courte que PT , le TIMER n’est pas démarré.

TEMPORISATION TOF
Son fonctionnement est le contraire de celui de TON

S. MARAOUI Page 27