Premier exemple pas à pas

On va implémenter le grafcet suivant, permettant d'allumer une lampe depuis un intérrupteur de type bouton poussoir.

Premier Grafcet à implémenter dans HomeIO avec c#

Définir les équations

En applications les règles vue en cours avec M. Riera, vous pouvez déterminer les équations.

Calcul des fonctions de transition

Rappel de la règle : $F T1(t)=X_{n-1}(t-1).R1(t)$

$$ft1 = X1. \uparrow bp \\ ft2 = X2. \uparrow bp$$

Calcul des étapes

Rappel de la règle : $Xi(t) = FTpred_i(t) + Xi(t-1).\overline{FTsucc_i(t)}$

$$X1=ft2+X1.\overline{ft1} \\ X2=ft1+X2.\overline{ft2}$$

Calcul des sorties

$$Allumer\_la\_lampe = X2$$

Rappel du fonctionnement du cycle API

Cycle API à reproduire

Mise en place dans C#

Dans C# (ou tout autre langage de programmation), le cycle API est en fait une boucle, qui se répète, sans fin, toutes les x ms (peut dépendre de l'automate que l'on souhaiterait simuler), afin de simuler le cycle d'un API.

A l'intérieur de cette boucle, le programme doit réaliser les différentes opérations du cycle :

1. Sauvegarder l'état précédent

2. Lire les entrées

3. Calculer les fonctions de transitions

4. Calculer les étapes

5. Calculer les sorties

6. Ecrire les sorties

Quelques éléments en C#

Récupérer une entrée depuis HomeIO

L'extrait de code ci-dessous permet de récupérer l'état d'un capteur (ou d'une entrée en général) et de le sauvegarder dans une variable.

bool bp = MemoryMap.Instance.GetBit(adresseDuComposant, MemoryType.Input).Value;

On peut procéder de manière similaire pour récupérer l'état d'une sortie, et ensuite pouvoir le modifier.

MemoryBit lampe = MemoryMap.Instance.GetBit(adresseDuComposant, MemoryType.Output);
//lampe contient l'adresse. Pour accéder à la valeur, il faut utiliser la propriété Value;

Traduction des différentes étapes du cycle

Considérons que le code ci-après se trouve dans une méthode nommée : runCycleApi()

Les extraits de code ci-après suppose que les déclarations sont effectuées. Le code ne concerne que la méthode qui est exécutée cycliquement par le timer.

Etape 1. Sauvegarde des états précédents

this.bpPrec = this.bp;

Etape 2. Lecture des entrées

La lecture des entrées implique de mettre à jour la memory map qui est en cache. Cette mise à jour ne se fait qu'en début de cycle pour récupérer l'état du système, et en fin de cycle pour écrire les sorties.

MemoryMap.Instance.Update();
this.bp = MemoryMap.Instance.GetBit(adresseDuComposant, MemoryType.Input).Value;

Etape 3. Calcul des fonctions de transition

Il est souvent nécessaire de manipuler des fronts (montant ou descendant) afin de traiter la donnée des entrées.

Le calcul d'un front montant peut se faire de la manière suivante :

this.front = ! this.bpPrec && this.bp;

Il serait très judicieux de définir une méthode pour calculer les fronts sur des exemples plus complexes

Les équations des fonctions de transition se calculent donc avec les lignes suivantes :

this.ft1 = this.X1 && this.front;
this.ft2 = this.X2 && this.front;

ft1, ft2, X1 et X2 sont des variables représentant les éléments du Grafcet. Les étapes (Xn) sont initialisées à false, sauf les étapes initiales qui doivent être à true pour pouvoir exécuter le Grafcet.

Etape 4. Calcul des étapes

La traduction des équations en C# donne :

this.X1 = this.ft2 || this.X1 && ! this.ft1;
this.X2 = this.ft1 || this.X2 && ! this.ft2;

Etape 5. Calcul des sorties

En fonction des actions associées aux étapes.

this.lampe.Value = X2; //on active la lampe que sur l'étape 2

Etape 6. Mise à jour des sorties

Il faut maintenant mettre à jour HomeIo en synchronisant le cache et la memory map:

MemoryMap.Instance.Update();

On répète le cycle

Si tout le code précédent est dans une méthode, on peut répéter ce cycle dans un time avec la méthode suivante, associée à un timer dans votre projet :

private void timer1_Tick(object sender, EventArgs e)
{
    runCylceApi();
}

Ce timer doit se déclencher soit de manière automatique au chargement, soit sur un bouton de votre interface, au choix. Il est nécessaire d'initialiser aussi l'état du grafcet (étape initiale à vraie this.X1 = true)