Codage 1

Université de Gabes
Ecole Nationale d'Ingénieurs de Gabes
Cours de Codage
Rhouma Rhouma
Pour les Etudiants de GCR2
Sujets des devoirs de contrôle et synthèse inclus

ENIG Université de Gabés
CHAPITRE 1
___
CODAGE DE CANAL
CODES DE BLOCS LINEAIRES
___
Codage : Codage Canal, codes de blocs linéaires R. Rhouma 1

CODES DE BLOCS LINEAIRES

Pour approcher au mieux la capacité C du canal si, conformément au théorème de Shannon, l'entropie de la
source H(X) < C nous pouvons ajouter de la redondance dans le codage de la source afin de diminuer les erreurs de
transmission. C'est le problème du codage de canal. A côté des premiers codes empiriques (bit de parité, répétition,…)
deux grandes catégories de codes ont été développées et sont actuellement utilisées en faisant l'objet permanent de
perfectionnements :
Les codes de blocs linéaires.
Les codes de convolution.
I. DEFINITIONS ET PROPRIETES DES CODES DE BLOC LINEAIRES

I.1 Code binaire :
Le codage de canal utilise les symboles d'une source pour construire des objets appelés mots de codes. Pour
une source discrète binaire nous utiliserons deux symboles. Pour un alphabet non binaire de q symboles (source q-ary)
si q = 2b, un code de longueur N peut se ramener à l'étude d'un code binaire de longueur b.N. Nous pouvons aussi
montrer que si q ≠ 2b il est possible de se rapporter à une telle étude. Pour ces raisons, l'étude des codes binaires est une
bonne introduction et nous nous contenterons de ce cas particulier.
I.2 Codes de blocs :

L'information de la source est mise en trames de longueur fixe que nous devons transmettre : c'est le message.
Le codage de canal prend ce message pour en faire un mot de code :
message → codage de canal → mot de code
Le message est constitué de k caractères soit 2k messages possibles. Le mot de code utilisé sera lui aussi de
longueur fixe de n caractères soit 2n mots de code possibles. Avec n > k il y aura donc n-k caractères du mot de code qui
sont redondants et serviront à traiter les erreurs éventuelles. Par ailleurs, 2n > 2k donc un certain nombre de mots de
code ne correspondent pas à un message mais seulement à des erreurs de transmission.
On parle ainsi d'un code de bloc ( n , k ) et du rapport du code défini par Rc = k/n.
Un cas particulier des codes de blocs est celui des codes où le message apparaît explicitement sur ses k
caractères c'est à dire "en clair". A côté de ces k caractères seront donc ajoutés n-k caractères redondants. Nous
obtenons alors un code dit code systématique et c'est ce sous ensemble que nous étudierons.
I.3 Poids d'un code :

Le poids d'un mot de code est par définition le nombre de caractères non nuls que contient ce mot.
11001000 est de poids 3 10011010 est de poids 4 00000000 est de poids nul
A l'ensemble des mots d'un code on associe l'ensemble des poids qui est la distribution de poids du code. Un
code est dit de poids fixe (ou poids constant) si tous les mots du code ont le même poids.
I.4 Distance de Hamming :
La distance de Hamming dij entre deux mots de code est le nombre de bits dont ils diffèrent.
11001000
et 10011010 ont une distance de 3.
La distance minimale du code est le minimum de l'ensemble des distances entre codes :
dmin = min { dij }
I.5 Code linéaire :

Un code est linéaire s'il répond au principe de superpostion :
αi Ci + αj Cj = Ck
Pour tout αi, αj = {0 , 1 } (en binaire), si Ci et Cj sont des mots de code, alors Ck est aussi un mot de code.
Conséquence : Si αi = αj = 0 ⇒ Ck = "0"
Un code linéaire contient le code "0".
Un code de poids fixe ne peut être un code linéaire.

Distance minimale d'un code linéaire :

Ci = Cc + Cm
Cj = Cc + Cq avec : Cc = code commun constitué des bits "1" identiques de Ci et Cj.
Cm et Cq n'ont par conséquence aucun bit commun.
Ci = 11001000
Cj = 10011010 ⇒ Cc = 10001000 , Cm = 01000000 , Cq = 00010010
En appelant w les poids des codes : dij = wm + wq .
Quel est le minimum de dij ?
Un code linéaire contient le code "0" ⇒ parmi les { dij } il y a un sous ensemble minimal correspondant à
Cj = "0" soit wm = wi et dij = wi. Ce qui justifie le théorème suivant :
Pour un code linéaire, la distance minimale est le plus petit poids du code, mot de code nul exclus.
min { dij } = min { wk } pour Ck ≠ "0"
II. GENERATION D'UN CODE DE BLOC LINEAIRE SYSTEMATIQUE

A partir d'un message Xm tel que :
Xm = [ m0 m1 ............. mk-1 ]
144424443
k caractères du message
nous devons générer un mot de code de bloc linéaire systématique qui a la structure suivante :
Cm = [ b0 b1 ..................... bn-k-1 m0 m1 ............. mk-1 ]
1444424444 3 14442444 3
(n-k) caractères de contrôle k caractères du message
1444444442444444443
n caractères du mot de code
Soit Cm = [ Bm Xm ] où Bm contient les caractères de contrôle appelés aussi caractères de parité.
II.1 Génération du mot de code :

Matrice de génération de code :
Matrice notée G, elle sert à générer le mot de code Cm à partir du message Xm soit :
Cm = Xm.G
Nous nous intéressons à des codes systématiques, la matrice G est donc de la forme :
G = [ P Ik ]
G étant une matrice ( k ,n ), P une matrice ( k , n-k ) et Ik la matrice identité ( k , k ).
Code non systématique :

Un code non systématique serait tel que : G = [ P M ] où la matrice M est une matrice qui mélange les bits du
message pour le crypter. Nous pouvons bien sûr nous ramener à un code systématique par combinaison des lignes entre
elles pour faire intervenir la matrice Ik. Tout code de bloc peut ainsi se ramener à l'étude d'un code systématique
équivalent.
La partie essentielle de la matrice G est donc la matrice P appelée matrice de parité.
Principe de la réalisation du codeur :

k
Chaque bit de parité s'exprime donc par : bi = ∑ m j p ji
j =1
En binaire les pji ∈ { 0 ;1 } ⇒ les bi sont obtenus par une
simple addition binaire. m0 m1 m2 m3
Le principe de la réalisation technique en est donc simple, il message
suffit de disposer de deux registres à décalage et d'un
inverseur (switch électronique bien sûr) ce qui donne le
schéma ci-contre. Mot de code
b0 b1 b2

Cet exemple est celui d'un code ( 7 , 4 ) tel que :

1 0 1 1 0 0 0
1 1 1 0 1 0 0 
G=
1 1 0 0 0 1 0
 
0 1 1 0 0 0 1
⇒ b0 = m0 + m1 + m2 b1 = m1 + m2 + m3 b2 = m0 + m1 + m3
II.2 Détection des erreurs de transmission :
Matrice de contrôle de parité :

Nous définissons un espace dual engendré par la matrice H telle que :
H = [ In-k PT ]
En décomposant les matrices nous obtenons :

I 
G.HT = [ P Ik ]  n-k  = P + P = 0
 P 
En effet P est constitué d'éléments binaires tels que : α + α = 0.
D'où la relation fondamentale : G.HT = 0

Avec l'exemple précédent :
1 0 0 1 1 1 0
H =  0 1 0 0 1 1 1 
 0 0 1 1 1 0 1 
Syndrôme :
A partir de la relation précédente nous pouvons établir la relation servant de base à la détection d'erreur :
Cm.HT = Xm.G.HT = 0 pour tout mot de code.
Le détecteur va utiliser cette relation. En effet, si le mot de code reçu Ym est entaché d'erreur nous pouvons l'exprimer
sous la forme :
Code reçu = code émis + erreur ⇒ Ym = Cm + Em
En effectuant le contrôle Ym.HT = Cm.HT + Em.HT = Em.HT. S'il n'y a pas eu erreur de transmission Em.HT = 0.
Em.HT est par définition le syndrôme de l'erreur Sm.
Sm = Ym.HT = Em.HT
Le syndrôme ne dépend que de l'erreur de transmission commise et non du mot de code.
Théorème :
Supposons deux syndrômes Si = Ei.HT et Sj = Ej.HT.
Si Si = Sj ⇒ ( Ei - Ej ).HT = 0 ⇒ ( Ei - Ej ) est un mot de code.
⇒ deux vecteurs d'erreur qui diffèrent d'un mot de code ont même syndrôme.
Ce théorème montre qu'il peut y avoir ambiguïté dans la détection des erreurs.
Lien avec la distance minimale :

M = Cm.HT
( 1 , n-k) ( 1 , n) ( n ,n-k )

Chaque élément de la matrice M est : m j = ∑ ci h ji ce qui est une combinaison linéaire sur une ligne j de tous les
i
éléments des colonnes ⇒ M est une combinaison linéaire des colonnes de la matrice H et cette combinaison
linéaire est nulle.
⇒ les colonnes de H sont linéairement dépendantes.
Le nombre de colonnes intervenant dans la combinaison est égale au nombre de "1" du code Cm ce qui est le
poids de Hamming du mot de code.
La distance de Hamming du code étant le poids minimal de ce code ⇒ La distance minimale de Hamming dmin
d'un code est égale au nombre minimal de colonnes de la matrice H dont la somme est nulle.
Le nombre de colonnes de H linéairement indépendantes est dmin-1 et le rang maximal de cette matrice est n-k
ce qui établi la relation :
dmin ≤ n-k+1
Code étendu :
Pour améliorer la détection des erreurs, on ajoute des bits de parité aux colonnes de H ce qui créé à partir d'un code ( n ,
k ) un code étendu ( n+1 , k ) tel que :
1 1 ← 1 1 → 1
0 
 
↑ ↑ 
He =   cela augmente la distance de Hamming dmin → dmin + 1
0 ← H → 
↓ ↓ 
 
 0 
II.3 Correction des erreurs :

Erreurs détectables :
Le nombre minimal de bits changeant entre chaque code est dmin la distance minimale du code. Compte tenu du
théorème du chapitre précédent, eD le nombre maximal d'erreurs détectables est donc :
eD = dmin-1
Nombre d'erreurs corrigeables :

Nous avons au maximum 2k messages à transmettre donc 2k mots de code corrects parmi les 2n possibles.
Si X est le mot de code émis, E l'erreur de transmission et Y le mot de code reçu :
Y=X+E
S'il y a t erreurs de transmission ⇒ la distance de Hamming entre Y et X est t.
Nous pouvons faire un schéma où un point représente un code, une croix un code correspondant à un message et la
distance entre deux points, la distance de Hamming.
S'il y a t erreurs de transmission, tous les mots de codes possibles correspondant à cette erreur sont situés dans une
sphère située autour du code réel transmis.
Soit deux codes Xi et Xj et t erreurs de transmission, si nous sommes dans la situation suivante :
Tout code appartenant à une sphère peut être sans ambiguïté attribué au code le plus proche ⇒ les erreurs de
t
t Xi Xj
transmission sont toutes corrigeables.

Une seconde situation:
t
Xj
Xi
t
Dans ce cas, les codes appartenant à l'intersection des sphères ne peuvent être attribués.
Pour éviter toute ambiguïté nous devrons donc respecter la condition :
2.t ≤ dmin-1
t étant un entier, eC le nombre maximum d'erreurs corrigeables sera :
eC = Int [ ½ (dmin-1 ) ]
Le nombre eDNC d'erreurs détectables et non corrigeables est tel que : eDNC + eC = eD. Compte tenu des relations
précédentes nous aurons aussi la relation : eDNC ≥ eC.
exemple :
dmin = 7 ⇒ erreurs détectables eD = 6.
erreurs corrigeables eC = 3.
Erreurs détectables non corrigeables eDNC = 3.
Correction des erreurs : méthode logicielle.

Il y a deux méthodes de correction des erreurs:
1. détecter la forme des signaux reçus et attribuer le symbole : cela dépend des formes d'ondes et donc de la
méthode de modulation choisie. C'est la méthode matérielle ("hard") de correction des erreurs.
2. interpréter la redondance d'un code pour lui attribuer un symbole : c'est la méthode dite logicielle ("soft") qui
est celle que nous allons développer.
A la réception d'un mot de code, nous lui associons le message dont le mot de code est le plus proche au sens de la
distance entre mots de code. C'est le maximum de vraisemblance dont l'illustration a été faite dans l'étude des erreurs
corrigeables.
Pour un mot de code reçu le syndrôme associé est :
Sm = Ym.HT = Em.HT
T
Chaque ligne de H (colonne de H) est le syndrôme d'une erreur simple. Pour un code (n , k), il y a n erreurs simples
possibles et avec ( n-k ) bits de contrôle nous pouvons coder ( 2(n-k) – 1 ) erreurs ( -1 car "000…" n'est pas un code
d'erreur) ⇒ il reste détectables ( 2(n-k) - 1 - n ) autres erreurs que des erreurs simples (erreurs doubles, triples, ….).
Exemple: Soit le code (5 , 2) défini par

1 0 0 1 0
1 0 1 1 0
G=  H =  0 1 0 0 1 
0 1 1 0 1  0 0 1 1 1 
5 erreurs simples possibles avec leurs syndrômes associés et ( 2(n-k) - 1 – n ) = 2 autres syndrômes.
Table des erreurs :
Dans cette table apparaissent les deux syndrômes non associés à Syndrômes Erreurs
une erreur simple. possibles Sm probables Em
Prenons le syndrôme 110. Il peut être associé à une erreur double 000 00000 Pas d'erreur
du type ( bit 0 + bit 1 ) soit 11000 mais aussi à une erreur du type 001 00100 Erreur bit 2
( bit 3 + bit 4 ) soit 00011. Il y a ici ambiguïté entre deux erreurs 010 01000 Erreur bit 1
doubles. 011 00001 Erreur bit 4
Pour le syndrôme 001 associé à une erreur bit 2 il pourrait être 100 10000 Erreur bit 0
associé à une erreur type ( bit 1 +bit 4 ) mais ici l'ambiguïté est 101 00010 Erreur bit 3
entre une seule erreur simple et d'autres erreurs doubles, triples,… 110
111

Dans cet exemple, H a au plus trois colonnes linéairement indépendantes ⇒ dmin = 3.

Le nombre d'erreurs corrigeables est : ec = Int [ ½ (dmin-1) ] = 1.
Le nombre d'erreurs détectables est : eD = dmin – 1 = 2.
En effet, si nous affectons la solution la plus vraisemblable au sens de la distance minimale, toutes les erreurs simples
peuvent être corrigées. En ce qui concerne les erreurs doubles, elles sont détectables mais nous pouvons soit les
confondre entre elles, soit les confondre avec une erreur simple. Dans le second cas le maximum de vraisemblance
corrige comme une erreur simple ( c'est effectivement ce qui a la plus forte probabilité d'arriver ) et dans le premier elle
tranche en faveur de la solution la plus probable qui, pour un code donné est toujours la même. Qu'arrive-t-il pour des
erreurs triples ? Au sens du critère, elles sont toujours systématiquement confondues soit avec une erreur simple soit
une erreur double, elles sont de ce fait non détectables et par là même non corrigeables.
La correction des erreurs:

Les opérations s'ordonnent ainsi :
1. réception d'un mot de code Ym.
2. calcul du syndrôme associé Sm.
3. avec une table des erreurs, calcul de l'erreur la plus vraisemblable Em* associée au syndrôme.
4. calcul du mot de code le plus vraisemblable : Cm* = Ym ⊕ Em* ( en binaire, le + est un ou exclusif ).
5. extraction du message Xm* de Cm*.
Avec l'exemple précédent :

Xm = [ 1 0 ] ⇒ Cm = Xm.G = [ 1 0 1 1 0 ]
Erreur sur le bit 3 ⇒ Ym = [ 1 0 1 0 0 ] ⇒ syndrôme Sm = Ym.HT = [ 1 0 0 ]

⇒ table Em* = [ 0 0 0 1 0 ] ⇒ Cm* = Ym ⊕ Em* = [ 1 0 1 0 0 ] ⊕ [ 0 0 0 1 0 ] = [ 1 0 1 1 0 ] = Cm.
Erreur sur les bits 1 et 3 ⇒ Ym = [ 1 1 1 0 1 ] ⇒ syndrôme Sm = Ym.HT = [ 0 1 0 ]

⇒ table Em = [ 1 0 0 0 0 ] ⇒ Cm* = Ym ⊕ Em* = [ 1 1 1 1 0 ] ⊕ [ 1 0 0 0 0 ] = [ 0 1 1 1 0 ] ≠ Cm.
*
III CODES DE BLOCS LINEAIRES

III.1 Codes de Hamming :
Les codes de Hamming sont des codes binaires qui ont la propriété :
( n , k ) = ( 2m-1 , 2m-1-m ) avec m entier.
m = 2 code ( 3 , 1 ) peu d'intérêt, k = 1 on ne transmet qu'un bit de message.
m = 3 code ( 7 , 4 )
m = 4 code ( 15 , 11 )
……..
matrice de contrôle :
Elle est de dimensions ( n-k , n ) = ( m , 2m-1 ).
Une colonne est donc constituée de m éléments binaires et nous avons 2m-1 colonnes c'est-à-dire toutes les
combinaisons possibles moins une ( la combinaison "000…" ). Ceci nous permet pour ces codes de construire très
rapidement la matrice de contrôle H et d'en déduire la matrice de génération de code G. La procédure est la suivante :
1. Commencer à remplir la matrice H en utilisant les combinaisons linéaires de m bits faisant apparaître la
matrice In-k.
2. Compléter cette matrice par les combinaisons de m bits non encore utilisées code "0" exclu. Il apparaît dans
cette opération que la solution n'est pas unique mais cela n'a aucune importance.
Exemple d'un code ( 7 ,4 ) :
 
1 0 0 1 1 0 1
 
H = 0 1 0 1 0 1 1
0 0 1 0 1 1 1
1424 3 14243 
 In-k PT 
Nous en déduisons G :

 
1 1 0 1 0 0 0
 
1 0 1 0 1 0 0
G=
0 1 1 0 0 1 0 
1 1 1 0 0 0 1
14243 142
4 434 
 P Ik 
erreurs corrigeables :
Le nombre maximum de colonnes de H linéairement indépendantes est (n-k) = m= dmin.
⇒ eD = Int [ ½ (m-1) ]
m = 3 eD = 1 ; m = 4 eD = 1 ; m = 5 eD = 2 ;……….
III.2 Codes de Hadamard :

Les codes de Hamming sont très populaires de par leur simplicité cependant, ils exigent un grand nombre de bits de
contrôle pour corriger des erreurs multiples.
Les codes de Hadamard sont constitués par itération à partir de matrices telles que :
M Mn 
M2n =  n où Mn désigne la matrice complémentaire 0 → 1 et 1 → 0.
 Mn Mn 
La matrice initiale est :
0 0 0 0
0 1 0 1 
0 0
M2 =   ⇒ M4 = 
0 1 0 0 1 1
 
0 1 1 0
Les matrices Mn et Mn contiennent comme lignes ou colonnes les 2n mots du code. La structure de la matrice
permet donc de détecter des erreurs de transmission. Sans démonstration, on montre que dmin = ½ n.

CHAPITRE 2
___
CODAGE DE CANAL
CODES CYCLIQUES
___
Codage : Codage Canal, codes cycliques R. Rhouma 1

CODAGE DE CANAL
CODES CYCLIQUES
Les codes cycliques constituent un sous-groupe des codes linéaires qui a pris une très grande
importance dans les applications du fait de la simplicité d'implantation des algorithmes de codage et de
décodage.
I. DEFINITIONS ET PROPRIETES DES CODES CYCLIQUES
I.1 Propriétés fondamentales :

Elles sont au nombre de deux :
1. Ce sont des codes linéaires : la somme de deux mots de code est un mot de code
αi Ci + αj Cj = Ck ∀ αi, αj.
2. Ils sont cycliques : Toute permutation circulaire des bits d'un mot de code est aussi un mot de code.
[ c0 c1 c2 ….cp-1. cp cp+1 ….. cn-2 cn-1 ] est un mot de code ⇒ [ cp cp+1 …..cn-p c0 c1 ….. cp-1 ] est
aussi un mot de code ∀ p.
I.2 Polynôme générateur :

Forme polynomiale d'un code :
En utilisant un opérateur D: opérateur décalage (ou opérateur de position), un mot de code Cm se voit associer un
polynôme Cm(D) tel que :
Cm(D) = cn-1 Dn-1 + cn-2 Dn-2 + cn-3 Dn-3 + ….. ck Dn-k + ….. c1 D1 + c0
Rôle de l'opérateur D :
D.Cm(D) = cn-1 Dn + cn-2 Dn-1 + cn-3 Dn-2 + ….. ck Dn-p+1 + ….. c1 D2 + c0 D
En rappelant que, en binaire, ck + ck = 0 ∀ k
⇒ D.Cm(D) = cn-1 Dn + cn-2 Dn-1 + cn-3 Dn-2 + ….. ck Dn-p+1 + ….. c1 D2 + c0 D + cn-1 + cn-1
= cn-1 Dn + cn-1 + cn-2 Dn-1 + cn-3 Dn-2 + ….. ck Dn-p+1 + ….. c1 D2 + c0 D + cn-1
= cn-1 ( Dn + 1 ) + Cm1 (D)
où Cm1 (D) est un mot de code obtenu par décalage des bits de Cm(D) de 1 position
En itérant le procédé nous montrons que :
D2.Cm(D) = ( D cn-1 + cn-2 ) ( Dn + 1 ) + Cm2 (D), Cm2(D) correspondant à un décalage de deux positions.
Dp.Cm(D) = ( Dp-1 cn-1 + Dp-2 cn-2 +…..+ cn-p ) ( Dn + 1 ) + Cmp (D)
= Qp-1(D) ( Dn + 1 ) + Cmp (D), Cmp(D) correspondant à un décalage de p positions et Qp-1(D)
est un polynôme de degré p-1.
Cmp(D) est ainsi le reste de la division de Dp.Cm(D) par ( Dn + 1 ). Cette remarque très importante nous donne le
théorème suivant :
Dp.Cm(D) mod ( Dn + 1 ) = Cmp (D)
Un cas particulier de ce théorème :

Dn.Cm(D) mod ( Dn + 1 ) = Cm (D) ⇒ Dn = 1 ⇒ Dα.n+p = Dp ( α ∈ Z )
Polynôme générateur :
Quel est le problème ?
Le message est constitué de k bits, nous pouvons lui associer un polynôme m(D) de degré (k-1). Au mot de code
correspondant il est associé un polynôme de degré (n –1) : Cm(D). Nos recherchons des codes tels que :
Cm(D) = Am(D).g(D)
Am(D) est un polynôme de degré (k-1) lié à m(D) par une relation que nous ne recherchons pas et g(D) est un
polynôme de degré (n-k) qui lui, est caractéristique du codage et par là même indépendant du message.

Le polynôme générateur de code est un polynôme de degré (n-k) qui factorise tous les mots de codes d'un
même code.
g(D) = Dn-k + gn-k-1 Dn-k-1 + gn-k-2 Dn-k-2 + ….... g1 D + 1
Dans ce polynôme gn-k = 1 et g0 = 1 conditions nécessaires pour que g(D) soit un polynôme de degré (n-k)
( gn-k ≠ 0 est une condition évidente. Pour g0, nous aurions g(D) = D.h(D) et h(D) serait un polynôme générateur
de degré (n-k-1) ce qui impossible ⇒ g0 = 1 )
Unicité de g(D) :
Cette unicité est montrée par l'absurde. Supposons l'existence d'un autre polynôme générateur g(1)(D) :
Cm(D) = Am(D).g(D)
Cm(1)(D) = Am(D).g(1)(D) ⇒ Cm(D) + Cm(1)(D) = Am(D).( g(D) + g(1)(D) )
D'après la propriété de linéarité : Cm(D) + Cm(1)(D) serait aussi un mot de code et donc g(D) + g(1)(D) serait aussi
un polynôme générateur g(2)(D).
g(2)(D) = ( Dn-k + gn-k-1 Dn-k-1 + …....+ g1 D + 1 ) + ( Dn-k + gn-k-1(1) Dn-k-1 + …....+ g1(1) D + 1 )
= ( Dn-k + Dn-k ) + ( gn-k-1 + gn-k-1(1) ) Dn-k-1 + …....+ ( g1 + g1(1) ) D + (1 + 1 ).
= ( gn-k-1 + gn-k-1(1) ) Dn-k-1 + …....+ ( g1 + g1(1) ) D
⇒ g(2)(D) serait un polynôme générateur de degré (n-k-2) qui ne peut générer un mot de
code de degré n ⇒ g(D) est unique.
II CODAGE ET DECODAGE D'UN CODE CYCLIQUE
II.1 Codage :
Le mot de code a la forme :
Cm = [ b0 b1 …..bn-k-1 m0 m1 .....mk-1 ]
Le polynôme associé est :
Cm(D) = b0 + b1D ….. + bn-k-1 D(n-k-1) + m0 D(n-k) + m1 D(n-k+1) + .... + mk-1 D(n-1)
Soit en posant :
b(D) = b0 + b1D ….. + bn-k-1 D(n-k-1) et m(D) = m0 + m1 D1 + .... + mk-1 D(k-1)
Cm(D) = b(D) + D(n-k) m(D) = Am(D).g(D)
En se rappelant que, en binaire, b(D) + b(D) = 0 nous obtenons la relation fondamentale du codage :
D(n-k) m(D) = Am(D).g(D) + b(D)
⇒ b(D) est le reste de la division de D(n-k) m(D) par le polynôme générateur g(D).
Le calcul du mot de code est donc de la forme :

1. multiplier m(D) par Dn-k
2. diviser par g(D) → reste b(D)
3. ajouter b(D) à Dn-k.m(D)
Remarque : le polynôme Am(D) n'est pas utile pour exprimer Cm.
exemple: un code ( 7 ,4 ) = ( n , k )
g(D) = 1+ D + D3 (son obtention sera vue plus loin) et Dn-k =D3
message = [ 1 0 1 1 ] ⇒ m(D) = 1 + D2 + D3 ⇒ Dn-k m(D) = D3 + D5 + D6
D6 + D5 + D3 D3 + D + 1 g(D)
D5 + D4 D3 + D2 + D + 1
D4 + D3 + D2
D3 + D
b(D) 1
Am(D)
Cm(D) = b(D) + D(n-k) m(D) = 1 + D3 + D5 + D6 ⇒ Cm = [ 1 0 0 1 0 1 1 ]

II.2 Contrôle de parité :

Polynôme de contrôle de parité :
Par équivalence avec le cas général, nous définissons un polynôme orthogonal à g(D) soit :
g(D).h(D) mod( Dn + 1 ) = 0
Parmi tous les polynômes h(D) possibles, nous choisissons celui de degré minimal d'où :
g(D).h(D) = Dn + 1
Avec comme conséquence : deg [ g(D) ] = n-k ⇒ deg [ h(D) ] = k

Pour tout mot de code : Cm(D).h(D) = Am(D).g(D).h(D) = 0
Cm(D).h(D) mod( Dn + 1 ) = 0
Choix des polynômes g(D) et h(D) :

La relation d'orthogonalité nous permet d'avoir une méthode de choix des polynômes :
1. Factorisation: Soit un code ( n , k ), nous pouvons factoriser au "maximum" Dn + 1 : décomposition en
polynômes dits polynômes primitifs. Dn + 1 = P1(D).P2(D)…….
2. Choix de g(D) : A partir de certains de ces polynômes primitifs, nous formons un polynôme de degré
(n-k) qui devient g(D).
3. Choix de h(D) : h(D) est constitué par le produit des polynômes primitifs non utilisés dans g(D), c'est le
complémentaire de g(D).
Remarque: la solution n'a aucune raison d'être unique mais deux polynômes générateurs différents ne génèrent
pas le même code.
Exemple: pour un code ( 7 ,4 ).

D7 + 1 = ( D + 1 ) ( D3 + D2 + 1 ) ( D3 + D + 1 )
Nous avons ici deux possibilités de choix de g(D) et donc de h(D) :
1. g(D) = ( D3 + D2 + 1 ) ⇒ h(D) = ( D + 1 ) ( D3 + D + 1 ) = ( D4 + D3 + D2 + 1 )
2. g(D) = ( D3 + D + 1 ) ⇒ h(D) = ( D + 1 ) ( D3 + D2 + 1 ) = ( D4 + D2 + D + 1 ).
Détection des erreurs de transmission :

En cas d'erreur de transmission, nous recevons un mot de code Ym qui ne correspond à aucun message.
Ym(D) = Cm(D) + Em(D) où Em(D) est le polynôme de l'erreur.
Ym(D).h(D) mod( Dn + 1 ) = Em(D).h(D) mod( Dn + 1 ) = Sm(D)
Ce qui définit un polynôme du syndrôme de l'erreur.

Une table des erreurs permet de remonter au polynôme d'erreur de transmission et la correction des erreurs se fait
toujours au sens du maximum de vraisemblance : Cm*(D) = Ym(D) + Em*(D).
Exemple:
En poursuivant avec l'exemple déjà utilisé pour illustrer g(D).
g(D) = 1+ D + D3
h(D) = 1 + D + D2 + D4
message = [ 1 0 1 1 ] ⇒ m(D) = 1 + D2 + D3 ⇒ Cm(D) = 1 + D3 + D5 + D6 ⇒ Cm = [ 1 0 0 1 0 1 1 ]
Vérification : Cm(D).h(D) :
( 1 + D3 + D5 + D6 ).( 1 + D + D2 + D4 ) = 1 + D3 + D5 + D6
+ D + D4 + D6 + D7
+ D2 + D5 + D7 + D8
+ D4 + D7 + D9 + D10 ≡ 0
En utilisant en binaire:
Di + Di = 0
Dn+k + Dk = Dk ( Dn + 1 ) ⇒ Dn+k + Dk = 0 mod( Dn + 1 )
Supposons une erreur de transmission

E m = [ 0 0 0 1 0 0 0 ] ⇒ Ym = [ 1 0 0 0 0 1 1 ] ⇒ Ym(D) = 1 + D5 + D6
Ym(D).h(D) = ( 1 + D + D ).( 1 + D + D + D ) = 1 + D + D2 + D4
5 6 2 4
+ D5 + D6 + D7 + D9
+ D6 + D7 + D8 + D10 = 1 + D3 + D4 + D5
= Em(D).h(D) = Sm(D)
III. LIEN ENTRE CODES DE HAMMING ET CODES CYCLIQUES

III.1 Théorème :
Un code cyclique ayant comme polynôme générateur un polynôme primitif est un code de Hamming de
distance minimale égale à trois.
Nous n'apporterons pas ici la preuve de ce théorème. Il peut être illustré sur l'exemple déjà utilisé qui entre dans
ce cadre et doit ainsi générer un code de Hamming ( 7 ,4 ).
III.2 Calcul de la matrice G à partir du polynôme g(D) :

Un mot de code de bloc est généré par : Cm = Xm.G . Les lignes de la matrice G sont des mots de codes
particuliers ( pour un code ( 7, 4 ) , la première ligne correspond à Xm = [ 1 0 0 0 ] et ainsi de suite ).
En revenant à la notation polynomiale, g(D) est un mot de code. Il en est de même pour D.g(D), D2.g(D),……
Nous pouvons ainsi générer une matrice G* dont les lignes sont des mots de code :
← g(D) →
 ← D.g(D) → 

2
*  ← D .g(D) →
G = 3 
 ← D .g(D) →
 . . . 
 
 . . . 
1 1 0 1 0 0 0
0 1 1 0 1 0 0 
avec notre exemple g(D) = 1+ D + D3 : G* = 
0 0 1 1 0 1 0
 
0 0 0 1 1 0 1
La matrice ainsi constituée n'est pas celle d'un code systématique puisqu'il n'apparaît pas la matrice identité Ik.
Pour faire apparaître cette propriété, comme toute superposition de mots de code est aussi un mot de code, il
suffit d'associer astucieusement les lignes de G*. Ici, les lignes 1 et 2 sont correctes, nous pouvons effectuer :
Ligne3 ← ligne3 + ligne 1
Ligne4 ← ligne4 + ligne 1 + ligne2
1 1 0 1 0 0 0
0 1 1 0 1 0 0 
G= 
1 1 1 0 0 1 0
 
1 0 1 0 0 0 1
ce qui avec le message déjà pris en exemple : Xm = [ 1 0 1 1 ] nous fournit le mot de code Cm = [ 1 0 0 1 0 1 1 ]
ce qui est conforme au polynôme Cm(D) = 1 + D3 + D5 + D6 établi avec g(D).
III.3 Calcul de la matrice H à partir du polynôme h(D) :

H peut bien sûr être calculée à partir de G mais aussi directement à partir de h(D).
A partir de G nous obtenons :

1 0 0 1 0 1 1
H =  0 1 0 1 1 1 0 
 0 0 1 0 1 1 1 
G.HT = 0 exprime le fait que les lignes de H ( colonnes de HT ) sont orthogonales à celles de G. Elles sont
constituées de mots d'un code qui est orthogonal au code généré par G.
Quelques rappels sur l'orthogonalité :

Dn + 1 = g(D).h(D) ⇒ D-n + 1 = g(D-1).h(D-1)
⇒ Dn ( D-n + 1 ) = Dn g(D-1).h(D-1) = Dn-k g(D-1).Dk h(D-1) = Dn + 1
D h(D-1) est un polynôme de degré k qui factorise Dn + 1 et il génère donc un code ( n , n-k ) qui est orthogonal
k
à celui généré par g(D).

h(D) = 1 + h1D + h2D2 + + hk-1Dk-1 + Dk
Dk h(D) = Dk + h1Dk-1 + h2Dk-2 + + hk-1D + 1 ⇒ Dk h(D-1) est le polynôme réciproque de h(D) c'est à
dire obtenu par permutation de hi et hk-i.
Dk h(D-1) est donc un mot de code orthogonal au code généré par g(D), comme ce sont des codes cycliques, il en
sera de même de Dk+j h(D-1). La matrice H* dont les lignes sont des mots de code orthogonaux à tout le code
généré par g(D) peut être construite selon le schéma :
 −1 
← D .h(D ) →
k
 k +1 −1 
 ← D .h(D ) → 
H* =  . 
 
 . 
 n −1 
 ← D .h(D ) → 
Cette matrice ne possède cependant pas la propriété des codes systématiques : ils font intervenir la matrice
identité In-k. Pour retrouver cette propriété, il suffit de refaire des combinaisons linéaires des lignes de H*.
Pour le code pris en exemple :

h(D) = 1 + D + D2 + D4 ⇒ Dk.h(D-1) = D4 + D3 + D2 +1
soit :
1 0 1 1 1 0 0
H =  0 1 0 1 1 1 0 
*
 0 0 1 0 1 1 1 
puis, pour faire intervenir I3, nous effectuons :
ligne1 ← ligne + ligne3
1 0 0 1 0 1 1
H =  0 1 0 1 1 1 0 
 0 0 1 0 1 1 1 
ce qui est bien identique à la matrice obtenue à partir de G.
IV CODES CYCLIQUES USUELS

IV.1 Codes de Hamming cycliques
Largement développés dans le chapitre précédent.
IV.2 Code de Golay :

C'est un code ( n , k ) = ( 23 , 12 ).

D23 + 1 = ( 1 + D ) ( 1 + D +D5 + D6 + D7 + D9 + D11 ) ( 1 + D + D4 + D5 + D6 + D10 + D11 )

Le polynôme générateur est g(D) = 1 + D +D5 + D6 + D7 + D9 + D11
Sa distance minimale de Hamming est : dmin = 7 ⇒ il peut détecter et corriger des erreurs triples. C'est le
seul ayant cette propriété. Malheureusement, il est unique dans son groupe et on ne peut le généraliser à d'autres
combinaisons.
IV.3 Codes de longueur maximale :
( n , k ) = ( 2m-1 , m ).
Ces codes utilisent donc tous les mots de code possibles. Ils sont générés simplement par des registres à décalage
correctement réalimentés et initialisés. Leur caractéristique est que la séquence générée ne possède aucune
autocorrélation sauf en 0, ils ont donc d'un point de vue signal les caractéristiques d'un bruit blanc ce sont des
pseudo-bruits ou pseudo-noise ⇒ codes PN.
Leur utilisation dépasse largement le domaine du traitement de l'information pour celui du traitement de signal et
de l'automatique.
IV.4 Codes BCH ( Bose-Chaudrui-Hocquenqhem) :
Toujours avec n = 2m – 1, k est choisi tel que k ≥ ( n-m.t ) où t est le nombre d'erreurs détectables et corrigeables.
La distance minimale obtenue correspond toujours à dmin ≥ 2t + 1.
Ces codes permettent des longueurs de code très variées et offrent de nombreuses possibilités d'efficacité de code
k/n. Ils ont fait l'objet de nombreuses études et utilisations. Les coefficients des polynômes générateurs sont
tabulés dans de nombreux ouvrages, la longueur des polynômes générateur devenant très grande, ces tables
fournissent les jeux de coefficients en utilisant un format octal par ordre décroissant.
Exemple : code ( 31 ,26 ), t = 1 , coefficients 45 en octal soit 100 101 → g(D) = D5 + D2 + 1
IV.5 Codes Reed-Solomon ( codes RS ) :

C'est une généralisation des codes BCH à des codes non binaires. Les données binaires sont traitées par groupes
de m bits formant l'ensemble des symboles.

CHAPITRE 3
CODAGE DE CANAL
CODES DE CONVOLUTION
Codage : Codes de convolutions R. Rhouma - 1 -

I. PRINCIPE
Les codes de convolution sont des codes binaires qui constituent une alternative aux codes de blocs par
leur simplicité de génération grâce à quelques registres à décalage. Introduits par Elias (1955) ils permettent
de générer en ligne le code sans passer par une bufferisation préalable comme c'est le cas avec les codes
BCH ou RS.
I.1 La convolution :
Le problème du codage se schématise par :
m(t) x(t)
message Encodeur code
m(t) et x(t) sont des signaux discrets dont les échantillons sont binaires. Si l'encodeur est un
système linéaire, x(t) peut être généré par un produit de convolution ⇒ code de convolution.
M
xj = ∑ gi m j-i
i=0
Le système de convolution utilisé est de type non récursif (système RIF).
Schéma de principe :
En binaire l'opération de convolution se réalise très simplement par :
Registre de M bascules
m(t) q-1 q-1 q-1 q-1
g0 g1 g2 g3 gM-1 gM
x(t)
En se rappelant que : gi = 0 ⇒ connexion absente
gi = 1 ⇒ connexion présente
Convolution et polynômes :
L'opération de convolution se représente mathématiquement par le produit polynomial :
x(D) = g(D).m(D)
ce qui est une opération formellement identique à celle de génération d'un code cyclique mais ici, on
ne recherche plus les caractéristiques code de bloc et codage systématique.

I.2 Propriétés :
Longueur de contrainte : paramètre K.

La longueur de contrainte est le nombre d'instants d'échantillonnage pendant lequel un bit du
message participe à l'élaboration du mot de code (la sortie). En regardant le schéma précédent il vient :
K=M+1
Début du codage, initialisation du registre :

Par convention, nous prenons comme instant initial la présence du bit m0 à l'entrée de l'encodeur.
L'expression mj-i pour le message n'existe que pour (j-i) ≥ 0. Quelles valeurs initiales utiliser pour
l'élaboration des premiers échantillons de la sortie qui font intervenir (j-i) < 0 ? Par convention, les registres
sont initialisés à "0" ce qui implique
des conditions initiales nulles. Le
nombre d'instants d'échantillonnage
pendant lesquels ces conditions
k=2
initiales influent sur la sortie est K – q-1
1 = M. m(t)
n=3
Fin du codage
q-1 x(t)
Pour un message de
longueur L, mj-i n'est défini que pour
(j-i) < L. Le codage est en cours tant
que le dernier bit mj-L+1 du message
est actif sur l'élaboration de la sortie
c'est-à-dire présent en sortie de la
dernière bascule du registre. Cependant entre sa présence en entrée de l'encodeur et sa présence en sortie
du registre, les bascules doivent toutes avoir une indication d'entrée d'où la nécessité de placer des bits
supplémentaires après le message : la "queue" du message. Par convention ces bits de queue sont des "0"
et il est nécessaire d'en placer M qui
pratiquement servent à réinitialiser les
bascules du registre. n=2
La conséquence de ceci est mi mi-1 mi-2 x(t)
m(t) q-1 q-1
que pour un message de longueur L
nous obtiendrons un mot de code de
longueur L+M.

I.3 Généralisation de l'encodage de convolution :

Pour améliorer le codage, il est possible de réaliser à partir du même message n séquences de
convolution différentes qui seront entrelacées. C'est ce qui est montré sur la figure ci-contre pour une
longueur de contrainte de K = 3 (2 bascules, M = 2 ) avec un entrelacement en sortie n = 2.
D'autres possibilités d'entrelacement sont envisageables comme traiter les bits d'entrée par paquets
de k bits et les entrelacer en sortie. C'est ce qui est figuré ci-contre avec k= 2, n = 3 et une longueur de
contrainte K = 2.
Cela définit de manière plus générale :
1. la longueur effective du message d'entrée : k.L
2. la longueur du message de sortie : n.( L + M )
3. le rapport de code : r = (k L) / ( n.(L+M)). En général L >> M ⇒ r≈k/n
II. FONCTIONNEMENT TEMPOREL

Nous le traiterons sur un exemple simple avec un rapport de code r = ½. Le principe est préservé
dans le cas général qui ne fait qu'augmenter la complexité des calculs.
Cet exemple pour lequel M= 2 génère deux séquences qui seront entrelacées selon le principe
suivant :
n=2
mi mi-1 mi-2 x(t)
m(t) q-1 q-1
M
x j(1) = ∑ gi(1) m j-i avec gi
(1) (1)
= [g0 g1
(1)
g2
(1)
]=[0 0 1]
i=0
M
x j(2) = ∑ gi(2) m j-i avec gi
(2) (2)
= [g0 g1
(2)
g2
(2)
]=[1 1 1]
i=0
La convolution se calcule sur K bits (ici K = 3) et tous les cas possibles peuvent se représenter dans
un tableau : la table de convolution

(1) (1) (1) (2) (2) (2)

Combinaisons d'entrée [ g0 g1 g2 ]=[001] [ g0 g1 g2 ]=[111]
(1) (2)
[ mj mj-1 mj-2 ] xj xj
0 0 0 0 0
0 0 1 1 1
0 1 0 0 1
0 1 1 1 0
1 0 0 0 1
1 0 1 1 0
1 1 0 0 0
1 1 1 1 1
Avec le message m = [m0 m1 m2 …..mL-1 ] = [ 1 0 0 1 1 ] (ici L= 5) :

(1) (2)
j remarque [ mj mj-1 mj-2 ] xj xj
0 Deux "0" d'initialisation [ m0 0 0 ] = 1 0 0 0 1
1 Un "0" d'initialisation [ m1 m0 0 ] = 0 1 0 0 1
2 [ m2 m1 m0 ] = 0 0 1 1 1
3 [ m3 m2 m1 ] = 1 0 0 0 1
4 [ m4 m3 m2 ] = 1 1 0 0 0
5 Un "0" de queue [ 0 m4 m3 ] = 0 1 1 1 0
6 Deux "0" de queue [ 0 0 m4 ] = 0 0 1 1 1
Ceci fournit donc le mot de code : x = [ 0 1 0 1 1 1 0 1 0 0 1 0 1 1 ]
III. METHODE POLYNOMIALE

La convolution est représentée dans le corps des polynômes par un simple produit polynomial. En
reprenant l'opérateur de position D déjà défini dans l'étude des codes cycliques nous définissons les
polynômes générateurs du code soit :
M
g(m)(D) = ∑ gi(m) Di
i=0
L-1
Nous associons au message le polynôme : m(D) = ∑ mj Dj
j=0

Avec l'exemple utilisé :

(1) 2 (2) 2 3 4
g (D) = D g (D) = 1 + D + D m(D) = 1 + D + D .
Nous pouvons ainsi effectuer les produits polynomiaux:

(1) (1) 2 3 4
x (D) = g (D).m(D) = ( D ).( 1 + D + D )
2 5 6
=D +D +D
(2) (2) 2 3 4 3 4
x (D) = g (D).m(D) = ( 1 + D + D ).( 1 + D + D ) = 1 + D + D
4 5
+D+D +D
2 5 6
+D +D +D
2 3 6
=1+D+D +D +D
Soit, en entrelaçant les coefficients des deux polynômes :
x=[01 01 11 01 00 10 11]
IV REPRESENTATIONS GRAPHIQUES
Il existe trois représentations graphiques équivalentes pour représenter les propriétés structurales
d'un encodeur de convolution. Elles sont d'un grand intérêt pour comprendre le fonctionnement du codeur et
aussi surtout du décodeur.
IV.1 Etat présent – état suivant :

La description des diverses représentations graphiques est plus simple et systématique si nous
utilisons les concepts développés dans la logique séquentielle :
A un instant présent t = j.Ts, l'état des bascules est défini par les K-1 bits de sortie : [ mj-1……mj-K+1 ]
et nous pouvons atteindre seulement deux états différents liés à la nature du bit mj. Les K bits pris
en compte pour le calcul du code sont : mj mj-1……mj-K+1.
De l'instant t = j.Ts à l'instant t = (j+1).Ts le passage se fait donc par un changement d'état :
de l'état présent [ mj-1……mj-K+1 ] à l'état suivant [ mj……mj-K+2 ] avec seulement deux possibilités
chacune réalisant son codage (sortie).
K-1
Nous pouvons donc systématiquement explorer les 2 états possibles ainsi que les deux transitions
possibles pour chacun d'entre eux. Ceci est directement apparent sur la table de convolution : l'état
ère
présent est constitué des K-1 bits de droite de la 1 colonne de la table (on exclut le bit de gauche
mj) et l'état suivant est défini par les K-1 bits de gauche de cette même colonne (on exclut le bit de
droite mj-K+1).
La sortie, c'est-à-dire le codage réalisé est constitué de l'ensemble des colonnes donnant le résultat
de la convolution.
Avec notre exemple :

= 4 états internes. Les états sont repérés par des lettres : a → (00), b → (01), c →
K-1
K=3 ⇒ 2
(10), d → (11). L'état présent est constitué par les deux bits de droite de la combinaison d'entrée active et
l'état suivant sera caractérisé par les deux bits de gauche. La "sortie" correspondant au passage de l'un à
(1) (2)
l'autre est constituée de l'indication des colonnes xj xj .
(1) (1) (1) (2) (2) (2)
[ g0 g1 g2 ]= [ g0 g1 g2 ]=
Etat suivant Combinaisons d'entrée Etat présent
[001] [111]
(1) (2)
[ mj mj-1 mj-2 ] xj xj
a 0 0 0 a 0 0
a 0 0 1 b 1 1
b 0 1 0 c 0 1
b 0 1 1 d 1 0
c 1 0 0 a 0 1
c 1 0 1 b 1 0
d 1 1 0 c 0 0
d 1 1 1 d 1 1
Nous pouvons en déduire les éléments de base du graphe avec pour convention :
mj = 0, déplacement vers le haut
mj = 1, déplacement vers le bas
0 00 11 01 10
a a b b
a b c d
1 c c d d
01 10 00 11
IV.2 Arbre du code :

Il représente la succession des états possibles. Ce sera donc une arborescence constituée des
éléments de base précédents et dont la complexité ira croissant.
Conventions usuelles:
l'évolution temporelle est représentée de la gauche vers la droite
chaque nouveau bit entré provoque un déplacement vers le haut s'il s'agit d'un "0" et vers le bas s'il
s'agit d'un "1"
sur chaque branche est porté le résultat de l'encodage (la sortie) conformément à la table de
convolution

Un exemple :
En reprenant le tableau précédent nous pouvons établir l'arbre de la page suivante :
Pour le message m = [m0 m1 m2 …..mL-1 ] = [ 1 0 0 1 1 ] nous vérifions bien l'obtention du mot de

code :
x = [ 0 1 0 1 1 1 0 1 0 0 1 0 1 1 ].
Remarques :
Avec la méthode proposée, on remarquera à un instant donné la périodicité des états possibles
K-1
(colonne de l'arbre) ainsi que celle des sorties possibles. Cette périodicité est de 2 .
Nous n'avons accès à tous les états possibles qu'après évacuation des conditions initiales nulles ce
qui représente M = K-1 instants (ici M = 2)
Pour que le codage soit complet il ne faut pas oublier de placer M zéros de queue.

00
a
00
a
01
c
00
a 01
b
01
c
00
d
00
a 11
a
01
b
10
c
01
c 10
b
00
d
11
d
00
a 00
a
11
a
01
c
01
b 01
b
10
c
00
d
01
0 c 11
a
10
b
10
c
00
d 10
b
11
d
11
d
a 00
a
00
a
01
c
11
a 01
b
01
c
00
d
01
1 b 11
a
01
b
10
c
10
c 10
b
00
d
11
d
01
c 00
a
11
a
01
c
10
b 01
b
10
c
00
d
00
d 11
a
10
b
10
c
11
d 10
b
11
d
11
d

IV.3. Treillis du code
L'inconvénient essentiel de l'arbre du code est que l'arborescence est multipliée par 2 à chaque bit
supplémentaire et la représentation devient vite impossible à réaliser. Les remarques faites sur le nombre
limité d'états possibles va nous permettre de compacter ce graphe en attribuant à chaque instant un noeud à
un état. Par convention la représentation utilise les normes suivantes :
Le passage d'un état à un autre par la prise en compte d'un bit "0" est représenté en trait continu.
Le passage d'un état à un autre par la prise en compte d'un bit "1" est représenté en trait pointillé.
Sur le trait, est indiquée la sortie générée c'est à dire la portion du mot de code correspondante.
Cellule élémentaire:
En utilisant soit l'arbre du code soit les éléments de base constitutifs nous pouvons dessiner une cellule
K-1
élémentaire du treillis reliant l'instant t à l'instant t+1. Cette cellule comporte 2 entrées et sorties.
Pour l'exemple choisi dans les chapitres précédents nous obtenons :
p(yi/xi) = p si yi ≠ xi
00
a a
11
01
b b
10
01
c c
10
00
11
d d
Phase initiale :
Pendant M = K-1 instants, une partie de l'état des bascules est constitué des "0" d'initialisation. Pendant
tous ces instants, toutes les combinaisons ne sont pas possibles et tous les états ne sont pas accessibles.
Le treillis comporte donc à l'origine M cellules correspondant à cette phase initiale.
00 00
a a
01 01
b
01
00

Phase finale :
A la fin du codage nous sommes amenés à introduire des "0" de queue. De ce fait, seules les transitions
en trait plein deviennent possibles et le treillis se résume à M cellules ne comportant que ces transitions.
00 00
a a
11 11
01
c
10
Avec ce treillis nous vérifions que le message m = [m0 m1 m2 …..mL-1 ] = [ 1 0 0 1 1 ] génère bien
le mot de code :
x = [ 0 1 0 1 1 1 0 1 0 0 1 0 1 1 ].
Phase Cellule Phase

initiale élémentaire finale
IV.4 Diagramme d'état :

Cette opération consiste en une contraction de la cellule élémentaire du treillis sur un graphe orienté
où :
un sommet représente un état interne
un arc orienté représente une transition. En trait plein pour celles induites par un "0" et en trait
pointillé pour celles induites par un "1"
la sortie ou portion de code généré est porté sur l'arc correspondant.

00
01
11
01
b
c
10
10
00
11
Avec ce graphe nous vérifions que le message m = [m0 m1 m2 …..mL-1 ] = [ 1 0 0 1 1 ] donne le
mot de code :
[ 0 1 0 1 1 1 0 1 0 0 1 0 1 1 ] sans oublier les "0" de queue.
V. DECODAGE DE CONVOLUTION
C'est donc une opération de déconvolution qui, en cas d'erreur, doit réaliser l'estimation la plus
probable pour corriger cette erreur.
V.1 Maximum de vraisemblance :

Le schéma de la transmission est :
Message m → code x → réception y = x + e
Rôle du décodeur :
Le décodeur doit faire la meilleure estimation de m qui correspond à la meilleure estimation de x
(convolution = relation linéaire ).
y → x̂ → m̂
Règle de décodage :
Connaissant y, l'estimation x̂ est optimale si la probabilité d'effectuer une erreur de décodage est
minimale. C'est l'expression simplifiée de la règle du maximum de vraisemblance et x̂ correspond à la
valeur qui rend maximale la probabilité conditionnelle p(y/x) soit : x̂ = [ p(y/ x) ]max .

Tous les messages sont équiprobables, et la fonction logarithme est une fonction monotone. Il est
équivalent d'exprimer ce maximum de vraisemblance en optimisant le Ln d'où :
x̂ → max [ Ln[ p(y/ x) ] ]
Cas du canal binaire symétrique :

Si le canal binaire symétrique est sans mémoire, tous les bits du message sont statistiquement
indépendants et :
[ ]
N N
p(y/ x) = ∏ p(yi / xi ) ⇒ Ln [ p(y/ x) ] = ∑ Ln p(yi / xi )
i=1 i=1
Pour le canal binaire symétrique de probabilité d'erreur de transmission p :
p(yi/xi) = p si yi ≠ xi
p(yi/xi) = 1-p si yi = xi
Si y et x diffèrent de d bits, d est la distance de Hamming entre les deux codes et pour un mot de
code de N bits :
Ln [ p(y/ x) ] = d Ln (p) + ( N - d ) Ln( 1-p ) = d Ln   + N Ln (1-p)

p
 1-p 
Il est plausible que p < 1/2 ⇒ d.Ln[ p/(1-p) ] < 0 et comme N.Ln(1-p) est une constante, Ln[
p(y/x) ] est maximum si d est minimum. Dans ce cas le maximum de vraisemblance s'exprime par :
Pour un canal binaire symétrique, nous devons choisir x̂

de manière à minimiser la distance de Hamming entre x et y
Pour cela, x est bien sûr inconnu mais nous avons à notre connaissance le treillis du code et, à la
réception de y, nous chercherons à minimiser la distance de Hamming entre le code reçu et tous les codes
possibles. Le plus "proche de y" constituera l'estimation la plus vraisemblable.
V.2 Algorithme de Viterbi : 00

a a
Tout ces résultats théoriques n'ont d'intérêt que si leur
11
application peut se faire de manière simple. C'est ici le cas grâce à
la méthode de déconvolution proposée par Viterbi. 01
b b
Nous l'expliquerons sur un exemple en utilisant le code dont 10
le treillis est rappelé ci-contre. 01
Avec ce treillis, nous avons obtenu le codage : c c
10
m = [m0 m1 m2 …..mL-1 ] = [ 1 0 0 1 1 ]
00
→ x=[01 01 11 01 00 10 11]
11
d d

Supposons une erreur de transmission telle que :
y=[01 01 01 01 00 10 11]
et recherchons la meilleure estimation grâce au treillis et aussi au fait que nous savons qu'il existe
une phase initiale et une phase finale toutes les deux de longueur M = K-1.
Ici M = 2.
Principe :
En utilisant le treillis nous réalisons les opérations suivantes :
1. nous examinons chaque portion de code reçue puis nous calculons la distance entre cette portion de
code et la sortie du treillis pour toutes les possibilités.
2. Cette distance ajoutée à celle associée au nœud d'origine (état présent) est portée sur le nœud ainsi
atteint (état suivant). Un nœud comportera deux indications puisqu'il y a deux façons de l'atteindre.
3. Pour l'étape suivante, nous ne conservons pour un nœud que la distance minimale ce qui revient à
ne conserver qu'un certain nombre de "trajets" probables : les survivants.
4. Nous recommençons l'opération 1 jusqu'à épuisement du code reçu.
5. Le code le plus probable sera celui qui à la suite de ces opérations correspondra à la distance totale
la plus faible et le message est reconstitué en interprétant la suite des "pleins" et "pointillés"
associés au trajet le plus probable
Phase initiale :
Elle dure M coups et les états ne peuvent être atteints que
Code reçu → 01 1 01
d'une seule façon. Durant cette phase il n'y a donc pour un état 2
a
suivant qu'une seule distance et aucun "trajet" ne sera rejeté. L'état
initial est nécessairement l'état interne "0" soit a dans notre 0
b
exemple.
0
1
c
1
d
Phase centrale :
Code reçu → 01 01 01
Tous les états sont atteignables de deux 1 2 3
a
manières et à chaque étape nous décidons de ne 1
conserver que les trajets correspondants pour chaque 0

1
b 3
état possible à une distance minimale : les survivants.
0 1 2
c 2
1
2
d 2

01 1 01 2 01
1
0
Survivants 1
0 1
2
2
1
2
étape suivante :
01 1 01 2 01 01
2
2
1
0 1
2
4
0 1 2
1
3
2
1 2
3
3
2
01 01 01 01
1 2
2
1 2
0
2
Survivants
0 1 2
1
2
1 2
3
2 3
étape suivante :
01 1 01 2 01 01 2 00
2
1 4
0 2
2
4
0 1 2 1
3
3
2
1 3
2 1
5
3

01 1 01 2 01 01 2 00 2
1
Survivants 0 2
2
0 2 1
3
3
2
Phase finale :
Nous savons que les M derniers blocs correspondent à la phase finale pendant laquelle seuls les "0"
(trait plein) sont introduits.
Premier zéro de queue :
01 1 01 2 01 01 2 00 2 10
3
3
1
0 2 2 5
1
0 2 1 3
2 3
01 01 01 01 2 00 2 10
3
3
1
0 2
1
0 1
Deuxième zéro de queue :
01 01 01 01 2 00 2 10 11
3 5
3 1
1
0 2
1
0 1

01 01 01 01 00 10 11
1
1
0
0 1
Le dernier trajet survivant est le plus vraisemblable et correspond au message [ 1 0 0 1 1 ] . L'erreur

de transmission a ainsi été corrigée.

ECOLE NATIONALE D’INGENIEURS DE GABES A.U 2009/2010
Département Communications & Réseaux
DS
Matière : Codage Documents : Autorisés

Classe : GCR 2 A-B Date : 09 / 11 / 2009
Enseignant : Dr. RHOUMA R. Durée : 2 H
Nb pages : 2
Exercice 1
Soit une source décrite par la variable aléatoire X qui peut prendre 6 valeurs {A, B, C, D, E,
⎧1 2 3 4 5 6⎫
F} avec les probabilités ⎨ , , , , , ⎬
⎩ 21 21 21 21 21 21⎭
1°) Construire un code de Huffman binaire pour X. (le dessin de construction de codes)
2°) Tracer l’arbre du code finale (verticalement).
3°) Donner finalement les codes de chaque symbole de X.
4°) Calculer l’entropie H(X) de ce code.
5°) Calculer la longueur moyenne de ce code.
6°) Calculer l’efficacité de ce code.
7°) Calculer le rapport de compression entre le code de Huffman et le code ASCII (version 8
bits) pour cette exemple.
8°) Refaire le codage en appliquant le code de Fano-Shannon.
9°) Comparer les 2 codes (Huffman et Fano-Shannon) en terme d‘efficacité. En déduire le
code le plus performant des deux pour cet exemple.
Exercice 2
Soit un code C, avec matrice de contrôle de parité H, de la forme :

⎛1 0 0 1 0⎞
⎜ ⎟
H = ⎜0 1 0 1 1⎟
⎜0 0 1 0 1⎟
⎝ ⎠
1. Déterminer les paramètres (n, k) de C.

2. Est-ce que les messages suivants sont des mots de code de C ?
m1 = (11101)
m2 = (11010)
3. Déterminer une matrice génératrice G de C.

4. Lister tous les mots de C.
5. Déterminer la distance minimale de C par trois méthodes.
Exercice 3
Soit le code cyclique de longueur 7 généré par le polynôme g(x) :

g(x) = 1 + x2 + x3
1. Quelle est la dimension de ce code ?

2. Donner une matrice génératrice G*.
3. Trouver la matrice génératrice sous forme systématique,
4. Déduire une matrice de contrôle H de ce code.
5. Le mot Cm = (1 0 1 1 1 0 0) est-il un mot de code ?
6. Comment peut-on vérifier que g(x) génère un code cyclique de longueur 7 ?
7. Soit le message m = [1 1 0 1]. Générer son mot de code en utilisant g(x).
8. Soit le mot de code reçu Ym(x)= x5 + x3 taché d’éventuelles erreurs. Décoder le et
donner le message information binaire correct m*.
DC

Classe : GCR 2 Cours de soir Date : 09 / 11 / 2009
Nb pages : 2
Exercice 1
Soit une source décrite par la variable aléatoire X qui peut prendre 7 valeurs
⎧1 2 3 4 5 6 7⎫
X= {A, B, C, D, E, F, G} avec les probabilités ⎨ , , , , , , ⎬
⎩ 28 28 28 28 28 28 28 ⎭
1°) Construire un code de Huffman binaire pour X. (le dessin de construction de codes)
2°) Tracer l’arbre du code finale (verticalement).
3°) Donner finalement les codes de chaque symbole de X.
4°) Calculer l’entropie H(X) de ce code.
5°) Calculer la longueur moyenne de ce code.
6°) Calculer l’efficacité de ce code.
7°) Calculer le rapport de compression entre le code de Huffman et le code ASCII (version 8
bits) pour cette exemple.
8°) Refaire le codage en appliquant le code de Fano-Shannon.
9°) Comparer les 2 codes (Huffman et Fano-Shannon) en terme d‘efficacité. En déduire le
code le plus performant des deux pour cet exemple.
Exercice 2
Soit un code C, avec matrice génératrice G, de la forme :

⎛ 1 0 1 0 0⎞
⎜ ⎟
G = ⎜ 0 1 0 1 0⎟
⎜1 1 0 0 1⎟
⎝ ⎠
1. Déterminer les paramètres (n, k) de C.
2. Déduire une matrice de contrôle H de C.
3. Lister tous les mots de codes de C.
4. Donner la distance minimale de ce code. En déduire le nombre maximal des erreurs
détectables eD et le nombre maximal des erreurs corrigeables eC.
5. Soit les mots de code reçus :
Ym1 = (11100)
Ym 2 = (10101)
Décoder les.
1
Exercice 3
1. Vérifier que x 2 + x + 1 divise x 6 + 1
2. Faire la liste des mots du code cyclique de longueur 6 ayant pour polynôme générateur x 2 + x + 1
3. Donner une matrice génératrice G*.
4. Trouver la matrice génératrice sous forme systématique,
5. Déduire une matrice de contrôle H de ce code.
6. Quelle est la distance de Hamming de ce code ?
2
DS

Classe : GCR 2 A-B-C Date : 15 / 11 / 2010
Enseignant : Dr. RHOUMA R. Durée : 1.5 H
Nb pages : 2
Exercice 1
1°) Le codage d'Huffman fournit un code préfixe. Qu'est-ce qu'un code préfixe ? Quels sont
ses propriétés essentielles ?
2°) Une source discrète sans mémoire a comme alphabet { A , F , I , R , U , V , X } auquel
sont associées les probabilités d'occurrence { 25% , 3% , 24% ,21% , 20% ,5% , 2% }.
Calculer son entropie.
3°) Réaliser une arbre de codage d'Huffman associée à cette source ( Règles de codage : 1.
Dans les étapes de constitution de l’arbre, en cas d'égalité des probabilités, on donnera
priorité au nœud le plus récent. 2. Dans la constitution d'un nœud père le code "0" est
attribué au nœud fils le plus probable. ).
4°) Définir et calculer : la longueur moyenne du code et son efficacité.
5°) Quel est le message codé par 11101100010 ?
Exercice 2
Un encodage systématique de canal (n,k) est réalisé avec la matrice de génération de code G:
1 0 1 1 0
G= 
0 1 1 0 1 
1°) Qu’est-ce que n et k ? Quelles sont leurs valeurs ? Ecrire la matrice P génératrice de ces
bits.
2°) Faire un tableau contenant tous les messages possibles et le mot de code qui leur est
associé.
3°) Etablir la relation générale entre la distance minimale d’un code et le nombre d’erreurs
corrigeables. Quelle est la distance minimale du code généré ? Quel est le nombre d’erreurs
corrigeables ?
1
4°) Définir et calculer la matrice H de contrôle du code. Quelle est son action sur un mot de
code ? Le vérifier sur l’un des mots non nul du code.
5°) Définir le syndrôme d’erreur. Etablir la table des syndrômes pour le code étudié.
6°) En utilisant la table des messages et celle des syndrômes, expliquer l’action du décodeur
dans le cas de réception des quatre mots suivants :
Y1=[0 1 1 0 1]
Y2=[1 0 0 1 0]
Y3=[1 0 1 0 1]
Y4=[0 1 0 1 0]
Exercice 3
Un code de convolution de longueur de contrainte K est généré de la manière suivante :
(1)
m(t) q-1 q-1 q-1 x(t)
(2)
1°) Donner en justifiant la valeur de K.

2°) Quels sont les deux polynômes générateurs de ce code.
3°) Quel est le code x(t) obtenu avec le message m(t)= LSB[1 0 0 1 1]MSB.
4°) Etablir la table de vérité correspondante.
5°) Identifier sur cette table les états internes possibles de l’encodeur et établir les différents
graphes d’états.
6°) Donner le Treillis de ce code.
7°) Avec ce Treillis, en précisant la succession des différents états internes de l’encodeur,
vérifier le code obtenu au 3°)
8°) décoder le code reçu suivant y(t)= LSB [11 00 11 00 11 01 00 11] LSB
2
DS

Classe : GCR 2 A-B Date : 12 / 01 / 2010
Nb pages : 2
Exercice 1 : Code cyclique
1°) Rappeler les propriétés d’un code cyclique systématique. Pour un tel code de type
(n,k) préciser le nombre de bits du message, le nombre de bits de contrôle et le nombre de bits
du mot de code généré. En appelant {ci} les bits du mot de code, {mj} les bits du message et
{bm} les bits de contrôle, indiquer clairement sur l’exemple d’un code (6,2) comment sont
générés les bits {ci}à partir des bits {mj} et {bm}. On précisera la place de ces bits dans le mot
de code ainsi que la position des poids faibles et des poids forts. Cette convention sera celle
que vous devrez utiliser dans toute la suite de l’exercice.
2°) Pour générer un code cyclique systématique (6,2) on sait que :

X6+1 = (1+X2) (1+X+X2) (1+X+X2)
2.a Quels sont tous les messages possibles ?
2.b Quels sont les polynômes générateurs possibles du code? On choisira celui
qui comporte le moins de termes.
2.c Pour tous les messages possibles calculer les bits de contrôle et en déduire
les mots de code correspondants. Le résultat final sera porté dans un tableau.
3°) détection et correction des erreurs

3.a Qu’est-ce que le syndrôme d’erreur ? Comment le calcule –t-on ? Combien
de bits comporte-t-il ? Effectuer ce calcul pour une erreur simple sur tous les bits du mot de
code transmis. Le résultat devra lui aussi être reporté dans un tableau.
3.b A la réception du mot de code 010111 quel sera le syndrôme calculé ?
3.c Quels seront les syndrômes calculés à la réception des mots de codes
111000 et 010010 ? Que déduisez-vous de ce résultat ?
4°) Etablir la relation générale entre la distance minimale d’un code et le nombre
d’erreurs corrigeables. Quelle est la distance minimale du code généré ? Vérifier la cohérence
avec les résultats du 3°)
Exercice 2 : Code de convolution.
1°) Un code de convolution est généré avec les trois polynômes :

• g1(X)= 1+X2
• g2(X)= 1+X
• g3(X)= 1+X+X2
1
l’entrelacement étant effectué dans l’ordre 1,2,3.
1.a Faire un schéma de principe représentant la génération de ce code.
1.b Quelle est la contrainte de longueur minimale K du code ? Si le message

est de longueur L, quelle sera la longueur du mot de code généré ?
1.c Avec la convention [poids faible……poids fort] quel sera le mot de code
généré par cet encodeur pour un message [1011] ?
2°) Approche graphique :
2.a Etablir la table de vérité de l’encodeur :

[mk mk-1 mk-2] [g1(0) g1(1) g1(2)] [g2(0) g2(1) g2(2)] [g3(0) g3(1) g3(2)]
2.b Tracer l’arbre du code. Quel est le nombre d’états différents intervenant ?
2.c Tracer le treillis correspondant.
2.d Tracer le graphe d’état correspondant.
2.e Avec l’un de ces graphes, vérifier le résultat de l’encodage du 1.c.
3°) Décodage
3.a On cherche à détecter les mots de code transmis. Citer un algorithme

permettant de réaliser ce décodage. Quel est son principe de base?
3.b On reçoit le mot de code [111 110 110 010 011 101] ([premier bit
transmis………...dernier bit transmis]). Quel était le message émis ? Est-ce le mot de
code qu’on aurait dû réceptionner pour ce message ?
2
DS

Classe : GCR 2 A-B-C Date : / 01 / 2011
Nb pages : 2
Exercice 1
Une source discrète sans mémoire comprend huit symboles {xi} i∈[1..8] de probabilités
respectives {0,36 - 0,14 - 0,13 - 0,12 - 0,1 - 0,09 - 0,04 - 0,02}.
1°) Rappeler la définition de la quantité d’information d’un symbole et la calculer pour
les symboles de la source précédente.
2°) Définir l’entropie d’une source. Dans quel cas est-elle maximale ? La calculer ainsi
que la valeur maximale pour la source précédente.
3°) Proposer un codage d’Huffman pour cette source. Définir et calculer l’efficacité de
ce codage.
Exercice 2
Un code cyclique (15,7) a comme polynôme générateur g(x)=1+x4+x6+x7+x8.
1°) Qu’est-ce que le polynôme générateur ?

2°) Définir la distance minimale d’un code ? Etablir la formule du nombre d’erreurs
détectables et corrigeables. Dans ce cas, ce nombre est de 2 (c'est-à-dire ec=2), quelles sont les
valeurs possibles de la distance minimale ?
3°) Le message binaire à transmettre est de la forme LSB[1101001]MSB. Calculer le
code systématique correspondant.
4°) Quelle est la relation entre g(x) et le polynôme h(x) permettant la correction des
erreurs de transmission ?
5°) En déduire h(x).
6°) Vérifier son action sur le code établi en 3°).
1
Exercice 3
Un code de convolution est généré de la manière suivante :
(1)
m(t) q-1 x(t)
(2)
1°) Donner en justifiant la valeur de la longueur de contrainte K.

2°) Quels sont les deux polynômes générateurs de ce code.
3°) Quel est le code x(t) obtenu avec le message m(t)= LSB[1 0 0 1 1]MSB.
4°) Etablir la table de vérité correspondant au code généré pour toutes les valeurs possibles de
mimi-1 tout en specifiant l’etat présent et suivant.
5°) En déduire les graphes d’états.
6°) Donner le Treillis de ce code (phase initiale, celleule élementaire, phase finale).
7°) Avec ce Treillis, vérifier le code obtenu en 3°)
8°) A l’aide de l’algorithme de Viterbi, decoder le mot de code reçu : x= [10 11 11 01 11 00].
2
DS

Classe : GCR 2 A-B Date : / 06 / 2010
Nb pages : 2
Exercice 1 : Code de Hamming
On considère le code de Hamming (n,k) avec n=7 et k=4. La matrice de contrôle de parité
correspondante est :
1 0 0 1 0 1 1
H=0 1 0 1 1 1 0
0 0 1 0 1 1 1
1. En déduire la matrice génératrice de code G

2. Dresser le tableau contenant le code correspondant aux 16 mots de messages
possibles. Calculer le poids de chaque mot et en déduire la distancez minimale
du code. Quel est le nombre d ‘erreurs que ce code est susceptible de corriger ?
3. Un mot de code quelconque est un vecteur ligne C. Rappeler la relation vérifiée
par H et C.
4. Quel est le syndrome des erreurs qui passeront inaperçues ?
5. Quels sont les différents codes d’erreurs ?
6. Dans le cas d’erreurs de transmission doubles, indiquer ce que comprendra le
décodeur ?
Exercice 2 : Code de convolution.
Un code de convolution est généré avec les deux polynômes :

• g1(X)= 1+X2
• g2(X)= 1+X
L’entrelacement étant effectué dans l’ordre 1,2
1. Faire un schéma de principe représentant la génération de ce code.

2. Quelle est la contrainte de longueur minimale K du code ? Si le message est de longueur
L, quelle sera la longueur du mot de code généré ?
3. Avec la convention [poids faible……poids fort] quel sera le mot de code généré par cet
encodeur pour un message [10101] ? (utiliser le calcul polynomial).
1
4. Etablir la table de vérité de l’encodeur :
[g1(0) g1(1) g1(2)] [g2(0) g2(1) g2(2)]
[mk mk-1 mk-2] x k(1) x k( 2)
. . .
. . .
. . .
5. Quel est le nombre d’états différents intervenant ? Tracer donc la table d’états.
Etat suivant Entrées Etat présent [g1(0) g1(1) g1(2)] [g2(0) g2(1) g2(2)]
[mk mk-1 mk-2] x k(1) x k( 2)
. . . . .
. . . . .
. . . . .
6. En déduire les éléments de base du graphe avec pour convention :

- mk = 0, déplacement vers le haut
- mk = 1, déplacement vers le bas
7. Tracer le treillis correspondant (cellule élémentaire + phase initiale + phase finale)

.
8. Tracer le diagramme d’état correspondant
9. Avec l’un de ces graphes, vérifier le résultat de l’encodage effectué dans la question 3.
2
Bibliographie
Le cours de « codage » a été principalement recueilli du cours suivant :
1) Cours de « Transmission de l’information ». Guy Binet. Université de Caen.

Codage 1

Transféré par

Droits d'auteur :

Formats disponibles

Codage 1

Transféré par

Informations du document

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

Codage 1

Transféré par

Droits d'auteur :

Formats disponibles

Université de Gabes

Ecole Nationale d'Ingénieurs de Gabes

Pour les Etudiants de GCR2

Sujets des devoirs de contrôle et synthèse inclus

CODES DE BLOCS LINEAIRES

Codage : Codage Canal, codes de blocs linéaires R. Rhouma 1

CODES DE BLOCS LINEAIRES

I. DEFINITIONS ET PROPRIETES DES CODES DE BLOC LINEAIRES

I.2 Codes de blocs :

I.3 Poids d'un code :

I.5 Code linéaire :

Codage : Codage Canal, codes de blocs linéaires R. Rhouma 2

Distance minimale d'un code linéaire :

II. GENERATION D'UN CODE DE BLOC LINEAIRE SYSTEMATIQUE

Soit Cm = [ Bm Xm ] où Bm contient les caractères de contrôle appelés aussi caractères de parité.

II.1 Génération du mot de code :

Code non systématique :

La partie essentielle de la matrice G est donc la matrice P appelée matrice de parité.

Principe de la réalisation du codeur :

Codage : Codage Canal, codes de blocs linéaires R. Rhouma 3

Cet exemple est celui d'un code ( 7 , 4 ) tel que :

II.2 Détection des erreurs de transmission :

Matrice de contrôle de parité :

En décomposant les matrices nous obtenons :

D'où la relation fondamentale : G.HT = 0

Cm.HT = Xm.G.HT = 0 pour tout mot de code.

Le syndrôme ne dépend que de l'erreur de transmission commise et non du mot de code.

Lien avec la distance minimale :

Codage : Codage Canal, codes de blocs linéaires R. Rhouma 4

II.3 Correction des erreurs :

Nombre d'erreurs corrigeables :

transmission sont toutes corrigeables.

Codage : Codage Canal, codes de blocs linéaires R. Rhouma 5

Une seconde situation:

Correction des erreurs : méthode logicielle.

Exemple: Soit le code (5 , 2) défini par

Codage : Codage Canal, codes de blocs linéaires R. Rhouma 6

Dans cet exemple, H a au plus trois colonnes linéairement indépendantes ⇒ dmin = 3.

La correction des erreurs:

Avec l'exemple précédent :

Erreur sur le bit 3 ⇒ Ym = [ 1 0 1 0 0 ] ⇒ syndrôme Sm = Ym.HT = [ 1 0 0 ]

Erreur sur les bits 1 et 3 ⇒ Ym = [ 1 1 1 0 1 ] ⇒ syndrôme Sm = Ym.HT = [ 0 1 0 ]

III CODES DE BLOCS LINEAIRES

Codage : Codage Canal, codes de blocs linéaires R. Rhouma 7

III.2 Codes de Hadamard :

Codage : Codage Canal, codes de blocs linéaires R. Rhouma 8

Codage : Codage Canal, codes cycliques R. Rhouma 1

I. DEFINITIONS ET PROPRIETES DES CODES CYCLIQUES

I.1 Propriétés fondamentales :

I.2 Polynôme générateur :

Un cas particulier de ce théorème :

Codage : Codage Canal, codes cycliques R. Rhouma 2

II CODAGE ET DECODAGE D'UN CODE CYCLIQUE

D(n-k) m(D) = Am(D).g(D) + b(D)

Le calcul du mot de code est donc de la forme :

Remarque : le polynôme Am(D) n'est pas utile pour exprimer Cm.

Cm(D) = b(D) + D(n-k) m(D) = 1 + D3 + D5 + D6 ⇒ Cm = [ 1 0 0 1 0 1 1 ]

Codage : Codage Canal, codes cycliques R. Rhouma 3

II.2 Contrôle de parité :

Avec comme conséquence : deg [ g(D) ] = n-k ⇒ deg [ h(D) ] = k