TP DASSERVISSEMENT ET DE

REGULATION PAR MATLAB

Dr NGOUABO Ulrich
 MEMBRES DU GROUPE

WAFEU Edouard
FOGUE CHOUDJA Borice
KUATE WAFO Dilane Narcice
NONO KOUAM Fabrel Aran
FOTSO CHATUE William
TP N°1 : instructions usuelles du logiciel Matlab
EXERCICE1 :

1. Créer la matrice

A = [4, 5, 6; 7, 8, 3; 0, 0, 2];

A=

4 5 6

7 8 3

0 0 2

2. Calculer le déterminant

det_A = det(A);
det_A =

-6.0000

3. Calculer la transposée

B = A';

B=

4 7 0

5 8 0

6 3 2

4. Calculer l’inverse

C = inv(A);

C=

-2.6667 1.6667 5.5000

2.3333 -1.3333 -5.0000

0 0 0.5000

5. Calculer (produit matriciel)

D = A * B;

D=

77 86 12

86 122 6

12 6 6
6. Calculer (multiplication scalaire)

E = 3 * A;

E=

12 15 18

21 24 9

0 0 6

7. Calculer la matrice (produit terme à terme

F = A .* B;

F=

16 35 0

35 64 0

0 0 4

8. Créer la matrice identité de même dimension

I = eye(size(A));

I=

1 0 0

0 1 0

0 0 1
9. Créer une matrice de dimension remplie de 1

G = ones(15, 10);

G=

1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1 1 1

10. Sauvegarder les matrices dans un fichier nommé [Link]

save('[Link]', 'A', 'B', 'C');

11. Effacer toutes les variables et vérifier

clear;

disp('Toutes les variables ont été effacées.');

whos; % Vérifie les variables en mémoire (doit être vide)

12. Restaurer les matrices

load('[Link]');

disp('Matrices A, B, C restaurées :');

disp(A);

disp(B);

disp(C);

Exercice N°2

1. Créer la matrice

F2 = [1, 2, 3; 4, 5, 6; 0, 9, 1];

F2 =

1 2 3

4 5 6

0 9 1
2. Créer la matrice

G = [F2, zeros(3, 3); ones(3, 3), eye(3)];

G=

1 2 3 0 0 0

4 5 6 0 0 0

0 9 1 0 0 0

1 1 1 1 0 0

1 1 1 0 1 0

1 1 1 0 0 1

3. Déterminer la taille de 

taille_G = size(G);

G=6 6

4. Remplacer la dernière colonne par le vecteur

G(:, end) = [7; 8; 9; 10; 5; 7];

G=

1 2 3 0 0 7
 4 5 6 0 0 8

0 9 1 0 0 9

1 1 1 1 0 10

1 1 1 0 1 5

1 1 1 0 0 7

5. Extraire les lignes 2 et 4, et les colonnes 2 et 6

sous_matrice = G([2, 4], [2, 6]);

sous_matrice =

5 8

1 10

6. Comparer les opérations

• Produit matriciel

W = F2 * F2';

W=

14 32 21

32 77 51

21 51 82

• Produit terme à terme

M = F2 .* F2;

M=
 1 4 9

16 25 36

0 81 1

• Puissance matricielle

N = F2^3;

N=

165 375 279

372 915 642

252 837 487

• Puissance terme à terme

T = F2 .^ 3;

T=

1 8 27

64 125 216

0 729 1

• Exponentielle terme à terme

I = exp(F2);

I = 1.0e+03 *

0.0027 0.0074 0.0201

 0.0546 0.1484 0.4034

0.0010 8.1031 0.0027

• Racine carrée terme à terme

J = sqrt(F2);

J=

1.0000 1.4142 1.7321

2.0000 2.2361 2.4495

0 3.0000 1.0000

TP N2 : instructions polynômes &graphisme.

Exercice 1 : Calculs sur les polynômes

[Link] afficher l’aide des fonctions mentionnées :

help poly % Création de polynômes

help roots % Calcul des racines

help conv % Multiplication des polynômes

help deconv % Division des polynômes

help polyder % Dérivée des polynômes

help polyval % Évaluation des polynômes

2. Entrer les polynômes :

p = [10 0 -2 0 10 0]; % p(x) = 10x^5 - 2x^3 + 10x

q = [1 0 4]; % q(x) = x^2 + 4

p = 10 0 -2 0 10 0

q=1 0 4

3. Construire un polynôme avec les racines données :

S = poly([-1, -5, -6]); % Racines : -1, -5, -6

J=

1.0000 1.4142 1.7321

2.0000 2.2361 2.4495

0 3.0000 1.0000

4. Calculer les racines des polynômes p et q :

roots_p = roots(p);

roots_p =

0.0000 + 0.0000i

-0.7416 + 0.6708i

-0.7416 - 0.6708i

0.7416 + 0.6708i

0.7416 - 0.6708i
roots_q = roots(q);

roots_q =

0.0000 + 2.0000i

0.0000 - 2.0000i

5. Calculer la dérivée de p :

p_prime = polyder(p);

p_prime =

50 0 -6 0 10

6. Calculer le produit de p et q :

product_pq = conv(p, q);

product_pq =

10 0 38 0 2 0 40 0

7. Calculer le quotient et le reste de la division de p par q :

q[quotient, reste] = deconv(p,);

disp('Quotient de p par q :');

disp(quotient);

disp('Reste de p par q :');

disp(reste);

8. Évaluer les valeurs de p en 0 et -1 :

val_p0 = polyval(p, 0);

val_p1 = polyval(p, -1);

disp('Valeur de p en 0 :');

disp(val_p0);

disp('Valeur de p en -1 :');

disp(val_p1);

9. Tracer la courbe de y = p(x) sur [-10, 10] :

x = linspace(-10, 10, 1000); % Intervalle [-10, 10]

y = polyval(p, x);

figure;

plot(x, y, 'r', 'LineWidth', 1.5);

grid on;

xlabel('x');

ylabel('y = p(x)');

title('Tracé de y = p(x) sur [-10, 10]');

Exercice 2 : Représentation Graphique

1. Créer un vecteur temps et tracer

t = -1:0.01:1; % Vecteur temps avec un pas de 0.01

f1 = sin(t) .* exp(-2*t);

figure(1);

plot(t, f1, 'r-*', 'LineWidth', 1.5);

grid on;

xlabel('Temps (s)');

ylabel('Amplitude (V)');

title('Courbe de f_1(t) = sin(t)exp(-2t)');

2. Tracer

f1 = sin(t) .* exp(-2*t); % f1(t)

f2 = -sin(t) .* exp(-2*t); % f2(t)

f3 = exp(-2*t); % f3(t)

f4 = -exp(-2*t); % f4(t)

figure(2);

plot(t, f1, 'b', 'LineWidth', 1.5); hold on;

plot(t, f2, 'g', 'LineWidth', 1.5);

plot(t, f3, 'r', 'LineWidth', 1.5);

plot(t, f4, 'c', 'LineWidth', 1.5);

grid on;

xlabel('Temps (s)');

ylabel('Amplitude');

title('Tracé de f_1, f_2, f_3 et f_4');

legend('f_1(t)', 'f_2(t)', 'f_3(t)', 'f_4(t)');

3. Utiliser SUBPLOT pour afficher , ,  dans une même fenêtre :

figure(3);

subplot(3, 1, 1);

plot(t, f1, 'b', 'LineWidth', 1.5);

title('f_1(t) = sin(t)exp(-2t)');

grid on;

subplot(3, 1, 2);

plot(t, f2, 'g', 'LineWidth', 1.5);

title('f_2(t) = -sin(t)exp(-2t)');

grid on;

subplot(3, 1, 3);

plot(t, f3, 'r', 'LineWidth', 1.5);

title('f_3(t) = exp(-2t)');

grid on;
xlabel('Temps (s)');

Explications :

1. Chaque étape du calcul sur les polynômes utilise les fonctions MATLAB appropriées pour :

• Créer, dériver, multiplier et diviser des polynômes.

2. La partie graphique utilise les fonctions plot et subplot pour afficher les courbes demandées.

3. Les couleurs et légendes sont adaptées pour chaque fonction.

TP N°3 : “Représentation des Systèmes Dynamiques Linéaires”.

Travail de Préparation : Équations Différentielles

Les circuits R-C et R-L sont régis par des équations différentielles du premier ordre :

1. Circuit R-C (Résistance-Capacité) :

• Équation différentielle :

En dérivée, cela devient :

2. Circuit R-L (Résistance-Inductance) :

• Équation différentielle :

Cela devient :
Programmation MATLAB

1. Tracé de pour le circuit

Paramètres :(échelon unitaire).

Solution analytique pour un circuit R-C soumis à une tension échelon :

Code MATLAB :

% Paramètres

R1 = 1000; % Résistance en ohms

C1 = 0.9e-6; % Capacité en Farads

Vin = 1; % Échelon unitaire

tau = R1 * C1; % Constante de temps

% Temps

t = linspace(0, 5e-3, 1000); % Intervalle de temps [0, 5 ms]

Vc1 = Vin * (1 - exp(-t / tau)); % Solution analytique

% Tracé

figure;

plot(t, Vc1, 'r', 'LineWidth', 1.5);

grid on;
xlabel('Temps (s)');

ylabel('Tension V_{C1}(t) (V)');

title('Tension aux bornes du condensateur pour R1-C1');

2. Tracé de pour le circuit

La tension aux bornes de la résistance est donnée par :

Code MATLAB :

% Tension aux bornes de la résistance

VR1 = Vin * exp(-t / tau);

% Tracé

figure;

plot(t, VR1, 'b', 'LineWidth', 1.5);

grid on;

xlabel('Temps (s)');

ylabel('Tension V_{R1}(t) (V)');

title('Tension aux bornes de la résistance pour R1-C1');

3. Tracé de pour le circuit

Paramètres :
La solution analytique pour le courant dans un circuit R-L est donnée par :

La tension aux bornes de l’inductance est :

Code MATLAB :

% Paramètres

R2 = 100; % Résistance en ohms

L = 70e-3; % Inductance en Henrys

tau_L = L / R2; % Constante de temps

% Tension aux bornes de l'inductance

VL = Vin * exp(-t / tau_L);

% Tracé

figure;

plot(t, VL, 'g', 'LineWidth', 1.5);

grid on;

xlabel('Temps (s)');

ylabel('Tension V_{L}(t) (V)');

title('Tension aux bornes de l inductance pour R2-L');

4. Tracé de pour le circuit

Le courant dans le circuit R-L est :

Code MATLAB :

% Courant dans le circuit R-L

I = (Vin / R2) * (1 - exp(-t / tau_L));

% Tracé

figure;

plot(t, I, 'm', 'LineWidth', 1.5);

grid on;

xlabel('Temps (s)');

ylabel('Courant I(t) (A)');

title('Courant dans le circuit R2-L');

Résultat attendu :

1. Tracé de la tension pour le circuit R-C.

2. Tracé de la tension pour le circuit R-C.

3. Tracé de la tension pour le circuit R-L.

4. Tracé du courant pour le circuit R-L.

Ces graphiques montrent la réponse temporelle des circuits R-C et R-L pour une entrée échelon.
TP N4: repartions des systèmes dynamiques linéaires a l’aide des fonctions de transfert
Par exemple :

help tf

help zpk

help tf2ss

help tf2zp

2. Créer un fichier de commande (script) :

Créez un fichier tp3ex1.m dans MATLAB avec les commandes nécessaires :

% Déclaration des fonctions de transfert

num1 = [5 5];

den1 = [1 8 17 10];

f1 = tf(num1, den1); % Fonction f1(s)

num2 = [10];

den2 = [1 2 3 1];

f2 = tf(num2, den2); % Fonction f2(s)

% Affichage des fonctions de transfert

disp('Fonction f1(s):');

f1
disp('Fonction f2(s):');

f2Fonction f1(s):

f1 =

5s+5

-----------------------

s^3 + 8 s^2 + 17 s + 10

Continuous-time transfer function.

Fonction f2(s):

f2 =

10

---------------------

s^3 + 2 s^2 + 3 s + 1

Continuous-time transfer function.

Fonction f1(s):
 3. Introduire sous MATLAB :

Les commandes ci-dessus introduisent sous forme de fonctions de transfert.

4. Donner les pôles des deux systèmes :

Utilisez la fonction pole pour extraire les pôles :

% Calcul des pôles

p1 = pole(f1);

p2 = pole(f2);

disp('Pôles de f1(s):');

disp(p1);

disp('Pôles de f2(s):');

disp(p2);

5. Introduire en utilisant la commande ZPK :

peut être introduit en forme ZPK :

% Déclaration de f3(s) en forme ZPK

gain = 4.25;

zeros_f3 = [];
poles_f3 = [-0.3 -1 -5];

f3 = zpk(zeros_f3, poles_f3, gain);

disp('Fonction f3(s) en forme ZPK:');

f3

6. Passage à la forme ZPK

Utilisez zpk pour convertir les fonctions en forme zéro-pôle-gain :

% Conversion en forme ZPK

zpk_f1 = zpk(f1);

zpk_f2 = zpk(f2);

disp('f1(s) en forme ZPK:');

zpk_f1

disp('f2(s) en forme ZPK:');

zpk_f2

7. Passage à la forme d’état

Utilisez tf2ss pour convertir les fonctions de transfert en forme d’état :

% Conversion en forme d'état

[A1, B1, C1, D1] = tf2ss(num1, den1);

[A2, B2, C2, D2] = tf2ss(num2, den2);

disp('Forme d''état pour f1(s):');

A1, B1, C1, D1

disp('Forme d''état pour f2(s):');

A2, B2, C2, D2

8. Passage de la forme ZPK à la forme d’état

Utilisez directement zpk2ss :

% Conversion ZPK vers forme d'état

[A3, B3, C3, D3] = zpk2ss(zeros_f3, poles_f3, gain);

disp('Forme d''état pour f3(s):');

A3, B3, C3, D3

9. Enregistrer l’espace d’état sous un fichier .mat :

Utilisez save pour sauvegarder :

% Enregistrer les variables dans un fichier .mat

save('f3_etat.mat', 'A3', 'B3', 'C3', 'D3');

Résumé des commandes clés :

 • Déclaration des fonctions de transfert : tf

• Passage à la forme ZPK : zpk

• Passage à la forme d’état : tf2ss, zpk2ss

• Calcul des pôles : pole

• Enregistrement de fichiers : save

Pour l’Exercice N°2 : Construction de Schémas Fonctionnels

1. Aide sur les commandes series, parallel et feedback

Utilisez la commande help pour obtenir l’aide MATLAB sur ces fonctions :

help series

help parallel

help feedback

2. Créer un fichier de commande tp3ex2.m

Créez un script avec toutes les commandes de cet exercice :

% tp3ex2.m - Construction des schémas fonctionnels

% Définition des fonctions de transfert

F4 = tf([1 1], [1 3 1]); % F4(s) = (s+1)/(s^2 + 3s + 1)

F5 = tf([1], [5 1]); % F5(s) = 1/(5s + 1)

F6 = tf([1], [1 1]); % F6(s) = 1/(s + 1)

% 3. Fonction de transfert en boucle ouverte

H_open = series(F4, F5); % Produit en série de F4(s) et F5(s)

disp('Fonction de transfert en boucle ouverte :');

H_open

% 4. Fonction de transfert en boucle fermée

H_closed = feedback(H_open, F6); % Boucle fermée avec F6(s) en retour

disp('Fonction de transfert en boucle fermée :');

H_closed

3. Donner la fonction de transfert en boucle ouverte

La commande series permet d’obtenir la fonction en boucle ouverte :

MATLAB calcule automatiquement la fonction en série.

4. Donner la fonction de transfert en boucle fermée

Utilisez la commande feedback pour la boucle fermée.

La formule théorique de boucle fermée est :

MATLAB réalise ce calcul directement.

5. Vérifier le résultat analytiquement

Comparez les résultats obtenus dans MATLAB avec les calculs analytiques manuels. MATLAB affiche les polynômes numérateur et
dénominateur pour vérification.

6. Calculer les pôles de la fonction de transfert en boucle fermée

Utilisez la fonction pole pour obtenir les pôles :

poles_closed = pole(H_closed);

disp('Pôles de la fonction en boucle fermée :');

disp(poles_closed);

7. Conversion vers les formes ZPK et SS

• Forme ZPK (zéro-pôle-gain) :

H_closed_zpk = zpk(H_closed);

disp('Fonction de transfert en forme ZPK :');

H_closed_zpk
 • Forme d’état (SS - State Space) :

[A, B, C, D] = tf2ss(H_closed.Numerator{1}, H_closed.Denominator{1});

disp('Forme d''état (SS) :');

A, B, C, D

8. Enregistrer l’espace de travail dans [Link]

Utilisez save pour sauvegarder toutes les variables de l’exercice :

save('[Link]');

Résumé des commandes utilisées :

• Séries de deux fonctions de transfert : series

• Retour unitaire (boucle fermée) : feedback

• Pôles : pole

• Forme zéro-pôle-gain : zpk

• Forme d’état : tf2ss

• Enregistrement des données : save

 TPN°5 : Génération des différents signaux d’entrées
sous MATLAB.

Objectif :

Ce TP vise à savoir programmer des signaux d'entrée sous MATLAB, tels que le signal carré,
triangulaire, dent de scie, et d'autres types de signaux périodiques. L’objectif est de comprendre
et de manipuler les étapes complètes pour générer ces signaux à l'aide de MATLAB.

Travail demandé :

1. Signal d'échelon unitaire :

Un signal d'échelon unitaire passe de 0 à 1 à partir de .

2. Signal Sinusoïdal Périodique :

Un signal sinusoïdal de la forme .

3. Signal Carré Périodique :

Un signal carré de période , où le signal prend alternativement les valeurs 1 et -1.

4. Signal Triangulaire Périodique :

Un signal périodique dont la forme est une fonction triangulaire.

5. Signal Dent de Scie :

Un signal périodique qui croît linéairement avec le temps, puis se réinitialise brusquement.

6. Autres Signaux Périodiques :

Cela pourrait inclure un signal carré avec une fréquence modifiée ou d'autres formes similaires.

7. Comparaison avec les instructions MATLAB :

1. Échelon Unitaire

L’échelon unitaire peut être généré avec la fonction heaviside :

t = -2:0.01:5; % Temps de -2 à 5 secondes

u = heaviside(t); % Fonction échelon unitaire
figure;
plot(t, u);
title('Échelon Unitaire');
xlabel('Temps (s)');
ylabel('Amplitude');
grid on;

C0MMENTAIRE:
X (Temps): L'axe des abscisses représente le temps, mesuré en secondes.
Y (Amplitude) : L'axe des ordonnées représente l'amplitude du signal, variant de 0 à 1.
La courbe représente un échelon unitaire, un type de signal couramment utilisé en traitement du
signal et dans l'analyse des systèmes dynamiques
2. Signal Sinusoïdal Périodique

Utilisation de la fonction sin pour générer un signal sinusoïdal :

t = 0:0.01:10; % Temps de 0 à 10 secondes

f = 1; % Fréquence en Hz
y = sin(2*pi*f*t); % Signal sinusoïdal
figure;
plot(t, y);
title('Signal Sinusoïdal Périodique');
xlabel('Temps (s)');
ylabel('Amplitude');
grid on;
C0MMENTAIRE:
X (Temps): L'axe des abscisses représente le temps, mesuré en secondes.
Y (Amplitude): L'axe des ordonnées représente l'amplitude du signal, oscillant entre -1 et 1.
La courbe représente un signal sinusoïdal périodique, qui est l'un des types de signaux les plus
fondamentaux et couramment utilisés en ingénierie.
3. Signal Carré Périodique

La fonction square est utilisée pour créer un signal carré :

t = 0:0.01:5; % Temps de 0 à 5 secondes

f = 1; % Fréquence en Hz
y = square(2*pi*f*t); % Signal carré
figure;
plot(t, y);
title('Signal Carré Périodique');
xlabel('Temps (s)');
ylabel('Amplitude');
grid on;
C0MMENTAIRE :
Signal Carré : Caractérisé par des transitions abruptes entre deux niveaux d'amplitude, idéal pour
tester la réponse des systèmes à des changements brusques.
Signal Triangulaire :Comportant des montées et descentes linéaires, utile pour analyser la réponse
des systèmes à des variations continues et linéaires.
4. Signal Périodique Triangulaire

Utilisez la fonction sawtooth avec un paramètre pour un signal triangulaire :

t = 0:0.01:5; % Temps de 0 à 5 secondes

f = 1; % Fréquence en Hz
y = sawtooth(2*pi*f*t, 0.5); % Signal triangulaire (0.5 pour une forme symétrique)
figure;
plot(t, y);
title('Signal Périodique Triangulaire');
xlabel('Temps (s)');
ylabel('Amplitude');
grid on;
C0MMENTAIRE :
Visualisation: La grille activée dans le graphique permet une meilleure lisibilité, facilitant l'analyse
des points de transition et la mesure de la période du signal.
Utilisation de MATLAB: L'utilisation de MATLAB pour générer et tracer ces signaux permet de
visualiser rapidement leur comportement et de les comparer avec d'autres types de signaux, ce
qui est crucial pour des applications pratiques en ingénierie.
En résumé, cette courbe montre efficacement les caractéristiques distinctives d'un signal
triangulaire périodique et ses utilisations potentielles dans divers domaines de l'ingénierie et des
sciences appliquées.
5. Signal Marche d’Escalier

Un signal discret en escalier peut être construit manuellement :

t = [Link]; % Temps discret avec pas de 1 seconde

y = floor(t/2); % Signal en escalier
figure;
stairs(t, y); % Utilisez stairs pour un affichage en escalier
title('Signal Marche d''Escalier');
xlabel('Temps (s)');
ylabel('Amplitude');
grid on;
C0MMENTAIRE :
X (Temps):L'axe des abscisses représente le temps, mesuré en secondes (de 0 à 10 s).
Y (Amplitude): L'axe des ordonnées représente l'amplitude du signal, variant de 0 à 5.
La courbe montre un signal marche d'escalier, un type de signal où l'amplitude change par paliers
successifs à des intervalles de temps réguliers.
6. Proposer d’autres signaux périodiques

Par exemple : Signal en dent de scie :

t = 0:0.01:5; % Temps de 0 à 5 secondes

f = 1; % Fréquence en Hz
y = sawtooth(2*pi*f*t); % Signal en dent de scie
figure;
plot(t, y);
title('Signal en Dent de Scie');
xlabel('Temps (s)');
ylabel('Amplitude');
grid on;
C0MMENTAIRE :
X (Temps):L'axe des abscisses représente le temps, mesuré en secondes.
Y (Amplitude):L'axe des ordonnées représente l'amplitude du signal, avec des valeurs variant de -
1 à 1.
La courbe montre un signal en dent de scie, caractérisé par une montée linéaire de l'amplitude
suivie d'une chute brusque. Ce motif se répète périodiquement, formant une séquence de
montées et de descentes linéaires régulières.
7. Comparer avec des instructions MATLAB intégrées

Les instructions intégrées pour générer ces signaux sont :

• heaviside : Échelon unitaire
• sin : Sinusoïdal
• square : Signal carré
• sawtooth : Signal triangulaire et dent de scie

Exemple de comparaison :

% Signal triangulaire manuel vs intégré

t = 0:0.01:5;
y_manual = sawtooth(2*pi*t, 0.5); % Triangulaire avec sawtooth
y_built = triang(length(t)); % Triangulaire intégré

figure;
plot(t, y_manual, 'r', 'LineWidth', 1.5); hold on;
plot(t, y_built, 'b--', 'LineWidth', 1.5);
title('Comparaison Signal Triangulaire : Manuel vs Intégré');
legend('Manuel (sawtooth)', 'Intégré (triang)');
grid on;

C0MMENTAIRE:
X (Temps): L'axe des abscisses représente le temps, mesuré en secondes.
Y (Amplitude): L'axe des ordonnées représente l'amplitude du signal, variant de -1 à 1.
La courbe compare deux signaux triangulaires différents :
Signal Manuel (Ligne Rouge Continue) : Généré manuellement en utilisant la fonction `sawtooth`
avec un paramètre ajusté pour produire un signal triangulaire.
Signal Intégré (Ligne Noire Pointillée): Utilise une fonction MATLAB intégrée, probablement
`triangle pour produire un signal triangulaire.
Instructions Utiles MATLAB

• heaviside : Échelon unitaire

• sin, cos : Sinusoïdal
• square : Signal carré
• sawtooth : Dent de scie / triangulaire
• stairs : Marche d’escalier
• triang : Génération de formes triangulaires