Vous êtes sur la page 1sur 28

UNIVERSITÉ PAUL SABATIER (TOULOUSE III)

--------

MASTER E.E.A. A.E.E.T.S


Electronique Electrotechnique Automatique
Spécialité ISTR

Unité d’Enseignement I7
Techniques de Mise en Œuvre pour les Systèmes à Evénements Discrets

TRAVAUX PRATIQUES

2013 – 2014
Salle de Travaux Pratiques

TP EEA
Info. Industrielle
Temps Réel

salle I1 - Bâtiment 3 TP 2 - du coté de l'amphi Maxwell


M1-EEA-ISTR – I7 – TMO-SEDs – 2013/14 Organisation et Consignes Importantes i

ORGANISATION ET CONSIGNES IMPORTANTES

1. OBJECTIFS DES TRAVAUX PRATIQUES

Cette série de 6 séances de 3 heures de Travaux Pratiques a pour but d'illustrer différentes techniques de
mise en œuvre pour les SED : MEF, Réseaux de Petri, MEF coordonnées.

Différentes techniques et différents langages sont envisagés, sans avoir la prétention de considérer toutes
les techniques possibles.

2. ORGANISATION DE LA SERIE DE MANIPULATIONS

Les 6 séances de la séquence s’articulent en 2 parties :

- 2 séances de manipulation
Chaque binôme réalise 2 manipulations parmi 3 thèmes proposés.
Les 3 manipulations sont basées sur la commande d’un procédé par 2 techniques différentes.

- 4 séances de mini-projet
Chaque binôme développe un mini-projet consistant à commander un processus qui n’a pas été
envisagé dans la 1e partie.
Le mini-projet consiste à développer un générateur de code dans un des langages disponibles et
pour une technique de mise en œuvre donnée, en partant de la modélisation du système de commande.

3. CONTROLE DES CONNAISSANCES

Le travail est évalué par un contrôle continu basé sur les comptes rendus remis en fin de séance et en fin
de mini-projet.
M1-EEA-ISTR Techniques de Mise en Œuvre pour les Systèmes à Evénements Discrets
Organisation des TP - 2013-14

2 séances de TP de 3h
Binômes répartis en 3 groupes (P, Q, R) de 2/3 binômes chacun pour choisir 2 manipulations sur les 3 :
TP1 : commande de l’Ascenseur par plusieurs MEF’s en C
TP2 : commande de la Machine à Laver par RdP en VHDL
TP3 : commande de Trains par MEF en langage ST

Groupe les TP les binômes


P TP1 & TP2 P1 P2 P3
Q TP2 & TP3 Q1 Q2 Q3
R TP3 & TP1 R1 R2 R3

P1 P2 P3 Q1 Q2 Q3 R1 R2 R3
Séance1 TP1 TP1 TP1 TP2 TP2 TP2 TP3 TP3 TP3
Séance2 TP2 TP2 TP2 TP3 TP3 TP3 TP1 TP1 TP1

1 TP-projet de 12h, en 4 séances de 3h


Dans chaque groupe, les binômes se répartissent en choisissant 1 projet :
Groupe TP binômes projets
P TP1-TP2 P1…P3 RdP + ST + Trains MEF + C + Trains
Q TP2-TP3 Q1…Q3 MEF + VHDL + Asc RdP + C + Asc
R TP3-TP1 R1…R3 RdP + VHDL + MàL MEF + ST + MàL

Groupe 1 lundi 16h30-19h30 du 10/03 au 14/04

P1=Detournay Diallo P2= El Kholy Lacaze P3=Ngampo Soulaimana

Q1= Chatrie Dénarié Q2=Benaissa Kerouane Q3= Oro .

R1=Foughali Grib R2= Fabre Obry R3= Essertel Robin

Groupe 3 vendredi 16h30-19h30 du 21/03 au 25/04

P1=Aggoune She P2= Addar Sahuguede P3=Vasconcelos Vincent

Q1= Safi Yadouz Q2=Cazenave Leclercq Q3=Barhoumi Kowet

R1=Fernbach Pichard R2=Bourgade Roblin R3= Belliot Meunier


M1-EEA-ISTR – I7 – TMO-SEDs – 2013/14 - Poste de manipulation 1 - 1/2

- Poste de manipulation 1 -
Commande d’une maquette d’ascenseur
Modélisation par MEF coordonnées – Mise en œuvre en C

1. BUT

Ce poste de manipulation a pour objectif d’effectuer la mise en œuvre en C d’un ensemble de MEF
coordonnées. Les MEF ne sont pas complètement indépendantes, et concourent à la commande du procédé. Deux
techniques de mise en œuvre sont envisagées : réalisation 1 parmi N, mise en œuvre directe de MEF coordonnées.

2. CONTEXTE DE LA MANIPULATION

2.1. Matériel disponible

La maquette d’ascenseur est constituée d’une cabine pouvant monter ou descendre entre 4 paliers (Monter,
Descendre), sa position étant connue lorsqu’elle est à un étage (ET_i). A l’intérieur sont disposés 4 boutons de
consigne d’étage à atteindre (AP_i). Chaque palier (sauf le 4e) a un bouton d’appel pour monter (P_j_m) et son
témoin (T_j_m) et un pour descendre (sauf le 1er) (P_k_d), et son témoin (T_k_d). Chaque porte d’étage a un capteur
d’ouverture, et la maquette présente comme information le fait qu’une porte, au moins, est ouverte (PorteOuverte).
Une alarme peut être émise (Alarme).

Bilan de ces signaux :

Capteurs : AP_i ET_i P_j_m P_k_d PorteOuverte Urgence


Actionneurs : Monter Descendre T_j_m T_k_d Alarme
i ∈ [1, 4] j ∈ [1, 3] k ∈ [2, 4]
ils seront ignorés dans cette étude

2.2. Commande envisagée : étape 1

La cabine se déplace entre les paliers 1 à 3.

La cabine étant à l’arrêt, elle se déplace vers l’étage i demandé si AP_i ≠ ET_i. A l’arrivée à l’étage, ouverture
puis fermeture de la porte autoriseront un nouveau déplacement. Un nouvel appel n’est pris en compte qu’après
fermeture de la porte ; il n’est par ailleurs pris en compte que lorsque la cabine est à l’arrêt.

Au départ, la cabine est à l’arrêt au palier 1.

Modéliser cette commande par une MEF élémentaire.

2.3. Commande envisagée : étape 2

Le fonctionnement précédent est repris comme base : déplacement si AP_i ≠ ET_i, nouveau déplacement
possible après ouverture-fermeture de la porte. Dans cette 2nde étape, les appels doivent être mémorisés pour pouvoir
être pris en compte lors du prochain départ. Un appel effectué en cours de déplacement de la cabine ne sera donc pas
oublié.

Modéliser cette commande par un réseau de Petri. Identifier les composantes conservatives et décomposer le
réseau en plusieurs MEF coordonnées.
M1-EEA-ISTR – I7 – TMO-SEDs – 2013/14 - Poste de manipulation 1 - 2/2

3. MISE EN ŒUVRE

La mise en œuvre de la commande suppose que le procédé est câblé au système de commande. La connectique
suivante devra être réalisée :

capteurs AP1=0 AP2=1 AP3=2 ET1=3 ET2=4 ET3=5 PorteOuverte=6


sur le port B : bits 0 à 7 = entrées 0 à 7
actionneurs Monter=0 Descendre=1
sur le port A : bits 0 à 7 = sorties 0 à 7

Des fichiers de base sont mis à disposition, sous Linux, dans un dossier partagé, et sont à recopier dans le
répertoire de travail :
dossier home/partage/commun/M1_ISTR_TMOSED/ASCENSEUR_C

Edition, compilation en C et exécution se feront sous Linux :


édition gedit FichierCommande.c &
compilation gcc –Wall FichierCommande.c –o Commande –lpci_dask
exécution ./Commande

3.1. Réalisation par codage 1 parmi N

Mettre en œuvre la commande envisagée à l’étape 1 en décrivant le système d’équations associé.

S’appuyer sur le fichier SqueletteCommande.c


et utiliser les fonctions LireEntree et EcrireSortie décrites dans entrees_sorties.c

3.2. Mise en œuvre directe

Mettre en œuvre la commande envisagée à l’étape 2.

Conserver la réalisation par codage 1 parmi N de la MEF de l’étape 1, en modifiant éventuellement les
équations qui la décrivent.

Réaliser par mise en œuvre directe toutes les autres MEF à coordonner.

4. TRANSMISSION DES RESULTATS

Expliquer dans le compte-rendu les raisons ayant permis de construire les différents modèles, ainsi que les
restrictions retenues, le cas échéant.

En s’appuyant sur ces modèles, donner des exemples de traduction dans les 2 cas de mise en œuvre envisagés.

Fournir avec le compte-rendu un listing des programmes développés en cours de séance.


Utiliser la commande : a2ps NomDufichierImprimable.c
M1-EEA-ISTR – I7 – TMO-SEDs – 2013/14 - Poste de manipulation 2 - 1/2

- Poste de manipulation 2 -
Commande d’une maquette de Machine à Laver
Modélisation par Réseau de Petri – Mise en œuvre en VHDL

1. BUT

L’objectif de cette manipulation est d’effectuer la mise en œuvre en VHDL (voir documentations VHDL et
« Quartus ») d’un Réseau de Petri sauf. Deux techniques de mise en œuvre sont envisagées : réalisation 1 parmi N
étendue, mise en œuvre directe du réseau de Petri.

2. CONTEXTE DE LA MANIPULATION

2.1. Matériel disponible

La maquette de machine à laver présente un ensemble de boutons de commande : un bouton d’acceptation


(Accept), un d’annulation (Cancel) et 3 choix de programmes (Program Selectors, Prog1 à Prog3). Un capteur
détecte l’ouverture de la porte (Door Open/Close : 1=ouverte). Le moteur du tambour peut être commandé (Moteur :
1=marche) en indiquant dans quel sens il doit tourner (Sens : 0 sens horaire, 1 sens trigo). Une alarme peut être émise
(Alarme), et un chiffre peut être écrit sur un afficheur 7 segments (quadruplet Aff3, Aff2, Aff1, Aff0). La maquette
requiert un signal de contrôle (Validation : à maintenir à 0).

Bilan de ces signaux :

Capteurs : Prog_i Accept Cancel Door


Actionneurs : Moteur Sens Aff_j Alarme Validation
i ∈ [1, 3] j ∈ [0, 3]

2.2. Commande envisagée : étape 1

Lorsque l’utilisateur choisit un des 3 programme, si la porte est ouverte alors l’alarme doit sonner jusqu’à ce
que la porte soit fermée, sinon, la porte étant fermée, le système se place en attente de confirmation ou annulation par
l’utilisateur. S’il annule son choix, le système est ramené dans son état de départ ; s’il le confirme, le programme de
lavage choisi est alors exécuté jusqu’à être terminé.

Le programme de lavage 1 consiste à faire tourner le tambour dans le sens horaire puis dans le sens trigo, à
chaque fois durant 5 secondes.

Les programmes 2 et 3 sont ignorés pour l’instant.

Modéliser cette commande par un réseau de Petri sauf. Il peut avoir la forme d’une MEF.

2.3. Commande envisagée : étape 2

La commande s’appuie sur l’étape 1 qu’elle reprend entièrement.

Le programme 2 consiste à exécuter 3 fois la séquence des 2 rotations. Dans la modélisation, cette séquence ne
devra être décrite qu’une seule fois : elle sera parcourue 1 fois pour le programme 1, 3 fois pour le programme 2.

De plus, durant l’exécution des rotations, et à tout instant, actionner l’un des boutons programme, acceptation
ou annulation déclenche l’alarme, qui cesse quand ces actions sont annulées. Le retour en situation de départ après la
fin du cycle du programme de lavage ne peut se faire que lorsqu’il n’y a pas d’alarme.

Le programme 3 est ignoré.

Modéliser cette commande par un réseau de Petri sauf, en profitant du pouvoir d’expression du parallélisme.
M1-EEA-ISTR – I7 – TMO-SEDs – 2013/14 - Poste de manipulation 2 - 2/2

3. MISE EN ŒUVRE

Quelle que soit la technique de mise en œuvre retenue, il faut connecter le système de commande avec le
procédé. Connectique avec la maquette :

Prog1 : 5 Prog2 : 6 Prog3 : 8 Accept: 10 Cancel : 9 Door : 4


Moteur : 21 Sens : 22 Aff[3..0] : 20,18,17,16 Alarme : 24 Validation : 25
Init : 30

Un certain nombre de fichiers sont mis à disposition, sous Windows, dans un dossier accessible en se
connectant au réseau, et sont à recopier dans le répertoire de travail :
se connecter Outils/Connecter un lecteur réseau depuis une fenêtre Windows
au dossier I1/Agamemnon/commun/M1_ISTR_TMOSED/MAL_VHDL

L’accès à l’outil Quartus de Altera permettant la programmation en VHDL du circuit EPM1728SLC84-6


(famille MAX7000S) se fait par un raccourci sur le bureau :
icône Quartus II 9.1 Web Edition

3.1. Réalisation par codage 1 parmi N étendu

Mettre en œuvre la commande envisagée à l’étape 1 en décrivant le système d’équations associé.

Une MEF décrivant la temporisation est déjà écrite. Elle attend en entrée la commande Tempo et compte le
temps tant que Tempo est vraie. Elle fournit en sortie le signal FinTempo, vrai lorsque la durée prévue s’est écoulée.

Un fichier VHDL de base est proposé :


RdP_commandeSquelette.vhd squelette de la commande, à compléter.

3.2. Mise en œuvre directe

Mettre en œuvre la commande envisagée à l’étape 2.

Pour cela, on dispose de fichiers VHDL spécifiques :


place_b.vhd description du composant place binaire
R_d_P.vhd liste de composants disponibles pour la commande
RdP_binaireSquelette.vhd squelette de la commande, à compléter.

R_d_P.vhd :
library ieee;
use ieee.std_logic_1164.all ;
package R_d_P is
component place_b
port (ck, ra0_init, ra1_init, activer, desactiver : in std_logic;
marque : out std_logic);
end component;
end R_d_P;

4. TRANSMISSION DES RESULTATS

Expliquer dans le compte-rendu les raisons ayant permis de construire les différents modèles, ainsi que les
restrictions retenues, le cas échéant.

En s’appuyant sur ces modèles, donner des exemples de traduction dans les 2 cas de mise en œuvre envisagés.

Fournir avec le compte-rendu un listing des programmes développés en cours de séance.


M1-EEA-ISTR – I7 – TMO-SEDs – 2013/14 - Poste de manipulation 3 - 1/2

- Poste de manipulation 3 -
Commande d’une maquette de Gare de triage
Modélisation par MEF – Mise en œuvre en ST sur API

1. BUT

L’objectif de cette manipulation est d’effectuer la mise en œuvre en langage ST (voir annexe) sur Automate
Programmable Industriel Télémécanique (TSX Prémium) d’un système de commande modélisé par MEF. Deux
techniques de mise en œuvre sont envisagées : réalisation 1 parmi N, mise en œuvre directe.

2. CONTEXTE DE LA MANIPULATION

2.1. Matériel disponible

La maquette de gare de triage est composée de 5 voies A à E découpées en cantons indépendants (A1 … E4)
pouvant être commandés vers la droite (A1D …) ou la gauche (A1G …), de 4 aiguillages (AigA1, AigA2, AigB1,
AigD) et 2 croisements-aiguillages (AigB2, AigC) commandés pour faire un trajet Direct (AigA1D, …) ou pour
Tourner (AigA1T, …), et de capteurs détectant les trains (AC1 … EC7).

2.2. Commande envisagée : étape 1

Il y a une machine X en BC1 et une machine Y en CC1. L’appui sur un poussoir P1 lance X et Y vers la droite
jusqu’à BC5 et CC4 d’où elles reviennent vers la gauche jusqu’à BC1 et CC1 où elles s’arrêtent. Un nouveau cycle
est alors possible.

Remarques :

1. Quand un train se déplace d’un canton à un autre, les DEUX cantons doivent être alimentés.
2. Aucune hypothèse ne doit être faite sur les vitesses relatives des deux trains. La solution doit
fonctionner dans tous les cas.
3. Les aiguillages n’ont pas à âtre commandés.

Modéliser cette commande par MEF.


M1-EEA-ISTR – I7 – TMO-SEDs – 2013/14 - Poste de manipulation 3 - 2/2

2.3. Commande envisagée : étape 2

Les 2 machines X et Y sont à gauche, en BC1 et en CC1.

Un appui sur P1 entraîne le cycle :

• X et Y partent vers la droite simultanément,


• X arrive en BC5 et repart immédiatement vers la gauche pour s’arrêter en BC1.
• Y arrive en CC4 et doit attendre que X ait atteint ou dépassé le capteur BC3 sur son trajet de retour pour
revenir en CC1.
• Un nouveau cycle ne peut être lancé que lorsque les deux trains sont revenus en position initiale.

Modéliser cette commande par un réseau de Petri sauf. En déduire la MEF équivalente en construisant son
graphe des marquages accessibles.

3. MISE EN ŒUVRE

Quelle que soit la technique de mise en œuvre retenue, il faut connecter le système de commande avec le
procédé. La connectique avec la maquette est déjà établie.

Des fichiers sont mis à disposition, sous Windows, dans un dossier accessible en se connectant au réseau, et
sont à recopier dans le répertoire de travail :
se connecter Outils/Connecter un lecteur réseau depuis une fenêtre Windows
au dossier I1/Agamemnon/commun/M1_ISTR_TMOSED/TRAINS_ST

3.1. Réalisation par codage 1 parmi N

Mettre en œuvre la commande envisagée à l’étape 1 en décrivant le système d’équations associé.

Le fichier suivant définit la connectique entre l’automate et la maquette de gare de triage :


modeleTrains.stu
Le recopier dans le répertoire de travail. Il sert de base, peut être renommé, et doit être complété.

3.2. Mise en œuvre directe

Mettre en œuvre la commande envisagée à l’étape 2.

Remplacer les équations de l’étape 1 par la MEF équivalente au réseau de Petri développé en étape 2.

4. TRANSMISSION DES RESULTATS

Expliquer dans le compte-rendu les raisons ayant permis de construire les différents modèles, ainsi que les
restrictions retenues, le cas échéant.

En s’appuyant sur ces modèles, donner des exemples de traduction dans les 2 cas de mise en œuvre envisagés.

Fournir avec le compte-rendu un listing des programmes développés en cours de séance.


M1-EEA-ISTR – I7 – TMO-SEDs – 2013/14 - Mini-Projet - 1/4

- Mini-Projet -
Génération de code de commande
Divers modèles sources et divers langages cibles – Mise en œuvre en C

1. BUT

L'objectif est de développer une application écrite en C produisant un fichier écrit dans un langage cible donné
(C, VHDL, ST ou IL) matérialisant le modèle de commande d'un procédé (MEF, réseau de Petri) suivant une
technique de mise en œuvre choisie (codage 1 parmi n, mise en œuvre directe). Un tel outil était disponible au 1°
semestre pour l'UE I1 : la "moulinette".

2. CONTEXTE DU MINI-PROJET

2.1. Matériel disponible

Trois maquettes sont mises à disposition : maquette d’ascenseur, maquette de machine à laver, maquette de
gare de triage. Les caractéristiques de ces matériels ont déjà été évoquées.

La commande de ces maquettes peut être sur plate-forme linux (en langage C) ou windows (langage VHDL ;
gestion d'automate programmable industriel pour les langages ST et IL).
maquette binômes modèle et langage
gare de triage P1…P3 RdP + ST MEF + C
Projets envisageables : ascenseur Q1…Q3 MEF + VHDL RdP + C
machine à laver R1…R3 RdP + VHDL MEF + ST

2.2. Contexte de développement mis à disposition

Les documents de base disponibles sont un ensemble de fichiers contribuant au fonctionnement d'une
application permettant de déduire le réseau de Petri obtenu à partir d'une modélisation par Tina. Cette application est
développée en langage C ; les fichiers disponibles sont des fichiers "source" (en C) et des fichiers "objet" (pré-
compilés), accompagnés de fichiers de contrôle de compilation (Makefile).

L'application décrit en interne une structure de données représentant le réseau de Petri : cette structure doit être
utilisée pour générer le code dans le langage cible (C, VHDL, ST ou IL) mettant en œuvre la technique choisie
(codage 1 parmi n, mise en œuvre directe).

Le modèle Machine à Etat Fini pouvant être décrit par le modèle réseau de Petri binaire, la structure de
données pourra être exploitée pour mettre en œuvre la commande aussi bien par un réseau de Petri que par une MEF.

2.3. Développement envisagé

Le fichier principal "main.c" présente les étapes principales suivies pour la génération de la "moulinetteRdP" :
CreerStructure (LeFichierTINA, &TransitionsRdP, &PlacesRdP);
crée la structure de données représentant le réseau de Petri vu des transitions. Les places listent les
actions associées.
GenererLog (PlacesRdP, TransitionsRdP, LeFichierLog);
génère un fichier texte indiquant la structure élaborée.
GenererPlaces (PlacesRdP, LeFichierPlaces);
génère un fichier C pour la déclaration des places (langage cible : C).
GenererBlocF (TransitionsRdP, LeFichierEnC);
génère un fichier pour la mise en œuvre de la commande par description des transitions.
GenererBlocG (PlacesRdP, LeFichierBlocG);
génère un fichier C pour la description des actions (langage cible : C).
M1-EEA-ISTR – I7 – TMO-SEDs – 2013/14 - Mini-Projet - 2/4

Pour être adaptable à n'importe quelle maquette commandée par n'importe quel langage, le développement est
organisé ainsi :
-1 choisir le matériel à commander, l'outil de modélisation et la technique de mise en œuvre,
-2 modéliser la commande par Tina,
-3 décrire un squelette de la commande du procédé (dans le langage cible choisi),
-4 développer la fonction "GenererBlocF" pour produire un fichier texte ("evolution_modele.txt")
décrivant l'évolution du modèle (MEF ou RdP) suivant la technique de mise en œuvre retenue, dans le langage cible
choisi,
-5 compiler la "moulinette" ainsi complétée,
-6 exécuter la "moulinette" : elle produit le fichier "evolution_modele.txt" dont le contenu est une partie de
la mise en œuvre de la commande modélisée sous Tina,
-7 insérer le contenu du fichier texte "evolution_modele.txt" généré dans le squelette de commande, et
compléter cette commande en déclarant correctement tous les éléments (entrées, sorties, variables internes), en lisant
toutes les entrées utiles, et en décrivant une équation d'activation pour toutes les sorties nécessaires,
-8 utiliser la commande pour piloter le procédé.

La première partie du projet consiste à développer et mettre au point la fonction "GenererBlocF".

Les étapes -4 à -8 seront réitérées jusqu'à satisfaction.

Ensuite, il peut être envisagé de décrire les autres fonctions, dans l'ordre "GenererBlocG", "GenererPlaces",
"CreerStructure".

3. MISE EN ŒUVRE

Pour développer le mini-projet, des fichiers sont mis à disposition dans un dossier partagé, à retenir en
fonction de la plate-forme de développement (pas en fonction du langage cible) :
linux : dossier : home/partage/commun/M1_ISTR_TMOSED/PROJET/linux

windows : se connecter à : I1/Agamemnon/commun/M1_ISTR_TMOSED/PROJET/windows

Des fichiers "Makefile" sont disponibles pour assurer les phases de compilation.
Le fichier "main.c" présente les étapes de traduction du fichier issu de la modélisation par Tina.
Le fichier "GenerateurCode.c" contient un squelette de la fonction "GenererBlocF".
Le fichier "types.c" définit les types utilisés par "CreerStructure" pour décrire le réseau de Petri.
Les autres fichiers sont des fichiers "objet" pré-compilés.

La modélisation sous Tina doit respecter l'utilisation d'étiquettes pour la description des actions associées aux
places (ex. : [Action1, Action2]) et des conditions de franchissement des transitions écrites dans le langage cible
(ex. en C : [CapteurA&&!CapteurB;]). Par ailleurs, pour un projet de mise en œuvre de MEF, la MEF sera décrite
par un réseau de Petri binaire : la fonction "GenererBlocF" adaptera la description de réseau de Petri à une MEF.

4. TRANSMISSION DES RESULTATS

Préciser dans le compte-rendu le projet retenu (maquette, modèle, technique de mise en œuvre et langage cible
envisagés), les choix et restrictions éventuelles par rapport au contexte du projet.

Présenter les algorithmes mis en jeu en indiquant leur articulation avec les autres éléments du projet, et
compléter le compte-rendu avec des listings commentés des parties de code développées.

Proposer la suite envisageable au travail fourni.


M1-EEA-ISTR – I7 – TMO-SEDs – 2013/14 - Mini-Projet - 3/4

Fichier "main.c" :

#define MAX_NOM 200

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include "types.c"

void NettoyerLaChaine (char *);

void CreerStructure (char [MAX_NOM], Transition **, Place **);


void GenererBlocF (Transition *TransitionsRdP, char [MAX_NOM]);
void GenererLog (Place *, Transition * , char [MAX_NOM]);
void GenererPlaces (Place *, char [MAX_NOM]);
void GenererBlocG (Place *, char [MAX_NOM]);

int main(void)
{
Transition * TransitionsRdP=NULL;
Place * PlacesRdP=NULL;

char LeFichierTINA[MAX_NOM] = "etiquette.ndr";


char LeFichierLog[MAX_NOM] = "etiquette.log";
char LeFichierEnC[MAX_NOM] = "evolution_modele.txt";
char LeFichierPlaces[MAX_NOM] = "LesPlaces.c";
char LeFichierBlocG[MAX_NOM] = "CalculDesSorties.c";

printf ("nom du fichier a Mouliner :");


scanf ("%s",LeFichierTINA);
strcpy(LeFichierLog,LeFichierTINA);
strcat(LeFichierTINA, ".ndr");
strcat(LeFichierLog,".log");

// ouverture du fichier issus de tina

CreerStructure (LeFichierTINA, &TransitionsRdP, &PlacesRdP);

// GenererLog (PlacesRdP, TransitionsRdP, LeFichierLog);


// GenererPlaces (PlacesRdP, LeFichierPlaces);
GenererBlocF (TransitionsRdP, LeFichierEnC);
// GenererBlocG (PlacesRdP, LeFichierBlocG);

return 1;
}
M1-EEA-ISTR – I7 – TMO-SEDs – 2013/14 - Mini-Projet - 4/4

Fichier "GenerateurCode.c" :

#include "types.c"
#include <string.h>

void GenererBlocF (Transition * PremiereTransition, char LeFichierEnC[MAX_NOM])


{
...
}

Fichier "types.c" :

// a rendre global dans le fichier types


#define MAX_NOM 200
#include <stdio.h>

typedef struct ACTION {


char Actions[MAX_NOM];
struct ACTION * Suivant;
} Action;

typedef struct ARC {


char Place[MAX_NOM];
int Poids ;
struct ARC * Suivant;
} Arc;

typedef struct TRANSITION{


char Nom[MAX_NOM];
int NbPlacesEntree;
Arc *ArcsEntrants;
int NbPlacesSortie;
Arc *ArcsSortants;
char Actions[MAX_NOM];
char Predicat[MAX_NOM];
struct TRANSITION * Suivant;
} Transition;

typedef struct PLACE{


char Nom[MAX_NOM];
int Mo;
int NbActions;
Action * Actions;
struct PLACE * Suivant;
} Place;
VHDL – UN LANGAGE DE DESCRIPTION
VHDL est un langage surtout utilisé pour la modélisation, l'analyse et la simulation de réalisations
électroniques de systèmes à événements discrets. Cette annexe n'a pas la prétention de présenter tous les
aspects du langage, mais uniquement ceux qui sont nécessaires à la réalisation d'un système de commande
basé sur un modèle séquentiel à événements discrets.

En VHDL, tout système est décrit par une Entité (Entity). La déclaration d'une entité ne s'intéresse
qu'à ses entrées/sorties (Port) : c'est une vision externe de l'entité qui est considérée comme une "boîte
noire".

Exemple :

a
Système S
b de
commande
Horloge

a, b, Horloge et S sont modélisées par des variables booléennes. La déclaration de l'entité


correspondant à ce système est la suivante :

Entity Commande is
Port
(a, b, Horloge : In Std_logic;
S : Out Std_logic);
End Commande;

A partir de cette déclaration, l'identificateur "Commande" peut être associé à la modélisation de TOUT
système logique possédant trois entrées et une sortie booléennes.

La description du comportement interne de l'entité fait l'objet d'un bloc nommé "Architecture". Les
données d'entrée/sortie sont bien sûr celles qui ont été déclarées dans l'entité. Si des données internes sont
nécessaires à la description de l'Architecture de l'entité, elles doivent y être déclarées comme des
signaux (signal). Le corps du bloc "Architecture" peut être constitué d'affectation représentant des
expressions logiques ou de la description de systèmes séquentiels logiques.

1. Système combinatoire
Exemple de système combinatoire constituant une "Architecture" de l'entité "Commande" déclarée
précédemment.

a
S

b
S_Interne
Horloge

Le bloc "Architecture" pouvant représenter ce système est :

Annexe VHDL VHDL - FPGA p.1/4


Architecture Ou_Non of Commande is
Signal : S_Interne : Std_logic;
Begin
S_Interne <= Not b;
S <= S_Interne OR a OR Horloge;
End Ou_Non;

Nota : La définition du signal S_Interne est, dans cet exemple, facultative.

L'affectation S <= Not b OR a Or Horloge;

suffirait à décrire le système Ou_Non.

2. Système séquentiel
Le modèle suivant est aussi une architecture possible de l'entité "Commande".

a a
S=1
Etat1 Etat2 S
b a
b
a.b
b
Horloge Etat3
S=1

Pour pouvoir décrire l'Architecture correspondante, il est nécessaire de déclarer les variables internes
EtatPresent et EtatSuivant ainsi que la liste des valeurs symboliques qu'elles prennent dans le graphe
d'états.

Type Etat Is (Etat1, Etat2, Etat3);


Signal EtatPresent, EtatSuivant : Etat;

Le bloc F est ensuite décrit grâce à des affectations dont la syntaxe est proche de celle des langages
de programmation classique (Pascal ou C). Ceci se fait dans un bloc "Process".

Le bloc M est toujours décrit dans un bloc "Process" comme suit :

Process (Horloge)
Begin
if ((Horloge'EVENT) And (Horloge = '1')) then
EtatPresent <= EtatSuivant ;
End if ;
End Process;

Le bloc G, combinatoire pur, est constitué par une suite d'affectations combinatoires.

Annexe VHDL VHDL - FPGA p.2/4


En résumé, le fichier décrivant le système séquentiel ci-dessus peut s'écrire :

Architecture GrapheTroisEtats of Commande is

-- ceci est un commentaire


-- d'abord la déclaration des variables internes

Type Etat Is (Etat1, Etat2, Etat3);


Signal EtatPresent, EtatSuivant : Etat;
Begin
-- Ensuite le process décrivant le bloc F
Process (EtatPresent, a, b)
Begin
Case EtatPresent Is
When Etat1 =>
IF (a = '1') THEN EtatSuivant <= Etat2;
ELSIF (b = '1') THEN EtatSuivant <= Etat3;
ELSE EtatSuivant <= EtatPresent; End IF;

When Etat2 =>


IF (a = '0') THEN EtatSuivant <= Etat1;
ELSIF (b = '1') THEN EtatSuivant <= Etat3;
ELSE EtatSuivant <= EtatPresent; End IF;

When Etat3 =>


IF (b = '0') THEN EtatSuivant <= Etat1;
ELSE EtatSuivant <= EtatPresent; End IF;

End Case;
End Process;

-- Ensuite le process décrivant le bloc M


Process (Horloge, Init)
Begin
If (Init = '1') then
Etatpresent <= Etat1;
Elsif (Horloge'EVENT) And (Horloge = '1')) THEN
EtatPresent <= EtatSuivant ;
End if ;
End Process;

-- Enfin les affectations décrivant le bloc G

S <= '1' When ((EtatPresent = Etat2) Or (EtatPresent = Etat3))


Else '0';

End GrapheTroisEtats;

Les affectations combinatoires (sorties en particulier) peuvent prendre trois formes :

1. Affectation simple

X <= ExpressionLogique;

2. Affectation conditionnelle

X <= Expression1 When Condition Else Expression2;

Annexe VHDL VHDL - FPGA p.3/4


3. Affectation sélectionnée

With ExpressionSelection Select


x <= Expression1 When Valeur1,
Expression2 When Valeur2,
...
ExpressionN When ValeurN,
ValeurParDefaut When Others;

Dans le cas de l'affectation sélectionnée, si toutes les valeurs prises par ExpressionSelection ne sont
pas décrites alors la clause When others doit être décrite. Le bloc G du système précédent peut s'écrire :

With EtatPresent Select


S <= '1' When Etat2 | Etat3, -- noter le | pour un ou logique
'0' When Etat1 ;

3. Type prédéfinis et opérateurs

Parmi les types prédéfinis nous citerons


Integer : type entier (32 bits). l’ intervalle de variation peut être limité.
a : IN integer range -128 to 127 ;

natural : entiers positifs ou nuls


a : IN natural range 0 to 6 ;

bit : type scalaire énuméré, deux valeurs possibles 0 et 1 ;

bit_vector : vecteur de bits


a : IN bit_vector (7 downto 0) ;
a(7) est le poids fort, a(0) est le poids faible.

Boolean : type scalaire énuméré, deux valeurs possibles FALSE et TRUE ;

Des types complémentaires sont apportés par des bibliothèques ; par exemple les types std_logic et
std_logic_vector acceptant les descriptions 0, 1, - (indéterminé)
Ce type est défini dans la bibliothèque ieee et impose l’inclusion des lignes suivantes en en-tête de
fichier source :
library ieee ;
use ieee-std-logic-1164.all ;
Ce sont ces types que nous utiliserons pour décrire des signaux logiques.

Enfin des types définis par l’utilisateur comme les types énumérés utilisés dans la description de
graphe d’états : Exemple :
Type Etat Is (etat1, etat2, etat3) ;

Aux opérateurs logiques déjà rencontrés (and, nand, or, nor, xor, not) s’appliquant à des opérandes
de type bit, bit_vector et boolean s’ajoutent les opérateurs arithmétiques +, -, *, / s’appliquant à des
opérandes de type integer.

Les opérateurs relationnels =, /=, <, <=, >, >= renvoient un résultat booléen.

NOTA : VHDL est insensible à la casse des caractères.

Annexe VHDL VHDL - FPGA p.4/4


Le logiciel Quartus II

1 Création et configuration d'un projet


Pour créer un nouveau projet Quartus, cliquer sur “File/Newproject Wizard”, une fenêtre d'assistance à
la création s'ouvre :
- la première page permet de choisir le répertoire de travail, le nom du projet et le nom de l'entité
principale.
- les pages suivantes permettent d'ajouter, si nécessaire, des fichiers existant dans le projet et d'ajouter
des outils supplémentaires de conception (aucun dans notre cas).
- la quatrième permet de spécifier la famille de FPGA (MAX7000S) et le type de FPGA utilisé
(EPM7128SLC84-6). Un filtre permet d'aider la recherche (pin count 84 par exemple permet de
sélectionner le bon composant dans une liste réduite).

Il est possible d'avoir une approche de conception descendante (top-down design) ou ascendante
(bottom-up design). Nous opterons pour cette dernière approche et nous concevrons et simulerons les
différents composants, avant de les exporter et de les intégrer dans une application de plus haut niveau.

2- Conception, simulation, exportation d'un composant.

1- Saisie d'un fichier vhdl


Dans 'File/New' Choisir la fenêtre 'Text editor' puis 'vhdl'. Ou encore si vous disposez d'un fichier
modele (exemple modele.vhd), l'ouvrir et le sauver en lui assignant un nom qui correspond au nom
de l'entité (Exemple cabine .vhd dans le cas où l'entity a pour nom cabine (ENTITY cabine IS ...))

2- Compilation
– Pour compiler un fichier autre que celui désigné “Top Level entity” , ouvrir ce fichier et cliquer sur
'Project/Set as Top-Level-Entity'.
– Puis “Processing/Start Compilation”.
Dans le cas d'erreurs de compilation, cliquer sur un message d'erreur ramène dans le fichier texte
(.vhd) où l'erreur a été détectée. Corrigez vos erreurs.

3- Simulation

Cette partie étant délicate, il est conseillé de faire appel à un enseignant lors d'une première
simulation.
– Dans “File/New “ choisir l'onglet “Other Files” et sélectionner 'Vector Waveform File'. Un éditeur
de chronogramme apparaît. Sauvegardez le fichier : “File/Save” ou “File/Save as ..”
– Pour faire apparaître les signaux à simuler, faire “Edit/Insert/Insert Node or Bus”. Cliquez sur
'Node Finder ' ... Un écran apparaît.
– Si ce n'est pas fait positionnez le filtre sur Pins all et cliquez sur List. Les signaux trouvés
s'inscrivent dans la fenêtre gauche (Nodes Found), sélectionnez ceux que vous voulez simuler en
les transférant dans la fenêtre droite (Selected Nodes). Cliquez sur OK.
Remarque : Dans le cas de mise en oeuvre de MEFs vérifiez que vous avez accès à l'état présent
de votre MEF.
– Les signaux à visualiser apparaissent sur le chronogramme. Il faut assigner des valeurs aux signaux
d'entrée, conformément à un scénario.
– Sur sélection du signal d'horloge, une fenêtre de dialogue s'ouvre :
On peut préciser la taille de la fenêtre de simulation (1 micro seconde : par défaut), et les
paramètres count every : 10ns (par défaut), puis le paramètre multiply by : 1 (par défaut).
Changer ce dernier en 2, 3, ou 4. Ceci permettra de ne ne pas avoir des fronts de signaux
d'entrée simultanés avec le front actif d'hologe.
– Pour changer localement la valeur d'un signal, sélectionnez avec la souris l'intervalle à
modifier et choisir la valeur adéquate (0 ou 1) dans la barre d'outil à gauche. La simulation
consiste à définir une suite de changements du vecteur d'entrée du système de commande.
Ces changements doivent respecter la logique d'évolution du procédé.

– Sauvegardez et simulez “Processing/Start Simulation”. A la première simulation il est nécessaire


de préciser le fichier source de la simulation (.vwf) : pour cela choisir “Processing/Simulator Tool”,
une page s'ouvre et dans le champ Simulator input préciser le fichier source. De cette page lancer la
simulation (Start) puis ouvrir le rapport (Rapport).

4- Créer un bloc symbolique pour le composant.

Pour pouvoir exporter le composant dans “File” choisir “ Create Symbol Files for current File”.
Un fichier “nom_composant.bsf” est créé. C'est ce composant qui sera par la suite inséré dans une
application de plus haut niveau.

5 - Les phases précédentes 2, 3, 4 sont à répéter pour tous les composants qui seront ensuite instanciés
dans l'application finale.

3- Entité principale du projet : Construction, compilation, chargement.

6- Entité principale du projet :

Nous utiliserons un schéma bloc dans lequel nous connecterons les différents blocs préalablement
définis.
– Faire “File/New” et choisir 'Block Diagram'. Sauvegarder sous le nom choisi lors de la création du
projet. Une page graphique s'ouvre.

7- Intégration des composants :

– Pour introduire les composants définis lors des étapes précédentes, aller dans “Edit/Insert
Symbol ...” et désigner le composant (.bsf) que vous voulez instancier. Autre solution, sur la page
graphique, faire un clic droit de la souris pour ouvrir un menu contextuel et choisir ''Insert/symbol”.

– Il faut alors connecter ces blocs entre eux et aux entrées/sorties.

- Pour ajouter les entrées/sorties il faut ouvrir la fenêtre d'ajout de symbole “Edit/Insert
Symbol ...”), les symboles d'entrée/sortie sont dans des librairies situées en
C:Quartus/70/librairies puis “primitives/pin”, choisir “input' ou 'output”.
Nommer les entrées /sorties. Clic droit sur la broche concernée, puis Properties et dans la zone
de saisie “Pin_name” taper le nom.

- Il faut également connecter les composants entre eux. Soit par connexion directe (à l'aide des
outils graphiques proposés ou en nommant les fils ou bus en sortie d'un composant et en
reprenant ce nom à l'entrée du composant suivant (même démarche que pour nommer les
entrées-sorties).

Quand ce travail est terminé, compiler l'application complète.

8- Assignation des broches.

Il faut maintenant spécifier le branchement physique de chaque broche à la carte.


Par “Assigments/Pins”, choisir la broche à assigner dans la colonne 'Location'. Un double clic dans la
cellule permet de choisir le numéro de broche dans une liste. Se conformer au brochage spécifié dans
le texte du TP. Pour le type de circuit utilisé le brochage du signal d'horloge n'a pas à être spécifié (83).

Recompiler avant de télécharger sur la cible !

9- Chargement sur la carte cible :

Choisir “Tools/programmer” . Une fenêtre apparaît. Sélectionner le fichier .pof à télécharger et cliquer
sur Start.
Après chargement sur la cible, tester le fonctionnement.

Remarques :

1. Des icônes offrent des raccourcis pour invoquer le compilateur, le simulateur, le chargeur.

2. On peut ajouter des fichiers VHDL à un projet “Project->Add/remove Files in Project”. Dans
la fenêtre qui s'affiche, ceux-ci sont ajoutés à la liste via 'Add'. Terminer par 'Ok'.

Les fichiers apparaissent alors dans le navigateur de projet (à gauche), sur l'onglet 'Files' dans le
dossier 'Device Design Files' on peut créer un bloc symbolique pour chaque composant (.vhd)
via le clic droit puis 'Create Symbol Files for Current File'.

Il faut ensuite ouvrir la fenêtre d'ajout de symbole dans l'entité principale (nom_projet.bdf) puis
rechercher les blocs par “Edit/Insert symbol” (ou clic droit et Insert symbol).
ANNEXE IL, ST

1. LES AUTOMATES PROGRAMMABLES

Un automate programmable est un calculateur spécialisé dans l'exécution d'opérations logiques. Il est
composé d'un processeur, d'une mémoire, de modules d'entrées/sorties et d'un moniteur.

La mémoire contient le programme qui décrit le fonctionnement du système de commande. Les blocs
d'entrées et de sorties assurent la connexion de l'automate avec le procédé à commander. Le moniteur de
l'automate (son système d'exploitation en quelque sorte) se charge d'enchaîner de manière cyclique les
tâches suivantes :

1. exécution du programme utilisateur,


2. lecture des entrées,
3. écriture des sorties,

le tout en temps réel, c'est à dire qu'un cycle programme (exécution des trois tâches ci-dessus) a une durée
compatible avec le temps de réponse du procédé.

Un programme manipule des bits et des mots. Il peut être décrit dans un des quatre langages normalisés.

1. Programme GRAFCET (SFC)


2. Programme LADDER (LD)
3. Programme LIST (IL)
4. Programme ST

Dans les séances de manipulation vous utiliserez le langage LIST (ou IL), le langage littéral structuré ST
et le GRAFCET.

Remarque : Le langage à contacts, historique et daté, est rappelé très succinctement ici (on peut
éventuellement l’utiliser pour décrire les transitions et les actions du GRAFCET mais on préférera les
langages IL et ST plus évolués).
Le langage à contacts est un diagramme à relais et peut être interprété comme un schéma électrique.
Deux éléments mis en série forment un ET. Deux éléments mis en parallèle forment un OU.

Exemple :
a c M

Ce diagramme traduit l’expression : ( a + b) . c qui est associée au récepteur M.

2. LE LANGAGE LIST (LISTE D’INSTRUCTIONS)

Le langage IL est un langage de bas niveau bien adapté à la programmation des équations logiques.
Nous utiliserons son caractère langage booléen pour programmer des machines à états partir des
équations logiques des variables d’état et des sorties.
L’automate peut être considéré comme un processeur booléen possédant un accumulateur booléen
(acc) auquel se rapportent toutes les instructions du langage.

Annexe IL, ST p.1/5


2.1 Présentation du langage LIST (ou langage IL)

Instructions de modification de la valeur de l’accumulateur (l’opérande x est une variable booléenne)

Instruction Effet sur l’accumulateur


Chargement : LD x (acc ← x)
OU Logique : OR x (acc ← acc + x)
ET logique : AND x (acc ← acc . x)
OU EXCLUSIF : XOR x (acc ← acc ⊕ x)

Ces quatre instructions peuvent s’appliquer à un opérande complémenté.

Chargement : LDN x (acc ← x )


OU Logique : ORN x (acc ← acc + x )
ET logique : ANDN x (acc ← acc . x )
OU exclusif : XORN x (acc ← acc ⊕ x )

Instructions de stockage de la valeur de l’accumulateur (l’opérande x est une variable booléenne)

ST x (x ← acc)
STN x (x ← acc )

Instructions de saut

JMP %Lx (saut inconditionnel à l’étiquette Lx)


JMPC %Lx (saut conditionnel (acc = vrai) à l’étiquette Lx)
JMPCN %Lx (saut conditionnel (acc = faux) à l’étiquette Lx)

Remarque : les instructions ST, STN, JMP, JMPC, JMPNC ne modifient pas la valeur de l’accumulateur

2.2 Structure d’un programme LIST

Un programme LIST peut comprendre les éléments suivants :


1. un commentaire (* ceci est un commentaire *)
2. une étiquette symbolique %Lx :
3. une liste d’instructions dont la première doit être un chargement (LD) ou un saut inconditionnel (JMP).
Les instructions s’écrivent une instruction par ligne ou un opérateur par ligne.

L’éditeur interprète les instructions au fur et à mesure de leur saisie et signale les erreurs de syntaxe,
variables non encore déclarées … en soulignant en rouge les problèmes détectés mais ces avertissements
ne sont pas bloquants pour la saisie ou la sauvegarde du fichier.
Exemple soit à programmer l’expression logique y = x 1 x. (2+ x 3

(* calcul de l’expression logique de y *)


%L0 :
LD x1
AND( x2
NOT
OR x3
)
ST y

Notez l’utilisation des parenthèses qui permettent d’exprimer des formes produit de somme sans les
développer. On peut associer des Négations aux parenthèses ouvertes avec AND et OR.

Annexe IL, ST p.2/5


3. LE LANGAGE LITTERAL STRUCTURE ST
Une section de programme littéral comporte les éléments optionnels suivants :
- une étiquette qui permet de repérer une phrase (par exemple %L22:)
- des commentaires : (*commentaires*)
- une à plusieurs instructions séparées par des « ; »

3.1 Présentation du langage ST

INSTRUCTIONS :

Affectation A := expression
Choix IF….THEN
Syntaxe forme simple
IF condition THEN
action_if ;
ELSE action_else ;
END_IF ;
Syntaxe forme générale
IF condition1 THEN
action_if1 ;
ELSIF condition2 THEN
action_if2;
ELSE
action_else ;
END_IF ;
Les conditions peuvent être multiples. Chaque action représente une liste d’instruction. Plusieurs IF
peuvent être imbriqués, le nombre de ELSEIF est illimité mais il y a au maximum une partie ELSE (il
peut ne pas y en avoir).

Choix multiple CASE OF


CASE selecteur OF
1: instruction1;
2 : instruction2;
ELSE instructiondefaut;
END_CASE;
Le sélecteur est de type entier, si le sélecteur prend une valeur différente des valeurs d’aiguillage,
l’instruction suivant la clause ELSE est exécutée.
Boucles
FOR Syntaxe
FOR indice:= valeur_initiale TO valeur_finale DO
action ;
END_FOR ;
L’action représente une liste d’instructions. L’incrémentation de l’indice se fait automatiquement. Plusieurs
FOR peuvent être imbriqués.

Annexe IL, ST p.3/5


WHILE….DO Syntaxe
WHILE condition DO
action ;
END_ WHILE;
La condition peut être multiple. L’action représente une liste d’instructions. Plusieurs WHILE peuvent
être imbriqués.

REPEAT…UNTIL Syntaxe
REPEAT
action ;
UNTIL condition
END_ REPEAT;
La condition peut être multiple. L’action représente une liste d’instructions. Plusieurs REPEAT
peuvent être imbriqués.

L’instruction EXIT permet d’arrêter l’exécution d’une boucle et de continuer sur l’instruction suivant
l’instruction fin de boucle. Cette instruction est rattachée à la boucle englobante la plus proche, elle n’arrête
pas toutes les boucles qui l’englobent.

Opérateurs
• LOGIQUE : and, not, or, xor
• RELATIONNEL : <, >, <=, >=, =, <>

3.2 Mise en œuvre directe d’une machine à états


Les variables etatpresent et etatsuivant sont de type entier (INT) , inter1 est de type booléen (EBOOL) , A,
B, S sont des bits d’entrée/sortie (type EBOOL) .
(* BLOC F *)
CASE etat present OF
1: IF ((not A) and M) THEN etatsuivant:= 2 ;
Inter1 M. /A
END_IF; S
2: IF (A) THEN etatsuivant:= 1; 1 2
ELSIF ((not A) and B) THEN etatsuivant:= 3; A

END_IF ; /A. B
/B
3: IF (not B) THEN etatsuivant:= 1;
END_IF ; 3
ELSE etat present :=1;
END_CASE ;

(*bloc M et initialisation de la MEF *)


IF (Inter1) THEN
etatsuivant:= 1 ;
END_IF ;
etatpresent := etatsuivant;

(*bloc G*)
S:= (etatpresent =2);

Annexe IL, ST p.4/5


4- TEMPORISATIONS
Dans un système de commande une temporisation est traitée comme une sortie du système (actionneur) et
une entrée de ce système (capteur), un exemple est donné figure suivante avec ActiveTempo (actionneur)
et FinTempo (capteur)

ActiveTempo
FinTempo
E2

Utilisation d'une temporisation dans un graphe d’état.

ActiveTempo

Durée
temporisation
FinTempo

Le fonctionnement du temporisateur est décrit par le chronogramme suivant (dans le cas d’une mise à 1 de
la sortie du temporisateur (entrée du système de commande)

Un temporisateur est une entité prédéfinie de type TON (mise à 1) ou TOFF (mise à zéro), invoquée à partir
de son nom (On choisit un nom de variable pour le temporisateur et on déclare cette variable de type TON).

Exemple : temporisateur de nom « Tempo1 » déclenchée sur l’état 2 (ou en présence de ActiveTempo1
variable de type BOOL, cas IL) , de durée préfixée 5s, de sortie FinTempo1, calculé avec une variable
interne de type TIME nommée Valeurtempo1.

En IL (appel de fonction dans le bloc G) :


cal Tempo1( IN := ActiveTempo1, PT := Time#5s, Q => FinTempo1, ET => Valeurtempo1)

En ST (invocation dans le bloc G) :


Tempo1( IN := (etatpresent = 2), PT := Time#5s, Q => FinTempo1, ET => Valeurtempo1) ;

Remarque : Il est également possible de définir la temporisation en LD (réseau de contacts). Le bit IN du


temporisateur de type TON est piloté par ActiveTermpo (connecté sur tempo1.IN), la sortie Q du
temporisateur (tempo1.Q) est reliée à Fintempo1.
Il est nécessaire de définir la durée du temporisateur sur le temporisateur : Ouvrir les Blocs FB prédéfinis,
cliquer sur le temporisateur choisi et faire apparaître ses différents champs pour documenter le Preset.

ActiveTempo Tempo1
FinTempo1
IN Q

Représentation temporisateur en LD

On peut donc être amené dans le cas de mise en œuvre de MEFs à avoir 3 sections IL, ST et LD :
- réalisation des variables internes à partir des équations logiques,
- mise en œuvre directe en ST.
- le temporisateur en LD.

Annexe IL, ST p.5/5

Vous aimerez peut-être aussi