1

Projet par : -Jihene Ben Tekaya

-Aya Hamza

Projet :

Chaîne de transmission numérique

Introduction :
Le but de ce projet de transmission numérique est de simuler une chaîne de transmission
numérique. La chaîne permet de transmettre un flux de données binaires d’un point A
(l’émetteur des données) à un point B (le récepteur des données) en passant par un canal de
transmission. La première partie de la chaîne est donc localisée en A et consiste en la
transformation du signal binaire en un signal émis, avec l’ajout de diverses sécurités pour
permettre une meilleure réception. La seconde partie se trouve dans B, le récepteur qui va
permettre de filtrer le signal, puis de retransmettre le flux de données vers la chaine binaire
d’origine. Pour ce faire, nous avons à notre disposition le logiciel Matlab 2015a et les
connaissances qui nous ont été dispensées en cours. Il nous faudra ensuite mettre en place
divers dispositif pour améliorer la qualité de la transmission. Nous allons donc pendant ce TP, à
l'aide de l'outil Matlab, mettre ces cours en pratique et construire un canal d'émission et de
réception. Nous allons également nous intéresser au codage de l'information et notamment
aux codes de correction de Hamming. Mais, une présentation générale de la chaîne de
transmission, suivie par une description de chacun des modules impliqués dans la chaîne, en
partant du centre (du canal) pour revenir vers les extrémités (le flux de données binaires
représentant l’information à transmettre).
 2

Les composants d’une chaîne de transmission numérique :

La source de message
Pour réaliser une transmission numérique, le message à transmettre doit être sous forme
numérique. Si la source délivre un message analogique tel que le signal de parole (sortie d'un
microphone) ou le signal d'image (sortie d'une caméra), il faut le numériser en échantillonnant le
message analogique puis en quantifiant les échantillons obtenus. Chaque échantillon quantifié
est ensuite codé sur n bits.

Le codage de source :
Consiste à supprimer la redondance contenue dans les messages de la source d’information.
Il peut être avec ou sans pertes d’information. La compression avec pertes vise les signaux
numérisés (image, audio ou vidéo). Après numérisation et codage, la source de message
numérique est caractérisée par son débit binaire D. défini comme le nombre d'éléments binaires
émet par unité de temps. D est égale à : avec T est la durée d’un bit.

Le codage :
Le codage de canal, encore appelé codage détecteur-Correcteur d’erreurs Consiste à
insérer dans le message des éléments binaires dits de redondance, suivant une loi donnée.
Exemple : Le bit de parité (paire ou impaire) ...

Les codes de Hamming, pour lesquels n=2k-1 et m=n-k, permettent de corriger une
erreur ; pour k fixé et n grand, le taux de transmission est voisin de 1. Leur
description fait appel à l'algèbre linéaire modulo 2, ou bien aux polynômes modulo
2. Un mot de p bits est représenté par un vecteur binaire de longueur p, c'est-à-dire
un élément de l'espace vectoriel (Z/2Z)p, par exemple pour 110 :

La matrice de parité d'un code de Hamming est une matrice binaire à klignes
et n colonnes : les colonnes contiennent les représentations binaires des entiers
entre 1 et n, par exemple :
 3

La matrice de parité, H, permet de définir les mots du code : ce sont les

vecteurs c de dimension n tels que Hc=0.

La détermination d'une base du sous-espace d'équation Hc=0 permet de formuler

le codage : si G est la matrice dont les lignes sont les vecteurs d'une telle
base, Hc=0 équivaut à c=aG pour a, un vecteur-ligne de longueur m. Ainsi a est
codé par c=aG ; on dit que G est la matrice génératrice du code.

Dans l'exemple précédent, on trouve facilement, par exemple :

ce qui fait que les 3 premiers bits sont ceux de correction, les 4 suivants étant les
bits d'information.

Une autre technique pour construire ce code consiste à utiliser des

polynômes primitifs. On note ainsi que la matrice H s'obtient en décomposant les
monômes Xi, pour dans la base de l'espace vectoriel des
3
polynômes à coefficients dans Z/2Z, et modulo P=1+X+X . On a
ainsi X3 = X+1, X4 = X2+X, X5 = X2+X+1, X6=X2+1 modulo P (ce polynôme est
primitif car les monômes forment une base de cet espace vectoriel). Par
construction de H, Hb est égal à modulo P. Il en résulte que
les bits de correction sont obtenus en calculant le reste de la division euclidienne
de par P. Pour le décodage, supposons qu'une erreur se
soit produite sur le bit p. Au lieu de recevoir le polynôme Q, c'est Q+Xp qui est
reçu. Le reste de la division euclidienne de Q+Xp par P est égal à Xp modulo P ;
ceci permet de déterminer p, donc l'erreur.
 4

Modulation à l’émission
Les modulations numériques consistent à utiliser une porteuse sinusoïdale haute
fréquence modulée par un signal informatif numérique. Les techniques de modulation
diffèrent mais les circuits modulateurs et démodulateurs sont identiques dans leur
principe aux modulations analogiques.
Le rapport signal sur bruit est meilleur avec un système numérique car, même si un
signal numérique est bruité, distordu ou parasité, il est facile de le reconstruire en
comparant ce signal déformé à un seuil.
Les densités spectrales des signaux modulés numériquement ont des largeurs
moindres qu’en analogique, ce qui permet d’augmenter le nombre de canaux utilisables
par Hz pour les transmissions d’informations Multiplexage fréquentielle.
Si on veut diminuer le bruit dont est victime l’information lors de sa transmission →on
augmente le rapport signal sur bruit SNR.
Dans ce TP on utilise La PSK-2 (Phase Shift Keying) ou modulation par saut de phase
Par exemple, pour la PSK-2 (ou « BPSK », Binary PSK), la phase de la porteuse, de
fréquence et d’amplitude constantes, saute brusquement de φ1 à φ2 lorsque e(t) passe de 1 à
0. Elle est utilisée dans les réseaux locaux, les modems…

Canal de transmission :
Une ligne de transmission est une liaison entre les deux machines. On désigne
généralement par le terme émetteur la machine qui envoie les données et par récepteur celle
qui les reçoit. La ligne de transmission, appelée aussi parfois canal de transmission ou voie de
transmission.
 5

Le canal de transmission est basé sur des supports physiques de transmissions qui sont les
éléments permettant de faire circuler les informations entre les équipements de transmission, ils
peuvent être :

 Les supports filaires permettent de faire circuler une grandeur électrique sur un
câble généralement métallique

 Les supports aériens désignent l'air ou le vide, ils permettent la circulation d'ondes
électromagnétiques ou radioélectriques diverses

 Les supports optiques permettent d'acheminer des informations sous forme

lumineuse

La transmission de données sur un canal de transmission ne se fait pas sans pertes, C’est
dûe aux perturbations qui peuvent être de nature :

 Les parasites : l'ensemble des perturbations modifiant localement la forme du signal.

On distingue généralement deux types de bruit : bruit blanc et bruit impulsif

 L'affaiblissement du signal représente la perte de signal en énergie dissipée dans la

ligne. Il se traduit par un signal de sortie plus faible que le signal d'entrée.

 La distorsion du signal caractérise le déphasage entre le signal en entrée et le signal

en sortie.

*L’entrée et la sortie d’un canal de transmission sont constitués de deux dispositifs

appelés « émetteur » et « récepteur » qui convertissent l’information à transmettre en
un signal qui pourra être acheminé par le canal de transmission et inversement.
L’émetteur peut aussi associer à chaque mot de n éléments binaires, issu du
message, un signal Si(t) appelé aussi symbole, de durée T = nT bi = 1, …, M avec M =
2n Rapidité de modulation R (exprimée en Bauds) Le nombre de signaux émis par le
modulateur par unité de temps
Le Récepteur qui a pour fonction de reconstituer le message émis par la source à
partir du signal. Le Récepteur qui a pour fonction de reconstituer le message émis par
la source à partir du signal reçu qui comprend des circuits de démodulation (pour les
transmissions sur onde porteuse), de filtrage puis d'échantillonnage et de prise de
décision.
On s’intéresse dans ce TP par Le canal binaire symétrique est l'exemple le plus
simple de canal bruyant. Sa matrice de transition est donnée par

Que l'on représente schématiquement ainsi

6
 7

Démodulation
L'étape de la démodulation consiste à récupérer l'information utile en supprimant la
porteuse. Ceci revient à passer du signal passe bande à un signal passe-bas. Nous
avons considéré ici une démodulation fondée sur un filtre adapté à base de cosinus
surélevé

Correction d’erreur /Décodage :

Dans cette partie nous faisons l'inverse de ce qui à été fait par la partie transmission
c’est la décodage des codes de Hamming, l'encodage de Hamming permet d'ajouter de
la redondance d'information dans le signal numérique et ainsi de pouvoir corriger les
erreurs insérer par le bruit de la transmission. Un code est parfait, si et seulement si la
borne de Hamming est atteinte. Cette propriété permet la détermination des paramètres
possibles pour un code de Hamming. Notons m la valeur de n - k. On dispose alors des
égalités :

L'égalité k = n - m et le fait que la distance minimale d'un code de Hamming

Le syndrome est un objet fondamental dans le décodage des codes linéaires. On rappelle qu’un
message msg est encodé avec le mot de code c=G*msg. Dans notre exemple, le message 011 est
encodé par
Le destinataire reçoit un mot bruité y=c + e, où e est un vecteur d’erreur contenant au
plus (d−1)/2 positions d’erreur. Le syndrome du mot y est la valeur

S = H y = H (c + e) = H c + H e = H e
Où les égalités découlent de la linéarité de la multiplication de matrices et du fait que H est la
matrice de parité du code (et que donc H c = 0 pour tout mot de code c), le syndrome d’un mot ne
dépend que de l’erreur e et pas du tout du mot de code c. Même sans connaître l’erreur, on peut
donc calculer son syndrome en calculant le produit S = H y.
Une fois calculé le, on trouve l’erreur e par recherche sur tous les mots d’erreur possibles.
Comme notre code est 1-correcteur, les seules erreurs qu’on peut corriger sont celles de poids au
plus 1, si le syndrome est zéro, alors nécessairement e=0 et il n’y a pas eu d’erreurs. Sinon, on
note e i le vecteur contenant un 1 à la position i et 0 partout ailleurs ;

Souvenez-vous qu’alors S=H e i = H i, où Hi est la i -ème colonne de H. Par exemple

On peut donc trouver l’erreur e simplement en cherchant dans H la colonne qui correspond au
syndrome, une fois trouvée l’erreur e, on retrouve le mot de code c =y + e. Il ne reste plus qu’à
trouver le mot d’origine tel que c =G msg. Mais, puisque G est sous forme systématique, le mot
d’origine apparaît tel quel dans les k premières composantes du mot de code.
 8

Pour résumer

1. Calculer le syndrome s=H y.

2. Chercher l’erreur e telle que s= H e.
3. Calculer le mot de code c=y + e ;
4. Le message d’origine se trouve dans les k premières composantes de c.

Le destinataire
Le destinataire qui a pour fonction de reconstituer le message émis par la source à
partir du signal. Le destinataire qui a pour fonction de reconstituer le message émis par
la source à partir du signal reçu qui comprend des circuits de démodulation (pour les
transmissions sur onde porteuse), de filtrage puis d'échantillonnage et de prise de
décision. Le démodulateur permet de ramener le signal modulé en bande de base. Le
signal en bande de base est, ensuit, filtré puis échantillonné à des instants
caractéristiques. Finalement un circuit de décision identifie la valeur des éléments
binaires transmis à partir des échantillons reçus. Le choix effectué par le circuit de
décision est binaire, décision 0 ou décision 1, ce qui correspond à une opération dite de
« détection ».
 9

Le code en MATLAB :
clc;
msg = [ 1 0 0 ] %le message juste en sequence de 3 bits
N=3;
%**********************aficher le msg binaire*************************
x_inp= msg;%pour ne risquer pas la perde de msg original
Tb=0.0001; % la periode (en second)
x_bit=[];
nb=100;
for n=1:1:N
if x_inp(n)==1;
x_bitt=ones(1,nb);
else % x_inp(n)==0;
x_bitt=zeros(1,nb);
end
x_bit=[x_bit x_bitt];
end
t1=Tb/nb:Tb/nb:nb*N*(Tb/nb);
subplot(7,1,1);plot(t1,x_bit,'r','lineWidth',2);
grid on;axis([ 0 Tb*N -0.5 1.5]);ylabel('Amp(volt)');
xlabel(' Time(sec)');title('le message a envoyé');
% ********************* le code de hamming *****************************
n = 6;k = 3;
A = [ 1 1 0;1 0 1;0 1 1 ];%(combinaison de 6,5,3)
G = [ eye(k) A ]%le matrice Generatrice
H = [ A' eye(n-k)]
% ENCODER
code = mod(x_inp*G,2); %coded with hamming
N=n; %pour eviter les problems de maj et min
% ********************* Representer le signal codé en hamming *************
x_inp= code;
x_bit=[];
nb=100;
for i=1:1:N
if x_inp(i)==1;
x_bitt=ones(1,nb);
else % x_inp(i)==0;
x_bitt=zeros(1,nb);
end
x_bit=[x_bit x_bitt];
end
t1=Tb/nb:Tb/nb:nb*N*(Tb/nb); % le temps de signal signal
subplot(7,1,2);
plot(t1,x_bit,'lineWidth',2);grid on
axis([ 0 Tb*N -0.5 1.5]);ylabel('Amp(volt)');
xlabel(' Time(sec)');title('le message codé en hamming');
% ********************* Modulation BPSK *********************************
Ac=5; % Amplitude de porteuse
fc=(1/Tb); % frequence de porteuse
fi1=pi/2; % le phase pour bit 1
fi2=-pi/2; % le phase pour bit 0
t2=Tb/nb:Tb/nb:Tb;
t2L=length(t2);
x_mod=[];
for (i=1:1:N)
if (x_inp(i)==1)
x_mod0=Ac*cos(2*pi*fc*t2+fi1);%modulation de signal pour bit 1
else
 10

x_mod0=Ac*cos(2*pi*fc*t2+fi2);%modulation de signal pour bit 0

end
x_mod=[x_mod x_mod0];
end
t3=Tb/nb:Tb/nb:Tb*N;
subplot(7,1,3);plot(t3,x_mod);grid on;
xlabel('Time(sec)');ylabel('Amp(volt)');
title('Le signal en modulation BPSK');
% ********************* Transmission dans le canal binaire symetrique
******************************
nz = bsc(x_inp,.1)
[numerrs, pcterrs] = biterr(x_inp,nz)% Number and percentage of errors
% ********************* a la sortie du canal ****************************
x_inp = nz ;
x_mod=[];
for (i=1:1:N)
if (x_inp(i)==1)
x_mod0=Ac*cos(2*pi*fc*t2+fi1);%modulation de signal pour bit 1
else
x_mod0=Ac*cos(2*pi*fc*t2+fi2);%modulation de signal pour bit 0
end
x_mod=[x_mod x_mod0];
end
t3=Tb/nb:Tb/nb:Tb*N;
subplot(7,1,4);plot(t3,x_mod);grid on;
xlabel('T(sec)');ylabel('Ampl(volt)');
title('Signal a la sortie du canal ');
% ********************* Define BPSK Demodulation **************************
y_dem=[];
for i=0:100:length(x_mod)-100
A_dem=x_mod((25+i));
if(A_dem<0) % logic level = Ac/2
A=1;
else
A=0;
end
y_dem=[y_dem A];
end
x_out=y_dem;% output signal;
% *************** Representer le signal récu avec un erreur ***************

xx_bit=[];
for i=1:length(x_out);
if x_out(i)==1;
xx_bitt=ones(1,nb);
else %x_out(i)==0;
xx_bitt=zeros(1,nb);
end
xx_bit=[xx_bit xx_bitt];
end
t4=Tb/nb:Tb/nb:nb*length(x_out)*(Tb/nb);
subplot(7,1,5);plot(t4,xx_bit,'LineWidth',2);grid on;
axis([ 0 Tb*length(x_out) -0.5 1.5]);
xlabel('T(sec)');ylabel('Ampl(volt)');
title('le signal récu avec un erreur');
% **************************** decoder/correcteur d'erreur le signal
numerique avec hamming*****************************
recd = x_out; %code recu avec erreur
syndrome = mod(recd * H',2);
 11

%trouver la position d'erreur

find = 0;
for ii = 1:n
if ~find
errvect = zeros(1,n);
errvect(ii) = 1;
search = mod(errvect * H',2);
if search == syndrome
find = 1;
index = ii;
end
end
end
if find
display(['Position d’erreur dans le msg=',num2str(index)]);
correctedcode = recd;
correctedcode(index) = mod(recd(index)+1,2);
code_corrige=correctedcode
end
msg_dec=msg_decoded(1:3)

% ********************* Representer le signal corrigé par hamming ****

x_inp= correctedcode; % binary signal 0 or 1 % message to be transmitted
x_bit=[];
N=6;
nb=100;
for i=1:1:N
if x_inp(i)==1;
x_bitt=ones(1,nb);
else % x_inp(i)==0;
x_bitt=zeros(1,nb);
end
x_bit=[x_bit x_bitt];
end
t1=Tb/nb:Tb/nb:nb*N*(Tb/nb);
subplot(7,1,6);plot(t1,x_bit,'green','lineWidth',2);
grid on;axis([ 0 Tb*N -0.5 1.5]);
xlabel('T(sec)');ylabel('Ampl(volt)');
title('le signal corrigé par hamming');

% ********************* Representer le msg aprés conv hamming ****

x_inp= msg_dec;
x_bit=[];
N=3;
nb=100;
for i=1:1:N
if x_inp(i)==1;
x_bitt=ones(1,nb);
else % x_inp(i)==0;
x_bitt=zeros(1,nb);
end
x_bit=[x_bit x_bitt];
end
t1=Tb/nb:Tb/nb:nb*N*(Tb/nb);
subplot(7,1,7);
plot(t1,x_bit,'black','lineWidth',2);grid on;
axis([ 0 Tb*N -0.5 1.5]);
xlabel('T(sec)');ylabel('Ampl(volt)');
 12

title('le signal final');

affichage du code :
 13

msg =

1 0 0

G=

1 0 0 1 1 0

0 1 0 1 0 1

0 0 1 0 1 1

H=

1 1 0 1 0 0

1 0 1 0 1 0

0 1 1 0 0 1

nz =

1 0 1 1 1 0

numerrs =

pcterrs =

0.1667

Position d’erreur dans le msg =3

Codecorrecte =

1 0 0 1 1 0

msg_dec =

1 0 0

Projet par : -Jihene Ben Tekaya

-Aya Hamza