Codage de canal redondant

1. Description d’un système de codage de canal redondant

Dans un système de communication, le canal est une entité qui relie l’émetteur et le
récepteur. Il peut être représenté par une fonction qui prend un vecteur 𝑥𝑥 en entrée et lui associé un
vecteur 𝑦𝑦 en sortie. C’est la version bruitée du vecteur 𝑥𝑥 selon la probabilité du canal 𝑝𝑝(𝑦𝑦/𝑥𝑥). Les
ensembles d’entrée et de sortie peuvent être finis ou continus selon l’application considérée.

Le codage de canal a pour objet de protéger les données sources contre les erreurs du canal
lors de la transmission. Les techniques du codage de canal permettent la réduction du taux d’erreur
pour avoir une distorsion faible entre 𝑥𝑥 et 𝑦𝑦. Elles se basent sur des structures qui permettent la
détection et/ou la correction des erreurs du canal. Une des méthodes traditionnelles est le codage du
canal redondant, où l'on ajoute des bits supplémentaires au message transmis afin de pouvoir
détecter et/ou corriger les erreurs. La séquence utile à transmettre sera alors représentée par une
autre séquence plus grande. Par conséquence le débit de transmission est plus grand.

La figure suivante (3.2), présente le schéma bloc du codage de canal où 𝑖𝑖(𝑘𝑘) est le message
utile à transmettre de taille 𝑘𝑘 et 𝑥𝑥(𝑛𝑛) est le message codé à transmettre via le canal, il est de taille 𝑛𝑛
( 𝑛𝑛 > 𝑘𝑘) . Après la transmission, le message 𝑥𝑥(𝑛𝑛) devient 𝑦𝑦(𝑛𝑛) à cause du bruit du canal. Le
décodeur du canal enlève la redondance et détecte et/ou corrige l’erreur produite. Par conséquent, il
produit un message 𝑖𝑖̀(𝑘𝑘) identique ou pas à 𝑖𝑖(𝑘𝑘) selon sa capacité de correction.

Bruit

Codeur de 𝑥𝑥(𝑛𝑛) 𝑦𝑦(n) Décodeur

𝑖𝑖(𝑘𝑘) 𝑖𝑖̀(k)
Canal de transmission de canal
canal
𝑛𝑛 > 𝑘𝑘

Schéma bloc du codage du canal.

2. Codes en bloc: codes linéaires

Dans la conception de codes de canal efficaces, la théorie des corps finis, initiées par Galois,
intervient de façon essentielle. En effet, c’est à l’aide d’une algèbre élaborée qu’ont été construits
des codes correcteurs d’erreurs très puissants. Les codeurs de canal redondants sont classés en deux
grandes catégories : les codes en bloc et les codes convolutifs.

Les codes en blocs les plus utilisés sont de type linéaires systématiques, en ce que les 𝑘𝑘
premiers bits sont directement positionnés par l’utilisateur (bits d'information utile) et que les
𝑟𝑟 = 𝑛𝑛 − 𝑘𝑘 bits ajoutés sont calculés par le codeur. Les bits de redondance étant soigneusement
choisis à la fois pour garantir une détection et une correction optimales.

2.1 Principe du codage des codes linéaires

Soit 𝑋𝑋 un message d’information utilisé en blocs de 𝑘𝑘 bits définis par :

𝑋𝑋 = (𝑥𝑥1 , 𝑥𝑥2 , … , 𝑥𝑥𝑘𝑘 ) avec 𝑥𝑥𝑖𝑖 ∈ {0, 1}, (1)

et 𝐶𝐶 le mot-code du message 𝑋𝑋 de 𝑛𝑛 bits, défini par :

𝐶𝐶 = (𝑐𝑐1 , 𝑐𝑐2 , … , 𝑐𝑐𝑛𝑛 ) avec 𝑐𝑐𝑖𝑖 = {0, 1} et 𝑛𝑛 > 𝑘𝑘 (2)

Le code linéaire 𝐶𝐶(𝑛𝑛, 𝑘𝑘) est considéré systématique, donc les 𝑘𝑘 premiers bits du mot-code sont le
message d’information utile.

𝑥𝑥𝑖𝑖 = 𝑐𝑐𝑖𝑖 pour 𝑖𝑖 = 1, 2, … , 𝑘𝑘 (3)

Les 𝑛𝑛 − 𝑘𝑘 bits restants (bits de redondance) sont générés par des combinaisons linéaires des 𝑘𝑘 bits
utiles selon certaines règles prédéterminés, telles que:

𝑐𝑐𝑘𝑘+1 = 𝑔𝑔11 𝑥𝑥1 + 𝑔𝑔21 𝑥𝑥2 + ⋯ + 𝑔𝑔𝑘𝑘,1 𝑥𝑥𝑘𝑘

𝑐𝑐𝑘𝑘+2 = 𝑔𝑔12 𝑥𝑥1 + 𝑔𝑔22 𝑥𝑥2 + ⋯ + 𝑔𝑔𝑘𝑘,2 𝑥𝑥𝑘𝑘 (4)

𝑐𝑐𝑛𝑛 = 𝑔𝑔1,𝑛𝑛−𝑘𝑘 𝑥𝑥1 + 𝑔𝑔2,𝑛𝑛−𝑘𝑘 𝑥𝑥2 + ⋯ + 𝑔𝑔𝑘𝑘,𝑛𝑛−𝑘𝑘 𝑥𝑥𝑘𝑘

Les coefficients 𝑔𝑔𝑖𝑖𝑖𝑖 dans l’équation précédente appartiennent à l’ensemble {0, 1} et l’opération
d’addition "+" est une addition binaire modulo 2 (sans retenue).

Le système d’équation (4) peut s’écrire sous forme matérielle, comme suit :

1 0 0 0 𝑔𝑔11 𝑔𝑔12 𝑔𝑔1,𝑛𝑛−𝑘𝑘

⎡ 𝑔𝑔21 𝑔𝑔22 … 𝑔𝑔2,𝑛𝑛−𝑘𝑘 ⎤
⎢0 1 0 ⋯ 0 ⎥
(𝑐𝑐1 , 𝑐𝑐2 , … , 𝑐𝑐𝑛𝑛 ) = (𝑥𝑥1 , 𝑥𝑥2 , … , 𝑥𝑥𝑘𝑘 ) ⎢0 0 1 0 𝑔𝑔31 𝑔𝑔32 𝑔𝑔3,𝑛𝑛−𝑘𝑘 (5)
⎥
⎢ ⋮ ⋱ ⋮ ⋱ ⎥
⎣0 0 0 ⋯ 1 𝑔𝑔𝑘𝑘,1 𝑔𝑔𝑘𝑘,2 … 𝑔𝑔𝑘𝑘,𝑛𝑛−𝑘𝑘 ⎦
D’où 𝐶𝐶 = 𝑋𝑋. 𝐺𝐺 (6)

La matrice 𝐺𝐺 est appelée la matrice génératrice. Le code 𝐶𝐶(𝑛𝑛, 𝑘𝑘) est entièrement défini par la
matrice génératrice 𝐺𝐺.

2.2 Principe du décodage des codes linéaires

Pour le décodage, une autre matrice déduite de 𝐺𝐺 est utilisée. Il s’agit de la matrice de
contrôle définie par :

𝑔𝑔11 𝑔𝑔21 𝑔𝑔𝑘𝑘,1 1 0 0 0

⎡ 𝑔𝑔12 𝑔𝑔22 … 𝑔𝑔𝑘𝑘,2 ⎤
⎢ 0 1 0 ⋯ 0⎥
𝐻𝐻 = ⎢𝑔𝑔13 𝑔𝑔23 𝑔𝑔𝑘𝑘,3 0 0 1 0⎥ (7)
⎢ ⋮ ⋱ ⋮ ⋱ ⎥
⎣𝑔𝑔1,𝑛𝑛−𝑘𝑘 𝑔𝑔2,𝑛𝑛−𝑘𝑘 … 𝑔𝑔𝑘𝑘,𝑛𝑛−𝑘𝑘 0 0 0 ⋯ 1⎦

Il a été démontré qu’un message 𝐶𝐶 n’est un mot-code du code linéaire 𝐶𝐶(𝑛𝑛, 𝑘𝑘) que si et seulement
si:
𝐶𝐶. 𝐻𝐻 𝑇𝑇 = 0 (8)

En présence du bruit, une technique de décodage, appelée décodage à distance minimale,

consiste à rechercher le mot-code le plus vraisemblable. C’est-à-dire, celui qui à la distance de
Hamming la plus faible du mot-code. Parmi les méthodes qui existent, on cite : décodage par
syndrome et décodage par tableau standard qu’on détaillera ci-dessous.

Décodage par tableau standard

Soit 𝐶𝐶 un mot-code transmis à travers un canal bruité et 𝑈𝑈 le vecteur reçu. Au niveau du

décodeur, le vecteur reçu 𝑈𝑈 (erroné ou pas) peut être considéré comme la somme du mot-code
original 𝐶𝐶 et un vecteur d’erreur 𝐸𝐸 :

𝑈𝑈 = 𝐶𝐶 + 𝐸𝐸 (9)

Avec 𝐸𝐸 = (𝑒𝑒1 , 𝑒𝑒2 , … , 𝑒𝑒𝑛𝑛 ), où 𝑒𝑒𝑖𝑖 = 1 correspond à la position 𝑖𝑖 avec un bit erroné. Le décodeur ne
connait ni 𝐶𝐶 ni 𝐸𝐸, sa fonction est de retrouver 𝐶𝐶 à partir de 𝑈𝑈 et par conséquent décoder le message
d’information utile 𝑋𝑋. Le fait d’estimer le vecteur d’erreur 𝐸𝐸, permettra au décodeur de trouver le
mot-code 𝐶𝐶 en utilisant les propriétés de l’addition modulo 2 :

(𝑈𝑈 = 𝐶𝐶 + 𝐸𝐸) ⇒ (𝐶𝐶 = 𝑈𝑈 + 𝐸𝐸) (10)

 Pour un code en bloc linéaire 𝐶𝐶(𝑛𝑛, 𝑘𝑘), formé de 2𝑘𝑘 mot-code (𝐶𝐶1 , 𝐶𝐶2 , … , 𝐶𝐶2𝑘𝑘 ), le vecteur
reçu 𝑈𝑈 peut être n’importe quelle vecteur de taille 𝑛𝑛 (2𝑛𝑛 possibilités). Le décodeur doit associer le
vecteur 𝑈𝑈 reçu avec un mot-code 𝐶𝐶𝑖𝑖 . Pour ce faire, il faut diviser l’ensemble des 2𝑛𝑛 vecteurs
possibles d’être reçus en 2𝑘𝑘 ensembles disjoints (𝑀𝑀1 , 𝑀𝑀2 , … , 𝑀𝑀2𝑘𝑘 ) où chacun est représenté par un
mot-code valide. Donc 𝑈𝑈 sera décodé par 𝐶𝐶𝑖𝑖 si 𝑈𝑈 ∈ 𝑀𝑀𝑖𝑖 . On obtient un décodage correct si 𝑈𝑈
(𝑈𝑈 = 𝐶𝐶𝑖𝑖 + 𝐸𝐸) ∈ 𝑀𝑀𝑖𝑖 . Dans le cas contraire, on obtient un faux décodage. Un tel partitionnement peut
être réalisé par le tableau standard construit selon le modèle donné ci-dessous (tableau 1).

Tableau 1 : Tableau standard pour un code en bloc 𝐶𝐶(𝑛𝑛, 𝑘𝑘).

𝐶𝐶1 𝐶𝐶2 𝐶𝐶3 ………… 𝐶𝐶2𝑘𝑘

𝐸𝐸2 𝐶𝐶2 + 𝐸𝐸2 𝐶𝐶3 + 𝐸𝐸2 ………… 𝐶𝐶2𝑘𝑘 + 𝐸𝐸2
𝐸𝐸3 𝐶𝐶2 + 𝐸𝐸3 𝐶𝐶3 + 𝐸𝐸3 ………… 𝐶𝐶2𝑘𝑘 + 𝐸𝐸3

…………

𝐸𝐸2𝑛𝑛 −𝑘𝑘 𝐶𝐶2 + 𝐸𝐸2𝑛𝑛 −𝑘𝑘 𝐶𝐶3 + 𝐸𝐸2𝑛𝑛 −𝑘𝑘 ………… 𝐶𝐶2𝑘𝑘 + 𝐸𝐸2𝑛𝑛 −𝑘𝑘

La règle du décodage est très simple. Il suffit de localiser le vecteur reçu 𝑈𝑈 dans le tableau
standard. Si, par exemple, 𝑈𝑈 appartient à la 𝑖𝑖 é𝑚𝑚𝑚𝑚 colonne du tableau standard, alors il sera décodé
par le mot-code 𝐶𝐶𝑖𝑖 .

2.3 Capacité de correction des codes en bloc linéaires

On définit la distance minimale 𝑑𝑑𝑚𝑚𝑚𝑚𝑚𝑚 d’un code en bloc linéaire comme étant le poids
minimal des mots-code non nuls appartenant au code 𝐶𝐶(𝑛𝑛, 𝑘𝑘). La capacité de correction du code
𝐶𝐶(𝑛𝑛, 𝑘𝑘) est égale à (𝑑𝑑𝑚𝑚𝑚𝑚𝑚𝑚 − 1)/2 erreurs sur le message reçu. Aussi il peut détecter 𝑑𝑑𝑚𝑚𝑚𝑚𝑚𝑚 − 1
erreurs. Il est donc évident que pour 𝑛𝑛 et 𝑘𝑘 donnés, on souhaite avoir 𝑑𝑑𝑚𝑚𝑚𝑚𝑚𝑚 aussi grande que
possible.

Donnons un petit exemple d’encodage de messages par un code en bloc 𝐶𝐶(6, 3) dont la
matrice génératrice est donnée par :

1 0 0 1 1 0
𝐺𝐺 = �0 1 0 0 1 1� (11)
0 0 1 1 0 1

Pour des messages bloc de longueurs 𝑘𝑘 = 3, il existe donc 8 messages utiles. Les mots-code du
code 𝐶𝐶(6, 3) et leurs poids sont donnés dans le tableau 2.
 Ce code donc peut détecter deux erreurs et corriger une erreur simple. Une conception du
tableau standard est montrée dans le tableau 3.

Tableau 2 : Mots-code du code 𝐶𝐶(6,3)

Message Mots-code Poids

000 000 000 0
001 001 101 3
010 010 011 3
011 011 110 4
100 100 110 3
101 101 011 4
110 110 101 4
111 111 000 3

Tableau 3 : Tableau standard pour le code 𝐶𝐶(6,3)

𝑀𝑀𝑖𝑖 𝑀𝑀1 𝑀𝑀2 𝑀𝑀3 𝑀𝑀4 𝑀𝑀5 𝑀𝑀6 𝑀𝑀7 𝑀𝑀8

𝐸𝐸𝑖𝑖 000 000 001 101 010 011 011 110 100 110 101 011 110 101 111 000
100 000 100 000 101 101 110 011 111 110 000 110 001 011 010 101 011 000
010 000 010 000 011 101 000 011 001 110 110 110 111 011 100 101 101 000
001 000 001 000 000 101 011 011 010 110 101 110 100 011 111 101 110 000
000 100 000 100 001 001 010 111 011 010 100 010 101 111 110 001 111 100
000 010 000 010 001 111 010 001 011 100 100 100 101 001 110 111 111 010
000 001 000 001 001 100 010 010 011 111 100 111 101 010 110 100 111 001
100 001 100 001 101 100 110 010 111 111 000 111 001 010 010 100 011 001

Supposons que le mot code 𝐶𝐶4 = 011 110 a été transmis et que lors de la transmission ce
mot code a été perturbé par l’erreur 𝐸𝐸3 = 001 000. Donc, le récepteur reçoit le mot erroné 𝑈𝑈 =
010 110. Le décodeur cherche alors la position du mot 𝑈𝑈 reçu dans le tableau standard (𝑈𝑈 ∈ 𝑀𝑀4 ).
Donc, il le décode par le mot code 𝐶𝐶4 . Le décodage est correct car ce code 𝐶𝐶(6, 3) peut corriger
toutes les erreurs simples avec une erreur double (1ére colonne du tableau standard).

Supposons maintenant que le mot code 𝐶𝐶4 a été perturbé par une erreur de poids double
𝐸𝐸 = 010 010. Le décodeur reçoit alors le mot 𝑈𝑈 = 001 100 qui appartient à 𝑀𝑀2 et par conséquente
le décode par 𝐶𝐶2 = 001 101 . Le décodage est donc incorrect puisque l’erreur est de poids double.