Introduction : Le comportement des systemes
L'approche comportementale decrit comment un systeme reagit au cours du temps en fonction des evenements qu'il recoit. Elle repond a la question : “Comment le systeme evolue-t-il ?”
Exemple : un portail automatique peut etre dans differents etats (ouvert, ferme, en mouvement) et passe de l'un a l'autre lors d'evenements (appui telecommande, fin de course atteinte, temporisation).
Types de comportements
Les sorties dependent uniquement des entrees actuelles (pas de memoire).
Ex: porte logique AND, decodeur
Les sorties dependent des entrees ET de l'etat precedent (memoire).
Ex: compteur, automate, machine a etats
Distinction comportement combinatoire vs sequentiel : ═══════════════════════════════════════════════════════════════ COMBINATOIRE │ SEQUENTIEL ────────────────────────────────┼──────────────────────────────── Sortie = f(Entrees) │ Sortie = f(Entrees, Etat) Pas de memoire │ Memoire de l'etat precedent Reponse instantanee │ Evolution dans le temps Ex: S = A AND B │ Ex: Machine a etats finis Sortie(t) = f(Entree(t)) │ Sortie(t) = f(Entree(t), Etat(t-1))
1. Le Diagramme d'Etats (stm)
Le diagramme d'etats SysML (State Machine Diagram) modelise les differents etats d'un systeme et les transitions entre ces etats. C'est l'outil central pour decrire le comportement sequentiel.
1.1 Elements du diagramme
Etat
Situation stable du systeme pendant laquelle il effectue une activite.
| ETAT |
|-------------|
| entry/action|
| do/activite |
| exit/action |
+-------------+
Transition
Passage d'un etat a un autre, declenche par un evenement.
Exemple :
appui_telecommande [porte_fermee] / demarrer_moteur
1.2 Notation complete des etats
- entry/ : Action executee UNE FOIS a l'entree dans l'etat (ex: entry/allumer_voyant)
- do/ : Activite executee en CONTINU pendant l'etat (ex: do/faire_tourner_moteur)
- exit/ : Action executee UNE FOIS a la sortie de l'etat (ex: exit/eteindre_voyant)
- [garde] : Condition booleenne qui doit etre vraie pour franchir la transition
- /action : Action executee lors du franchissement de la transition
1.3 Exemple : Portail automatique
stm [Portail automatique]
═══════════════════════════════════════════════════════════════
*-----------------------------------------------------------*
| |
v |
+-------------+ appui [ferme] +-------------+ |
| FERME |---------------->| OUVERTURE | |
| | | | |
| entry/led=0 | | do/moteur+ | |
| do/veiller | | entry/led=1 | |
+-------------+ +-------------+ |
^ | |
| | fin_course_haut |
| v |
| tempo_ecoulee +-------------+ |
|<--------------------------| OUVERT | |
| | | |
| | entry/tempo | |
| | do/attente | |
| +-------------+ |
| | |
| | appui [ouvert] |
| v |
| +-------------+ |
| fin_course_bas | FERMETURE | |
+---------------------------| |-----------------+
| do/moteur- | obstacle
| entry/led=1 | detecte
+-------------+
Legende :
* = Etat initial (pseudo-etat)
o = Etat final (si existant)Point important : Les actions entry/, do/, exit/ s'executent respectivement a l'entree, pendant, et a la sortie de l'etat. La garde [condition] doit etre vraie pour que la transition se fasse.
1.4 Etats composites et hierarchiques
Un etat peut contenir d'autres etats (sous-etats). Cela permet de structurer des comportements complexes et de factoriser les transitions communes.
stm [Ascenseur - Etat composite]
═══════════════════════════════════════════════════════════════
+-----------------------------------------------------------+
| EN_MOUVEMENT |
| +--------------------------------------------------+ |
| | | |
| | +----------+ etage_atteint +----------+ | |
| | | MONTEE |---------------->| ARRET | | |
| | | do/mot+ | | entry/ | | |
| | +----------+ | ouvrir | | |
| | ^ +----------+ | |
| | | | | |
| | | appel_bas |appel_haut | |
| | | v | |
| | +----------+<-------------------+----------+ | |
| | | DESCENTE | | ATTENTE | | |
| | | do/mot- | | do/tempo | | |
| | +----------+ +----------+ | |
| +--------------------------------------------------+ |
+-----------------------------------------------------------+
|
| urgence_appuyee
v
+----------+
| ARRET_ |
| URGENCE |
+----------+
Note : La transition "urgence" s'applique a TOUS les sous-etats2. Les Chronogrammes
Un chronogramme represente l'evolution temporelle des variables (signaux, etats) sur un axe horizontal de temps. C'est l'outil ideal pour analyser les sequences d'evenements et verifier le comportement reel d'un systeme.
2.1 Lecture d'un chronogramme
Temps (s) 0 1 2 3 4 5 6 7 8
| | | | | | | | |
Telecommande -----+ +---------------------+
____!____!_____________________!______________
Moteur _____+----+_________________+----+________
ouverture -----! !-----------------! !--------
Capteur ----------+ +-------------
fin_haut ----------!_________________!-------------
Etat FERME!OUVR! OUVERT !FERM! FERME
-----+----+----------------+----+--------
Legende :
_____ = Niveau bas (0)
----- = Niveau haut (1)
+ = Front montant
! = Front descendant2.2 Grandeurs typiques
Signaux TOR
Tout Ou Rien : 0 ou 1 (capteurs, relais, boutons)
Signaux analogiques
Variation continue (temperature, vitesse, tension)
Etats systeme
Niveaux discrets (FERME, OUVERT, EN_COURS...)
2.3 Mesures sur chronogramme
Grandeurs mesurables sur un chronogramme :
═══════════════════════════════════════════════════════
Temps de montee (tr) : duree pour passer de 10% a 90% de la valeur finale
Temps de reponse (ts) : duree pour atteindre +/-5% de la valeur finale
Retard (td) : temps entre l'evenement et le debut de la reaction
Periode (T) : duree d'un cycle complet (signaux periodiques)
Rapport cyclique (alpha) :
alpha = t_haut / T x 100%
Exemple : Si T = 20 ms et t_haut = 5 ms
alpha = 5 / 20 x 100% = 25%
Frequence (f) :
f = 1 / T
Exemple : Si T = 20 ms = 0.020 s
f = 1 / 0.020 = 50 Hz2.4 Exemple industriel : Signal PWM
Signal PWM pour controle de moteur (f = 1 kHz, alpha = 75%)
═══════════════════════════════════════════════════════════════
T = 1 ms
|<-------->|
| t_haut |
|<------>| |
| 0.75ms| |
+--------+ +--------+ +--------+
| | | | | |
----+ +-+ +-+ +---- Vcc (ex: 12V)
| | | | | |
| | | | | |
----+--------+-+--------+-+--------+---- 0V
Tension moyenne = Vcc x alpha = 12V x 0.75 = 9V
(C'est ainsi qu'on controle la vitesse du moteur)3. Tables de Verite et Logique Combinatoire
Pour les systemes combinatoires, on utilise des tables de verite qui decrivent la sortie pour chaque combinaison possible des entrees.
3.1 Portes logiques de base
AND (ET)
S = A . B
| A | B | S |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
OR (OU)
S = A + B
| A | B | S |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
NOT (NON)
S = /A (A barre)
| A | S |
|---|---|
| 0 | 1 |
| 1 | 0 |
3.2 Exemple : Systeme d'alarme
Cahier des charges : L'alarme (A) se declenche si la porte (P) EST ouverte ET le systeme est arme (S) ET il n'y a PAS de code valide (C).
Equation logique : A = P . S . /C
| P (porte) | S (arme) | C (code) | A (alarme) |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 0 | 0 | 1 | 0 |
| 0 | 1 | 0 | 0 |
| 0 | 1 | 1 | 0 |
| 1 | 0 | 0 | 0 |
| 1 | 0 | 1 | 0 |
| 1 | 1 | 0 | 1 |
| 1 | 1 | 1 | 0 |
4. Le Diagramme de Sequence (sd)
Le diagramme de sequence SysML montre les interactions entre les differents elements du systeme (blocs, acteurs) au cours du temps, avec l'ordre des messages echanges.
4.1 Exemple : Commande d'ouverture de portail
sd [Ouverture portail]
═══════════════════════════════════════════════════════════════
Utilisateur Telecommande Recepteur Moteur
| | | |
|---- appui ---->| | |
| |--- signal RF ->| |
| | |-- verif ---->|
| | |<---- OK -----|
| | | |
| | |-- PWR ON --->|
| | | |-+
| | | | | rotation
| | | |<+
| | | |
| | |<- fin_course-|
| | | |
| | |-- PWR OFF -->|
| | | |
-----|----------------- temps ------------------------->4.2 Operateurs de sequence
opt (option)
Fragment execute si la condition est vraie.
[obstacle_detecte] - arret_moteur
alt (alternative)
Choix entre plusieurs fragments (if/else).
[code_OK] - ouvrir / [code_KO] - alarme
loop (boucle)
Fragment repete n fois ou tant que condition vraie.
loop(3) - clignotement_led
par (parallele)
Fragments executes simultanement.
par - [moteur_ON || led_ON]
4.3 Exemple avec operateurs
sd [Distributeur automatique]
═══════════════════════════════════════════════════════════════
Client IHM Controleur Mecanisme
| | | |
|-- choix -->| | |
| |--- produit ---->| |
| | | |
|-- paiement>| | |
| |--- montant ---->| |
| | | |
+============================================+ |
| alt | |
| +---------------------------------------+ | |
| | [montant >= prix] | | |
| | |<-- OK ----------| | | |
| | | |-- livrer ->| |
| | | |<-- fait ---|
| | |<-- rendre monnaie-----------|
| +---------------------------------------+ | |
| +---------------------------------------+ | |
| | [montant < prix] | | |
| | |<-- insuffisant -| | | |
| |<-message| | | | |
| +---------------------------------------+ | |
+============================================+ |
| | | |5. Du Comportement au Programme
Le diagramme d'etats se traduit directement en algorithme de programmation. Chaque etat devient une portion de code, chaque transition un test conditionnel.
// Structure switch-case (C/Arduino)
switch(etat) {
case FERME:
// Actions entry/
led = 0;
// Actions do/
surveiller();
// Test transitions
if(telecommande) {
demarrer_moteur();
etat = OUVERTURE;
}
break;
case OUVERTURE:
led = 1;
faire_tourner_moteur(SENS_PLUS);
if(fin_course_haut) {
arreter_moteur();
lancer_tempo();
etat = OUVERT;
}
break;
case OUVERT:
attendre();
if(tempo_ecoulee) {
etat = FERMETURE;
}
break;
case FERMETURE:
faire_tourner_moteur(SENS_MOINS);
if(obstacle_detecte) {
etat = OUVERTURE;
}
if(fin_course_bas) {
arreter_moteur();
etat = FERME;
}
break;
}Correspondance
- Etat - case du switch
- Evenement - condition if
- Action - appel de fonction
- Transition - changement de variable etat
- Garde - condition supplementaire dans le if
- entry/ - debut du case (avant la boucle)
- do/ - corps du case (repete)
- exit/ - juste avant le changement d'etat
Pattern Machine a Etats
Ce pattern est tres utilise en programmation embarquee (Arduino, STM32) et permet de gerer des comportements complexes de maniere claire et maintenable.
6. Exemples Industriels
6.1 Machine a laver le linge
stm [Machine a laver]
═══════════════════════════════════════════════════════════════
*--> ARRET --[start ET porte_fermee]--> REMPLISSAGE
| |
| | niveau_eau_OK
| v
| LAVAGE
| (do/rotation)
| |
| | tempo_lavage
| v
| VIDANGE
| (do/pompe_ON)
| |
| | cuve_vide
| v
| ESSORAGE
| (do/rotation_rapide)
| |
|<--------- cycle_termine ---------+
Etats : ARRET, REMPLISSAGE, LAVAGE, VIDANGE, ESSORAGE
Capteurs : porte, niveau_eau, cuve_vide
Actionneurs : electrovannes, moteur, pompe6.2 Feu tricolore de carrefour
| Etat | Feu Nord-Sud | Feu Est-Ouest | Duree | Transition |
|---|---|---|---|---|
| E1 | VERT | ROUGE | 30s | tempo - E2 |
| E2 | ORANGE | ROUGE | 3s | tempo - E3 |
| E3 | ROUGE | VERT | 30s | tempo - E4 |
| E4 | ROUGE | ORANGE | 3s | tempo - E1 |
Points Cles a Retenir
- 1L'approche comportementale decrit l'evolution du systeme dans le temps (combinatoire ou sequentiel).
- 2Le diagramme d'etats (stm) modelise etats, transitions, gardes et actions (entry/do/exit).
- 3Les chronogrammes visualisent l'evolution temporelle (periode, rapport cyclique, temps de reponse).
- 4Les tables de verite decrivent le comportement combinatoire (AND, OR, NOT).
- 5Le diagramme de sequence (sd) montre l'ordre des messages (opt, alt, loop, par).
- 6Un diagramme d'etats se traduit en switch-case en programmation.
Mini-Quiz
1. Que represente une transition dans un diagramme d'etats ?
Reponse : Le passage d'un etat a un autre, declenche par un evenement et conditionne par une garde
2. Comment mesure-t-on le rapport cyclique alpha d'un signal ?
Reponse : alpha = t_haut / T x 100% (temps a l'etat haut divise par la periode)
3. Quel operateur SysML permet d'executer deux actions en parallele ?
Reponse : L'operateur par (parallel)
4. Quelle est la difference entre comportement combinatoire et sequentiel ?
Reponse : Combinatoire : sortie = f(entrees). Sequentiel : sortie = f(entrees, etat precedent) - avec memoire
5. Que signifie do/ dans un etat ?
Reponse : C'est une activite continue executee tant que le systeme reste dans cet etat
6. Comment se traduit un diagramme d'etats en code ?
Reponse : Par une structure switch-case ou chaque etat est un case et les transitions sont des if
