Université Ibn Zohr

Faculté des Sciences Appliquées

Génie Informatique et Systèmes Intelligents

Année Universitaire : 2024/2025

Module : Traitement du signal
TC : Informatique Appliquée - S2

Plan du TP N°1

Titre du TP :
Introduction à Matlab

Public cible :
Les étudiants en Licence sciences et techniques.

Niveau : Première année.

Objectifs :

A la fin de la séance de travaux pratiques l’étudiant doit être capable de :

➢ Manipuler le logiciel Matlab ;

➢ Générer des signaux.

Pré-requis :

➢ L’informatique
➢ Programmation

Réalisé par : Rachid FATEH

Page 1 sur 17
1 Objectif
Matlab est un outil très important dans l'analyse de signaux, et sera beaucoup utilisée dans
ce cours. Le but du premier laboratoire est d'acquérir une familiarité avec Matlab et des
aptitudes de base. Ce laboratoire n'est qu'une introduction ; la section d'aide de Matlab
(appuyer sur F1 dans Matlab) est très complète avec beaucoup d'exemples. Les trois
objectifs principaux de ce laboratoire sont :

1. Apprendre à utiliser le système d'aide de Matlab,

2. Apprendre à écrire ses propres fonctions et fichiers m,
3. Approfondir les techniques pour dessiner des graphes

2 Introduction
2.1 Interface
Après avoir démarré Matlab, l’interface devrait ressembler à la figure suivante.

Les différentes fenêtres sont :

Les commandes Matlab sont tapées dans la «Command Window»

• Workspace : permet de voir les variables (taille, minimum, maximum)
• Current Directory : permet de changer de répertoire.
• Command History : Affiche les commandes utilisées.

Page 2 sur 17
2.2 Commandes de base
Voici quelques exercices de base :

1. Essayer un peu le système d'aide de Matlab. Essayer les commandes suivantes :

help plot

help colon

help zeros

doc plot

2. Utiliser Matlab comme une calculatrice. Essayer les commandes suivantes :

pi*pi - 10

sin(pi/4)

ans ^2

3. Une variable peut stocker une valeur ou une matrice dans Matlab. Essayer les commandes
suivantes :

x = sin(pi/5);

cos(pi/5)

y = sqrt(1-x*x)

ans

4. Les nombres complexes sont très faciles à utiliser dans Matlab. Essayer les commandes
suivantes :

z = 3 + 4i

conj(z)

abs(z)

angle(z)

real(z)

imag(z)

exp(sqrt(-1)*pi)

exp(j*[pi/4 -pi/4])

Page 3 sur 17
2.3 Calculs avec une fonction
Matlab enregistre des données en mémoire sous forme de vecteurs. Les données sont en
colonne. Par exemple, la commande t = [0 1 2] va placer en mémoire un vecteur de 3
colonnes. Les éléments de ces vecteurs sont numérotés à partir de 1. Donc, la commande
t(1) donne comme réponse 0.

Si on veut faire un vecteur ayant plusieurs éléments, par exemple pour tracer une courbe, on
utilise un deux-points « : » pour effectuer ceci.

Ex : on veut faire une séquence de points, de 0 à 8, en pas de 1. On peut utiliser :

t = [0 1 2 3 4 5 6 7 8];

ou bien, pour être plus rapide :

t = 0:8;

ce qui va créer un vecteur de 0 à 8, en pas de 1. Si on veut faire un vecteur qui a des pas de
0.5, la commande serait :

t = 0:0.5:8;

Le point-virgule à la fin de la commande indique à Matlab qu’on ne veut pas qu’il affiche le
résultat à l’écran. Sans le point-virgule, tous les éléments sont affichés à l’écran.

Page 4 sur 17
Cette méthode d’écrire une séquence permet de calculer des fonctions. Par exemple, si on
veut calculer la fonction x = sin(t), pour -2 < t < 2, on va taper :

t = -2*pi :0.001 :2*pi;

x = sin(t);

Pour chaque valeur de t, Matlab va calculer la valeur de sin(t) et appliquer le résultat dans la
variable x.

Si on veut calculer la fonction t sin(t), il faut utiliser « .* » pour faire la multiplication. Le .*

indique qu’on veut faire la multiplication point par point.

t = -2*pi :0.001 :2*pi;

x = t.*sin(t);

2.4 Fichiers .m
Les fichiers . m sont des fichiers où l’on peut mettre une série de commandes, qui seront
exécutées l’une après l’autre par Matlab.

Cliquer sur le bouton pour créer un nouveau fichier m, ou aller dans le menu New → Script.
L’éditeur ressemble à la fenêtre suivante :

On entre les commandes dans l’éditeur, un peu comme si on écrirait un programme en C.

Exemple :

Page 5 sur 17
Avant d’exécuter le programme, il faut sauvegarder le fichier. Il y a quelques restrictions
quant au nom que l’on peut donner au fichier. Le nom de fichier ne doit pas contenir de trait
d’union.

Pour exécuter le programme, on peut soit appuyer sur le bouton vert (qui ressemble à un
icône typique de «play» multimédia) ou taper le nom du fichier dans la ligne de commande.

Ou

2.5 Tracer des graphes

La commande la plus utilisée pour tracer des graphes est plot. Les arguments de cette
fonction sont, au plus simple, plot(x,y), où x contient les valeurs de l’axe x et y contient les
valeurs de l’axe y. La commande plot ouvrira automatiquement une nouvelle fenêtre qui
contient le graphe. Exemple :

Page 6 sur 17
Donne le graphe :

Question 1 : Tracer le graphe de la fonction 3tcos(5t), pour -1 < t < 2. Utiliser un pas de 0.01.

On n’a pas besoin d’utiliser un axe de temps qui est une séquence, si on veut tracer un
graphe simple. Il suffit de connaître les coordonnées des points.

Exemple : on veut tracer le graphe de la figure suivante :

1.5

0.5

-1 -0.5 0 0.5 1 1.5 2 2.5 3 3.5 4

Les commandes sont :

Page 7 sur 17
Remarquer qu’on a écrit les points du temps dans un vecteur, de façon consécutive, et aussi
pour les amplitudes (vecteur x).

Question 2 : Tracer le graphe de la fonction suivante, selon la méthode ci-haut.

1.5

0.5

-1 -0.5 0 0.5 1 1.5 2 2.5 3 3.5 4

Le grillage est appliqué au graphe avec la commande grid on.

2.6 Modifier les graphes

On peut modifier les graphes (changer la grosseur des lignes, la taille du texte, etc) de deux
façons : à l’aide de commandes dans le fichier m, ou à l’aide de la souris directement sur le
graphe.

L’avantage d’utiliser les commandes dans le fichier m, c’est si on fait plusieurs graphes, ils
auront tous la même apparence, et c’est plus rapide. Cependant, si on fait seulement un
graphe, il est souvent plus rapide de modifier le graphe.

Exemple :

La commande ‘r’ permet de tracer la courbe en rouge. D’autres options sont :

Page 8 sur 17
‘k’ pour noir, ou ‘o’ pour tracer les points, etc. La commande doc LineSpec

Donnera toutes les options nécessaires.

Question 3 : Tracer le graphe de la fonction 4t2 -2t + 1, pour -1 < t < 2. La courbe doit être en
vert, avec des cercles pour indiquer les points. Utiliser un pas de 0.1.

On peut aussi modifier la largeur des lignes et la grosseur des marqueurs directement dans
la commande plot.

Exemple :

Encore une fois, la commande doc LineSpec explique les différentes options possibles (c’est
environ au milieu de la page, sous la rubrique «Related Properties».

Question 4 : Tracer le graphe de la fonction 5e-0.4tcos(2t), pour 3 < t < 6. La courbe doit
être en rouge, avec des + pour indiquer les points, et les points doivent être de grosseur 12.
Utiliser un pas de 0.1.

Une dernière commande est la commande xlim (et ylim). Ces commandes permettent de
modifier l’affichage des courbes. Dans l’exemple suivant, on veut seulement afficher la
fonction sin(2t) entre 1 et 4s, même si on calcule la fonction pour plus long. Ceci permet,
d’une façon, d’effectuer un zoom sur une partie de fonction. La même chose s’applique pour
l’amplitude (ylim).

Question 5 : Tracer le graphe de la fonction 5e-0.4tcos(2t), pour 3 < t < 6. Afficher la courbe
seulement entre 4 et 6.5s. Utiliser un pas de 0.01.

Page 9 sur 17
2.7 Échelon dans Matlab
La fonction échelon est obtenue d’une façon un peu différente dans Matlab. On doit
modifier une fonction à l’aide d’un opérateur logique. L’échelon unitaire est obtenu selon :
(t >= 0)

Pour modifier une fonction par un échelon, il faut multiplier la fonction par l’opérateur
logique correspondant. Soit : x(t) = 2t*(u(t-1) – u(t-3)). Dans Matlab, on écrit :

Pour obtenir :

Question 6 : Tracer le graphe de la fonction 5e-0.4t(u(t-2) – u(t-4)), pour -1 < t < 6. Utiliser un
pas de 0.01.

2.8 Tracer plusieurs courbes sur un graphe

Il y a deux méthodes possibles pour tracer plus d’une courbe sur le même graphe. On peut
soit utiliser la commande hold on, ou bien écrire directement les arguments dans la même
commande plot. La syntaxe est (axe x 1, axe y 1, options1, axe x 2, axe y 2, options 2, etc…)

Page 10 sur 17
Exemple:

Remarquer que chaque courbe a son propre axe x. Même si c’est pareil pour chaque graphe,
il faut le spécifier quand même. Le graphe obtenu est le suivant :

Cependant, lorsqu’on utilise cette méthode, seulement certaines propriétés peuvent être
différentes pour chaque courbe. Les 3 seules propriétés qui peuvent être différentes sont : la
couleur de la ligne, le type de ligne (pointillé, etc) et le type de marqueur.

Si on veut que les lignes aient des grosseurs différentes, ou des marqueurs de différentes
taille, il faut utiliser la commande hold on. Exemple :

Donne le résultat suivant :

Page 11 sur 17
Question 1 : Tracer le graphe de la fonction 3tsin(5t) et t2cos(3t), sur le même graphe, pour -
1 < t < 2. La première courbe doit être en vert, et la deuxième courbe en rouge, mais
n’utilisez pas hold on. Utiliser un pas de 0.01.

Ajouter une légende

La commande legend permet d’ajouter une légende au graphe. On utilise
legend(‘Courbe 1’, ‘Courbe 2’, …) où le nom de chaque courbe est dans l’ordre que ça
apparait dans la fonction plot.

Question : 2 Tracer le graphe de la fonction 3tsin(5t) et t2cos(3t), sur le même graphe, pour -
1 < t < 2. La première courbe doit être en vert, et la deuxième courbe en rouge, avec une
grosseur de ligne de 5. Utiliser un pas de 0.01. Ajouter une légende au graphe, où la courbe 1
est « Originale » et la courbe 2 est « Modifiée ».

2.9 Tracer plusieurs graphes

Si on veut tracer plusieurs graphes superposés, ou un à côté de l’autre, on doit utiliser la
commande subplot(R,C,N). L’argument R représente le nombre de rangées,
l’argument C représente le nombre de colonnes, et l’argument N permet d’identifier le
graphe qu’on veut tracer. Les graphes sont numérotés de gauche à droite, de haut en bas.
Exemple : la commande subplot(2,2,1) va indiquer à Matlab qu’on veut tracer le
premier graphe d’une série de 4 graphes arrangés en 2 rangées et 2 colonnes.

Graphe 1 Graphe 2

Graphe 3 Graphe 4

Page 12 sur 17
Il faut donner la commande subplot avant chaque commande plot. Exemple :

Ce qui donne :

Noter l’utilisation des commandes title et ylabel.

Question 3 : Tracer deux graphes, l’un à côté de l’autre. Le premier graphe doit tracer la
fonction y1(t) = sinc(2*t), pour -2 < t < 3. Le deuxième graphe doit tracer y2(t) = 3e-0.5t, pour
0 < t < 3. Utiliser un pas de 0.01. Ajouter un titre, un nom à l’axe x, et un nom à l’axe y pour
chaque graphe.

Page 13 sur 17
2.10 Représentation graphique des signaux usuels

L’objectif de cette partie est de représenter graphiquement les signaux usuels

étudiés en cours à l’aide de MATLAB afin d’analyser leurs caractéristiques
temporelles et fréquentielles. Exemple :

clc; clear; close all;

% Paramètres généraux
fs = 1000; % Fréquence d'échantillonnage (Hz)
T = 1; % Durée du signal (s)
t = 0:1/fs:T; % Axe temporel
f = 5; % Fréquence du signal (Hz)

%%************************** 1. Impulsion de Dirac****************************

figure;
dirac = zeros(size(t));
dirac(1) = 1;
stem(t, dirac, 'b', 'MarkerFaceColor', 'b');
title('Impulsion de Dirac');
xlabel('Temps (s)'); ylabel('Amplitude'); grid on;

%%************************** 2. Train d'impulsions de Dirac*********************

figure;
train_dirac = zeros(size(t));
interval = fs/10;
train_dirac(1:interval:end) = 1;
stem(t, train_dirac, 'r', 'MarkerFaceColor', 'r');
title('Train d''impulsions de Dirac');
xlabel('Temps (s)'); ylabel('Amplitude'); grid on;

%%************************** 3. Signal Sinusoïdal ****************************

figure;
signal_sin = sin(2*pi*f*t);
plot(t, signal_sin, 'g');
title('Signal Sinusoïdal');
xlabel('Temps (s)'); ylabel('Amplitude'); grid on;

%%************************** 4. Signal Carré ********************************

figure;
signal_carre = square(2*pi*f*t);
plot(t, signal_carre, 'm');
title('Signal Carré');
xlabel('Temps (s)'); ylabel('Amplitude'); grid on;

%%************************** 5. Signal Triangulaire **************************

figure;
signal_triangle = sawtooth(2*pi*f*t, 0.5);
plot(t, signal_triangle, 'c');
title('Signal Triangulaire');
xlabel('Temps (s)'); ylabel('Amplitude'); grid on;

%%************************** 7. Signal Rampe ******************************

figure;
signal_rampe = t;
plot(t, signal_rampe, 'r');
title('Signal Rampe');
xlabel('Temps (s)'); ylabel('Amplitude'); grid on;

Page 14 sur 17
 %%************************** 8. Signal Échelon *******************************
figure;
signal_echelon = t >= 0.5;
plot(t, signal_echelon, 'b');
title('Signal Échelon');
xlabel('Temps (s)'); ylabel('Amplitude'); grid on;

%%************************** 9. Signal Porte **********************************

figure;
signal_porte = (t >= 0.3 & t <= 0.7);
plot(t, signal_porte, 'g');
title('Signal Porte');
xlabel('Temps (s)'); ylabel('Amplitude'); grid on;

%%************************** 10. Signal Exponentiel

*************************
*
figure;
signal_exp = exp(-3*t);
plot(t, signal_exp, 'm');
title('Signal Exponentiel');
xlabel('Temps (s)'); ylabel('Amplitude'); grid on;

%%************************** FIN *******************************************

2.11 Travail demandé

a. Représentation des signaux typiques : δ(t), u(t), a.t.u(t)
Soit le programme suivant :

%Génération d'une impulsion unité

%Génération d'un vecteur de -10 0 20
n=-10:20;
%Génération de l'impulsion unité
u=[zeros(1,10) 1 zeros(1,20)];
%Tracer le signal généré
stem(n,u);
xlabel('Temps indexé en n');
ylabel('Amplitude');
title('impulsion unité'); axis([-
10 20 0 1.2]);

1. Exécuter ce programme.
2. Faire les changements nécessaires au programme ci-dessus pour
représenter les impulsions suivantes :
2δ(t), δ(t + 2) et 2δ(t-2)
3. Modifier le programme précédent pour générer un échelon unité, puis
un échelon d’amplitude 1.5v décalé de 20 échantillons.

Page 15 sur 17
 b. Génération d’une impulsion rectangulaire
Soit le programme suivant :
%Génération d'une impulsion unité
%Génération d'un vecteur de -10 0 20
n=-10:20;
%Génération de l'impulsion unité
u=[zeros(1,10) 1 zeros(1,20)];
%Tracer le signal généré
stem(n,u);
xlabel('Temps indexé en n');
ylabel('Amplitude');
title('impulsion unité'); axis([-
10 20 0 1.2]);

1. Exécuter ce programme et déterminer les caractéristiques.

2. Modifier ce programme pour construire une impulsion rectangulaire de
durée T=2 s et d’amplitude A=1.5V.

c. Génération du sinus cardinal :sinc (x)

Soit la fonction y(x) = sinc(x)=sin(x)/x.
On utilise l’expression logique(x= =0) pour exprimer : que la lim y(x) = 1
lorsque x→ 0.

Soit le programme suivant :

%Tracage de la fonction sinus cardinal
%Domaine des valeurs de la variable x
x=-4*pi:pi/100:4*pi;
%valeurs de la fonction
y=(x==0)+sin(x)./(x+(x==0));
%Tracage de la fonction sinus cardinal
plot(x,y)
grid
title('sinus cardinal y=sin(x)/x')

1. Exécuter ce programme.
2. Faire les changements nécessaires au programme ci-dessus pour
représenter juste la valeur absolue de y(x) = sinc(x).

Page 16 sur 17
 d. Génération de quelques signaux
❖ Ecrire un programme avec Matlab pour générer un signal sinusoïdal
d’amplitude 10v et de fréquence 50hz. Pour cela, il suffit de suivre les
étapes suivantes :
✓ Ouvrir Matlab ;
✓ Cliquer sur New M-file ;
✓ Copier le code suivant :
%Traçage de la fonction 10*sin(wt) entre 0 et 1
t=0:0.001:1;
f=50;
y=10*sin(2*pi*f*t);
plot(t,y);grid;

● Modifier le programme pour tracer la fonction suivante :

Y=cos(wt- (pi/6)) pour une fréquence égale à 1hz.

Page 17 sur 17