TP - Traitement Du Signal - SMP6 2022-2023

TRAVAUX PRATIQUES
Traitement du signal
------------------------------
L
F
:
S
M
P
6
Filière : Sciences de la Matière Physique (SMP)
Parcours Electronique
Semestre : S6
Responsable : Année universitaire :

Professeur M. LAABOUBI 2022-2023
Faculté des Sciences Appliquées, Route Nationale N°10 cite d’Azrou à côté de l'institut Agronomique et Vétérinaire
Hassan II Ait Melloul, Site web : cuam.uiz.ac.ma
Introduction à Matlab………………………………………………………….3
TP1 :
Calcul élémentaire en traitement du signal...…….…………..............20
TP2 :
Produit de convolution, Echantillonnage, Transformée de Fourier...26
TP3 :
Analyse spectrale par la TFD, Fenêtre d’observation et Filtrage…...32
Licence fondamentale SMP6 : Parcours Electronique Travaux Pratiques
Modalités de fonctionnement
Ce polycopié de TP a été rédigé à l’intention des étudiants de la licence fondamentale des

Sciences de la Matière Physique (SMP6) parcours électronique. Il englobe une partie de
l’introduction au langage de programmation MATLAB, et une série de travaux pratiques en
traitement du signal qui ont pour objectifs d’aider l’étudiant à assimiler une grande partie de
la théorie du signal vue en cours.
Les modalités de fonctionnement des TP sont :
1. Présence aux T.P :
La présence aux T.P est obligatoire. Toute absence devra être valablement justifiée. Une
absence non justifiée conduira automatiquement à la note 0.
A chaque séance, un seul rapport devra être rendu pour les deux membres du binôme. Le
rapport devra être rédigé avec soin, sur une feuille double, avec nom/prénom de chaque
binôme. De plus, chaque rapport, devra comporter le numéro de la question à laquelle vous
répondez. Si ces conditions ne sont pas respectées, des points seront retirés.
2. Modalités d’évaluation :
Chaque TP est constitué de 2 parties : « préparation » et « manipulation ». Une note sera

attribuée à chacune des parties. La note finale de chaque TP sera la somme de ces deux notes.
- Préparation : à effectuer avant la séance. Elle est indispensable pour la
compréhension de la manipulation.
- Manipulation : le soin apporté aux manipulations sera pris en compte dans la note :
3. Préparations théoriques :
Les préparations théoriques sont indispensables à la compréhension du T.P. et même parfois

à son exécution. Les T.P. étant conçus pour durer 3 heures hors préparation théorique, il est
nécessaire de préparer le T.P. avant la séance.
2
Pr. Mostafa LAABOUBI Année : 2022-2023
1. Introduction à Matlab
Le but de ce manuscrit est d’apprendre à utiliser le logiciel Matlab, et de manipuler les

variables dans l’environnement de travail. Les différentes types de visualisation des données
et l’utilisation de scripts et de fonctions est représentée au travers des exemples simples.
2. Généralité
MATLAB (MATrix LABoratory) comprend de nombreuses fonctions graphiques, un système
puissant d’opérateurs s’appliquant à des matrices, des algorithmes numériques, ainsi qu’un
langage de programmation extrêmement simple à utiliser.
Matlab est un outil très efficace qui est largement utilisé pour le calcul numérique et la
visualisation graphique. Dans Matlab, les variables et les scalaires sont manipulés comme des
matrices de "n" colonnes par "m" rangées. MATLAB peut être aussi considéré comme un
langage de programmation adapté pour les problèmes scientifiques.
MATLAB est un interpréteur: les instructions sont interprétées et exécutées ligne par ligne.
MATLAB fonctionne dans plusieurs environnements tels que X-Windows, Windows,
Macintosh.
3. Principales caractéristiques
Matlab est un environnement logiciel de calcul et visualisation scientifique :
- Matlab (pour Matrix Laboratory) repose sur un langage interprété.
- La programmation est aisée car la syntaxe du langage est proche de l’écriture mathématique.
- La donnée de base est la matrice ou tableau (vecteur ou scalaire étant des cas particuliers).
- La dimension des données n’a pas besoin d’être spécifiée (ni leur type).
- L’interactivité de Matlab permet de programmer et simuler plus vite qu’en d’autre langage
comme C ou Fortran…
- Matlab est couramment utilisé dans la recherche et l’industrie.
- Les inconvénients éventuels sont la lenteur d’exécution et le coût en mémoire.
Matlab est fourni avec des Toolboxes (boîtes à outils) dédiées à des applications spécifiques :
- Ce sont des bibliothèques de fonctions (fichiers ASCII d’extension .m)
- Symbolic Math : calcul symbolique (intégrale, équation différentielle)
- Signal Processing : traitement de signal (filtrage, analyse spectrale, …)
- System Identification et Control System : automatique (identification, correcteur)
- Image Processing : traitement d’image
Le système interactif MATLAB comporte :
- Environnement de développement (fenêtres de commandes)
- Bibliothèque de fonctions mathématiques (algèbre, trigonométrie, transformées)
- Langage (contrôles de flux, fonctions, structures)
3
- Commandes graphiques (visualisation 2-D et 3-D)
3-1. Session MATLAB

- licence PC sous Windows
- double-cliquer sur l’îcone MATLAB pour lancer une session
- fenêtre de commande : pour saisir des variables, écrire des instructions, lancer des
programmes (après le prompt («) de l’interpréteur Matlab), et voir des résultats en mode texte
- fenêtre déditeur : pour écrire des fichiers .m
- fenêtre graphique (Figure) : pour visualiser des courbes
- répertoire de travail par défaut : work (modifiable dans startup.m)
3-2. Contrôle de session

- CTRL C : interruption de programme
- exit/quit : fin de session
- ↑ : rappel de commande précédente
- ! : redonner la main au système d’exploitation
- help <nom de fonction> : aide en ligne (très utile !)
- who/whos : liste des variables en mémoire
- clear : libération de la mémoire vive (très utile !)
- clc : efface la fenêtre de commande.
3-3. Principe de la syntaxe

MATLAB est un langage d’expression, i.e. interprété (pas de compilation nécessaire). Il
interprète et évalue en ligne les instructions tapées au clavier.
Une instruction peut être :
- tapée directement dans la fenêtre de commande pour exécution en ligne.
- insérée dans un programme exécutable (fichier .m)
- insérée dans une fonction externe (fichier .m)
Une instruction est constituée de variables, nombres, opérateurs et fonctions. Elle est de la
forme :
variable=expression;
ou simplement :
expression;
Séparateurs :
- une instruction se termine par un point-virgule (;) sauf si l’on veut voir à l’écran
tous les calculs intermédiaires auquel cas on utilise à la place le simple retour chariot
(<RET>) ou la virgule (,).
- % : séparateur qui annonce un commentaire dans un fichier MATLAB.
4
Exemples d’instructions
- formation d’un vecteur-ligne t contenant des instants d’échantillonnage espacés d’une
période Te :
t=0:Te:T; %vecteur-temps échantillonné
- extraction des n premiers échantillons :
t(1:n);
- génération d’un vecteur x contenant les échantillons d’une sinusoïde :
x=A*sin(2*pi*f*t);
A, π , f étant des scalaires, x récupère la dimension de t (aucune déclaration de type ou de
dimension n’est nécessaire).
- transposition pour former le vecteur colonne correspondant :
y=x';
- formation d’une matrice M de taille 3x3 :
M=[a11 a12 a13 ; a21 a22 a23 ; a31 a32 a33];
- extraction du premier coefficient de la matrice :
coeff1=M(1,1);
3-4. Variables
On peut indiquer le nom de la variable dans laquelle le résultat doit être stocké (commence
par une lettre, moins de 19 caractères).
Attention, Matlab prend en considération les majuscules (x est différent de X).
>> x = pi/4
x = 0.7854
Le nom de cette variable ainsi que le résultat sont affichés.
Un point virgule à la fin de la ligne permet de ne pas afficher ce résultat. On peut taper
plusieurs commandes par ligne, séparées par un point virgule.
>> x = pi/2; y = sin(x);
Variables complexes
Matlab travaille indifféremment avec des nombres réels et complexes. Par défaut les variables
i et j sont initialisées à la valeur complexe. Naturellement si vous redéfinissez la variable i
ou j avec une autre valeur elle n'aura plus la même signification.
>> z = 3 + 2*i
z = 3.0000 + 2.0000i
Les fonctions usuelles de manipulation des nombres complexes sont prédéfinies dans Matlab :
real, imag, abs, angle (en radian), conj.
>> r = abs(z);
>> theta = angle(z);
>> y = r*exp(i*theta);
5
4. Vecteurs, matrices et leur manipulation

En fait, toute variable de Matlab est une matrice (scalaire : matrice 1x1, vecteur : matrice 1xN
ou Nx1). On peut spécifier directement une matrice sous la forme d'un tableau, l’espace ou la
virgule sépare deux éléments d’une même ligne, les points virgules séparent les éléments de
lignes distinctes.
>> A = [ 1, 2, 3 ; 4, 5, 6 ; 7, 8, 9 ]
A = 1 2 3
4 5 6
7 8 9
Les éléments d’une matrice peuvent être n'importe quelle expression de Matlab :
>> x = [ -1.3, sqrt(3), (1+2+3)*4/5 ]
x = -1.3000 1.7321 4.8000
Les éléments d’une matrice peuvent être référencés par leurs indices :
>>x(2)
ans = 1.7321
On peut aussi créer des matrices avec les fonctions zeros, ones et eye, ces fonctions
créent des matrices de la taille précisée, respectivement remplies de zéros , de un, et de un sur
la diagonale et des zéros ailleurs
(eye = prononciation anglaise de I comme identité).
>> eye(2,3)
ans = 1 0 0
0 1 0
>> ones(1,5)
ans = 1 1 1 1 1
On peut avoir des informations sur la taille d'une matrice :
>> size(x)
ans = 1 5
>> length(x)
ans = 5
On peut ajouter des lignes et des colonnes à des matrices déjà existantes.
>> r = [15, 11, 3];
>> A = [A ; r]
A = 1 2 3
4 5 6
7 8 9
15 11 3
>> r1 = zeros(4,1);
>> A = [A, r1]
A = 1 2 3 0
4 5 6 0
7 8 9 0
10 11 12 0
On peut avoir le transposé ou le transposé conjugué d’une matrice :
>> A' % Transposée conjuguée de A
6
>> A.' % Transposée de A

Mais aussi des retournements horizontaux (flipud : Up/Down), verticaux (fliplr :
Left/Right), ou des rotations de matrices :
>> flipud(A) % Retournement vertical de A
>> fliplr(A) % Retournement horizontal de A
>> rot90(A) % Rotation de A de 90 degrés
On peut également remettre en forme des matrices et vecteurs sur un nombre de lignes et de
colonnes donnés (à condition que le nombre total d’éléments corresponde)
>> A = [1 2 3 4 5 6];
>> A = reshape(A,2,3) % Remise en forme avec 2 lignes et %
3 colonnes
A = 1 3 5
2 4 6
4-1. Opérations matricielles

Les opérations usuelles sont définies de façon naturelle pour les matrices :
>> 2*A % Produit par un scalaire
>> A*B % Produit de deux matrices (de dimensions %
cohérentes)
>> A^p % Elève la matrice carrée A à la puissance p
>> inv(A) % Inversion d'une matrice carrée inversible (message
% d'alerte éventuel)
>> A.*B % Produit élément par élément de deux matrices
Attention : A*A est différent de A.*A.
>> X = A/B % Donne la solution de A*X = B

>> X = B/A % Donne la solution de X*A = B
>> X = A./B % Division éléments par éléments
La plupart des fonctions mathématiques n’ayant pas de signification particulière pour des
matrices les considèrent comme un simple tableau de valeur, par exemple :
>> exp(A)
Renverra une matrice dans laquelle tous les éléments seront l'exponentielle des éléments de A,
de même pour log, sqrt, round, rem (correspond au modulo), sign. Pour
calculer l’exponentielle matricielle, le logarithme matriciel ou la racine carrée d’une matrice
on utilisera respectivement expm, logm et sqrtm.
Certaines fonctions de Matlab agissent indépendamment sur chaque colonnes de la matrice.

C'est le cas de la fonction max (et min ) :
>> max(A)
renverra un vecteur ligne dont chaque élément sera le maximum (minimum) de la colonne
correspondante.
C’est aussi le cas des fonctions sum, prod et median qui donnent respectivement les
sommes, produit, et la valeur médiane des colonnes de la matrice. Les fonctions cumsum,
7
cumprod et sort renvoient une matrice dont chaque colonne contient les sommes et
produits cumulés et un tri des colonnes de la matrice initiale.
D’autres fonctions sont très utiles sur les matrices :
>> poly(A) % Polynôme caractéristique de A
>> det(A) % Déterminant de A
>> trace(A) % Trace de A
>> [V, D] = eig(A) % Renvoie les valeurs propres et les
vecteurs %propres de A (eigenvalues, eigenvectors)
4-2. Opérateur " : "

L’opérateur " : ", sous Matlab, peut être considéré comme l'opérateur d’énumération. Sa
syntaxe usuelle est :
debut:pas:fin
Il construit un vecteur dont le premier élément est deb puis deb+pas, deb+2*pas... jusqu'à
deb+n*pas.
>> x = 0.5:0.1:0.85
x = 0.5000 0.6000 0.7000 0.8000
Le pas d’incrémentation peut être omis, 1 est alors pris par défaut :
>> x =1:5
x = 1 2 3 4 5
On peut aussi utiliser le " : " pour sélectionner des éléments d’un vecteur ou d’une matrice :
>> A(1,3) % Troisième élément de la première ligne de A
>> A(1,1:3) % Premier, deuxième et troisième éléments de la
première ligne de A
>> A(1,:) % Tous les éléments de la première ligne
>> A(:,3) % Tous les éléments de la troisième colonne
>> A(:) % Vecteur colonne contenant tous les éléments % de A
lus colonne par colonne.
5. Affichages graphiques et alphanumériques
5-1. Initialisation de variables à partir du clavier

Il également possible d'assigner une valeur provenant du clavier à une variable en utilisant la
commande "input". Ceci veut dire que l'utilisateur doit manuellement initialiser les variables
une fois que le programme est exécuté.
Exemple 1:
Tapez:
>>clear
>>clc
>>test= input('S.V.P entrer un chiffre\n');
>>2
8
>>test=
2
>>
Exemple 2:
Tapez:
>>clear
>>clc
>>test_string= input('Entrer un mot:\n', 's');
>>Ahmed
>>test_string=
Ahmed
>>
5-2. Affichage alphanumérique

On peut afficher des chaînes de caractères dans la fenêtre de commande :
>> disp(message)
pi vaut 3.142
Les fonctions sprintf et fprintf existe également (même syntaxe qu'en langage C).
>> fprintf('pi vaut %f\n',pi)
pi vaut 3.141593
5-3. Graphique 2D
Une courbe 2D est représenté par une série d'abscisses et une série d'ordonnées. Le logiciel
trace généralement des droites entre ces points. La fonction de MATLAB s'appelle plot.
1-Tracer une courbe simple

L’utilisation la plus simple de l’instruction plot est la suivante.
plot ( vecteur d’abscisses, vecteur d’ordonnées ) ou encore,
plot ([ x1 x2 ... xn ], [ y1 y2 ... yn ])
Les vecteurs peuvent être indifféremment ligne ou colonne, pourvu qu’ils soient tous deux de
même type. En général ils sont lignes car la génération de listes de valeurs vue précédemment
fournit par défaut des vecteurs lignes.
Par exemple, si on veut tracer sin(x) sur l'intervalle [0; 2π], on commence par définir une série
(de taille raisonnable, disons 100) de valeurs équidistantes sur cet intervalle :
>> x = 0: 2*pi/100 : 2*pi;
puis, comme la fonction sin peut s'appliquer terme à terme à un tableau :
>> plot(x, sin(x))
qui fournit le graphe suivant dans la fenêtre graphique :
9
2- Superposer plusieurs courbes

Il suffit de spécifier autant de couples (abscisses, ordonnées) qu’il y a de courbes à tracer. Par
exemple pour superposer sin et cos :
>> plot(x, cos(x),x, sin(x))
Exemple :
>> t=0:0.01e-3:0.06;
>> y=10*exp(-60*t).*cos(120*pi*t);
>> z=10*exp(-60*t).*sin(120*pi*t);
>> plot(t,y,'r',t,z,'g'),grid
>> a=10*exp(-60*t);
>> hold
Current plot held
>> plot(t,a,'b--')
>> plot(t,-a,'b--')
>> title('Fonctions sinusoidales amorties')
>> xlabel('Temps , s'),ylabel('Tension , V')
10
3- Titre
C'est l'instruction title à laquelle il faut fournir une chaîne de caractères. Le titre apparaît en
haut de la fenêtre graphique :
>> plot(x,cos(x),x,sin(x))
>> title('Fonctions sin et cos')
4-Labels
Il s'agit d'afficher quelque chose sous les abscisses et à coté de l'axe des ordonnées :
>> plot(x,cos(x))
>> xlabel('Abscisse')
>> ylabel('Ordonnée')
5- Légendes
Utilisation de l'instruction legend. Il faut lui communiquer autant de chaînes de caractères que
de courbes tracées à l'écran. Un cadre est alors tracé sur le graphique, qui affiche en face du
style de chaque courbe, le texte correspondant. Par exemple :
>> plot(x,cos(x),':',x,sin(x),'-.',x,sqrt(x),'--')
>> legend('cosinus','sinus','racine')
6-Afficher plusieurs graphiques (subplot)

On peut tracer plusieurs graphiques dans la même fenêtre en utilisant l’instruction subplot
pour diviser la fenêtre en plusieurs parties.
subplot spécifiant le nombre de pavés sur la hauteur, le nombre de pavés sur la
largeur, et le numéro du pavé dans lequel on va tracer :
subplot (Nbre pavés sur hauteur, Nbre pavés sur largeur, Numéro pavé)
- Diviser la fenêtre en deux parties (2 x 1)
11
- Diviser la fenêtre en deux parties (1 x 2)
- Diviser la fenêtre en quatre parties (2 x 2)
- Diviser la fenêtre en quatre parties (4 x 1)
Exemple :
12
>> subplot(221)
>> plot(x,sin(x))
>> subplot(222)
>> plot(x,cos(x),x,sin(x),'-.')
>> subplot(223)
>> plot(cos(x),sin(x))
>> subplot(224)
>> plot(sin(2*x),sin(3*x))
7- Traçage de courbes
On utilise l'instruction plot pour tracer un graphique 2D:
plot(x,y) : Tracer le vecteur y en fonction du vecteur x
plot(t,x,t,y,t,z) : Tracer x(t), y(t) et z(t) sur le même graphique
plot(t,z,'r--') : Tracer z(t) en trait pointillé rouge
8- Format de graphique
On peut choisir le format du graphique:
plot(x,y) : Tracer y(x) avec échelles linéaires
semilogx(f,A) : Tracer A(f) avec échelle log(f)
semilogy(w,B) : Tracer B(w) avec échelle log(B)
polar(theta,r) : Tracer r(theta) en coordonnées polaires
bar(x,y) : Tracer y(x) sous forme des barres
grid : Ajouter une grille
Exemple :
>> w=logspace(0,3,1000);
>> s=j*w;
>> H=225./(s.*s+3*s+225);
>> AdB=20*log10(abs(H));
>> phase=angle(H)*(180/pi);
>> subplot(2,1,1),semilogx(w,AdB),grid
>> xlabel('w , rad/s'),ylabel('Amplitude , dB')
>> subplot(2,1,2),semilogx(w,phase),grid
>> xlabel('w , rad/s'),ylabel('Phase , degre')
13
9- Ajout du texte au graphique

title('Titre du graphique') : Donner un titre au graphique
xlabel('Temps') : Étiquette de l’axe x
ylabel('Tension') : Étiquette de l’axe y
gtext('Valeur absolue') : Ajouter du texte au graphique avec la souris
axis([-1 5 -10 10]) : Choix des échelles x = (-1,5) et y = (-10,10)

hold : Garder le graphique sur l'écran (pour tracer plusieurs courbes
sur le même graphique).
Par défaut une instruction plot efface systématiquement le graphique précédent. Il est parfois
utile de le conserver et de venir le surcharger avec une nouvelle courbe. Pour cela on utilise la
commande hold. Pour démarrer le mode surcharge, taper hold on, pour revenir en mode
normal, hold off.
6. Programmation et algorithmique
6-1. Structure conditionnelles
A) Boucles
Boucle "for"
La boucle "for" s'écrit de la manière suivante:
for index = expression
…
…
…
end
où "expression" prend généralement la forme suivante:
Début: incrémentation: fin
14
Exemple:
>>clear
>>clc
>>for x=1:2:9
>>y=x;
>> disp(x);
>>end
Boucle "while"
Dans Matlab, la boucle "while" s’écrit de la façon suivante:
while expression
…
…
…
end
Le code dans la boucle est exécuté aussi longtemps que la condition de départ est "vrai".
Exemple:
>>clear
>>clc
>>x=1;
>>while x<10
>>x = x+1;
>>end
>>disp(x)
"if" et "if-else"
"if" et "if – else" sont utilisés pour imposer des conditions. Si la condition est respectée, alors
le code qu’elle contient est exécuté. A noter qu’il faut toujours terminer le "if" par un
"end" en Matlab.
Forme :
if "expression"
---
---
elseif "expression"
---
---
else
---
---
15
end
Instruction "switch"
Dans Matlab, l’instruction "switch" prend la forme suivante:
SWITCH switch_expr
CASE case_expr,
statement, ..., statement
CASE {case_expr1, case_expr2, case_expr3,...}
...
OTHERWISE,
END
Dans Matlab, il n’est pas nécessaire d’inclure le "break" à la fin de chaque case de
l’instruction "switch ". Une fois qu’une case est "vrai", l’instruction "switch " est
automatiquement terminée.
6-2. Fonctions construites par l’utilisateur

Il est possible de créer des fonctions dans Matlab, en utilisant la commande "function".
Une fois qu'une fonction est créée dans un "M-file", elle peut être exécutée à tout moment à
partir de la fenêtre de commande en écrivant le nom de cette fonction.
Interaction fichiers externes

Transfert matrice <-> fichier ASCII : load/save
Entrée/sortie fichier : fopen, fclose, fread, fwrite, fseek, fprintf...
Accès image externe : imread, imwrite...
6-2-1. Fonctions pour Séries et Transformées de Fourier

Les fonctions Matlab les plus utilisées pour l'analyse de Fourier sont les suivantes, où x est un
vecteur ou une matrice sur lequel les opérations de Fourier sont appliquées:
Fonctions : fft
Description : "Fast Fourier Transform", (similaire à la série de Fourier en temps
discret, aussi utilisée pour évaluer la transformée de Fourier en temps
discret)
Dans Matlab : X = fft(x)
Fonctions : ifft
Description : "Inverse Fast Fourier Transform"
Dans Matlab : x = ifft(X);
16
Exemple:
Pour trouver des échantillons de la transformée de Fourier d'un signal, il faut utiliser la
fonction "fft". Tapez dans la fenêtre de commande:
>> figure(1)
>>T=0.01;
>>Fs=1/T; % fréquence d'échantillonnage de 100 Hz
>>t = 0:T:1;
>>x = sin(2*pi*10*t); % signal fréquence de 10 Hz
>>plot(t,x)
>>title('Signal')
>>xlabel('temps (ms)')
Résultat:
>>figure(2)
>>FFT_size=2048;
>>X=fft(x,FFT_size);
>>f=(0:FFT_size/2)/(FFT_size/2)*Fs/2;
>>plot(f,abs(X(1:FFT_size/2+1))); % on voit bien que le signal est à 10 Hz
>>title('Signal en fréquence');
>>xlabel('Fréquence(Hz)');
>>ylabel('Amplitude');
17
7. Signaux de base
- randn : génère un bruit aléatoire normal de moyenne nulle et de variance 1. Syntaxe :
randn(size(A)) pour avoir un vecteur de nombres aléatoires de même taille que A.
- y=sin(x) : fonction sinus (qui opère élément par élément dans le cas d'une matrice). où x est
un scalaire, un vecteur ou une matrice. y recupère la même dimension que x.
- square(t,duty) : génère un signal carré de rapport cyclique variable (fait partie du toolbox
Signal Processing) où t est le vecteur-temps et duty le rapport cyclique exprimé en % de la
période où le signal est positif (par défaut : duty=50 %).
Fonctions internes
fft : Calcul de la transfomée de Fourier discrète (TFD) avec l’algorithme rapide de
FFT (Fast Fourier Transform) si le nombre de points est une puissance de 2. Sinon, le calcul
utilise un algorithme plus lent de DFT (Discrete Fourier Transform). C’est pourquoi on a
intérêt à choisir un nombre N de points qui est une puissance de 2. Syntaxe :
z=fft(x,N);
où x est le vecteur contenant les échantillons du signal, N le nombre de points sur lequel on
veut calculer la FFT et z est le vecteur de sortie (a priori complexe) récupérant les
échantillons de la TFD. Signalons que N n’est pas nécessairement égal au nombre
d’échantillons du signal. Si
N est supérieur au nombre d’échantillons de signal disponibles, le calcul de la TFD se fait
après l’ajout automatique du nombre nécessaire d’échantillons nuls en queue de signal pour
compléter les échantillons manquant et obtenir au total N points. Cet artifice de calcul, qui
s’appelle zero-padding, est intéressant pour avoir un spectre discret (TFD) (évidemment,
puisqu’on travaille sur ordinateur) qui est une approximation très fine du spectre continu
(TFDT). Typiquement, on prend N = 1024. Cela rajoute sur le spectre échantillonné d’origine
des points intermédiaires qui réalisent une interpolation en sinus cardinal (donc exacte) entre
les points originels, au lieu de l’interpolation linéaire (donc fausse) faite par l’oeil. On
améliore ainsi la visualisation du spectre, mais cela n'ajoute évidemment pas d'information
utile d'un point de vue mathématique.
abs : calcul de la valeur absolue (resp. du module) des éléments d(une matrice réelle
(resp. complexe).
Fonctions externes
- sinus : génération d’une sinusoïde. Syntaxe :
[x,t] = sinus(Fe,T,f,A)
Cette fonction requiert 4 paramètres d’entrée : la fréquence d’échantillonnage Fe, la durée T
(en secondes), la fréquence f et l’amplitude A. Elle donne en sortie 2 vecteurs de même
dimension :
x contient les échantillons du signal sinusoïdal et t contient les instants d’échantillonnage.
- carre : génération d'un signal carré. Syntaxe identique à sinus.
18
- spectre : calcul d'un spectre. Syntaxe :

[Sxx,freq]=spectre(Fe,x,N,dB)
Cette fonction requiert 4 paramètres d'entrée : la fréquence d’échantillonnage Fe, le vecteur
des échantillons du signal x, le nombre de points de calcul N et une chaîne de caractères dB
(n/o) qui spécifie l’échelle désirée (linéaire ou en dB). Elle donne en sortie 2 vecteurs de
dimension N : Sxx contient les échantillons du spectre et freq contient les fréquences discrètes
correspondantes (de 0 à Fe).
19
TP1 :
Calcul élémentaire en traitement du signal
1. Introduction :
Un signal numérique est défini par un nombre d’échantillons N relevés à une fréquence
d’échantillonnage Fe. Les signaux sont toujours captés de manière temporelle, mais on
s’intéresse souvent à leur allure fréquentielle.
L’objectif de ce TP est de générer et de visualiser des signaux usuels tels que les signaux
types (sinusoïde, triangle, carré, …), puis d’effectuer leur analyse à l’aide des outils
disponibles sous Matlab et aussi l’analyse d’un signal bruité.
1-1. Représentation de signaux

Un signal est une entité qui sert à véhiculer une information. C’est une quantité physique
mesurable qui évolue en fonction d’une ou plusieurs variables.
Un système est une entité physique qui réalise une opération sur un signal.
1-2. Traitement du signal

Le traitement du signal (analogique ou numérique) consiste
1. A étudier le signal, l’analyser, en extraire les informations pertinentes (radar, sonar,
…etc).
2. A modifier le signal (enlever les parasites d’un son, éclaircir une image ….etc.)
3. A synthétiser/reproduire des signaux nouveaux « voix artificielles »
1-3. Approche de caractérisation d’un signal

1. Description Temporelle x(t) : valeur instantanée d’un signal.
2. Description Fréquentielle X(f):

- signaux périodiques ⇒ Décomposition en Série de Fourier (DSF)
- Signaux non périodiques ⇒ Transformée de Fourier (TF)
3. Description Statistique : Signaux aléatoires ⇒ Propriétés statistiques (Moyenne,

Variance, Puissance, …)
x(t) et X(f) sont deux descriptions équivalentes (temporelle ou fréquentielle) du même signal.
On peut définir trois spectres de x (t) :
20
-. Le spectre en amplitude si l’on trace |X (f)|.

-. Le spectre en phase si l’on trace Arg (X (f)).
2
-. Le spectre d’énergie si l’on trace X ( f ) .
2. Déroulement du TP
Une première séance est consacrée essentiellement à la familiarisation avec le langage de
programmation MATLAB (voir annexe) et à l’étude de différentes commandes ou fonctions
utiles en traitement du signal.
Vous devez tout d’abord effectuer un travail préparatoire qui consiste à calculer le
développement en séries de Fourier puis la transformée de Fourier des signaux types
(sinusoïdal, rectangle (carré), triangle, ….) présenté dans le cours. Il est évidemment
nécessaire de lire le sujet à l’avance.
3. Les Scripts
Plutôt que de taper les commandes au clavier les unes après les autres pour effectuer une
tâche, ce qui vous oblige à refaire la même chose à chaque utilisation de cette tâche, il est
préférable de grouper les commandes dans un fichier à extension .m, ainsi tous les
programmes auront pour nom nom.m .
Exemple 1 :
Créez un fichier qui s’appelle essai1.m, qui génère un signal sinusoïdal x(t) de n points, puis
visualisez-le à l’aide de la commande plot (x).
- Etape 1 : édition du fichier par la commande :
- edit essai1.m
- Etape 2 : saisie des commandes suivantes:
%ce fichier génère et affiche une sinusoïde
n=input(‘Entrer le nombre de points du signal : ’) ;
pas=2*pi/(n-1); %le pas dépend du nombre de points sur une période 2*pi
t=0:pas:2*pi; %la variable temps est un vecteur t de taille n couvrant une
période
x=sin( ω t); %le signal x est un vecteur de même taille que le vecteur t
plot(t,x) ; %dessine à l’écran x en fonction de t
Remarques :
1- Le texte débutant par % est un commentaire de votre choix, il est ignoré par le
logiciel. Vous pouvez supprimer ces commentaires, mais ils sont utiles lorsqu’on a plusieurs
programmes.
2- Chaque instruction doit être suivie d’un point virgule.
- Etape 3 : Sauvegardez le fichier dans le répertoire en cours ;
- Etape 4 : Exécutez le programme en entrant la commande suivante
>>essai1
21
Pour consulter le contenu de votre fichier il suffit de taper >>type nomfichier.m
Exemple 2 :
Générez, à l’aide d’un programme essai2.m, cos( ω t) et sin( ω t) et visualisez les deux signaux
sur une même figure, l’une en rouge et l’autre en bleu à l’aide de la fonction :
plot(t,x,’b’,t,y,’r’).
Exemple 3 :
Visualisez sur une même figure, à l’aide d’un programme essai3.m, les 4 signaux cos( ω t),
sin( ω t), log10(t) et exp(t) en utilisant la fonction :
>>subplot(2,2,1),plot(t,x);
qui divise l’écran en quatre sous figures : (2,2,1),(2,2,2),(2,2,3) et (2,2,4).
Utilitaires graphiques
- L’instruction title(‘titre de la courbe ou la figure’) ajoute un titre à la figure visualisée.
- xlabel(‘unité des abscisses’) marque l’unité de la grandeur horizontale.
- ylabel(‘unité des ordonnés’) marque l’unité de la grandeur verticale.
- grid on et grid off quadrille ou non le graphique.
4. Manipulation : Production de signaux sous Matlab
Manip.1 : Génération N échantillons d’une sinusoïde

1. Synthèse d’un signal sinusoïdal
Théorème de Shannon :
Générer un signal sinusoïdal x(t) de n échantillons de fréquence f :

Procédure :
1. donner une valeur à la fréquence de x(t) : f=100Hz ;
2. choisir un pas d’échantillonnage Te (période d’échantillonnage) ou fréquence
1
d’échantillonnage Fe ( Fe = ), Te =1ms ou Fe =1000Hz ;
Te
3. créer le vecteur t=(0 : Te :N Te ) ou N=128 ;
4. Calculer les échantillons de x(t) ;
5. Tracer x(t) à l’aide de la fonction plot(x) ou plot(t,x)
Dans les manipulations qui suivent, nous allons uniquement modifier la valeur de la variable
Te qui représente la période d’échantillonnage.
- Te =5ms ;
- Te =10ms ;
- Te =20ms
22
6. Commenter les figures obtenues, en déduisant la relation suffisante de la fréquence

d’échantillonnage pour synthétiser un signal sinusoïdal.
Manip.2 : Opérations élémentaires sur les signaux
Ecrire le code MATLAB pour générer et représenter graphiquement les quatre signaux
suivants signaux suivants :
x1 (t ) = cos(2* π * f1 * t + P1 )
x2 (t ) = cos(2* π * f 2 * t )
x3 (t ) = cos(2* π * f 3 * t + P3 )
x4 (t ) = x1 (t ) + x2 (t ) + 2* x3 (t )
1. Générer un vecteur temps t de 100 points entre t0 = 0s et t1 = 0.1s.
2. Tracer les xi(t). Utiliser la commande subplot afin de tracer les quatre courbes les unes en
dessous des autres.
3. Multiplier les signaux.
4. Si on veut isoler des échantillons d’indices bien spécifiés, il suffit de taper x(p :q). Essayer
d’isoler une partie de votre signal.
Manip.3 : Ajout d’un bruit Gaussien :
Notion de bruit
Le bruit B(N) est défini comme étant un signal indésirable se mêlant additivement ou
autrement à un signal s(t) qui intéresse l’observateur.
Le model le plus fréquent de bruit de mesure de grandeurs physiques est le bruit blanc
gaussien : c’est un bruit aléatoire B(N) dont les échantillons sont dé-corrélés.
La fonction B=randn(1,N) permet de générer un vecteur bruit B de taille N de moyenne nulle
et d’écart type 1. Un coefficient multiplié par randn permet d’augmenter à volonté la
puissance du bruit.
Ainsi pour générer un bruit blanc de taille N, de moyenne m et d’écart type σ la commande
est :
B(N)= m+σ *randn(1,N);
Dont la puissance est P = m 2 + σ 2 (Puissance de la moyenne plus celle des fluctuations autour
de cette moyenne)
Rapport Signal à Bruit RSB :

Généralement on observe un signal y(n) bruité additivement :
y(n) = x(n)+B(n)
Le RSB en dB définit la puissance ou l’énergie du signal Ps par rapport à celle du bruit Pb :
23
⎛P ⎞
RSB = 10 log10 ⎜ s ⎟
⎝ Pb ⎠
On distingue trois cas de figure :
- RSB positif : le signal est plus puissant que le bruit.
- RSB nul : il y a autant de bruit que de signal.
- RSB négatif : le signal est dégradé, il ya plus de bruit que d’information.
Sinusoïde bruitée
Réaliser un seul programme pour cet exemple :
1. Générer une sinusoïde x(t) de fréquence 50Hz, d’amplitude 1, échantillonnée à
2.5KHz (Te=0.4ms) et de longueur 256 points.
2. Quelle est l’énergie de x(t) ? Utilisez la définition et comparez le résultat à celui
donné par std.
3. Générer un bruit d’amplitude de votre choix et visualisez-le. Quelle est son énergie?
4. Additionner le bruit à la sinusoïde et visualisez les trois signaux simultanément.
Quel est le RSB ?( σ = 0.3 et m=0, B=0.3* randn(1,N+1))
5. Choisissez trois bruits donnant des RSB négatif, nul et positif.
- L’énergie ou la puissance d’un signal est fournie sous Matlab par le carré de la fonction std
(standard deviation ou écart-type) ce qui donne en fait la variance dans le cas du bruit ou tout
autre signal aléatoire.
Manip.4 : Synthèse de Fourier (décomposition en série de Fourier)

1. Signal triangulaire
Soit le signal f(t) périodique de période T0= 2π , donné sur le schéma ci-dessous. Sa
décomposition en série de Fourier s’écrit :
+∞ +∞
f (t ) = a0 + ∑ an cos(2πf 0t ) + ∑ bn sin(2πf 0t )
n =1 n =1
1. Tracez le signal f(t) sur Matlab.
24
2. Montrer que :
8
a0 = bn = 0 et a2 p +1 =
π (2 p + 1) 2
2
3. Réaliser un programme permettant de calculer la décomposition en série de Fourier d’un

signal triangulaire.
4. Superposez le signal et sa série de Fourier tronquée au rang p=3.

6. Que remarquez-vous ?
25
TP2 :
Produit de convolution, Echantillonnage, Transformée de Fourier
Objectif :
L’objectif de ce TP est de générer, de visualiser quelques signaux analogiques, de déterminer
leur produits de convolutions, d’échantillonner et de déterminer la Transformée de Fourier en
utilisant Matlab.
Compte rendu du TP
• Le rapport écrit contiendra l’analyse des problèmes, le cheminement utilisé pour les
résoudre, le détail des calculs des solutions théoriques /mathématiques des problèmes posés,
les figures commentées, vos remarques et explications associées à chaque manipulation de
façon à montrer si les résultats obtenus correspondent oui ou non aux résultats attendus.
• La qualité du rapport (remarques, commentaires et explications), ainsi que les codes du
programme (utilisation de fonctions/ scripts Matlab, gestion des variables) seront au cœur de
l’évaluation.
• Chaque étudiant/binôme sera responsable de la sauvegarde de ses fichiers (Rapport
écrit+programmes)
Manipulation
1. Produit de convolution de deux signaux analogiques
La réponse y(t) d’un système linéaire ; ayant pour réponse impulsionelle h(t) ; à une entrée
x(t) est une superposition de réponses impulsionelle amplifiées par des valeurs instantanées de
x(t) ; cette opération est appelée : convolution de x par h et noté « * ».
Fig.1 : Système à temps continu
+∞ +∞
y (t ) = x(t ) ∗ h(t ) = ∫ x(τ)h(t − τ)d τ = ∫ x(t − τ)h(τ)d τ
−∞ −∞
26
Manip1 :
Le programme Matlab suivant calcule le produit de convolution (La commande : conv) de
deux signaux rectangulaires, l’un de durée 20s et d’amplitude 2v et l’autre de durée 20s et
d’amplitude
3v.
Programme :
1./ Tester le programme ci-dessus et vérifier théoriquement le résultat obtenu.
2./ Changer le programme pour avoir le produit de convolution de deux signaux
rectangulaires non identiques.
3./ Interpréter les résultats des deux questions.
« « clear
x=zeros(100,1);
for i=41:60,x(i)=2;end;
y=zeros(100,1);
for i=41:60,y(i)=3;end;
N=100;
a=-N/2:N/2-1;
b=-N:N-2;
subplot(2,2,1);plot(a,x);axis([-50,50,0,2.5]);grid;
title('premier signal');xlabel('t');ylabel('x(t)');
subplot(2,2,2);plot(a,y);axis([-50,50,0,3.5]);grid;
title('deuxième signal');xlabel('t');ylabel('y(t)');
subplot(2,2,4);plot(b,conv(x,y));grid;
axis([-60 60 0 140]);title('convolution');xlabel('t');
Manip2 :
Soit un système linéaire invariant dans le temps de réponse impulsionnelle h(t) (figure a), et
du signal d’entrée (figure b)( pulse de largeur finie).
1./ Générer et afficher sous Matlab le signal d’entrée x(t) et la réponse impulsionnelle h(t) ;
2./ Calculer l’expression du signal de sortie y(t) ((La commande : conv) ;
3./ Afficher le résultat de la convolution et les signaux x(t) et h(t) la commande subplot.
2. Echantillonnage
Principe
27
Échantillonner un signal consiste à prendre un certain nombre de points régulièrement espacés

de ce signal. Mathématiquement cette opération revient à multiplier le signal analogique
original x(t) par un signal δTe (t ) d’amplitude 1 à chaque instant pour lequel on prend un
échantillon (opération répétée à la période Te ) et d’amplitude zéro sinon. Cette fonction est
appelée peigne de Dirac.
x(t )
xe (t )
Fig. 2 : échantillonnage d’un signal analogique
La période d’échantillonnage Te est l’intervalle de temps entre deux valeurs prélevées sur le
signal analogique. La fréquence d’échantillonnage f e correspond donc au nombre de valeurs
prélevées par seconde.
1
fe =
Te
L’opération d’échantillonnage consiste à remplacer un signal analogique continu dans le
temps x(t), par un autre signal à temps discret. e(t)=x[nTe], qui n’est défini que pour des
valeurs discrètes du temps, multiples entiers d’une durée Te dite période d’échantillonnage.
n =+∞
x[nTe ] = ∑ x(t ).δ(t − nT )
n =−∞
e
Manip3 :
1. Echantillonnage d’un signal test
28
Génération et affichage de signaux

On souhaite générer afficher un signal sinusoïdal d’équation :
x(t ) = A.sin(2πf 0t )
où A est son amplitude et f0 sa fréquence (ω0 sa pulsation).
Les différentes étapes ci-dessous permettent de réaliser cette opération.
Pour connaître les instants des échantillons de ce signal, il faut générer un vecteur dont les
éléments représentent des instants régulièrement espacés (on l’appellera "vecteur de temps"),
par exemple de la manière suivante :
…
t=(0:N-1)*Te; %N : nombre d’éch. total ; Te : période
d’échantillonnage
…
Le signal peut alors être généré à l’aide de la commande suivante :
…
s=a*sin(2*pi*f0*t);
…
On choisit les paramètres suivants :
- fréquence d’échantillonnage : fe=50Hz, 100Hz et 1000Hz,
- fréquence du signal : f0=10Hz,
- amplitude du signal : A=1.
1./ Vérifier que cette fréquence d’échantillonnage est correcte, du point de vue théorique (en
justifiant la réponse).
2./ Ecrire un programme permettant de générer et d’afficher quelques périodes du signal x(t).
3./ Ecrire un programme, utilisant les 2 lignes de code ci-dessus, permettant de générer (et
d’afficher) une période de signal.
2. Affichage du spectre
4./ Rappeler (sans démonstration) l’expression théorique de son spectre (complexe)
d’amplitude.
5./ Représenter le spectre théorique du signal sur un intervalle allant de –fe à 2fe (en
considérant que sa durée est infinie).
6./ Afficher son spectre à l’aide de la fonction fft (l’algorithme FFT, pour Fast Fourier
Transform, est un algorithme de calcul rapide de la TFD, Transformée de Fourier Discrete).
3. Sous-échantillonnage
On simule un sous-échantillonnage de ce signal modifiant la fréquence d’échantillonnage.
7./ Donner l’expression théorique du signal non-tronqué échantillonné.
29
Observer l’effet du sous-échantillonnage en faisant varier la fréquence du signal aux valeurs

suivantes :
f0=fe/10, f0=fe/4, f0=fe/2, f0=fe*3/4, et f0=fe*10/9
8./ Interpréter les résultats en raisonnant sur le spectre (pour le 3e cas, on précisera quelles
sont les valeurs théoriques des échantillons).
Manip4 :
Générer un signal x(t) de durée 0.8 secondes sinusoïdal d’amplitude 1 de fréquence f0=100
Hz échantillonné à fe=1000 Hz.
1./ Combien y a t'il d'échantillons (Ne) ?
Quelle est la longueur du vecteur s ?
2./ Représenter le module de spectre de x(t) la commande :
plot(abs(fft(s))).
4. Générer le vecteur des fréquences freq = n. fe/Ne, avec n variant de 0 à Ne-1.
5. Représenter le module de la TFD en fonction du vecteur fréquences freq : commande
plot(freq,abs(fft(s))).
6. Vérifier qu’il y a bien une raie à la fréquence du signal.
3. Transformée de Fourier
Manip5 :
Soit le signal :
−a t
x(t ) = e avec a>0
Ecrire un script Matlab pour réaliser les opérations suivantes :
1./ Tracer le signal x(t) entre –5 et 5, avec un pas de temps Te = 0.01s, et pour a = 1.
2./ Tracer le spectre en amplitude de X(f) et son spectre d’amplitude en dB :
20.log10(|fft(s,N)|),
3./ Tracer le module et la phase de la transformée de Fourier (fonctions abs et angle) :
angle(fft(s,N))
4./ Calculer la transformée de Fourier Inverse de X(f). Retrouve t’on exactement le signal de
départ x(t)?
5./ Illustrer la propriété de décalage fréquentiel de la TF en représentant le module de la TF
de :
x(t ).ei 2 πf0t avec fo=10 Hz.
Notes Matlab :
1. fft(X,N) est la transformée de Fourier discrète sur N points du vecteur X, complété avec des
zéros si X a moins de N points et tronqué si X a plus de N points.
30
2. La commande X(f)=fft(X,N) codant les fréquences négatives entre N/2+1 et N valeurs du

signal Xf, la commande fftshift(Xf) permet de centrer le spectre sur les fréquences nulles
(entre –1/(2 Te) et 1/(2 Te).
3. Pour approximer la Transformée de Fourier continue X(f) d’un signal x(t), représenté
suivant un pas Te, on utilise la commande : X(f)= fftshift(Te * fft(x)) ;
4. La transformée de Fourier Inverse s’obtient par la commande x(t)=abs(ifft(Xf)/Te). Notez

qu’il est nécessaire de considérer le module de la TF inverse , car la TF et la TF inverse sont
des opérateurs à valeurs complexes
31
TP3 :
Analyse spectrale par la TFD, Fenêtre d’observation et Filtrage
Objectif :
Dans cette séance, nous allons voir un l’application de l’analyse fréquentielle par la TFD,
l’influence de la taille de la fenêtre d’observation et le filtrage.
On présente l’opération du filtrage comme celle de la multiplication du spectre du signal par
une fenêtre censée atténuer certaines composantes fréquentielles.
Analyse spectrale par TFD
- On désire voir ici différentes effets de la TFD en terme de précision d’analyse et de

résolution fréquentielle. Un algorithme par la transformée de Fourier rapide est réalisé par la
fonction fft. Cet algorithme est rapide lorsque la taille des signaux analysés est une puissance
de 2 (128, 256, 512, …). On prendra donc soin de travailler sur des signaux dont la longueur
est une puissance de 2.
- Il est possible d’appliquer la TFD sur le signal ou sur une partie de longueur N. la partie
analyser est appelée fenêtre d’observation.
Manip1 : TFD de la fenêtre rectangulaire

Pour chacune des fenêtres étudiées, on présentera son équation h[n] et une figure comportant :
- son graphe temporel
- son spectre d’amplitudes
- son spectre d’amplitudes en dB
h[n] = {10 pour 0 ≤ n ≤ N

sin on
1- Générer une porte de longueur N=10 échantillons (10 points).
2- Calculer la TFD de la porte sur M=1000 point fréquentiels.
3- Afficher le module de la TFD
Le résultat contient la TFD du signal qui est échantillonné aux points fréquentiel fk=10/M
pour 0<= k<=M-1
4- A quoi est due la symétrie que l’on observe ?
5- Quelle est la largeur du lobe principale ?
32
6- Afficher le module de la TF en décibels, entre 0 et 15dB. Utiliser la fonction « log10 »,

utiliser axis([Xmin, Xmax, Ymin, Ymax]).
7- Vérifier que l’on obtient environ 13dB entre le max du lobe principal et le max du lobe
secondaire.
8- vérifier que pour une porte de largeur N=50 points, on a toujours environ de 13db
Manip2 : TFD de la fenêtre triangulaire
⎧⎪ 2 n si 0 ≤ n ≤
N
h[n] = ⎨ 2−N2 n N
≤n≤ N
2
⎪⎩ 0 N
si
2
sin on
1- Générer une triangulaire de longueur N=50 échantillons (50 points) et de valeur max 1.
3- Afficher le module de la TFD puis en dB.
5- Quel est le rapport en dB entre le max du lobe principal et le max du lobe secondaire.
Manip3 : Fenêtre en cosinus (ou de Hanning)
⎧ 0.5(1−cos(2 π Nn si 0 ≤ n ≤ N
h[n] = ⎨ 0 sin on
⎩
Manip4 : Fenêtre de Blackman
⎧ 0.42−0.5cos(2π Nn )+0.08cos(4π Nn ) si 0 ≤ n ≤ N
h[n] = ⎨ 0 sin on
⎩
33
Faire changer la taille de la fenêtre d’observation (128, 256, 512,…), observer l’influence sur
l’allure du spectre, notamment au niveau des lobes secondaires et la largeur du lobe principal.
Pour cela comparer les effets sur les spectres en dB.
Manip5 : Filtrage
De nombreuses fenêtres de pondération ont été proposées pour l’analyse spectrale. Ces
fenêtres sont utilisées pour limiter (tronquer) la durée temporelle due signal x(t) à analyser.
En notant x(t) le signal. F(t) la fenêtre d’analyse et xtr(t) le signal tronqué, on obtient la
relation suivante :
xtr (t ) = x(t ).F (t )
Soit le signal x(t) défini par :
x(t ) = a cos(2πf 0t ) + b cos(2πf1t ) ,
1- Générer le signal x(t) échantillonné à 1 KHz de 1024points, constitué 2 sinusoïdes
d’amplitude 1 et de fréquences respectivement 100 Hz et 110 Hz.
2- Choisir la fenêtre et la taille (N= 50, …) pour tronquer le signal x(t) et afficher le signal
tronqué xtr(t) (figure ci-dessous).
Fig : signal tronqué
3- Calculer la TFD du signal tronqué xtr(t) et afficher le module de la TF.

4- Changer la taille de la fenêtre d’observation (N= 50, 100 …) et observer l’influence sur
l’allure du spectre Xtr(f).
5- Que devient le spectre quand la taille de la fenêtre N est petite et quand N est grand (N>>).
6- Changer la fenêtre d’observation (rectangulaire, triangulaire, Hanning, …) et observer
l’influence sur l’allure du spectre Xtr(f).
34

TP - Traitement Du Signal - SMP6 2022-2023

Transféré par

Droits d'auteur :

Formats disponibles

TP - Traitement Du Signal - SMP6 2022-2023

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

TP - Traitement Du Signal - SMP6 2022-2023

Transféré par

Droits d'auteur :

Formats disponibles

TRAVAUX PRATIQUES

Responsable : Année universitaire :

Ce polycopié de TP a été rédigé à l’intention des étudiants de la licence fondamentale des

Les modalités de fonctionnement des TP sont :

1. Présence aux T.P :

Chaque TP est constitué de 2 parties : « préparation » et « manipulation ». Une note sera

Les préparations théoriques sont indispensables à la compréhension du T.P. et même parfois

Le but de ce manuscrit est d’apprendre à utiliser le logiciel Matlab, et de manipuler les

- Commandes graphiques (visualisation 2-D et 3-D)

3-1. Session MATLAB

3-2. Contrôle de session

3-3. Principe de la syntaxe

4. Vecteurs, matrices et leur manipulation

>> A.' % Transposée de A

4-1. Opérations matricielles

>> X = A/B % Donne la solution de A*X = B

Certaines fonctions de Matlab agissent indépendamment sur chaque colonnes de la matrice.

4-2. Opérateur " : "

5. Affichages graphiques et alphanumériques

5-1. Initialisation de variables à partir du clavier

5-2. Affichage alphanumérique

1-Tracer une courbe simple

2- Superposer plusieurs courbes

6-Afficher plusieurs graphiques (subplot)

- Diviser la fenêtre en deux parties (1 x 2)

- Diviser la fenêtre en quatre parties (2 x 2)

- Diviser la fenêtre en quatre parties (4 x 1)

9- Ajout du texte au graphique

axis([-1 5 -10 10]) : Choix des échelles x = (-1,5) et y = (-10,10)

6-2. Fonctions construites par l’utilisateur

Interaction fichiers externes

6-2-1. Fonctions pour Séries et Transformées de Fourier

- spectre : calcul d'un spectre. Syntaxe :

1-1. Représentation de signaux

1-2. Traitement du signal

1-3. Approche de caractérisation d’un signal

2. Description Fréquentielle X(f):

3. Description Statistique : Signaux aléatoires ⇒ Propriétés statistiques (Moyenne,

-. Le spectre en amplitude si l’on trace |X (f)|.

Pour consulter le contenu de votre fichier il suffit de taper >>type nomfichier.m

4. Manipulation : Production de signaux sous Matlab

Manip.1 : Génération N échantillons d’une sinusoïde

Générer un signal sinusoïdal x(t) de n échantillons de fréquence f :

6. Commenter les figures obtenues, en déduisant la relation suffisante de la fréquence

Manip.2 : Opérations élémentaires sur les signaux

Manip.3 : Ajout d’un bruit Gaussien :

Rapport Signal à Bruit RSB :

Manip.4 : Synthèse de Fourier (décomposition en série de Fourier)

1. Tracez le signal f(t) sur Matlab.

3. Réaliser un programme permettant de calculer la décomposition en série de Fourier d’un

4. Superposez le signal et sa série de Fourier tronquée au rang p=3.

Fig.1 : Système à temps continu

Échantillonner un signal consiste à prendre un certain nombre de points régulièrement espacés

Fig. 2 : échantillonnage d’un signal analogique

1. Echantillonnage d’un signal test

Génération et affichage de signaux

Observer l’effet du sous-échantillonnage en faisant varier la fréquence du signal aux valeurs

x(t ).ei 2 πf0t avec fo=10 Hz.

2. La commande X(f)=fft(X,N) codant les fréquences négatives entre N/2+1 et N valeurs du