Modélisation et Simulation d`un système robotisé avec des réseaux

Modélisation et Simulation d'un système
robotisé avec des réseaux de Pétri
POHU Thomas
superviseur : Bruno VILHENA ADORNO
27/07/2012
Table des matières
1 Introduction
2
1.1
Motivations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2
1.2
Présentation de la situation
. . . . . . . . . . . . . . . . . . . . .
2
1.3
Objectifs à réaliser . . . . . . . . . . . . . . . . . . . . . . . . . .
3
2 Modélisation du système avec les réseaux de Pétri
4
2.1
Présentation des réseaux de Pétri . . . . . . . . . . . . . . . . . .
4
2.2
Réseau de Pétri du robot A . . . . . . . . . . . . . . . . . . . . .
5
2.3
Réseau de Pétri du robot B
. . . . . . . . . . . . . . . . . . . . .
6
2.4
Réseau de Pétri global . . . . . . . . . . . . . . . . . . . . . . . .
7
2.4.1
Cas sans arrêt du robot B après b passages
. . . . . . . .
7
2.4.2
Cas sans arrêt du robot B après b passages
. . . . . . . .
8
Simulation graphique des réseaux de Pétri . . . . . . . . . . . . .
9
2.5
3 Réalisation de la simulation sous Matlab
10
3.1
Simuler les réseaux de Pétri sous Matlab . . . . . . . . . . . . . .
10
3.2
Gestion de l'achage . . . . . . . . . . . . . . . . . . . . . . . . .
11
4 Conclusion
12
1
Chapitre 1
Introduction
1.1 Motivations
Dans le cadre d'étude sur l'automatisme il est intéressant de travailler sur
l'interaction entre diérents systèmes robotisés indépendants. Ces travaux peuvent
avoir des applications dans le monde de l'industrie avec à terme un partage et
un enchainement des tâches ne nécessitant plus d'intervention humaine.
Ce projet est aussi l'occasion de découvrir de nouvelles méthodes de travail
notamment avec les réseaux de Pétri.
1.2 Présentation de la situation
On considère deux robots mobiles A et B et un robot manipulateur. Chaque
robot ne peut suivre que les mouvement indiqués par les èches (Figure 1.1).
L'objectif est de synchroniser les robots dans le but de produire un produit
X, X est composé de a unitées d'un élément
b unitées d'un élément
Xb
Xa
délivrées par le robot A et de
délivrées par le robot B.
Une fois que X est construite, soit après a passages de A et b passages de B
au point de construction (marqué 'x' sur la Figure 1.1), le manipulateur baisse
son bras pour prendre le produit X et se relève.
Les robots mobiles sont soumis aux conditions suivantes :
Quand les robots arrivent aux limites de l'aire de fabrication, ils heurtent
le mur et retournent sur leurs pas.
Le robot A ne s'arrête jamais, il va et vient sans arrêt, le robot B peut
s'arrêter quand il heurte le mur.
La vitesse
vb
du robot B est deux fois plus grande que celle
A.
2
va
du robot
CHAPITRE 1.
3
INTRODUCTION
Figure 1.1 Schéma de fonctionnement du système
1.3 Objectifs à réaliser
1. Le premier objectif est de réaliser le réseau de Pétri permettant de modéliser le système en fonction des variables suivantes :
a et b, nombres d'éléments composant X ;
vb et v a , vitesses des robots ;
Dx et Dy , dimensions de l'aire de fabrication ;
xd et y d , coordonnées du point de construction
x.
2. Il s'agit ensuite de simuler le système sous Matlab, les diérentes variables,
a, b,
vb , v a , (Dx ; Dy ), (xd ;y d ),
peuvent être dénies en fonction des
besoins.
3. Pour terminer, implémenter le programme dans les robots.
Chapitre 2
Modélisation du système avec
les réseaux de Pétri
2.1 Présentation des réseaux de Pétri
Un réseau de Pétri est un graphe avec :
des places
des transitions
reliés par des arcs orientés
Tout arc doit être relié à ses sommets par une place/transition et deux places
ou deux transitions ne peuvent se suivre.
Chaque place peut contenir une ou plusieurs marques ou jetons indiquant
dans quel état se trouve le système.
Une transition ne peut être franchie que si toutes les places en amont sont
marquées avec le poids de l'arc correspondant (poids de 1 par défaut). Lors du
franchissement des places celles placées en amont se voient retirer le nombre de
marques indiquées par le poids de l'arc de même que celles en aval se voient
ajouter des marques selon la même règle[1].
Quelques exemples de réseaux de Pétri peuvent êtres trouvés sur le site de
Pétri Nets World[2].
4
CHAPITRE 2. MODÉLISATION DU SYSTÈME AVEC LES RÉSEAUX DE PÉTRI5
2.2 Réseau de Pétri du robot A
Le robot A ne peut se trouver que dans deux états d'avance dans un sens ou
dans l'autre, on appelle Avance quand il est dans le sens aller et Recul dans
le sens retour. Comme on doit également connaitre sa position pour interagir
avec le robot B on va utiliser 4 places :
AvanceA1 et ReculA1 avant le passage sur le point de construction x ;
AvanceA2 et ReculA2 après le passage sur le point de construction x.
Le robot a une vitesse
la coordonnée
yd
va ,
les dimensions
Dx
et
Dy
de l'espace de fabrication et
du point x servant à déterminer les transitions :
Le passage de AvanceA1 à AvanceA2 se fait au bout d'une durée
va · yd
.
Le passage de AvanceA2 à ReculA1 se fait au bout d'une durée
va ·
(Dy − y d ).
Le passage de ReculA1 à ReculA2 se fait au bout d'une durée
v a ·(Dy −
y d ).
Le passage de ReculA2 à AvanceA1 se fait au bout d'une durée
.
Figure 2.1 Réseau de Pétri du robot A
va · yd
CHAPITRE 2. MODÉLISATION DU SYSTÈME AVEC LES RÉSEAUX DE PÉTRI6
2.3 Réseau de Pétri du robot B
Le robot B peut se trouver dans trois états diérents ; deux d'avance dans
un sens ou dans l'autre, on appelle Avance quand il est dans le sens aller
et Recul dans le sens retour et également un état d'arrêt. Comme on doit
également connaitre sa position pour interagir avec le robot A on va utiliser 6
places :
AvanceB1 et ReculB1 avant le passage sur le point de construction x ;
AvanceB2 et ReculB2 après le passage sur le point de construction x ;
ArrêtB2 et ArrêtB2 dans le cas où le robot s'arrête contre le mur avant
de repartir quand il en a le temps avant le prochain passage du robot A.
On va également utiliser deux places vides P19 et P20 après chaque arrêt,
elles permettent l'interaction avec le robot A (cf point 2.4).
Le robot a une vitesse
et la coordonnée
xd
vb , les dimensions Dx
et
Dy
de l'espace de fabrication
du point x servant à déterminer les transitions :
Le passage de ArrêtB1 à AvanceB1 se fait immédiatement après la mise
en place du marquage sur P19.
Le passage de AvanceB1 à AvanceB2 se fait au bout d'une durée
vb ·
(Dx − xd ).
Le passage de AvanceB2 à ArrêtB2 se fait au bout d'une durée
v b · xd .
Le passage de ArrêtB2 à ReculB1 se fait immédiatement après la mise
en place du marquage sur P20.
vb · xd .
v b ·(Dx −
Le passage de ReculB1 à ReculB2 se fait au bout d'une durée
Le passage de ReculB2 à ArrêtB1 se fait au bout d'une durée
xd ).
Figure 2.2 Réseau de Pétri du robot B
CHAPITRE 2. MODÉLISATION DU SYSTÈME AVEC LES RÉSEAUX DE PÉTRI7
2.4 Réseau de Pétri global
On considère un état initial où chaque robot se trouve contre le mur et le
manipulateur est en position haute. Les places AvanceA1 et ArrêtB1 sont
les seules à être marquées.
L'interaction entre les réseaux de Pétri des deux robots mobile se fait au
moyen d'une place P11. Pour que le robot B puisse passer de l'état d'arrêt à
l'état d'avance(resp. recul) il faut que P11 soit marquée ce qui permet le passage
à la place P19 (resp. P20) puis vers la place permettant le mouvement.
La place P11 est marquée après le passage de la place AvanceA1 vers AvanceA2 et de ReculA1 vers ReculA2. Le passage de ReculA2 vers AvanceA1
et de AvanceA2 vers ReculA1 supprime ce marquage puisque dans cette situation le robot B n'a plus le temps de passer avant le robot A.
2.4.1
Cas sans arrêt du robot B après b passages
Dans cette situation on suppose que le robot B ne s'arrête contre le mur que
s'il n'a pas le temps de retraverser avant le passage du robot A.
Pour compter le nombre de passages du robot A (resp. B) on utilise une place
compteurA (resp. compteurB). Lors du passage de la première place Avance
vers la deuxième (de même avec les places de Recul) on vient ajouter une marque
dans la place de compteur. Quand le nombre de marque dans compteurA est
égale à a et celui de compteurB à b on vient agir sur le bras. Pour ce faire on
utilise des arc pondérés de a et b pour aller des places de comptage vers la place
BaisserBras, puis quand le bras est en position basse on évolue vers la place
MonterBras. Pour arrêter le manipulateur, une fois rendu en position haute,
on utilise une transition puits ce qui permet de démarquer la place MonterBras
sans rien marquer ensuite.
Cette transition n'arrête pas totalement le système puisque les deux réseau
de Pétri des robots mobiles ne s'interrompent jamais.
CHAPITRE 2. MODÉLISATION DU SYSTÈME AVEC LES RÉSEAUX DE PÉTRI8
Figure 2.3 Réseau de Pétri global
2.4.2
Cas sans arrêt du robot B après b passages
La situation précédente pose un problème ; si la valeur de b est petite on va
très rapidement se retrouver avec un excédent très important de pièces délivrées
par le robot B. On peut pallier à ce problème en réalisant quelques modications
sur le réseau de pétri précédent (Figure 2.3).
Deux nouvelles places P21 et P22 sont créées pour y parvenir.
P22 est marqué à l'état initial, cette place va servir à autoriser ou non le
départ du robot B, elle est donc incluse comme entrées dans les transition de
l'état d'arrêt vers l'état d'avance ou de recul. Quand compteurB contient b
marques on eace ces b marques ainsi que la marque de P22 et on vient en
ajouter une dans P21.
C'est donc P21 et compteurA qui vont permettre de franchir la transition
T13 pour marquer la place BaisserBras et marquer de nouveau P22 pour
ré-autoriser le robot B à se déplacer.
CHAPITRE 2. MODÉLISATION DU SYSTÈME AVEC LES RÉSEAUX DE PÉTRI9
Figure 2.4 Réseau de Pétri global avec arrêt de B après b passages
2.5 Simulation graphique des réseaux de Pétri
Deux logiciels ont permis de simuler les réseaux de Pétri pour vérier leur
bon fonctionnement avant de simuler sous Matlab
SimHPN (pmeditor)[3] ; Permet de tracer graphiquement des réseaux de
Pétri et de les simuler en mode pas à pas. Si deux transitions peuvent
être franchies il demande laquelle on souhaite franchir ce qui permet de
bien voir ce qui se passe. Pour y arriver il faut, dans les paramètres de
chaque transition, remplir le champs signal comme suit : en où n est
un nombre.
PetriParc ; Moins bien pour simuler puisqu'il ne propose pas de mode pas à
pas (il fait tout automatiquement et en cas de conit franchi une transition
au hasard parmi les choix possibles), il a l'avantage de fournir les matrices
complètes du système. Ces matrices servent à réaliser la simulation sous
Matlab.
Chapitre 3
Réalisation de la simulation
sous Matlab
3.1 Simuler les réseaux de Pétri sous Matlab
Pour pouvoir simuler un réseau de Pétri sous Matlab on utilise la représentation matricielle de celui-ci.
La matrice M représente l'état présent du système ;
La matrice PRE est la matrice d'incidence avant (le marquage existant
avant une transition pour autoriser son passage) ;
La matrice POST est la matrice d'incidence arrière (le marquage existant
après le passage de la transition) ;
La matrice T des transitions.
La condition permettent une transition est la suivante :
M (Pi ) > P RE(Pi , Tj )
Cela signie que, pour toute place
Pi
en entrée de la transition
Tj ,
la
transitionTj sera franchissable si le nombre de jetons présent dans chaque place
Pi
est supérieur ou égal au poids de l'arc reliant la place
Pi
à la transition
Tj .
Si la transition est franchissable on applique cette formule pour passer de
l'état actuel à l'état suivant :
M 0 (Pi ) = M (Pi ) − P RE(Pi , Tj ) + P OST (Pi , Tj )
M étant l'état actuel et M' l'état suivant.
Cela signie que, pour toute place
chissement de la transition
Tj
Pi
en entrée de la transition
consiste à enlever dans la place
de jetons égal au poids de l'arc reliant la place
toute place
Tj
Pi
en sortie de la transition
consiste à ajouter dans la place
reliant la place
Pi
à la transition
Tj
Pi
Pi
à la transition
Tj
, le fran-
un nombre
Tj
et pour
, le franchissement de la transition
P i un nombre de jetons égal au poids de l'arc
Tj .
10
CHAPITRE 3.
RÉALISATION DE LA SIMULATION SOUS MATLAB
11
Pour pouvoir gérer les temporisations dues aux temps de traversée qui sont
très importantes dans la gestion du système et ne peuvent être négligée on va
utiliser une deuxième matrice (Mt) décrivant l'état du système.
Au moment de franchir la transition on va appliquer la formule suivante :
M t(Pi ) = M (Pi ) − P RE(Pi , Tj ) + P OST (Pi , Tj )
Si une place P i temporisée devient active on déclenche le chronomètre, quand
la durée programmée est passée on applique cette règle :
M 0 (Pi ) = M t(Pi )
et
M t(Pi ) = 0
Il devient donc possible de franchir la transition suivante si les conditions
sont réunies.
3.2 Gestion de l'achage
Le système programmé tourne en boucle, si une place correspondant à un
déplacement est active on vient déplacer de une unité la coordonnée (abscisse
ou ordonnée suivant le robot considéré) et réacher les robots sur le graphique.
L'achage des robots est géré par la toolbox rvctools de Matlab[4]. Grâce à
cet outil il sut d'entrer la matrice des coordonnées (x,y et angle) et la couleur
souhaitée du robot pour générer son achage. Cette manipulation se fait au
moyen de l'instruction suivante :
plot_vehicle(A, 'r') ;
Dans ce cas A est la matrice de coordonnées et 'r ' correspond à la couleur
rouge.
Chapitre 4
Conclusion
Les trois mois qu'on duré le projet m'ont permis de réaliser un réseau de
Pétri et une simulation sous Matlab fonctionnels et correspondant au cahier des
charges. Le projet aura malheureusement été trop court pour avoir le temps de
passer à l'étape suivante, à savoir l'implémentation du programme sur les robots
pour simuler le système en conditions réelles.
Ce stage m'aura permis de découvrir et d'apprendre à me servir des réseaux
de Pétri et de Matlab ce qui devrait me resservir à l'avenir.
12
Bibliographie
[1] SCORLETTI
G.
et
BINET
G.
Réseaux
de
Pétri.
[document
électro-
nique]. Caen, Université de Caen/Basse Normandie U.F.R. Sciences Caen,
2006, http ://www.metz.supelec.fr/metz/personnel/vialle/course/CNAMACCOV-NFP103/extern-doc/RdP/Cours_Petri_etudiant_GS_2006.pdf
[2] Université d'Hambourg. Welcome to the Petri Nets World. [en ligne].
http ://www.informatik.uni-hamburg.de/TGI/PetriNets/ [10/05/2012]
[3] GISED(Group of Discrete Event Systems Engineering). SinHPN. [en ligne].
http ://webdiis.unizar.es/GISED/ ?q=tool/simhpn [05/06/2012]
[4] CORKE
Peter.
Robotics
Toolbox.
[en
corke.com/Robotics_Toolbox.html [15/06/2012]
13
ligne].
http
://peter-
Annexe : Code Matlab du
système
14
%Efface les données en mémoire
clear;
%initialisation grille affichage
xg = [5 5 3.14/2];
clf
axis([0 100 0 100]);
hold on
xyzlabel
grid on
xa = 25; ya = 75;
xb = 5; yb = 40;
xc = 50; yc =60;
radius = 4;
%initialisation
PRE = [1 0 0 0 0
0 0 0 0 0
0 0 1 0 0
0 0 0 1 0
0 0 0 0 1
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 1
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 1 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 1
POST = [0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
3
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
1
0
0
0
0
0
1
0
0
0
0
0
0
0
0
1
0;
0;
0;
0;
0;
0;
0;
0;
0;
0;
0;
2;
0;
0;
0;
0;
0;
0;
1];
0
0
0
0
0
0
0
0
0
1
0
0
0
0
1
0
0
0
1
0;
0;
0;
0;
0;
0;
0;
0;
0;
0;
0;
0;
0;
0;
0;
0;
0;
1;
0];
TEXT
= ['AvanceB2
';
'ArretB1
';
'ReculB2
';
'ReculB1
';
'ArretB2
';
'ReculA1
';
'AvanceA2
';
'AvanceA1
';
'ReculA2
';
'P11
';
'CompteurA ';
'CompteurB ';
'BaisserBras';
'MonterBras ';
'AvanceB1
';
'P19
';
'P20
';
'P21
';
'P22
'];
T = [2;
0;
3;
2;
0;
5;
5;
6;
6;
0;
0;
0;
3;
3;
3;
0;
0;
0;
0];
%situation initiale
M0 = [0;
1;
0;
0;
0;
0;
0;
1;
0;
0;
0;
0;
0;
0;
0;
0;
0;
0;
1];
M = [0;
0;
0;
0;
0;
0;
0;
0;
0;
0;
0;
0;
0;
0;
0;
0;
0;
0;
0];
pause on;
tour = 1;
Incidence = -PRE+POST;
PMt = M;
%démarrage du cyale
t0=clock;
Mt = M0;
%démarrage des tempo sur la situation initiale
for i=1:19
switch(i)
case(1)
if Mt(i,1)>PMt(i,1)
t1 = clock;
PMt(i,1) = Mt(i,1);
end
case(3)
if Mt(i,1)>PMt(i,1)
t3 = clock;
PMt(i,1) = Mt(i,1);
end
case(4)
if Mt(i,1)>PMt(i,1)
t4 = clock;
PMt(i,1) = Mt(i,1);
end
case(6)
if Mt(i,1)>PMt(i,1)
t6 = clock;
PMt(i,1) = Mt(i,1);
end
case(7)
if Mt(i,1)>PMt(i,1)
t7 = clock;
PMt(i,1) = Mt(i,1);
end
case(8)
if Mt(i,1)>PMt(i,1)
t8 = clock;
PMt(i,1) = Mt(i,1);
end
case(9)
if Mt(i,1)>PMt(i,1)
t9 = clock;
PMt(i,1) = Mt(i,1);
end
case(13)
if Mt(i,1)>PMt(i,1)
t13 = clock;
PMt(i,1) = Mt(i,1);
end
case(14)
if Mt(i,1)>PMt(i,1)
t14 = clock;
PMt(i,1) = Mt(i,1);
end
case(15)
if Mt(i,1)>PMt(i,1)
t15 = clock;
PMt(i,1) = Mt(i,1);
end
otherwise
PMt(i,1) = Mt(i,1);
end
end
while tour<=1000
%affichage robot
%avance
A = [xa ya -pi/2];
B = [xb yb 0];
C = [xc yc -pi/2];
if (M(7,1)==1 || Mt(7,1)==1 || M(8,1)==1 || Mt(8,1)==1)
A = [xa ya -pi/2];
ya = ya-1 ;
end
if (M(1,1)==1 || Mt(1,1)==1 || M(15,1)==1 || Mt(15,1)==1)
B = [xb yb 0];
xb = xb+1 ;
end
%recul
if (M(9,1)==1 || Mt(9,1)==1 || M(6,1)==1 || Mt(6,1)==1)
A = [xa ya pi/2];
ya = ya+1 ;
end
if (M(3,1)==1 || Mt(3,1)==1 || M(4,1)==1 || Mt(4,1)==1)
B = [xb yb -pi];
xb = xb-1 ;
end
%bras
if (M(13,1)==1 || Mt(13,1)==1)
C = [xc yc -pi/2];
yc = yc-1 ;
end
if (M(14,1)==1 || Mt(14,1)==1)
C = [xc yc -pi/2];
yc = yc+1 ;
end
%comptage des passages du robot B
if M(12,1) == 1
valeurB = 1;
else
if M(18,1) == 1
valeurB = 2;
else
valeurB = 0;
end
end
clf
axis([0 100 0 100]);
hold on
xyzlabel
grid on
%affichage des véhicules
plot_vehicle(A, 'r');
plot_vehicle(B, 'g');
plot_vehicle(C, 'b');
plot(25,40,'co');
%affichage des légendes et nombre de passages des robots
uicontrol('style','text','position',[155 357 15
15],'string',num2str(M(11,1)));
uicontrol('style','text','position',[285 357 15
15],'string',num2str(valeurB));
text(3,95,'rouge A');
text(3,92,'compteur');
text(33,95,'vert B');
text(33,92,'compteur');
text(63,92,'manipulateur');
text(63,95,'bleu');
%test des chronos et passage de matrice temporaire Mt à la matrice M
for i=1:19
switch(i)
case(1)
if ((Mt(i,1) == 1)&&(etime(clock,t1)>=T(i,1)))||(Mt(i,1) == 0)
M(i,1) = Mt(i,1);
end
case(3)
if ((Mt(i,1) == 1)&&(etime(clock,t3)>=T(i,1)))||(Mt(i,1) == 0)
M(i,1) = Mt(i,1);
end
case(4)
if ((Mt(i,1)
M(i,1) =
end
case(6)
if ((Mt(i,1)
M(i,1) =
end
case(7)
if ((Mt(i,1)
M(i,1) =
end
case(8)
if ((Mt(i,1)
M(i,1) =
end
case(9)
if ((Mt(i,1)
M(i,1) =
end
case(13)
if ((Mt(i,1)
== 1)&&(etime(clock,t4)>=T(i,1)))||(Mt(i,1) == 0)
Mt(i,1);
== 1)&&(etime(clock,t6)>=T(i,1)))||(Mt(i,1) == 0)
Mt(i,1);
== 1)&&(etime(clock,t7)>=T(i,1)))||(Mt(i,1) == 0)
Mt(i,1);
== 1)&&(etime(clock,t8)>=T(i,1)))||(Mt(i,1) == 0)
Mt(i,1);
== 1)&&(etime(clock,t9)>=T(i,1)))||(Mt(i,1) == 0)
Mt(i,1);
== 1)&&(etime(clock,t13)>=T(i,1)))||(Mt(i,1) ==
0)
M(i,1) = Mt(i,1);
end
case(14)
if ((Mt(i,1) == 1)&&(etime(clock,t14)>=T(i,1)))||(Mt(i,1) ==
0)
M(i,1) = Mt(i,1);
end
case(15)
if ((Mt(i,1) == 1)&&(etime(clock,t15)>=T(i,1)))||(Mt(i,1) ==
0)
M(i,1) = Mt(i,1);
end
otherwise
M(i,1) = Mt(i,1);
end
end
%test et passage à l'état suivant dans matrice temporaire Mt avec
déclenchement des chronos
for j=1:16
if all(M >= PRE(:,j))
for i=1:19
Mt(i,1) = Mt(i,1)+Incidence(i,j);
switch(i)
case(1)
if Mt(i,1)>PMt(i,1)
t1 = clock;
PMt(i,1) = Mt(i,1);
end
if Mt(i,1)== 0
M(i,1) = Mt(i,1);
PMt(i,1) = Mt(i,1);
end
case(3)
if Mt(i,1)>PMt(i,1)
t3 = clock;
PMt(i,1) = Mt(i,1);
end
if Mt(i,1)== 0
M(i,1) = Mt(i,1);
PMt(i,1) = Mt(i,1);
end
case(4)
if Mt(i,1)>PMt(i,1)
t4 = clock;
PMt(i,1) = Mt(i,1);
end
if Mt(i,1)== 0
M(i,1) = Mt(i,1);
PMt(i,1) = Mt(i,1);
end
case(6)
if Mt(i,1)>PMt(i,1)
t6 = clock;
PMt(i,1) = Mt(i,1);
end
if Mt(i,1)== 0
M(i,1) = Mt(i,1);
PMt(i,1) = Mt(i,1);
end
case(7)
if Mt(i,1)>PMt(i,1)
t7 = clock;
PMt(i,1) = Mt(i,1);
end
if Mt(i,1)== 0
M(i,1) = Mt(i,1);
PMt(i,1) = Mt(i,1);
end
case(8)
if Mt(i,1)>PMt(i,1)
t8 = clock;
PMt(i,1) = Mt(i,1);
end
if Mt(i,1)== 0
M(i,1) = Mt(i,1);
PMt(i,1) = Mt(i,1);
end
case(9)
if Mt(i,1)>PMt(i,1)
t9 = clock;
PMt(i,1) = Mt(i,1);
end
if Mt(i,1)== 0
M(i,1) = Mt(i,1);
PMt(i,1) = Mt(i,1);
end
case(13)
if Mt(i,1)>PMt(i,1)
t13 = clock;
PMt(i,1) = Mt(i,1);
end
if Mt(i,1)== 0
M(i,1) = Mt(i,1);
PMt(i,1) = Mt(i,1);
end
case(14)
if Mt(i,1)>PMt(i,1)
t14 = clock;
PMt(i,1) = Mt(i,1);
end
if Mt(i,1)== 0
M(i,1) = Mt(i,1);
PMt(i,1) = Mt(i,1);
end
case(15)
if Mt(i,1)>PMt(i,1)
t15 = clock;
PMt(i,1) = Mt(i,1);
end
if Mt(i,1)== 0
M(i,1) = Mt(i,1);
PMt(i,1) = Mt(i,1);
end
otherwise
PMt(i,1) = Mt(i,1);
M(i,1) = Mt (i,1);
end
end
end
end
tour = tour+1;
pause(0.1);
end