⚙️ Simulink – Modélisation & Simulation (MATLAB)

1.1 Vue d'ensemble : Simulink (On hyper-densifie)

Modélisation Graphique & Simulation

Simulink est un environnement de programmation **graphique** (diagramme-bloc) intégré à MATLAB, conçu pour la **modélisation**, la **simulation** et l'**analyse** de systèmes dynamiques (systèmes dont l'état évolue dans le temps).

Il est le standard de l'industrie pour le Model-Based Design (MBD) : au lieu d'écrire du code textuel (MATLAB, C, Python), vous "dessinez" le système en connectant des blocs fonctionnels.

Cas d'usage principaux

Automatique (Control Systems) : Conception et test de régulateurs (ex: PID) pour un moteur, un robot, une fusée.
Automobile : Modélisation de systèmes ABS, ESP, gestion de batterie (BMS).
Aérospatiale : Simulation de guidage, navigation et contrôle (GNC) de satellites ou de drones.
Traitement du Signal : Conception de filtres audio/radio (DSP) graphiquement.
Physique :Monitoring : Modélisation de systèmes physiques (mécanique, thermique, hydraulique) via Simscape.

MATLAB vs. Simulink

Ils sont indissociables mais servent des buts différents.

Critère	MATLAB	Simulink
Paradigme	Textuel (Scripts `.m`)	Graphique (Diagrammes-blocs `.slx`)
Usage principal	Calcul, Analyse de données, Visualisation	Simulation de systèmes dynamiques
Flux	Séquentiel (Top-down)	Parallèle / Événementiel (basé sur le temps)
Point fort	Algorithmes complexes, algèbre matricielle	Systèmes complexes (feedback), état, temps continu
Exemple	`y = sin(x); plot(x,y);`	`[Sine Wave] -> [PID] -> [Plant] -> [Scope]`

1.2 Installation (Toolbox)

Simulink est une Toolbox MATLAB

Simulink n'est pas un logiciel indépendant. C'est un **produit (Toolbox)** qui s'ajoute à votre installation MATLAB de base.

Installation

Lors de l'installation de MATLAB (voir guide MATLAB 1.2), assurez-vous de cocher "Simulink" dans la liste des produits auxquels votre licence vous donne accès.

Si MATLAB est déjà installé :

Dans MATLAB, onglet Home.
Cliquez sur Add-Ons -> Get Add-Ons.
Cherchez "Simulink".
Installez-le (votre licence doit le permettre).

Toolboxes Simulink Essentielles

Simulink possède ses propres Add-Ons :

Toolbox	Description
Simulink Coder	Génère du code C/C++ depuis votre modèle (pour l'embarqué).
Stateflow	Modélisation de machines à états (logique complexe).
Simscape	Modélisation physique (électrique, mécanique, hydraulique).
Control System Toolbox	(Base MATLAB) Blocs pour l'automatique (PID, Transfer Fcn).

1.3 Environnement Simulink

Lancement

Pour démarrer Simulink :

Tapez simulink dans la Command Window MATLAB.
Cliquez sur l'icône "Simulink" dans l'onglet "Home" de MATLAB.

Cela ouvre la page de démarrage de Simulink, où vous pouvez choisir un modèle vierge (Blank Model) ou des templates.

Les 3 Fenêtres Clés

Library Browser (Bibliothèque) : La "palette" de tous les blocs disponibles (Sources, Sinks, Math...).
Model Editor (Éditeur) : La "toile" où vous glissez-déposez et connectez les blocs. C'est votre fichier .slx.
Configuration Parameters (Ctrl+E) : La "salle des machines". C'est ici que l'on choisit le Solveur, le temps de simulation, etc.

Schéma de l'interface.

2.1 Concepts de base : Modèle, Blocs, Signaux

1. Modèle (`.slx`)

Le fichier principal (format .slx, un XML compressé). Il contient la description de tous les blocs, leurs connexions et la configuration.

2. Blocs (Blocks)

Les "fonctions" de Simulink. Un bloc a des ports d'entrée (>) et des ports de sortie (>).

(Ex: un bloc Gain a 1 entrée, 1 sortie. Un bloc Sum a 2+ entrées, 1 sortie).

3. Signaux (Signals)

Les "lignes" (flèches) qui connectent les ports. Elles représentent le flux de données (un nombre, un vecteur, une matrice) dans le temps.

(Signal d'entrée)     +-----------+
    In1 >---------|           |
                  | Bloc 'Sum'|----> Out1 (Signal de sortie)
    In2 >---------|           |
                  +-----------+

2.2 Premier Modèle (Sine -> Gain -> Scope)

"Hello World" de Simulink

Objectif : Générer un sinus, l'amplifier, et le visualiser.

Ouvrir Simulink (simulink) et créer un "Blank Model".
Ouvrir le "Library Browser" (Ctrl+Shift+L).
Glisser-déposer les blocs suivants dans le modèle :
- Simulink > Sources > Sine Wave
- Simulink > Math Operations > Gain
- Simulink > Sinks > Scope
Connecter (cliquer-glisser) la sortie de "Sine Wave" à l'entrée de "Gain".
Connecter la sortie de "Gain" à l'entrée de "Scope".
Double-cliquer sur "Gain" et mettre sa valeur à 5.
Cliquer sur "Run" (bouton Play).
Double-cliquer sur "Scope" pour voir le résultat.

Diagramme-bloc

+-----------+      +-----------+      +-----------+
| Sine Wave |----->| Gain      |----->| Scope     |
| (Source)  |      | (K=5)     |      | (Sink)    |
+-----------+      +-----------+      +-----------+

Résultat (Fenêtre "Scope")

Le Scope affiche une sinusoïde d'amplitude 5.

2.3 Configuration des Solveurs (Ctrl+E)

Le "moteur" de la simulation

Un "Solver" (Solveur) est l'algorithme mathématique qui calcule l'état du système à chaque pas de temps (t). Pour les systèmes continus (ex: Integrator), il résout des Équations Différentielles Ordinaires (ODE).

Ouvrez la configuration avec Ctrl+E (ou Simulation > Model Configuration Parameters).

Start time / Stop time : Durée de la simulation (ex: 0 à 10.0 secondes).
Type : Variable-step (pas variable) ou Fixed-step (pas fixe).
Solver : L'algorithme (ex: ode45, ode4).

Solveurs à pas Variable (Variable-step)

Défaut. Le solveur ajuste la taille du pas (dt) : petits pas si le signal change vite, grands pas s'il est stable.
Usage : Simulation "pure", analyse physique, quand la précision est clé.

Solveur	Description
`ode45` (Défaut)	Runge-Kutta (4,5). Le meilleur choix généraliste.
`ode23`	Bogacki-Shampine. Moins précis mais plus rapide (systèmes "stiff").
`auto`	Laisse Simulink choisir.

Solveurs à pas Fixe (Fixed-step)

Le pas (dt) est constant (ex: 0.01s).
Usage : Codegen (Simulink Coder) (requis pour l'embarqué), systèmes discrets, co-simulation.

Solveur	Description
`ode4` (Runge-Kutta)	Bon choix généraliste pour le pas fixe.
`discrete`	Utilisé si le modèle ne contient QUE des blocs discrets.

3.1 Blocs : Sources & Sinks

Sources (Entrées du système)

Bloc	Description
Constant	Sort un scalaire constant (ex: 9.81).
Step	Signal échelon (passe de 0 à 1 au temps 'Step time').
Sine Wave	Génère une sinusoïde (Amplitude, Fréquence, Phase).
Signal Generator	Génère Onde Carrée, Triangle, Dent de scie...
Clock	Sort le temps de simulation actuel.
From Workspace	Lit un signal depuis une variable MATLAB.

Sinks (Sorties / Visualisation)

Bloc	Description
Scope	Le plus utilisé. Affiche le signal vs. temps (oscilloscope).
Display	Affiche la valeur numérique actuelle du signal.
XY Graph	Affiche Entrée Y vs. Entrée X (ex: `plot(x,y)`).
To Workspace	Enregistre le signal dans une variable MATLAB à la fin.
Terminator	"Corbeille" pour les sorties de bloc non utilisées.

3.2 Blocs : Mathématiques

Blocs "Math Operations"

Bloc	Description
Gain	Multiplication par une constante (K). (`y = K * u`).
Sum	Addition/Soustraction (`++`, `+-`).
Product	Multiplication/Division (`*`, `/`). (Element-wise).
Fcn (MATLAB Fcn)	Applique une expression MATLAB (ex: `sin(u[1]) + u[2]`).
Trigonometric Fcn	`sin`, `cos`, `tan`...
Relational Operator	`>`, `<`, `==` (Sort 1 ou 0).

Exemple : `Sum`

Par défaut, Sum est |++. Pour une boucle de feedback (erreur = Consigne - Mesure), on le règle sur |+-.

(Consigne) + >---|
                | Sum |-----> (Erreur)
(Mesure)   - >---|     |
                +-----+

3.3 Blocs : Continus (Temps-continu)

Ces blocs introduisent des "états". Ils nécessitent un solveur (ODE) car ils décrivent le comportement du système dans le temps.

Blocs Continus Principaux

Bloc	Maths (Laplace)	Description
Integrator (1/s)	$Y(s) = \frac{1}{s} \cdot U(s)$	Intègre le signal d'entrée (`y = ∫u dt`). Le bloc le plus important pour la modélisation physique.
Derivative (s)	$Y(s) = s \cdot U(s)$	Dérive le signal d'entrée (`y = du/dt`). (Bruyant, à éviter si possible).
Transfer Fcn	$\frac{Num(s)}{Den(s)}$	Implémente une fonction de transfert (Laplace). (Ex: $\frac{1}{s+1}$).

Exemple : Résolution d'ODE

Comment modéliser $\dot{y} = -2y + u$ (avec $y(0)=1$) ?
On isole la dérivée la plus haute : $\dot{y}$.
Puis on intègre : $y = \int \dot{y} dt$.


(u) ---->+-----------+
         | Sum       |
         | (+ -)     |----->[Integrator (1/s)]-----> (y)
         +-----------+           | (Condition Initiale: 1)
             ^                   |
             |  +--------+       |
             +--| Gain   |-------+
                | (K=2)  |
                +--------+

3.4 Blocs : Discrets (Temps-discret)

Ces blocs ne fonctionnent qu'à des "pas de temps" (échantillons) spécifiques. Ils nécessitent un solveur "Discrete" ou "Fixed-step".

Blocs Discrets Principaux

Bloc	Maths (Z-Transform)	Description
Unit Delay	$z^{-1}$	Retarde le signal d'un pas de temps. (`y[k] = u[k-1]`). Le "registre" de la logique discrète.
Zero-Order Hold (ZOH)	-	Bloqueur d'ordre zéro. Convertit un signal continu en signal discret (escalier).
Discrete Transfer Fcn	$\frac{Num(z)}{Den(z)}$	Implémente une fonction de transfert discrète (Transformée en Z).
Discrete-Time Integrator	$\frac{T_s}{z-1}$	Implémente une intégration discrète (ex: méthode d'Euler).

4.1 Subsystems (Sous-systèmes)

Abstraction & Hiérarchie

Un "Subsystem" (Sous-système) est un bloc qui contient d'autres blocs. C'est l'équivalent d'une "fonction" ou d'un "dossier" : il permet de nettoyer et d'organiser un modèle complexe.

Création

Sélectionnez les blocs que vous voulez regrouper.
Appuyez sur Ctrl+G.
Simulink les remplace par un seul bloc "Subsystem".
Double-cliquer sur le bloc permet d'"entrer" dedans.

Simulink gère automatiquement les ports d'entrée (Inport) et de sortie (Outport).

Avant `Ctrl+G`

(Input)-->[Gain1]-->[Sum]-->[Integrator]-->[Gain2]--> (Output)
                       ^                      |
                       |                      |
                       +-------[Gain3]--------+

Après `Ctrl+G`

(Input)-->[Mon_Sous_Systeme]--> (Output)

4.2 Masks (Masques)

Créer une UI Custom

Un "Mask" (Masque) est une interface utilisateur (UI) personnalisée que l'on place *par-dessus* un bloc ou un Subsystem.

Usage : Permet de cacher la complexité interne et de n'exposer que les paramètres importants (ex: Masse (M), Raideur (K)).

Création

Clic droit sur un Subsystem -> Mask -> Create Mask (ou Ctrl+M).
Onglet "Parameters" : Ajoutez vos contrôles (ex: un "Edit" pour la variable Masse).
Onglet "Code" : (Optionnel) Code MATLAB pour initialiser.
Onglet "Icon" : (Optionnel) Code pour dessiner l'icône du bloc.

Avant (Subsystem simple)

Double-clic : Ouvre le schéma interne (compliqué).

Après (Bloc Masqué)

Double-clic : Ouvre une pop-up "Parameters" (simple).

+-------------------------+
| Masse (M): [ 10  ] (kg) |
| Raideur (K): [ 50  ] (N/m)|
| [ OK ] [Cancel]         |
+-------------------------+

4.3 Exemple : PID Controller

Schéma de régulation (Boucle fermée)

Le but est de forcer un "Système" (ex: un moteur) à suivre une "Consigne" (ex: 100 rad/s).

         (Consigne)
(Step)----->+-----------+  (Commande)   +-------------+  (Mesure)
          | Sum       |------------->| PID         |------------->| Système     |----+
          | (+ -)     |              | (P, I, D)   |              | (Transfer Fcn)|    |
          +-----------+              +-------------+              +-------------+    |
              ^ (Erreur)                                                          |
              |                                                                   |
              +-------------------------------------------------------------------+
                                   (Feedback)

Résultat (Scope)

Le Scope (avec 2 entrées) montre la Consigne (bleu) et la Mesure (jaune). Un PID bien réglé fait converger la Mesure vers la Consigne, en minimisant l'erreur, le dépassement (overshoot) et le temps de réponse.

4.4 Exemple : Modèle Physique (Masse-Ressort)

Équation Différentielle (ODE)

Système Masse-Ressort-Amortisseur : $F = m\ddot{x} + c\dot{x} + kx$

Pour modéliser, on isole la dérivée la plus haute (l'accélération) :
$\ddot{x} = \frac{1}{m} (F - c\dot{x} - kx)$

Puis on intègre 2 fois pour trouver $x$ :
$\dot{x} = \int \ddot{x} dt$
$x = \int \dot{x} dt$

Diagramme-bloc (Résolution d'ODE)

(F)-->+-------+   (F - cx' - kx)   +------+   (1/m)   +--------+ (x'') +------------+ (x') +------------+ (x)
      | Sum   |------------------->| Gain |---------->| Gain   |------>| Integrator |----->| Integrator |----+
      | (+--)|                   +------+           +--------+       | (1/s)      |      | (1/s)      |    |
      +-------+                                      (1/M)           +------------+      +------------+    |
          ^                                                                |                   |
          |                                                                |                   |
          |  +-------+         +------+                                    |                   |
          +--| Gain  |<--------| Mux  |<----------------------------------+                   |
             | ( [c k] )     +------+                                                        |
             +-------+                                                                       |
                                                                                             |
                                                                                             +---------------+
                                                                                                             |
                                                                                                             ▼
                                                                                                       [Scope]

(Note: Un diagramme plus simple utilise deux boucles de feedback séparées pour c et k vers le bloc Sum).

5.1 Interaction : MATLAB <-> Simulink

`To Workspace` (Simulink -> MATLAB)

Ce bloc "Sink" enregistre un signal (ex: la sortie de votre simulation) dans une variable du Workspace MATLAB à la fin de la simulation.

Configuration :

Variable name : mon_resultat
Save format : Timeseries (recommandé) ou Array.

... -> [Gain] -> [To Workspace] (var: 'mon_resultat')

% (Après 'Run')
>> plot(mon_resultat)

`From Workspace` (MATLAB -> Simulink)

Ce bloc "Source" injecte un signal (défini dans le Workspace) dans Simulink.

% (Avant 'Run', dans MATLAB)
>> t = (0:0.01:10)';
>> u = sin(t);
>> mon_signal_entree = [t, u]; % Format [Temps, Valeur]

% (Dans Simulink)
[From Workspace] (var: 'mon_signal_entree') -> [Integrator] -> ...

`sim()` (Contrôler depuis MATLAB)

Permet de lancer une simulation Simulink (.slx) depuis un script MATLAB (.m). Indispensable pour les tests paramétriques (boucles for).

% script_test.m

% 1. Définir des paramètres
Gain_K = 10;
Temps_Stop = 5;

% 2. Lancer la simulation 'mon_modele.slx'
% (Utilise les variables 'Gain_K' et 'Temps_Stop'
%  définies dans le Workspace)
out = sim('mon_modele.slx');

% 3. 'out' est une structure contenant
%    les signaux de sortie (To Workspace, etc.)
plot(out.mon_resultat);

5.2 MATLAB Function Block

Écrire du code MATLAB dans Simulink

Parfois, il est plus simple d'écrire une logique complexe (if/else, for) avec du code MATLAB que de dessiner des blocs logiques.

Le bloc **MATLAB Function** (Simulink > User-Defined Functions) permet cela.

Exemple : Logique "Saturation"

(Input)-->[MATLAB Function]--> (Output)

Double-cliquer sur le bloc ouvre un éditeur :

function y = fcn(u, min_val, max_val)
%#codegen (requis pour la compilation)
    
    if u > max_val
        y = max_val;
    elseif u < min_val
        y = min_val;
    else
        y = u;
    end

end

5.3 Stateflow (Machines à États)

Logique Événementielle

Simulink est excellent pour les flux de données (continu), mais mauvais pour la logique de contrôle (if/else, "états").

Stateflow est une Toolbox (séparée) pour modéliser des **machines à états** (logique de supervision).

Usage : "Mode de vol" (Décollage, Croisière, Atterrissage), "Gestion d'alarme" (Normal, Alerte, Urgence), "Logique d'un feu tricolore".

Exemple (Feu tricolore)

+-------------------------+
| État: Vert              |
| entry: led_vert = 1;    |
| exit: led_vert = 0;     |
+-------------------------+
       |
       | [after(30, sec)]  (Transition)
       ▼
+-------------------------+
| État: Orange            |
| entry: led_orange = 1;  |
| exit: led_orange = 0;   |
+-------------------------+
       |
       | [after(5, sec)]
       ▼
+-------------------------+
| État: Rouge             |
| ...                     |
+-------------------------+

5.4 Simulink Coder (Génération de code)

Du Modèle au Code Embarqué

Le but ultime du "Model-Based Design" (MBD) est de générer le code C/C++ (optimisé) *directement* depuis le modèle Simulink, pour le déployer sur une cible (microcontrôleur, ECU...).

Cela garantit que le code sur la cible est 100% identique à ce qui a été simulé.

Processus (`Ctrl+B`)

Modèle : Doit utiliser un solveur Fixed-step.
Configuration (Ctrl+E) : Onglet "Code Generation".
Target : Choisir la cible (ex: ert.tlc pour Embedded Coder).
Build (Ctrl+B) : Simulink génère des milliers de lignes de code C et (optionnellement) le compile pour la cible.

6.1 Cheat-sheet (Simulink)

Raccourcis Clavier

(Cliquer sur la toile, taper le nom...)
(ex: 'integ' -> 'Integrator')

Ctrl+E     : Ouvrir Configuration (Solver)
Ctrl+G     : Créer un Subsystem
Ctrl+M     : Créer un Mask
Ctrl+Shift+L : Ouvrir Library Browser
Spacebar   : Plein écran (Bloc sélectionné)
R (clic)   : Rotation d'un bloc

Blocs Incontournables

Bloc	Bibliothèque
Scope	Sinks
Constant	Sources
Step	Sources
Sine Wave	Sources
Gain	Math Operations
Sum	Math Operations
Integrator (1/s)	Continuous
Transfer Fcn	Continuous
Unit Delay	Discrete
To Workspace	Sinks
From Workspace	Sources
MATLAB Function	User-Defined

⚙️ Simulink – Modélisation & Simulation (MATLAB)

Vue d'ensemble

Installation (Toolbox)

Environnement

Concepts de base

Premier Modèle

Solveurs (ODE)

Sources & Sinks

Blocs Mathématiques

Blocs Continus

Blocs Discrets

Subsystems (Sous-systèmes)

Masks (Masques)

Exemple : PID Controller

Exemple : Physique (Masse)

MATLAB <-> Simulink

MATLAB Function Block

Stateflow

Simulink Coder

Cheat-sheet

⚙️ Simulink – Modélisation & Simulation (MATLAB)

Vue d'ensemble

Installation (Toolbox)

Environnement

Concepts de base

Premier Modèle

Solveurs (ODE)

Sources & Sinks

Blocs Mathématiques

Blocs Continus

Blocs Discrets

Subsystems (Sous-systèmes)

Masks (Masques)

Exemple : PID Controller

Exemple : Physique (Masse)

MATLAB <-> Simulink

MATLAB Function Block

Stateflow

Simulink Coder

Cheat-sheet

Modélisation Graphique & Simulation

Cas d'usage principaux

MATLAB vs. Simulink

Simulink est une Toolbox MATLAB

Installation

Toolboxes Simulink Essentielles

Lancement

Les 3 Fenêtres Clés

1. Modèle (.slx)

2. Blocs (Blocks)

3. Signaux (Signals)

"Hello World" de Simulink

Diagramme-bloc

Résultat (Fenêtre "Scope")

Le "moteur" de la simulation

Solveurs à pas Variable (Variable-step)

Solveurs à pas Fixe (Fixed-step)

Sources (Entrées du système)

Sinks (Sorties / Visualisation)

Blocs "Math Operations"

Exemple : Sum

Blocs Continus Principaux

Exemple : Résolution d'ODE

Blocs Discrets Principaux

Abstraction & Hiérarchie

Création

Avant Ctrl+G

Après Ctrl+G

Créer une UI Custom

Création

Avant (Subsystem simple)

Après (Bloc Masqué)

Schéma de régulation (Boucle fermée)

Résultat (Scope)

Équation Différentielle (ODE)

Diagramme-bloc (Résolution d'ODE)

To Workspace (Simulink -> MATLAB)

From Workspace (MATLAB -> Simulink)

sim() (Contrôler depuis MATLAB)

Écrire du code MATLAB dans Simulink

Exemple : Logique "Saturation"

Logique Événementielle

Exemple (Feu tricolore)

Du Modèle au Code Embarqué

Processus (Ctrl+B)

Raccourcis Clavier

Blocs Incontournables

1. Modèle (`.slx`)

Exemple : `Sum`

Avant `Ctrl+G`

Après `Ctrl+G`

`To Workspace` (Simulink -> MATLAB)

`From Workspace` (MATLAB -> Simulink)

`sim()` (Contrôler depuis MATLAB)

Processus (`Ctrl+B`)