Programmation d'un grafcet en C

Le Grafcet est un manière de représenter un automatisme, très utilisée dans le monde francophone.
Il diffère des graphes d'état par la terminologie utilisée et sur un point fondamental :
– Les termes utilisée sont un peu différents: on parle d'étapes et non d'état. La condition d'une
transition s'appellent la réceptivité. Lorsque qu'une étape donnée peut être suivie soit d'une
étape, soit d'une autre, on parle de divergence en OU.
– Mais de manière plus fondamentale, alors qu'une machine d'état ne peut avoir qu'un seul état
actif à un instant donné, plusieurs étapes d'un Grafcet peuvent être actives en même temps.
En effet, le concept de divergence en ET permet l'activation de plusieurs étapes par le
franchissement d'une transition.
Le but de cette fiche n'est pas de présenter la théorie des Grafcet, le lecteur se réfèrera à l'un des
nombreux documents pédagogiques qu'on trouve sur Internet à ce sujet. Le but est simplement de
présenter une technique simple permettant de « traduire » un Grafcet en un programme C, en vue de
l'exécuter sur un microcontrôleur.
Voici le squelette d'un programme permettant d'implémenter un Grafcet:
#include <MSP430G2553.h>
#define MaxEtapes 10 // nombre maximal d'étapes
#define MaxTransitions 10 // nombre maximal de transitions
char Etapes[MaxEtapes]; // Variables des étapes, vrai si une étape est active
char Transitions[MaxTransitions]; // vrai si la transition est franchissable
void InitIO() { // Initialisation des entrées et sorties
PxREN...|=(Bit...); ...
PxDIR...|=(Bit...); ...
}
void LitEntrees() { // Lecture des entrées
if(!(Pin...&(Bit...))) ...=1; else ...=0; ...
}
void CalculeTransitions() { // Recherche des transitions franchissables
Transitions[x]=Etapes[y] && Receptivite; ...
}
void DesactiveEtapes() { // Désactive les étapes précédant les transitions franchissables
if (Transitions[x]) Etapes[y]=0; ...
}
void ActiveEtapes() { // Active les étapes suivant les transitions franchissables
if (Transitions[x]) { Etapes[z]=1; } ...
}
void AffecteSorties () { // Gère les sorties en fonction des étapes actives
SortieX=Etapes[x]; ...
if(SortieX)Port...|=(Bit...); else Port...&=~(Bit...); ...
}
int main () { // Programme principal
InitIO();
int i; for (i=0; i<MaxEtapes; i++) Etapes[i]=0;
Etapes[0]=1; // Activation de l'étape initiale
while (1) { // boucle infinie
AffecteSorties();
LitEntrees();
CalculeTransitions();
DesactiveEtapes();
ActiveEtapes();
}
}
Le tableau Etapes[] est constitué d'une variable booléenne pour chaque étape du Grafcet. Chaque
étape peut être inactive (valeur nulle) ou active (valeur non nulle). Au début du programme, seule
l'étape initiale est activée.
De même, le tableau Transitions[] indique pour chaque transition si elle est non-franchissable
(valeur nulle) ou franchissable (valeur non nulle).

2013 Pierre-Yves Rochat, pierre-yves.rochat@epfl.ch, version du 01/04/2013

La boucle principale while(1) est constituée de l'appel de cinq procédures qui correspondent à la
théorie des Grafcet. En début de boucle, la procédure AffecteSorties() active toutes les sorties
qui doivent l'être en fonction des étapes actuellement actives.
On aura par exemple : Avance=Etapes[1]; suivi plus loin de :
if(Avance)PortAvance|=(BitAvance); else PortAvance&=~(BitAvance);
Afin de rendre le programme bien lisible, la procédure LitEntrees() lit l'état de chaque entrée et
affecte le résultat à une variable nommée selon le nom de l'entrée. Par exemple: char Start;
La lecture se fera alors par exemple de la manière suivante:
if (!(PinStart&(BitStart))) Start=1; else Start=0;
La procédure CalculeTransitions() va déterminer pour chaque transition si elle est
franchissable ou non. Rappelons qu'une transition est franchissable si l'étape qui la précède est
active et si sa réceptivité est vraie. On aura donc par exemple:
Transitions[0]=Etapes[0] && Start;
Les procédures DesactiveEtapes() et ActiveEtapes() correspondent au franchissement
des transitions franchissables:
– l'étape ou les étapes précédant chaque transition franchissable sont désactivées
– l'étape ou les étapes suivant chaque transition franchissable sont activées.
La boucle principale va ensuite s'exécuter à nouveau, en commençant par activer les sorties qui
doivent l'être en fonction des étapes devenues actives.
Exemple : le problème de la perceuse, décrit dans la fiche « Graphes d'état et machines d'état » peut
être écrit de la manière suivante : (les définitions n'ont pas été écrites ici)
void InitIO() { void ActiveEtapes() {
DdrUp|=(BitUp); if (Transitions[0]) Etapes[descente]=1;
DdrDown|=(BitDown); if (Transitions[1]) Etapes[montee]=1;
P1OUT|=(BitStart);PullUpStart|=(BitStart); if (Transitions[2]) Etapes[arret]=1;
P1OUT|=(BitBas);PullUpBas|=(BitBas); }
P1OUT|=(BitHaut);PullUpHaut|=(BitHaut); char Down, Up;
} void AffecteSorties () {
char Etapes[MaxEtapes]; Down=Etapes[descente];
char Transitions[MaxTransitions]; Up=Etapes[montee];
enum {arret, descente, montee}; if(Up) PortUp|=(1<<BitUp);
else PortUp&=~(1<<BitUp);
char Start, Bas, Haut; if(Down) PortDown|=(1<<BitDown);
void LireEntrees() { else PortDown&=~(1<<BitDown);
if(!(PinStart&(BitStart))) Start=1; }
else Start=0; int main () { // Programme principal
if(!(PinBas&(BitBas))) Bas=1; InitIO(); int i;
else Bas=0; for (i=0; i<MaxEtapes;i++)
if(!(PinHaut&(BitHaut))) Haut=1; Etapes[i]=0;
else Haut=0; Etapes[0]=1;
} while (1) {
void CalculeTransitions() { AffecteSorties();
Transitions[0]=Etapes[arret] && Start; LireEntrees();
Transitions[1]=Etapes[descente] && Bas; CalculeTransitions();
Transitions[2]=Etapes[montee] && Haut; DesactiveEtapes();
} ActiveEtapes();
void DesactiveEtapes() {
if (Transitions[0]) Etapes[arret]=0; }
if (Transitions[1]) Etapes[descente]=0; }
if (Transitions[2]) Etapes[montee]=0;
}

Pour un problème aussi simple, cette méthode peut sembler bien compliquée ! Son avantage est
qu'elle consiste simplement à suivre systématiquement chaque élément du Grafcet. Elle se prête
donc bien à des Grafcet complexe. On peut facilement lui ajouter des temporisations.

2013 Pierre-Yves Rochat, pierre-yves.rochat@epfl.ch, version du 01/04/2013