TP01: Transmissions en Bande de Basse et par porteuse

modulee
abdi chakib et kelkouli aniss
October 2023

1 Introduction
La télévision numérique repose sur deux principales méthodes de transmission : la transmission en
bande de base et la transmission par porteuse modulée. La transmission en bande de base con-
siste à transmettre directement des signaux numériques non modulés. Elle est couramment utilisée
à l’intérieur des studios de télévision pour la manipulation des signaux avant la diffusion. La trans-
mission par porteuse modulée, quant à elle, est utilisée pour transmettre des signaux numériques sur
de plus longues distances vers les antennes de réception des téléspectateurs. Les signaux numériques
sont modulés sur une porteuse avant d’être transmis et démodulés à la réception. En résumé, la
transmission en bande de base est utilisée en interne et pour la distribution initiale, tandis que la
transmission par porteuse modulée est employée pour la diffusion vers les téléspectateurs, assurant
ainsi une distribution efficace des signaux numériques de haute qualité.

1
2 Programe de la seance:
nous mettons en evidence deux phenomenes importants apparaissant lors de transmission de donnees

2.1 la limitation en frequence d’un canal de transmission

lors d’une transmission en bande de base, un canal ideal ne deforme naturellement pas les symbles
emit pour un canal reel de bande passante finie, la reaction face aux symboles n’est plus instantanee,
ai bien qui symbole que nous mettrons en evidence au moyen de diagrammes de l’oeil.

2.2 L’immunite au bruit des transmission par porteuse modulee

un autre probleme nuisible a la restuti est la presance de bruit sur le canal. la deuxieme partie de
cette etude vise a etablir une compression a techniques de modulation PSK et QAM a partir de leurs
contellation.

NB: Les questions sont à préparer avant la séance de correction du compte-rendu final, compte tenu
de l’effort de rédaction réalisé par les étudiants. Les résultats numériques doivent être justifiés à
l’aide de représentations graphiques commentées (figure, axe, ...).

2
3 Quelques operations elementaires sous matlab
3.1 generation et observation d’une sequence
Q0: saisie le code dans l’editeur de MATLAB et proceder a son execution

___________________________________________________________________
clear all; clc; % Efface toutes les variables et la console

p = 3; M = 2^p; L = 1000; N = 50; % Définition de plusieurs variables

% Génération de x en utilisant la formule donnée

for i = 1:L
x(i) = (1 + (-1)^i) / 2; % Génère la séquence x en alternant entre 0 et 1
end

Lx = length(x); % Calcule la longueur de x

figure(1); % Crée une nouvelle figure avec l’identifiant 1
subplot(211); % Crée le premier sous-tracé dans la figure
plot(x, ’b*’); % Trace la séquence x en utilisant des astérisques bleus
title(’Generation and Observation’); % Définit le titre du sous-tracé
xlabel(’Iteration’); ylabel(’Symbol’); % Étiquettes des axes x et y
axis([0 L 0 M]); grid; % Définit les limites des axes et ajoute une grille

% Génération d’un x aléatoire

x = randi(M, 1, L); % Réutilisation de la variable x et génération de nombres aléatoires

Lx = length(x); % Recalcule la longueur de x

subplot(212); % Crée le deuxième sous-tracé dans la figure
plot(x, ’r+’); % Trace la séquence x en utilisant des plus rouges
title(’Generation and Observation’); % Définit le titre du sous-tracé
xlabel(’Iteration’); ylabel(’Symbol’); % Étiquettes des axes x et y
axis([0 L 0 M]); grid; % Définit les limites des axes et ajoute une grille

% Génération de xe
N = 50; % Réaffecte la valeur de N
xe = zeros(1, N * L + 1); % Augmente la taille du tableau à N*L+1
for i = 1:N * L
if (i < N * L)
xe(i) = x(1 + floor(i / N)); % Étire la séquence x en répétant chaque élément N fois
end
end
________________________________________________________________

3
 Figure 1: Generation and Observation

Commentaires: Le graphique intitulé ≪ Génération et observation ≫ se compose de deux tracés, l’axe

des x représentant ≪ Itération ≫ et l’axe des y représentant ≪ Symbole ≫.
Le graphique du haut est un graphique linéaire avec une ligne bleue, qui semble être relativement
constante et tourne autour de la valeur 2 sur l’axe des y. Cela pourrait suggérer que quel que soit le
processus ou la variable que représente cette ligne, il est stable au fil des itérations.
Le graphique du bas est un nuage de points avec des croix rouges. Les points de données ici sont
dispersés et ne semblent pas former un modèle ou une tendance claire. Cela pourrait indiquer un
caractère aléatoire ou une grande variabilité dans les données représentées.
• Dans la fenêtre de commande MATLAB, vous pouvez voir diverses indications et informations
qui vous aident à interagir avec MATLAB. Voici quelques-unes des indications les plus
courantes que vous pouvez trouver dans la fenêtre de commande MATLAB :
1. ”¿¿” : C’est le prompt MATLAB qui indique que MATLAB est prêt à accepter une
commande.
2. Erreurs et avertissements : Si vous tapez une commande incorrecte ou s’il y a une erreur
dans votre code, MATLAB affichera un message d’erreur ou d’avertissement pour vous
informer de ce qui ne va pas.
3. Résultats des calculs : Lorsque vous effectuez des calculs, MATLAB affiche les résultats
directement dans la fenêtre de commande.
4. Variables : Vous pouvez voir la liste des variables actuellement définies dans votre session
MATLAB en tapant ”whos” ou ”who” dans la fenêtre de commande.
5. Chemin d’accès : MATLAB affiche également le chemin d’accès du répertoire de travail
actuel en haut de la fenêtre de commande.
6. Commandes précédentes : MATLAB conserve un historique des commandes
précédemment saisies. Vous pouvez utiliser les flèches vers le haut et vers le bas pour
parcourir les commandes précédentes.
7. Messages de sortie : Lorsque vous exécutez des scripts ou des fonctions, MATLAB peut
afficher des messages de sortie pour vous informer de l’état de l’exécution.
8. Autres informations : En fonction de ce que vous faites dans MATLAB, d’autres
informations contextuelles peuvent apparaı̂tre dans la fenêtre de commande.

4
 Ces indications vous aident à comprendre ce que fait MATLAB et à diagnostiquer les
problèmes éventuels. Vous pouvez également personnaliser l’apparence de la fenêtre de
commande en fonction de vos besoins.
• si on supprime le point virgule à la fin de la ligne 6 et 8 Matlab affichera le résultat ou la sortie
de cette expression ou commande dans la fenêtre de commande pour notre cas affiche une train
binaire
• La séquence de symboles générée par le code est une séquence binaire, ce qui signifie qu’elle ne
contient que deux symboles distincts, qui sont généralement notés comme 0 et 1. La nature de
cette séquence est telle qu’elle alterne entre les deux symboles, créant une séquence périodique
de symboles binaires.

• Le point-virgule (;) dans un code MATLAB a pour rôle principal de supprimer l’affichage de la
sortie d’une commande ou d’une expression dans la fenêtre de commande. Cela permet de
maintenir la fenêtre de commande propre en évitant d’afficher des résultats inutiles, ce qui peut
améliorer la lisibilité du code. De plus, le point-virgule peut également être utilisé pour séparer
plusieurs commandes sur une même ligne, facilitant ainsi l’exécution de plusieurs instructions
en une seule ligne de code. Dans l’ensemble, son utilisation principale réside dans la gestion de
l’affichage des résultats dans la fenêtre de commande MATLAB.

Q1: completer ce programme coomme indeque ci-contre

1. La fonction ‘randi(L, 1, M)‘ en MATLAB génère un vecteur de nombres aléatoires entiers entre
1 et M (inclus), avec une taille de L lignes et 1 colonne. Chaque élément du vecteur sera un
nombre entier aléatoire compris entre 1 et M. Dans le code que vous avez fourni, ‘randi(M, 1,
L)‘ est utilisé pour générer un vecteur ‘x‘ de longueur L, où chaque élément de ‘x‘ est un
nombre entier aléatoire entre 1 et M. La nature de la séquence de symboles générés dépend de

la valeur de M dans ce contexte. Dans votre code, M est défini comme 2’p, où p est égal à 3, ce
qui signifie que M est égal à 2’3, soit 8. Par conséquent, la séquence de symboles générés dans
le vecteur ‘x‘ sera constituée d’entiers aléatoires compris entre 1 et 8.

2. % Create and customize Figure 1

figure(1);
subplot(211);
plot(x, ’b*’);
title(’Generation and Observation’);
xlabel(’Iteration’);
ylabel(’Symbol’);
axis([0 L 0 M]);
grid;

% Allow the user to interactively select a region to zoom in

disp(’Cliquez sur deux points pour sélectionner une région à agrandir.’);
[x_selected, ~] = ginput(2);
x_min = round(min(x_selected));
x_max = round(max(x_selected));

% Create a new figure to display the zoomed-in region

figure(2);
plot(x(x_min:x_max), ’b*’);
title(’Zoomed-In Region’);
xlabel(’Iteration’);
ylabel(’Symbol’);
axis([x_min x_max 0 M]);
grid;

5
 Figure 2

3. Si vous voulez faire la même expérience pour p =2 et p =3, il suffit de changer la valeur de p
dans le code et d’exécuter à nouveau le programme. La valeur de M correspondra alors à 4 et
8, respectivement. M représente le nombre de niveaux différents que peut prendre le signal
modulé. Plus M est grand, plus la modulation est complexe, mais plus elle permet de
transmettre d’informations par symbole.

6
3.2 simulation d’un signal à l’entrée du canal
Q2:
1. Pour déterminer la taille du tableau xe à l’aide de la fonction length dans la fenêtre de
commande de MATLAB, vous pouvez simplement saisir length(xe) dans la fenêtre de
commande et appuyer sur Entrée. Cela vous donnera la longueur du tableau xe. Cependant, en
se basant sur le code que vous avez fourni, la taille du tableau xe est calculée comme suit dans
votre code : xe = zeros(1, N * L + 1); Le tableau xe est initialisé avec une longueur de N * L +
1. Dans votre code, N est défini comme 50 et L est défini comme 1000. Par conséquent, la taille
du tableau xe est 50 * 1000 + 1, ce qui équivaut à 50001. Donc la taille du tableau xe est de
50001 éléments. Vous pouvez également vérifier cela en exécutant length(xe) dans la fenêtre de
commande de MATLAB pour confirmer la taille.
2. La fonction ‘floor(i/N)‘ dans le code que vous avez fourni réalise une division entière de ‘i‘ par
‘N‘ et retourne le quotient en tant que nombre entier arrondi vers le bas. Voici comment cela
fonctionne :
• Si ‘i‘ est un multiple de ‘N‘, alors ‘floor(i/N)‘ renverra le quotient de la division entière,
c’est-à-dire ‘i/N‘.
• Si ‘i‘ n’est pas un multiple de ‘N‘, alors ‘floor(i/N)‘ renverra le quotient entier inférieur à
‘i/N‘. Par exemple, si ‘i = 7‘ et ‘N = 3‘, alors ‘floor(7/3)‘ renverra ‘2‘, car la division 7 par
3 donne un quotient de 2 avec un reste de 1, et ‘floor‘ arrondit vers le bas.Cette fonction
est utilisée dans le code que vous avez fourni pour découper la séquence ‘x‘ en segments de
longueur ‘N‘ lors de la génération de la séquence ‘xe‘. Chaque élément de ‘xe‘ est obtenu
en prenant la valeur de ‘x‘ correspondante à l’indice ‘floor(i/N)‘ dans la séquence ‘x‘. Cela
permet de répéter chaque valeur de ‘x‘ ‘N‘ fois dans la séquence ‘xe‘.

7
4 transmission en bande de base
4.1 limitations en fréquence
Q3: le code :

q=2;
eyediagram(y,q*N);grid;
clear all; clc; title(’diagramme de oeil’);
p = 4; M = 2^p; L = 1000; N = 50;
T=L/q;
% Generate the first signal for t=1:T
for i = 1:L for i=1:q*N
x1(i) = mod(i, M); oeil(i,t)=y(i+N*(t-1));
end end
figure(1); end
subplot(211); figure(4);plot(oeil);grid;
plot(x1, ’b*’); title(’observation a lechelle de la duree de q symb’);
title(’Generation and Observation’); xlabel(’temps’);ylabel(’sortie du canal’);
xlabel(’Iteration’); ylabel(’Symbol’);
axis([0 L 0 M]); grid; xm=pskmod(x2,M);scatterplot(xm);grid;
Lx=length(x2);Lxm=length(xm)
% Generate the second signal y=pskmod(xe,M);scatterplot(y);grid;
x2 = randi([0, M-1], 1, L); title(’donner un titre a ce grahique’);
subplot(212); xlabel(’axe reel’);ylabel(’axe’);
plot(x2, ’r+’);
title(’Generation and Observation’); z=pskdemod(y,M);
xlabel(’Iteration’); ylabel(’Symbol’); figure(3);plot(xe,z,’r.’);grid;
axis([0 L 0 M]); grid; title(’restitution sans bruit’);
xlabel(’signal original’);
% Increase the array size to N*L+1 ylabel(’signal restitue’);
xe = zeros(1, N * L + 1);
for i = 1:N * L RSB=15;yn=awgn(y,RSB);
if (i < N * L) scatterplot(yn);grid;
xe(i) = x2(1 + floor(i / N)); title(’donner un titre de ce grahe ’);
end xlabel(’axe...’);ylabel(’axe..’);grid;
end
zn=pskdemod(yn,M);
n=4;wn=0.05; figure(5);plot(xe,zn,’r.’);
[b,a]=butter(n,wn,’LOw’); title(’donner un titre ’);
y=filter(b,a,xe); xlabel(’signal original’);grid;

figure(2); [N,R]=symerr([1 2 3 4],[1 2 3 5])

subplot(211);plot(xe); p=3;L=1000;N=50;
title(’signal entree’); M = 4; % Modulation order
xlabel(’temps’);ylabel(’valeur de xe’); x = randi([0, M-1], 1, L);
axis([0 N*L 0 M]);grid;
subplot(212);plot(y); taux=zeros(20,4);
title(’signal de sortie’); xe=zeros(1,N*L);
xlabel(’temps’);ylabel(’valeur de y’); for i=1:N*L
axis([0 N*L 0 M]);grid; if(i<N*L)
xe(i)=x(1+floor(i/N));
end
end

8
y=pskmod(xe,M);

for RSB=1:20
yn=awgn(y,RSB);
zn=pskdemod(yn,M);
[number,ratio]=symerr(xe,zn);
taux(RSB,p)=ratio;
end

figure(6);plot(taux);grid;
title(’donner titre ’);
xlabel(’RSB’);ylabel(’...’);

Figure 3

1. dans le cas de wn=0,2 on trouve que le signal émise presque le signal reçue
2. l’ordre et la fréquence de coupure d’un filtre Butterworth influencent la capacité du filtre à
atténuer les fréquences indésirables, la largeur de bande passante utile du système, la latence
(en fonction de l’ordre), et la capacité à traiter les signaux à large bande passante. Le choix
entre un ordre élevé ou faible et une fréquence de coupure élevée ou basse dépendra des
exigences spécifiques de la transmission, notamment la bande passante du signal, le bruit, les
interférences et d’autres contraintes du système.

9
4.2 confusion inter-symbole
Q4:

Figure 4: diagramme de loeil de la sortie de canal

1. la fonction eyediagram(y,q*N), qui permet de tracer le diagramme de l’œil d’un signal

numérique filtré y avec q symboles par période d’échantillonnage. le diagramme de l’œil est un
outil graphique qui permet d’évaluer la qualité d’un signal numérique en fonction du bruit, de
la distorsion, de l’interférence
2. Les arguments de cette fonction sont les suivants :

• y : le signal numérique filtré, qui doit être un vecteur ou une matrice contenant les valeurs
du signal reçu. Si y est une matrice, chaque colonne représente un canal différent
• q*N : le nombre d’échantillons par période d’échantillonnage pour le diagramme de l’œil,
qui doit être un entier positif. Le produit q*N donne le nombre d’échantillons par symbole
multiplié par le nombre de symboles par période d’échantillonnage. Ce paramètre
détermine la largeur du diagramme de l’œil

10
 (a) n=1 (b) n=2

(c) n=3

3. filtrage d’ordre (1,2,3)

• quand diminue l’ordre de filtre on trouve que on a pas une confusion inter- symbole

Q5:

1. La ligne 53 du code est la suivante : eyediagram(y,q*N);grid; Cette ligne permet de tracer le

diagramme de l’œil du signal numérique filtré y avec la fonction eyediagram(y,q*N). La variable
q représente le nombre de symboles par période d’échantillonnage pour le diagramme de l’œil.
La valeur de q est fixée à 2 dans le code, ce qui signifie que le diagramme de l’œil affiche deux
symboles par période d’échantillonnage. Le produit q*N donne le nombre d’échantillons par
période d’échantillonnage pour le diagramme de l’œil. La fonction grid ajoute une grille à la
figure.
2. La dimension de la matrice de l’œil est q*N x T, où q est le nombre de symboles par période
d’échantillonnage, N est le nombre d’échantillons par symbole et T est le nombre de périodes
d’échantillonnage. Par exemple, si vous avez un signal numérique de 1000 symboles, avec 2
symboles par période d’échantillonnage et 50 échantillons par symbole, alors la dimension de la
matrice de l’œil sera 100 x 500.

11
 (a) p=2 (b) p=3

3. simulation pour p=[2,3]

•
La simulation du signal numérique avec p=2 et p=3 donne des résultats différents pour le
diagramme de l’œil. En effet, la valeur de p influence la bande passante du signal numérique,
qui est proportionnelle au nombre de bits par seconde. Plus p est grand, plus le signal
numérique a une bande passante élevée et plus il est sensible au bruit et à la distorsion. Le
filtrage du signal numérique avec un filtre passe-bas de Butterworth permet de réduire la bande
passante du signal numérique et d’atténuer les effets du bruit et de la distorsion. Le choix de la
fréquence de coupure normalisée wn du filtre passe-bas de Butterworth dépend de la valeur de
p. Plus p est grand, plus wn doit être petit pour limiter la bande passante du signal numérique.
• Par exemple, si on utilise les mêmes paramètres que dans le code MATLAB que vous avez
écrit (n=4, wn=0.05), on obtient les diagrammes de l’œil suivants pour p=2 et p=3 :
on peut voir que le diagramme de l’œil pour p=2 est plus ouvert que celui pour p=3, ce
qui signifie que le signal numérique pour p=2 est de meilleure qualité que celui pour p=3

Q6

p = 3; M = 2^p; L = 1000; N = 50;

% ... (previous code remains unchanged)
q = 2;
eyediagram(y, q * N);
title(’Eye Diagram’);

T = L / q;
for t = 1:T
for i = 1:q * N
oeil(i, t) = y(i + N * (t - 1));
end

% Add a pause statement to pause for a moment before continuing the loop.
pause(1); % Pause for 1 second.
end

12
 Figure 5

Avec cette modification, la commande pause(1) sera exécutée à la fin de chaque itération de la boucle
où la valeur de T est variée. Cela signifie qu’après le traitement et l’affichage de chaque image du
diagramme de l’œil, le programme fera une pause d’une seconde avant de passer à l’itération
suivante. Cette pause vous permettra d’observer les résultats ou les changements dans le diagramme
de l’œil avant que la boucle ne passe à l’étape suivante
• n = 0.05 : Avec cette valeur de wn, le filtre Butterworth appliqué au signal xe est un filtre
passe-bas avec une bande passante relativement étroite. Cela signifie que le filtre laisse passer
les basses fréquences et atténue fortement les hautes fréquences. L’effet de wn = 0.05 sur le
filtrage sera observé dans le diagramme de l’œil et le signal de sortie. wn = 0.5 : Si vous
modifiez wn à 0.5, le filtre Butterworth aura une bande passante beaucoup plus large, ce qui
signifie qu’il laissera passer un plus large spectre de fréquences. Cela peut avoir un impact
significatif sur le filtrage du signal xe et, par conséquent, sur le diagramme de l”œil et le signal
de sortie. Vous devriez observer un changement significatif dans la réponse du filtre et la forme
du diagramme de l’œil.
L’exécution de ces deux simulations vous permettra de comparer l’impact de deux valeurs différentes
de wn sur le système de communication. Vous devriez observer des différences dans le filtrage, le
diagramme de l’œil et la qualité du signal en sortie.

13
5 transmission par modulation d’une porteuse:
5.1 Rappel theorique:
Q7:
1. Modulation PSK (Phase Shift Keying) : La modulation PSK est une technique de
modulation numérique qui modifie la phase d’une onde porteuse pour transmettre des données
binaires. Dans la modulation PSK, différentes phases de la porteuse représentent différents
symboles binaires. Par exemple, en PSK binaire (BPSK), une phase représente 0, et l’opposée
représente 1. En PSK à quatre phases (QPSK), quatre phases différentes (0, p/2, p, 3p/2) sont
utilisées pour représenter 2 bits par symbole.
2. Modulation QAM (Quadrature Amplitude Modulation) : La modulation QAM est une
technique de modulation numérique qui combine à la fois la phase et l’amplitude d’une onde
porteuse pour transmettre des données. Dans la modulation QAM, il y a une constellation de
points dans le plan complexe, où la position de chaque point représente un symbole ou une
combinaison de bits. Par exemple, dans la modulation QAM 16, il y a 16 points dans la
constellation, et chaque point représente 4 bits (comme 0000, 0001, 0010, etc.). La distance
entre les points dans la constellation dépend de la qualité de la modulation.
3. Représentation dans le Plan Complexe :
• En PSK, chaque symbole est représenté par une phase spécifique sur le plan complexe, ce
qui signifie que les points de la constellation sont répartis uniformément sur un cercle.
• En QAM, chaque point de la constellation est représenté par une amplitude et une phase.
Les points sont répartis dans le plan complexe en formant une grille ou un motif, avec une
distance spécifique entre les points voisins en amplitude et phase.
La principale différence réside dans le fait que la modulation PSK modifie principalement la
phase de la porteuse tout en maintenant l’amplitude constante, tandis que la modulation QAM
modifie à la fois l’amplitude et la phase pour représenter des symboles différents. En
conséquence, la modulation QAM est capable de transmettre plus d’informations (bits) par
symbole que la modulation PSK, mais elle est plus sensible au bruit et à l’atténuation du signal.

5.2 Modulation par saut de phase

Q8:
clc;clf
p=3,M=2^p;x=[0:M-1];
xm=pskmod(x,M);scatterplot(xm);grid;
Lx=length(x);Lxm=length(xm)
x,Lx,xm,Lxm

1. La fonction pskmod dans MATLAB génère des nombres complexes pour la modulation PSK
(Phase Shift Keying). Chaque nombre complexe représente un symbole dans le schéma de
modulation. nombres avec leurs modules (amplitudes) et phases :
• 1.0000 + 0.0000i : Module = 1, Phase = 0 rad
• 0.7071 + 0.7071i : Module = 1, Phase = p/4 rad
• 0.0000 + 1.0000i : Module = 1, Phase = p/2 rad
• -0.7071 + 0.7071i : Module = 1, Phase = 3p/4 rad
• -1.0000 + 0.0000i : Module = 1, Phase = p rad
• -0.7071 - 0.7071i : Module = 1, Phase = -3p/4 rad
• -0.0000 - 1.0000i : Module = 1, Phase = -p/2 rad
• 0.7071 - 0.7071i : Module = 1, Phase = -p/4 rad

14
 Figure 6

clc;clf
P = [2 3 4 5]; % Vector of p values to check
for i = 1:length(P)
p = P(i);
M = 2^p;
x = [0:M-1];
xm = pskmod(x,M);
figure;
scatterplot(xm);grid;
title([’PSK Modulation for p = ’, num2str(p)]);
Lx = length(x);
Lxm = length(xm);
disp([’For p = ’, num2str(p), ’, x and xm are:’]);
disp(’x = ’); disp(x);
disp(’Lx = ’); disp(Lx);
disp(’xm = ’); disp(xm);
disp(’Lxm = ’); disp(Lxm);
end

15
(a) Caption a (b) Caption b

(c) Caption c (d) Caption d

Figure 7: n=[2,3,4,5]

16
 2. La fonction scatterplot dans MATLAB est utilisée pour créer un diagramme de dispersion.
Voici une explication détaillée de ce que fait cette fonction :
• scatterplot(xm) : Cette ligne crée un diagramme de dispersion avec des marqueurs
circulaires aux emplacements spécifiés par le vecteur xm.
Le diagramme de dispersion est un type de graphique qui utilise des coordonnées cartésiennes
pour afficher les valeurs de deux variables pour un ensemble de données. Les points sur ce
graphique sont marqués avec des cercles.

5.3 modulation et demodulation

clear all; clc;

p = 3; M = 2^p; L = 1000; N = 50;

% Generate the first signal q=2;

for i = 1:L eyediagram(y,q*N);grid;
x1(i) = mod(i, M); title(’diagramme de oeil’);
end
figure(1); T=L/q;
subplot(211); for t=1:T
plot(x1, ’b*’); for i=1:q*N
title(’Generation and Observation’); oeil(i,t)=y(i+N*(t-1));
xlabel(’Iteration’); ylabel(’Symbol’); end
axis([0 L 0 M]); grid; end

% Generate the second signal figure(4);plot(oeil);grid;

x2 = randi([0, M-1], 1, L); title(’observation a lechelle de la duree de q symb’);
subplot(212); xlabel(’temps’);ylabel(’sortie du canal’);
plot(x2, ’r+’); xm=pskmod(x2,M);scatterplot(xm);grid;
title(’Generation and Observation’); Lx=length(x2);Lxm=length(xm)
xlabel(’Iteration’); ylabel(’Symbol’); y=pskmod(xe,M);scatterplot(y);grid;
axis([0 L 0 M]); grid; title(’donner un titre a ce grahique’);
xlabel(’axe reel’);ylabel(’axe’);
% Increase the array size to N*L+1
xe = zeros(1, N * L + 1); z=pskdemod(y,M);
for i = 1:N * L figure(3);plot(xe,z,’r.’);grid;
if (i < N * L) title(’restitution sans bruit’);
xe(i) = x2(1 + floor(i / N)); xlabel(’signal original’);
end ylabel(’signal restitue’);
end
RSB=15;yn=awgn(y,RSB);
n=4;wn=0.05; scatterplot(yn);grid;
[b,a]=butter(n,wn,’LOw’); title(’donner un titre de ce grahe ’);
y=filter(b,a,xe); xlabel(’axe...’);ylabel(’axe..’);grid;

figure(2); zn=pskdemod(yn,M);
subplot(211);plot(xe); figure(5);plot(xe,zn,’r.’);
title(’signal entree’); title(’donner un titre ’);
xlabel(’temps’);ylabel(’valeur de xe’); xlabel(’signal original’);grid;
axis([0 N*L 0 M]);grid;
subplot(212);plot(y);
title(’signal de sortie’);
xlabel(’temps’);ylabel(’valeur de y’);
axis([0 N*L 0 M]);grid;

17
 [N,R]=symerr([1 2 3 4],[1 2 3 5])

p=3;L=1000;N=50;
M = 4; % Modulation order
x = randi([0, M-1], 1, L);

taux=zeros(20,4);
xe=zeros(1,N*L);
for i=1:N*L
if(i<N*L)
xe(i)=x(1+floor(i/N));
end
end

y=pskmod(xe,M);

for RSB=1:20
yn=awgn(y,RSB);
zn=pskdemod(yn,M);
[number,ratio]=symerr(xe,zn);
taux(RSB,p)=ratio;
end

figure(6);plot(taux);grid;
title(’donner titre ’);
xlabel(’RSB’);ylabel(’...’);

Q9:
1. Le vecteur z contient les données démodulées du signal y

Figure 8

18
 2. commentaire: L’image que vous avez partagée semble être un nuage de points intitulé
≪ restitution sans bruit ≫, qui se traduit par ≪ restitution sans bruit ≫. L’axe des x est

étiqueté ≪ signal original ≫ (signal original) et l’axe des y est étiqueté ≪ signal restitué
≫ (signal restitué). L’intrigue contient des points rouges dispersés partout.

Ce tracé montre probablement la relation entre le signal d’origine et le signal restauré après une
certaine forme de traitement, telle qu’une modulation ou une démodulation. Si le traitement
était parfait et qu’il n’y avait pas de bruit, tous les points se trouveraient le long d’une ligne
avec une pente de 1. Cependant, dans des scénarios pratiques, il pourrait y avoir un certain
écart dû au bruit ou à des non-idéalités du système. Ce graphique peut vous aider à mieux
comprendre ces effets.

5.4 Immunite au bruit en PSK

Q10:

Figure 9

1. e vecteur zn contient les données démodulées du signal yn qui a été ajouté avec du bruit. La
fonction pskdemod(yn,M) est utilisée pour démoduler le signal yn qui a été modulé en utilisant
la modulation par déplacement de phase (PSK) avec M comme ordre de modulation.
2. commentaire: diagramme de constellation d’un signal modulé par modulation par déplacement
de phase (PSK) y après avoir été ajouté à un bruit gaussien blanc (awgn(y,RSB)). Le motif
circulaire suggère que le signal a été affecté par le bruit, provoquant l’écartement des points
depuis leur emplacement idéal.
Q11:
1. La fonction MATLAB symerr permet de calculer le nombre d’erreurs de symboles (N) et le
taux d’erreur de symboles (R) entre deux séquences. Dans ce cas, les séquences sont [1 2 3 4] et
[1 2 3 5].

19
 2. • La sortie indique qu’il y a 1 erreur de symbole (N = 1). En effet, le quatrième élément de
la deuxième séquence est 5, alors qu’il est 4 dans la première séquence.
• Le taux d’erreur de symbole (R) est calculé comme le nombre d’erreurs de symbole divisé
par le nombre total de symboles. Donc, R = N/Nombre total de symboles = 1/4 = 0,25

Q12:

Figure 10

1. La matrice qui consigne les différents taux d’erreurs est taux. Cette matrice a 20 lignes et 4
colonnes. Chaque ligne correspond à une valeur de Signal-to-Noise Ratio (SNR) de 1 à 20.
Chaque colonne correspond à une valeur de p (dans votre code, p=3). Donc, taux(RSB, p)
donne le taux d’erreur de symbole pour un SNR donné et une valeur p donnée.
2. Ces valeurs correspondent à la troisième colonne de notre matrice taux, qui est associée à p=3
dans notre code.
3. L=1000;N=50;
M = 4; % Modulation order
taux=zeros(20,4);

for p=1:4
x = randi([0, M-1], 1, L); % Generate random symbols in the range [0, M-1]
xe=zeros(1,N*L);
for i=1:N*L
if(i<N*L)
xe(i)=x(1+floor(i/N));
end

20
 end

y=pskmod(xe,M);

for RSB=1:20
yn=awgn(y,RSB);
zn=pskdemod(yn,M);
[number,ratio]=symerr(xe,zn);
taux(RSB,p)=ratio;
end
end

taux
figure(6);plot(taux);grid;
title(’donner titre ’);
xlabel(’RSB’);ylabel(’...’);

Figure 11

4. L’axe des x est étiqueté ≪ RSB ≫ et l’axe des y est étiqueté ≪ . . . ≫. Les deux lignes
commencent dans le coin supérieur gauche du graphique et diminuent à mesure qu’elles se
dirigent vers la droite. La ligne rouge diminue plus rapidement que la ligne bleue.
Ce graphique montre probablement les taux d’erreur de symbole pour différents rapports signal
sur bruit (RSB) pour deux valeurs différentes de p (1 à 4). La tendance à la baisse suggère qu’à
mesure que le RSB augmente, le taux d’erreur des symboles diminue, ce qui est un
comportement typique dans les systèmes de communication numérique. La différence dans les
taux de diminution pourrait être due aux différents schémas de modulation ou paramètres du
système utilisés pour chaque ligne.
5. bien que l’augmentation de M permette de transmettre plus de bits par symbole et
d’augmenter ainsi le débit des données, elle rend également le système plus sensible au bruit. Il
s’agit donc d’un compromis entre le débit des données et la robustesse au bruit.

21
5.5 modulation d’amplitude en quadrature
Q13:
clear all; clc;
p = 4; M = 2^p; L = 1000; N = 50;
% Generate the first signal
for i = 1:L
x1(i) = mod(i, M);
end
figure(1);
subplot(211);
plot(x1, ’b*’);
title(’Generation and Observation’);
xlabel(’Iteration’); ylabel(’Symbol’);
axis([0 L 0 M]); grid;
% Generate the second signal
x2 = randi([0, M-1], 1, L);
subplot(212);
plot(x2, ’r+’);
title(’Generation and Observation’);
xlabel(’Iteration’); ylabel(’Symbol’);
axis([0 L 0 M]); grid;
% Increase the array size to N*L+1
xe = zeros(1, N * L + 1);
for i = 1:N * L
if (i < N * L)
xe(i) = x2(1 + floor(i / N));
end
end
n=4;wn=0.05;
[b,a]=butter(n,wn,’LOw’);
y=filter(b,a,xe);
figure(2);
subplot(211);plot(xe);
title(’signal entree’);
xlabel(’temps’);ylabel(’valeur de xe’);
axis([0 N*L 0 M]);grid;
subplot(212);plot(y);
title(’signal de sortie’);
xlabel(’temps’);ylabel(’valeur de y’);
axis([0 N*L 0 M]);grid;
q=2;
eyediagram(y,q*N);grid;
title(’diagramme de oeil’);
T=L/q;
for t=1:T
for i=1:q*N
oeil(i,t)=y(i+N*(t-1));
end
end
figure(4);plot(oeil);grid;
title(’observation a lechelle de la duree de q symb’);
xlabel(’temps’);ylabel(’sortie du canal’);
xm=qammod(x2,M);scatterplot(xm);grid;Lx=length(x2);Lxm=leng
y=qammod(xe,M);scatterplot(y);grid;
title(’donner un titre a ce grahique’);
xlabel(’axe reel’);ylabel(’axe’);
z=qamdemod(y,M);
figure(3);plot(xe,z,’r.’);grid;
title(’restitution sans bruit’);
xlabel(’signal original’);
ylabel(’signal restitue’);
RSB=15;yn=awgn(y,RSB);
scatterplot(yn);grid;
title(’donner un titre de ce grahe ’);
xlabel(’axe...’);ylabel(’axe..’);grid;
zn=qamdemod(yn,M);
figure(5);plot(xe,zn,’r.’);
title(’donner un titre ’);
xlabel(’signal original’);grid;
[N,R]=symerr([1 2 3 4],[1 2 3 5])
p=3;L=1000;N=50;
M = 4; % Modulation order
x = randi([0, M-1], 1, L); % Generate random symbols in the
taux=zeros(20,4);
xe=zeros(1,N*L);
for i=1:N*L
if(i<N*L)
xe(i)=x(1+floor(i/N));
end
end
y=qammod(xe,M);
for RSB=1:20
yn=awgn(y,RSB);
zn=qamdemod(yn,M);
[number,ratio]=symerr(xe,zn);
taux(RSB,p)=ratio;
end
figure(6);plot(taux);grid;
title(’donner titre ’);
xlabel(’RSB’);ylabel(’...’);
22
(a) .modulation en quadrature à 16 états sans (b) restitition d’un signal sans bruit.
bruit.

(c) modulation en quadrature d’un signal bruité. (d) restitition d’un signal bruité.

(e) Taux d’erreur en modulation QAM.

Figure 12: RESULTA

23
Comparaison : PSK est généralement plus résistant au bruit de phase par rapport à QAM, tandis
que QAM est plus sensible au bruit d’amplitude en raison de sa dépendance à l’amplitude du signal.
Le choix entre PSK et QAM dépend des conditions spécifiques du canal de communication, de la
tolérance au bruit, et des exigences de débit binaire de l’application. Il est courant de réaliser des
simulations ou des tests pour déterminer la meilleure modulation dans un contexte particulier.

6 conclusion:
En conclusion, le choix entre la transmission en bande de base et la transmission par porteuse
modulée dépend des besoins spécifiques d’une application. La transmission en bande de base est
adaptée aux signaux à basse fréquence sur de courtes distances, tandis que la transmission par
porteuse modulée est préférée pour des communications à longue distance et des signaux à haute
fréquence. Les deux techniques jouent un rôle essentiel dans le domaine des communications, offrant
des solutions adaptées à différentes situations.

24