Codage de Canal - جامعة حسيبة بن بوعلي

MINISTERE DE L'ENSEIGNEMENT SUPERIEUR ET DE LA RECHERCHE SCIENTIFIQUE

UNIVERSITE HASIBA BEN BOUALI CHLEF

FACULTE DE TECHNOLOGIE

DEPARTEMENT D'ELECTRONIQUE

Polycopié de

Cours & Travaux Dirigés

Codage de Canal

Réalisé par

MOSTARI LATIFA

Année universitaire 2016/2017

Préface ....................................................................................................................................... I

Chapitre I- Codes Correcteurs d'Erreurs: une Introduction ......................................... 111

I.1 De la théorie de communications au codage ........................................................................ 1

I.2 Principe des codes correcteurs d'erreurs .............................................................................. 1

I.3 Avantages et inconvénients ................................................................................................... 2

I.4 Distinction entre détection et correction d'erreurs ............................................................... 2

I.5 Classification des codes correcteurs d'erreurs ...................................................................... 3

I.6 Mesure des performances des codes correcteurs d'erreurs .................................................. 4

I.7 Rappels sur les propriétés du corps de Galois ...................................................................... 5

Chapitre II- Codes en Bloc ................................................................................................... 11

II.1 Définition .......................................................................................................................... 11

II.2 Représentation matricielles des codes en bloc linéaires ................................................... 11

II.2.1 Code a contrôle de parité linéaire ............................................................................. 11

II.2.2 Matrice de contrôle de parité .................................................................................... 13

II.2.3 Décodage syndromique ............................................................................................. 14

II.2.4 Code dual .................................................................................................................. 14

II.3 Détection et correction d'erreurs d'un code en bloc .......................................................... 14

II.3.1 Distance de Hamming ............................................................................................... 14

II.3.2 Distance minimale .................................................................................................... 14

II.4 Présentation de quelques codes en blocs linéaires ............................................................ 17

II.4.1 Code de Hamming .................................................................................................... 17

II.4.2 Code de parité ........................................................................................................... 18

II.4.3 Code à longueur maximale ....................................................................................... 19

II.4.4 Code à répétition ....................................................................................................... 19

II.5 Performances des codes en bloc linéaires ......................................................................... 19

Chapitre III- Codes Cycliques ............................................................................................. 21

III.1 Définition ........................................................................................................................ 21

III.2 Propriétés des corps finis .................................................................................................. 21

III.3 Représentation des codes cycliques ................................................................................ 22

III.4 Polynôme générateur d'un code cyclique ........................................................................ 22

III.5 Procédure de codage systématique .................................................................................. 24

III.6 Racine primitive nième de l'unité .................................................................................... 26

III.7 Présentation de quelques codes cycliques . ...................................................................... 26

II.7.1 Code BCH ................................................................................................................. 26

II.7.2 Code de Reed-Solomon ............................................................................................ 29

II.7.3 Code de Golay ........................................................................................................... 32

II.7.4 Code pour détection d'erreurs en paquets ................................................................. 32

III.8 Réalisation du codeur cyclique ........................................................................................ 33

III.9 Décodage des codes cycliques- calcul de syndrome ....................................................... 33

Chapitre IV- Codes Convolutifs ........................................................................................... 36

IV.1 Définition ........................................................................................................................ 36

IV.2 Principe de codage ........................................................................................................... 37

IV.3 Représentation des codes convolutifs ............................................................................ 37

IV.3.1 Digramme en treillis ................................................................................................ 38

IV.3.2 Digramme en arbre .................................................................................................. 39

IV.3.3 Diagramme d'état ..................................................................................................... 40

IV.4 Décodage des codes convolutifs ...................................................................................... 40

IV.4.1 Algorithme de Viterbi ............................................................................................. 41

IV.4.2 Décodage séquentiel ................................................................................................ 43

IV.5 Performances des codes convolutifs ............................................................................... 43

IV.6 Quelques exemples de codes ........................................................................................... 44

IV.6.1 Codes catastrophiques ............................................................................................. 44

IV.6.2 Codes convolutifs poinçonnés ................................................................................. 45

Chapitre V- Codes Concaténés ............................................................................................ 47

V.1 Codes concaténés à un niveau .......................................................................................... 47

V.2 Codes concaténés à un multiniveaux ................................................................................. 49

V.3 Techniques d'entrelacement et de désentrelacement ....................................................... 49

V.4 Concaténation binaire ........................................................................................................ 51

Chapitre VI- Turbo-Codes ................................................................................................... 52

VI.1 Définition ........................................................................................................................ 52

VI.2 Conception des turbo-codes ............................................................................................. 52

VI.3 Analyse des performances des turbo-codes .................................................................... 55

VI.4 Décodage itératif .............................................................................................................. 55

Chapitre VII- Modulation Codée en Treillis ...................................................................... 56

VII.1 Introduction .................................................................................................................... 56

VII.2 Construction du code ...................................................................................................... 61

VII.3 Analyse des performances ............................................................................................. 62

Travaux Dirigés ..................................................................................................................... 63

Conclusion Générale ............................................................................................................. 69

Bibliographie 70

................................................................................................................................................ 707

......................................................................................................................................................

I

Préface

__________________________________

Le mathématicien Shannon était capable de montrer théoriquement une transmission

sans erreurs sans donner le code correcteur d’erreurs qui permet de réaliser la solution de

correction des erreurs. Après cette théorie, des recherches ont été faites afin de réaliser le code

correcteur d’erreurs. Dans le but d’atteindre la limite théorique de Shannon et d’avoir un bon

compromis performance/complexité. Deux grandes familles de codes correcteurs d'erreurs ont

été introduites : les codes en blocs et les codes convolutifs.

Il existe deux catégories de codes en bloc : les codes en bloc linéaires et non-linéaires.

Les codes en bloc non-linéaires ne sont jamais employés dans les applications pratiques et ne

sont pas beaucoup étudiés. Les codes en bloc linéaires se subdivisent en plusieurs codes tels

que les codes cycliques, les codes de Reed Solomon...

Les performances d'un code binaire augmentent avec sa longueur de bloc, tandis que la

complexité de décodage augmente avec la longueur du code. Une façon d'aborder le problème

de la complexité, est de construire de bons codes qui présentent une complexité de décodage

raisonnable, est d'utiliser des codes concaténés. Les performances des codes concaténés

peuvent être améliorer avec une technique itérative utilisée pour leur décodage. Ce nouveau

schéma de code, appelé turbo-code, permet d'atteindre la limite de Shannon. Les codes les

plus performants sont associés a des modulations d'ordre élevé pour les transmission à haut

débit dans des bandes de fréquence étroite tel que les modulation codées en treillis.

Dans ce cours, on s'intéresse aux codes correcteurs d'erreurs et leurs différents types.

Ainsi, on étudie les modulations codées. Le chapitre 1 présente une introduction des codes

correcteurs d'erreurs. Les chapitres 2, 3 et 4 montrent respectivement les codes en bloc, les

codes cycliques et les codes convolutifs. Les codes concaténés sont illustrés dans le chapitre

5. Le chapitre 6 discute les turbo-codes. Enfin, le cours se termine avec les modulations codée

en treillis.

1 Cours & Travaux Dirigés M2: Codage de Canal Latifa MOSTARI

UHBC

Chapitre I

Codes Correcteurs d'Erreurs: une

Introduction ___________________________________________________________________________

I.1 De la théorie des communications au codage

La communication est devenue aujourd’hui un besoin essentiel de la vie de tous les

jours. Avec la démocratisation d’Internet, de la téléphonie mobile, les exigences des

utilisateurs deviennent de plus en plus grandes et diverses.

En effet, on recherche tout d’abord à pouvoir communiquer depuis n’importe ou, aussi

bien en contexte fixe que mobile. On demande également à ce que les données échangées

soient aussi bien de la voix, de la vidéo, des images, que des messages instantanés ou bien

même des données informatiques.

Face à de telles exigences, les communications numériques constituent une solution

désormais incontournable. Une solution parmi d’autres, est de pouvoir augmenter l’efficacité

spectrale tout en garantissant une qualité de transmission inchangée.

En 1948, le mathématicien Shannon prouve théoriquement qu’il existe une efficacité

spectrale limite maximal si on souhaite une transmission sans erreurs. Shannon était capable

de donner une limite sans donner le code qui permet la correction des erreurs. Après des

recherches ont été faites afin de réaliser la solution de codage. Le but est de se rapprocher au

maximum de la limite de Shannon et d’obtenir un bon compromis performance/complexité.

Afin de réaliser la solution de codage, des efforts intensifs de recherches ont été faits

dans le monde entier. L’essentiel est de réaliser un code correcteur d'erreurs permettant de se

rapprocher à la limite de Shannon, et aussi d’atteindre un bon compromis

performance/complexité.

I.2 Principes des codes correcteurs d’erreurs

Le codeur correcteur d’erreurs également appelé codeur de canal ajoute des bits de

redondance au message qui ne porteront pas d’information mais qui permettront de détecter

Chapitre I- Codes Correcteurs d'Erreurs: une Introduction


UHBC

et/ou de corriger les erreurs de transmission à la réception.

I.3 Avantages et inconvénients

Le codeur correcteur d’erreurs permet de transmettre le message avec la fiabilité

maximum. Plus le nombre de bit de redondance augmente, Plus la correction des erreurs est

meilleur. Cependant, plus le message est long plus l’usage d’un canal coûte cher.

Ainsi, la mémoire à code correcteur d'erreurs est plus couteuse que la mémoire

conventionnelle en raison du matériel supplémentaire nécessaire pour la produire et de plus

faibles volumes de production de cette mémoire et des composantes associées.

Une mémoire à code correcteur d'erreurs peut être de 2 à 3 pour cent plus lente qu'une

mémoire conventionnelle en raison du temps additionnel nécessaire pour la vérification et la

correction des erreurs.

Par conséquent, il y a un compromis entre la correction des erreurs et le coût plus

élevé de la mémoire et du canal.

I.4 Distinction entre détection et correction d'erreurs

Les méthodes de correction des erreurs se regroupent principalement en deux modes

d'utilisation :

Correction par retransmission (ARQ: Automatic Repeat Request) ;

Auto-correction (FEC: Forward Error Correction).

L'objectif du mode ARQ est l'ajout d'une petite quantité de redondance au message, de

manière à permettre la détection d'éventuelles erreurs de transmission. Dans le cas d'une

détection d'erreurs, le décodeur demande la retransmission du message erroné.

Par contre, dans le cas du mode FEC, la redondance introduite permet de détecter et

corriger au niveau du décodeur un nombre fini d'erreurs. La quantité de redondance nécessaire

est naturellement plus grande pour le mode FEC que pour le mode ARQ.

Le principal désavantage du mode FEC est l'utilisation constante d'une plus large

bande passante, même en l'absence d'erreurs. Cette méthode s'applique surtout pour des



UHBC

systèmes de transmission où le retard de retransmission n'est pas acceptable. Généralement,

pour des systèmes ayant des taux d'erreurs raisonnables, les coûts liés aux demandes et aux

retransmissions des blocs de signaux erronés (mode ARQ) sont normalement moins

importants que ceux causés par l'usage d'une bande passante plus large (mode FEC).

On observe que pour des applications supportant un retard de retransmission, un mode

mixte ou hybride (ARQ-FEC) permettant de bénéficier des avantages des deux approches est

couramment utilisé. Grâce à la redondance fournie par le mode FEC, le système cherche

d'éventuelles erreurs qui sont ensuite corrigées. Si le taux d'erreurs est supérieur à celui

supportable par la méthode FEC, la méthode ARQ intervient en exigeant la retransmission du

message.

I.5 Classification des codes correcteurs d'erreurs

Jusqu’aux années 80, le code permettant d’atteindre la limite de Shannon avec une

complexité raisonnable n’était pas encore introduit. Deux grandes familles de code correcteur

d’erreurs ont été imposées sont : les codes en bloc qui se subdivisent en plusieurs types et les

codes convolutifs.

Les performances d'un code binaire augmentent avec sa longueur de bloc N, tandis que

la complexité de décodage d'un code binaire de dimension N est de l'ordre de O(N). Une

approche de ce problème est de réduire la complexité de décodage. Une façon d'aborder le

problème, est de construire de bons codes qui présentent une complexité de décodage

raisonnable, est d'utiliser des codes concaténés.

La stratégie de la concaténation de codes est de construire des codes correcteurs

d'erreurs puissants en combinant, en parallèle, en série ou hybride, deux ou plusieurs codes

correcteurs d'erreurs, en blocs ou convolutifs, de longueurs faibles à modérées avec une

complexité de décodage raisonnable.

En 1993 Berrou a montré que les performances des codes concaténés peuvent être

améliorer avec une technique itérative utilisée pour leur décodage. Ce nouveau schéma de

code, appelé turbo-code, permet d'atteindre la limite de Shannon. Les turbo-codes peuvent

être des turbo-codes en bloc ou des turbo-codes convolutifs selon le type des codes



UHBC

concaténés. Ainsi, selon le type de la concaténation, parallèle ou série, on peut avoir des

turbo-codes parallèles ou séries.

Après la puissance du décodage itératif qui a été mise en évidence grâce à l'invention

des turbo-codes. Les codes LDPC (Low-Density Parity-Check), qui ont été négligés, à cause

de leur complexité, pendant de longues années depuis leur introduction par Gallager en 1962,

ont été redécouverts par Mackay en 1995 et Spieleman et autres en 1996. Les codes LDPC

sont des codes en blocs permettent aussi d'atteindre la limite de Shannon, leur décodage se fait

selon le principe de décodage itératif.

I.6 Mesure des performances des codes correcteurs d’erreurs

On mesure les performance d’un code correcteur d’erreurs par l’évaluation du Taux

d’Erreurs Binaires (TEB), à la sortie du décodeur au niveau du récepteur, en fonction du

rapport signal à bruit (SNR 0NEb (dB) où bE étant l’énergie reçue par symbole binaire

d’information transmis et N0 la densité spectrale de puissance du bruit contenue dans la

bande).

𝑇𝐸𝐵 =𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒 𝑠𝑦𝑚𝑏𝑜𝑙𝑒𝑠 𝑏𝑖𝑛𝑎𝑖𝑟𝑒𝑠 𝑒𝑟𝑟𝑜𝑛 é𝑠

𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒 𝑠𝑦𝑚𝑏𝑜𝑙𝑒𝑠 𝑏𝑖𝑛𝑎𝑖𝑟𝑒𝑠 𝑡𝑟𝑎𝑛𝑠𝑚𝑖𝑠 (I.1)

L'efficacité d'un codeur de canal se reflète dans le gain de codage (figure I.1).

0 2 4 6 8 10 12 14 16 𝐸𝑏 𝑁0 𝑑𝐵

Gain de

codage à 10-5

Système non codée

Système codé

𝑇𝐸𝐵 10-2

10-5

10-6

Figure I.1- Illustration du gain de codage pour

un 𝑇𝐸𝐵 = 10−5



UHBC

I.7 Rappels sur les propriétés du corps de Galois

Les corps de Galois font partie d’une branche particulière des mathématiques qui

modélise les fonctions du monde numérique. La dénomination « corps de Galois » provient

du mathématicien français Galois qui en a découvert les propriétés fondamentales.

Il y a deux types de corps, les corps finis et les corps infinis. Les corps de Galois finis

sont des ensembles d’éléments fermés sur eux-mêmes. L’addition et la multiplication de deux

éléments du champ donnent toujours un élément du corps fini.

I.7.1 Définition

Un corps de Galois à mq 2 éléments noté qGF , où m est un entier positif. Le corps

de Galois consiste en un ensemble de nombres, ces nombres sont constitués à l’aide de

l’élément de base comme suit :

210 ,,,,0 qqGF avec 11 q (I.2)

Avec est l’élément primitif du corps de Galois qGF .

qGF est formé à partir du corps de base 2GF , où 1,02 GF .

Exemple 1 : 2210 ,,1,0,,,04 GF

I.7.2 Polynôme primitif

Le polynôme primitif, ayant comme racine, est utilisé pour construire le corps

qGF , il est sous la forme suivante :

m

mppppP ... 2

210 (I.3)

Le polynôme primitif doit être :

irréductible c’est-à-dire être non factorisable dans 2GF (autrement dit 0 et 1 ne

sont pas racines de P ;

de degré m ;



UHBC

à coefficients dans 2GF (c-à-d 10 oupi , avec mi ,,0 ) ;

diviseur de 112 m

x , où l’opération de la division se faite modulo 2.

Détermination du polynôme primitif

Prenons un exemple d’un corps de Galois 4GF , avec 2m , et on détermine son

polynôme primitif comme suit :

Pour 2m on peut avoir 42 m polynômes de degré m :

2

4

2

3

2

2

2

1

1

1

xxP

xxxP

xxP

xxxP

(I.4)

Pour déterminer le polynôme irréductible, on remplace 0 et 1 dans chaque polynôme et

on prend le polynôme où 0 et 1 ne sont pas des racines (c-à-d 0100 PetP ). On trouve

que 2

1 1 xxxP est un polynôme irréductible.

On fait la division polynomiale : la division de 111 31212 2

xxxm

par

2

1 1 xxxP . On trouvé le reste = 0. Donc, le polynôme xP1 est diviseur 112 m

x .

Par conséquent : le polynôme 2

1 1 xxxP est un polynôme primitif du corps

4GF .

Comme mentionné ci-dessus, l’élément est racine du polynôme primitif, on peut en

déduire :

110

1

1

22

2

2

P

xxxP

(I.5)

Toutes les opérations dans le corps de Galois sont faites modulo 2 et modulo

polynôme primitif. Donnons pour le corps 4GF , à titre d’exemple, les règles régissant les



UHBC

opérations d’addition (Tableau I.1) et de multiplication (Tableau I.2). Les opérations sont

faites modulo 2 et modulo 12 .

I.7.3 Représentation des éléments du qGF

Les éléments du corps de Galois qGF sont définis modulo polynôme primitif.

Chaque élément de ce corps peut être représenté par deux types de

représentations polynomiale et binaire :

Représentation polynômiale : l’élément est représenté par un polynôme de

degré égal à (m-1) et à coefficient dans 2GF , sous la forme :

02211 . xxx mmmm (I.6)

Avec : 01 m éléments dans 2GF

Représentation binaire : l’élément est représenté par une séquence des

éléments dans 2GF , sous la forme :

0321 mmm (I.7)

Où 01 m correspondent aux éléments de l’équation (I.3).

Le tableau (I.3) illustre les différentes représentations des éléments du corps de Galois

16GF .

Tableau I.1- Adition dans 4GF Tableau I.2- Multiplication dans 4GF

+ 0 1 2

0 0 1 2

1 1 0 21 21

21 0 12 2

2 21 12 0

0 1 2

0 0 0 0 0

1 0 1 2

0 2 13 2 0 2 13 4



UHBC

Eléments

du corps

Représentation polynomiale Représentation

binaire

0 0 0000

1 1 0001

0010

2 2 0100

3 3 1000

4 1 (polynôme primitif) 0011

5 24 1.. 0110

6 2325 .. 1100

7 1.. 334236 1011

8 1.2111. 2244 0101

9 328 1.. 1010

10 1.. 22439 0111

11 23210 1.. 1110

12 1.. 232342311 1110

13 11

1..

2323234

2312

1101

14 11.21

1..

33334

2313

1001

I.7.4 Polynôme minimal à coefficients dans 2GF associé à un élément d’un

corps de Galois qGF

Le polynôme minimal xm à coefficient dans 2GF associé à un élément

quelconque d’un corps de Galois qGF , est un polynôme de degré au plus égal à

qm 2log , ayant comme racine :

Tableau I.3- Représentations des éléments du corps de Galois 16GF



UHBC

1

1

242

1

2

.

m

i

xxxxxm

xxmm

i

(I.8)

Exemple 2

La détermination du polynôme minimal associé à dans 16GF , se fait comme

suit :

4m 842 ... xxxxxm (I.9)

On remplace par , xm devient :

12482322

12482322

842

..

..

...

xxxxxm

xxxxxxxm

xxxxxm

(I.10)

Avec :

544448

542

.1

.1

(polynôme primitif 14 )

L’équation (I.10) devient :

158172310123554

1252352

...

..

xxxx

xxxxxm (I.11)

Avec 2215217

55

1..

0

; où 1151161 q (voir l’équation I.2)

L’équation (I.11) devient :

1.. 822310124 xxxxm (I.12)

Pour faire la sommation 31012 et 82 : on remplace chaque élément par sa

représentation binaire et on fait la sommation.



UHBC

0000

1000:

0111:

1111:

3

10

12

et

0001

0101:

0100:

8

2

La représentation binaire 0000 correspond à l’élément du corps 0 et 0001 correspond à

l’élément 1. Donc, le polynôme minimal associé à dans 16GF est 14 xxxm

On remarque que le polynôme minimale associé à est le polynôme primitif. De la

même manière on calcule le polynôme minimale associé à 3 ou

4 …


UHBC

Chapitre II

Codes en Bloc ___________________________________________________________________________

II.1 Définition

Le codage en bloc s’effectue par bloc de symboles, la séquence d’information est

segmentée en bloc de longueur fixe, il y a K symboles dans chaque bloc. On va ajouter de la

redondance, on va ajouter KNM symboles, c'est-à-dire que le bloc final à transmettre

possède N KN symboles. Les M symboles introduits par le codeur sont appelés symboles

de contrôle ou de parité. Ces symboles offrent une grande diversité.

II.2 Représentation matricielle des codes en blocs linéaires

II.2.1 Code à contrôle de parité linéaire

Un code en bloc linaire est une application biunivoque entre des blocs de K symboles

issus de la source d’informations, appelés message ou mot d’information, et des blocs de N

symboles, appelés mot de code. La figure II.1 montre le principe de codage en bloc linéaire.

Chaque code en bloc est défini par la quantité suivante qui s’appelle le rendement:

𝑅 =𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒 𝑠𝑦𝑚𝑏𝑜𝑙𝑒𝑠 𝑑′𝑒𝑛𝑡𝑟 é𝑒

𝑛𝑜𝑚𝑏𝑟𝑒 𝑑𝑒 𝑠𝑦𝑚𝑏𝑜𝑙𝑒 𝑑𝑒 𝑠𝑜𝑟𝑡𝑖𝑒=

𝐾

𝑁 (II.1)

Les symboles prennent leurs valeurs dans le corps de Galois.

G est la réponse du code définissant aussi les codes en bloc, et celle-ci est déterminée

par une matrice génératrice de taille 𝐾 × 𝑁, où K : le nombre de colonnes et N : le nombre de

lignes.

Mot de code

NccccC 321

Mot d’information

KddddD 321 Code en bloc

NKG

Figure II.1- Codage en bloc

Chapitre II- Codes en Bloc


UHBC

En effet, puisque le code est linéaire (la correspondance entre la sortie et l’entrée est

une fonction linéaire), la convolution temporelle correspond à la multiplication polynomiale.

On passe du message M au mot de code C par la matrice génératrice G :

GMC . (II.2)

Avec K symboles d’entrée, on peut construire K2 messages, le codeur va donc utiliser

K2 mots de code choisis parmi N2 possibilités.

La matrice génératrice est toujours équivalente à une forme particulièrement simple,

construisant des codes appelés codes systématiques. C’est le cas le plus utilisé, dont la matrice

systématique s’obtient à partir de la matrice génératrice du code non-systématique.

Code en bloc systématique

Un code est systématique si les symboles d’entrées sont toujours retrouvés intacts dans

la séquence de symboles codés à la sortie du code. Le mot de code est représenté sous la

forme suivante :

KNK ddccC 11 , (II.3)

La matrice génératrice G prend alors la forme suivante :

101

010

001

,1

,221

,111

KNKK

KN

KN

qq

qq

qq

G (II.4)

La matrice G peut se mettre sous la forme :

KIQG , (II.5)

Où KI est la matrice unité à K lignes et à K colonnes et Q une matrice à K ligne et

KN colonnes qui caractérise le code. La figure II.2 illustre le schéma d’un code en bloc

sous la forme systématique.



UHBC

A partir de la matrice génératrice on peut déterminer une matrice définissant le

décodeur d’un code en bloc et elle possède encore une forme particulièrement simple. Cette

matrice est appelée matrice de contrôle de parité. Elle permet comme nous allons le voir de

détecter les erreurs de transmission.

II.2.2 Matrice de contrôle de parité

Pour une matrice systématique G de taille 𝐾 × 𝑁, avec K lignes indépendantes, on

peut toujours trouver une matrice H de dimension 𝑀 × 𝑁, non nulle qui vérifie la relation

suivante:

0. THG (II.6)

Où l’indice T indique la transposition.

Compte-tenu de la matrice G, la matrice H est égale à :

KKNKN

K

K

qq

qq

qq

H

,1,

,221

,111

100

010

001

(II.7)

Qui peut encore s’écrire :

T

KN QIH , (II.8)

Où KNI est une matrice unité à M ligne et à M colonnes.

Figure II.2- Code en bloc systématique

Mot d’information

KdddD 21

Bloc de parité

NKK cccP 21

Mot d’information

KdddD 21

Code en bloc

systématique



UHBC

Les mots de code doivent être suffisamment différents les uns des autres pour avoir de

meilleures performances. Cette distinction est caractérisée par un paramètre important qui

explique les performances d’un code correcteur d’erreurs en terme de probabilité d’erreur,

appelé distance minimale.

II.2.3 Décodage syndromique

l’algorithme de décodage par syndrome.

Entrée: Un mot bruité y, la matrice de parité H (sous forme systématique).

Sortie: Le message d’origine v.

1. Calculer le syndrome s=Hy;

2. Chercher l’erreur e telle que s=He;

3. Calculer le mot de code c=y+e;

4. Le message d’origine se trouve dans les k premières composantes de c.

II.2.4 Code dual

Le code dual d'un code linéaire C de dimension k est un code de même longueur n et

de dimension n - k. Dans le cas d'un code systématique, la matrice de contrôle de C devient

une matrice génératrice de son dual. De même une matrice génératrice de C est une matrice de

contrôle de son dual.

II.3 Détection et correction d'erreurs d'un code en blocs

II.3.1 Distance de Hamming

La distance de Hamming entre deux mots de code est égale au nombre de symboles

binaires codés différents entre les séquences associées à chacun des deux mots de code.

II.3.2 Distance de minimale

La distance minimale mind , est définie comme la plus petite distance de Hamming

existant entre deux mots de code.



UHBC

La recherche de la distance minimale bénéficie de la propriété de linéarité des codes

en bloc, qui permet de se concentrer uniquement sur les distances entre les mots de code

potentiels et le mot de code zéro. Le mot de code "zéro" est le message codé contenant une

séquence de zéros, générée par le codage d'une série de bits d'informations 'zéro'.

De ce fait, la distance minimale est aussi égale au poids minimal Hw des mots de code

non-nuls. Le poids d’une séquence est le nombre de bit égal à 1.

0minmin iiH CCwd ; 12,,1 Ki (II.9)

Lorsque le nombre de mots de code est très élevé, la recherche de la distance minimale

peut s’avérer laborieuse. Une première solution pour contourner cette difficulté est de

déterminer la distance minimale à partir de la matrice de contrôle de parité: La propriété

d’orthogonalité 0. THC implique que la somme de mind colonnes de la matrice de contrôle

de parité est nulle. Ainsi mind correspond au nombre minimal de colonnes de la matrice de

contrôle de parité linéairement dépendantes.

Principe de la détection des erreurs

Considérons le modèle de transmission de la figure II.3.

Soit 'C le mot reçu, constitué de N symboles binaires lorsque le mot de code C est

émis :

ECC ' (II.10)

Figure II.3- Modèle de transmission simplifié utilisant le codeur

et le décodeur en bloc

Erreurs

NeeE 1

Mot reçu

''

1

'

NccC

Mot estimé

KddD ˆˆˆ1

Mot de code

NccC 1

Chaine

Mot d’information KddD 1 Codeur

NKG

Décodeur

NMH



UHBC

Où E est un mot de N symboles binaires qui représente les éventuelles erreurs de

transmission.

En utilisant la matrice de contrôle de parité pour détecter les erreurs de transmission.

Une propriété importante pour n’importe qu’elle type de code en bloc est donnée par :

codedemotunpasestnCHC T '0. '' (II.11)

Si on multiplie le mot reçu 'C par la matrice de contrôle de parité transposée, on

obtient :

TTTTT HEHGMHEHCHCS ......' (II.12)

En tenant compte que 0. THG , on obtient :

THES . (II.13)

S s’appelle le syndrome, il permet de détecter les erreurs de transmission. Le

syndrome S peut être nul ou pas, notons que H est une matrice non-nulle :

1er

cas : 0S signifie deux possibilités

- E est identiquement nul alors il n’y a pas d’erreurs de transmission ;

- E est égal à un mot de code. Dans ce cas on ne peut pas détecter les erreurs de

transmission.

2ème

cas : 0S

- E est différent de zéro et les erreurs de transmission sont détectées.

Principe de la correction des erreurs

La correction des erreurs consiste à rechercher le mot de code émis C c'est-à-dire à

réaliser un décodage de C à partir du mot reçu C' . Deux stratégies sont possibles :

Un décodage à entrée ferme ou pondéré et à sortie ferme ;



UHBC

Un décodage à sortie pondérée.

Un décodage à entrée ferme, c’est-à-dire l’entrée du décodeur est constituée par des

symboles binaires, la règle de correction consiste à choisir pour un mot de code émis, celui

qui est à la distance de Hamming minimale du mot reçu.

Un décodage à entrée pondérée, c’est-à-dire l’entrée du décodeur est constituée par

des échantillons analogiques, on remplace la distance de Hamming par la distance

Euclidienne.

Chaque type de codes en bloc à ses propres algorithmes de décodage. Le bon code est

celui qui corrige plus d’erreurs et à moins de complexité de décodage.

II.4 Présentation de quelques codes en blocs

Il existe deux catégories de codes en bloc : les codes en bloc linéaires et non-linéaires.

Les codes en bloc non-linéaires ne sont jamais employés dans les applications pratiques et ne

sont pas beaucoup étudiés. Les codes en bloc linéaires se subdivisent en plusieurs codes tels

que les codes de Hamming, les codes de parité, les codes à longueur maximale, les codes à

répétition...

II.4.1 Code de Hamming

Pour un code de Hamming les colonnes de la matrice de contrôle de parité sont les

représentations binaires des nombres de 1 à n. Chaque colonne étant constituée de knm

symboles binaires, les paramètres du code de Hamming sont donc :

12 mn , 12 mk m

(II.14)

Les colonnes de la matrice de contrôle de parité étant constituées par toutes les

combinaisons possibles de kn symboles binaires sauf 000 , la somme de deux

colonnes est égale à une colonne. Le nombre minimal de colonnes linéairement dépendantes

est de 3. La distance minimale d’un code de Hamming est donc égale à 3, quelle que soit la

valeur des paramètres n et k.



UHBC

Exemple

Soit un code de Hamming de paramètre m = 3. Les mots de code [c1 c2 c3 c4 m3 m2 m1]

et les blocs de données [m3 m2 m1] sont alors respectivement constitués de n = 7 et k = 4

symboles binaires. Prenons c1=m1+m2+m3, c2 = m2+m3, c3 = m1+m3, c4 = m1+m2, la matrice

de contrôle de parité peut être la suivante :

3

1001101

0101011

0010111

IPH T

Et la matrice génératrice correspondante est égale à :

PIG 4

1101000

1010100

0110010

1110001

II.4.2 Code de parité

Ce code utilise un symbole binaire de redondance 1 kn déterminé de façon à

assurer la nullité modulo 2 de la somme des symboles de chaque mot de code.

11210 nkk cddddc avec

1

0

1

k

j

jn dc

(II.15)

Où 1210 kk ddddd représente les symboles de données. La distance minimale

de ce code est de 2.

Exemple

Une matrice génératrice G de ce code pour n = 5, k = 4 est égale à :

PIG 4

11000

10100

10010

10001



UHBC

Et la matrice de contrôle de parité H se réduit à un vecteur :

111111 IPH T

II.4.3 Code à longueur maximale

Les colonnes de la matrice génératrice d’un code à longueur maximale sont les

représentations binaires des nombres de 1 à n. Les paramètres de ce code sont donc 12 mn

, mk et on peut montrer que sa distance minimale est de 12 k. Le code à longueur maximale

de paramètres 12 mn , mk est le code dual du code de Hamming de paramètres

12 mn , 12 mk m , c’est-à-dire que la matrice génératrice de l’un est la matrice de

contrôle de parité de l’autre.

II.4.4 Code à répétition

Pour ce code de paramètres 1k et 12 mn , chaque donnée binaire issue de la

source d’information est répétée un nombre impair de fois. La distance minimale de ce code

est 12 m . Le code à répétition 1,12 mC est le code dual du code de parité mmC 2,12 .

Exemple

La matrice génératrice et la matrice de contrôle de parité de ce code, pour k = 1, n = 5,

peuvent être les suivantes :

PIG 111111

4

10001

01001

00101

00011

IPH T

II.5 Performances des codes en blocs linéaires

Les mots de code doivent être suffisamment différents les uns des autres pour avoir de

meilleures performances. Cette distinction est caractérisée par la distance minimale qui

explique les performances d’un code correcteur d’erreurs en terme de probabilité d’erreur.



UHBC

Un bon code est un code avec une grande distance minimale, mais il doit pouvoir être

bien décodé. Cette distance nous permet de déterminer la capacité de détection et correction

de code.

Pour une distance minimale mind d’un code en bloc, le code pourra alors détecter dt

erreurs et corriger ct erreurs :

Le nombre d’erreurs à détecter est :

1min dtd (II.16)

Le nombre d’erreurs à corriger est:

pairestdsid

impairestdsid

tr

minmin

minmin

2

2

2

1

(II.17)

La distance minimale de notre exemple est égale à 4. Dans ce cas, le code pourra

détecter 3 erreurs et corriger 2 erreurs. Alors, les deux équations précédentes montrent bien

que la distance minimale détermine les performances d’un code en bloc.


UHBC

Chapitre III

Codes Cycliques ___________________________________________________________________________

III.1 Définition

Les codes cycliques sont des codes en bloc linéaires. Un code en bloc linéaire est dit

cyclique si : 110 ,,, NcccC étant un mot de code alors : 2011 ,,, NN cccC est aussi

un mot de code.

Il est clair que cette définition entraine que tout mot de code iC obtenu à partir du mot

de code C après i permutations circulaire est aussi un mot de code.

III.2 Propriétés des corps finis

Un corps est un anneau ou tous les éléments non nuls sont inversibles. Un corps fini

est aussi appelé corps de Galois qu'on note GF(q).

Théorème: un anneau est un corps si est seulement si n est un nombre premier.

Définition: tout corps K contenant le corps F s'appelle extension de F. K est un espace

vectoriel sur F.

Théorème: soit F un corps. Alors ou bien F est une extension du corps Q des nombres

rationnels, ou bien F est une extension de Zp pour un nombre premier p uniquement

déterminé.

Corollaire: soit F un corps, alors la caractéristique de F est soit nulle, soit un nombre

premier.

Définition: soit R un anneau. la caractéristique de R est le plus petit entier m>0

lorsqu'il existe vérifiant m = 1+...+1=0. Si un tel m n'existe pas, c'est à dire pour tout m

*, m.1 ≠0, on dit alors que R est de caractéristique nulle.

Chapitre III- Codes Cycliques


UHBC

Lemme : soit F un corps fini de caractéristique pi, alors (a+b)

pi =a

pi + b

pi pour tout a,

b F et i *.

Définition: l'ordre d'un corps fini F est le nombre d'éléments de F.

Théorème: soit F un corps fini alors l'ordre de F est pr ou p est un nombre premier et r

est un entier > 0.

III.3 Représentation des codes cycliques

Pour les codes cycliques, on utilise une représentation polynomiale des mots de code

et des blocs de données (messages). Ainsi, au mot de code 110 ,,, NcccC on associe le

polynôme xC de degré 1n .

1

1

2

210

N

N

j

j xcxcxcxccxC (III.1)

Et au bloc de données d le polynôme xd de degré 1K .

1

1

2

210

K

K

j

j xdxdxdxddxd (III.2)

Où jd et

jc sont binaires.

III.4 Polynôme générateur d'un code cyclique

Les mots de code d’un code cyclique sont engendrés par un polynôme générateur de

degré KN .

xgxdxC . (III.3)

Où le polynôme générateur xg est de la forme

KN

KN

j

j xgxgxgxggxg

2

210 (III.4)

Avec : 1. Nxxhxg



UHBC

Matrice génératrice d’un code cyclique

À partir du polynôme générateur xg il est possible de construire une matrice

génératrice G du code knC , . On se rappelle que les k lignes de la matrice G sont constitués

de k mots de code linéairement indépendants. Ces k mots de code peuvent être obtenus à partir

d’un ensemble de k polynômes indépendants de la forme :

0,1,,2,1 kkjxgx j

(III.5)

Soit xd la représentation polynomiale d’un bloc de données quelconque. Les k mots

de code engendrés par les polynômes xgx j ont pour expression :

0,1,,2,1. kkjxdxgxC j

j (III.6)

Exemple

Soit le code 4,7C de polynôme générateur 321 xxxg . Prenons pour bloc de

données 1xd . Les 4 lignes de la matrice génératrice G sont obtenues à partir des 4 mots

de code xC j.

32

0

43

1

542

2

653

3

1 xxxC

xxxxC

xxxxC

xxxxC

Une matrice génératrice du code 4,7C est égale à :

0001101

0011010

0110100

1101000

G



UHBC

III.5 Procédure de codage systématique

Lorsque les mots de code sont sous forme systématique, les données issues de la

source d’information sont séparées des symboles de redondance. Le mot de code xC

associé au bloc de données xd est alors de la forme :

xd

K

K

KN

N

K

KN

xv

KN

KN

xddxxv

xdxdxcxcxccxC

1

10

1

10

1

1

2

210

xdxxvxC KN

xvxdxxC KN

(III.7)

Où xv est le polynôme associé aux symboles de redondance.

En tenant compte du fait que xc est un multiple du polynôme générateur et que les

opérations étant faites modulo 2, l’addition est équivalente à la soustraction, alors on peut

écrire :

xvxgxrxdx

xvxCxdx

KN

KN

)().( (III.8)

xv est donc le reste de la division xdx KN par le polynôme générateur xg . Le

mot de code associé au bloc de données xd est égal à xdx KN augmenté du reste de la

division de xdx KN par le polynôme générateur.

Exemple

Pour illustrer le calcul d’un mot de code écrit sous forme systématique, prenons

l’exemple d’un code 4,7C de polynôme générateur 31 xxxg et déterminons le mot

de code xC associé au message 321 xxxd , soit :



UHBC

xvxdxxC KN ; 3KN

xvxdxxC 3 ; ??xv

xvxgxrxdx KN )().(

653323 1. xxxxxxxdx KN

Le reste de la division 653 xxxxdx KN par le polynôme générateur

321 xxxg est 1xv .

16533 xxxxvxdxxC

Donc, Le mot de code xC associé au bloc de données xd est :

6531 xxxxC

Ainsi au bloc de données d, constitué de 4 symboles binaires d’information est associé

le mot de code C avec :

11010011101 Cd

Pour obtenir la matrice génératrice, il suffit de coder 32 ,,,1 xxxxd . On obtient :

3

2

1

x

x

x

xd

52

52

42

3

1

1

1

xx

xxx

xxx

xx

xc

1000101

0100111

0010110

0001011

G



UHBC

On peut vérifier que pour 1101d , le produit matriciel Gd. fournit bien

1101001C .

III.6 Racine primitive nième de l'unité

Soit C un (n, k)-code cyclique engendré par g. Soit une racine primitive n-ième de

l'unité. Si g admet parmi ses racines puissance de successives, alors d +1.

III.7 Présentation de quelques codes cycliques

III.7.1 Codes BCH

Les codes BCH permettent de construire de manière systématique des codes cycliques

corrigeant au moins t erreurs dans un bloc de n symboles.

Pour construire un code BCH, on se fixe t ou de manière équivalente d, appelée

distance construite du code et on détermine son polynôme générateur g(x). Le code obtenu

possède une distance minimale dmin qui est toujours supérieure ou égale à la distance

construite.

III.7.1.1 Code BCH primitif

Le polynôme générateur g(x) d’un code BCH primitif construit sur un corps de Galois

qGF avec mq 2 éléments, de distance construite d (d= 2t+2 ou 2t+1), possède (d−1)

racines. Le code BCH est dit primitif car les racines de son polynôme générateur sont des

puissances de α, élément primitif du corps de Galois qGF .

Code BCH primitif avec 12 td

Le polynôme générateur g(x) d’un code BCH primitif de distance construite 12 td

est égal à :

xmxmxmMCPPxg t 123 ,,,....

(III.9)

Où xm iest le polynôme minimal à coefficients dans le corps 2GF associé à j et

P.P.C.M. désigne le Plus Petit Commun Multiple.



UHBC

Les paramètres d’un code BCH primitif de distance construite d = 2t + 1 sont les

suivants :

12;12;12 min tdmtKN mm

(III.10)

Exemple

Soit un code BCH primitif de distance construit 12 td avec 4m et 2t .

1) Déterminer la valeur de N et le corps de Galois utilisé.

2) Déterminer le polynôme générateur.

3) Déterminer les paramètres de ce code.

Solution

1512 mN

1624 GFGFm m


xmxmMCPPxgàdeallantt 3,....21

14 xxxm

12343 xxxxxm

Le P.P.C.M des polynômes xm et xm 3 est évidemment égal au produit de ces

deux polynômes puisqu’ils sont irréductibles et ainsi, le polynôme générateur est égal à :

1.1

.

,....

2344

3

3

xxxxxxxg

xmxmxg

xmxmMCPPxg



UHBC

En développant on obtient :

14678 xxxxxg

Finalement les paramètres de ce code BCH sont :

2;7;8;15;4 tKKNNm

Code BCH primitif avec 22 td

Le polynôme générateur g(x) d’un code BCH primitif de distance construite 22 td

est égal à :

xmxmxmxmMCPPxg t 12310 ,,,,....

(III.11)

10 xxm (III.12)

III.7.1.2 Code BCH non primitif

Un corps de Galois qGF , avec mq 2 éléments, possède des éléments non primitifs

si 12 m n’est pas premier. Les éléments non primitifs sont alors de la forme

où λ est

un diviseur de 12 met α est un élément primitif du corps.

La longueur N des mots d’un code BCH non primitif est égale à p, où p est l’exposant

de tel que 1p .

Le polynôme générateur g(x) d’un code BCH non primitif de distance construite

12 td est égal à :


(III.13)

Exemple

Soit un corps de Galois 64,6,26 qmGF



UHBC

La quantité 6312 m n’est pas égale un nombre premier, elle divisible par 3, 7, 9, 21

et 63.

Les éléments non primitifs de ce corps sont donc : 1,,,, 6321973

Construire un code BCH non primitif avec 2t sur le corps 64GF et prenons pour

élément non primitif 3 .


xmxmMCPPxgàdeallantt 3,....21

1

.

,....

45789

3

3

xxxxxxxg

xmxmxg

xmxmMCPPxg

Les paramètres de ce code BCH non primitif sont :

121 6321321 carN

12;9 KKN

III.7.2 Codes de Reed-Solomon

Les codes de Reed-Solomon sont les codes à symboles non binaire les plus connus et

surtout les plus utilisés. Pour les codes à symboles non-binaires les plus connus et surtout les

plus utilisé.

Pour les codes à symboles non-binaires les coefficients jc des mots de code et

jd des

blocs de donnée prennent leur valeur dans un corps de Galois qGF à mq 2 élément. Ainsi,

chaque symbole des codes peut être code sur m symboles binaires.



UHBC

Les codes de Reed-Solomon étant des codes cycliques, ils sont engendrés par un

polynôme générateur xg diviseur de 1nx dont les coefficients 1,,1,0 KNjg j

prennent également leur valeur dans le corps de Galois qGF .

Le polynôme générateur d’un code de Reed-Solomon, de distance construit d possède

1d racines 2,,,, dljll . Il a donc pour expression :

xmxmxmMCPPxg dljll 2,,,,....

(III.14)

Où xm jl est le polynôme minimal associé à l’élément jl du corps qGF .

Le polynôme minimal xm jl a pour unique racine jl :

jlxxm jl

(III.15)

Le polynôme générateur d’un code de Reed-Solomon est donc de la forme :

21 dljlll xxxxxg (III.16)

En général, le paramètre l est fixé à 0 ou à 1.

Le polynôme générateur d’un code de Reed-Solomon, de degré KN possède

1d racines soit 1 dKN . Sa distance construite est donc égale à :

1 KNd (III.17)

La distance minimale mind d’un code de Reed-Solomon est égale à sa distance

construite. Un code dont la distance minimale est égale à 1KN est appelé un code à

distance maximale.

Les paramètres d’un code de Reed-Solomon corrigeant t erreurs dans un bloc de n

symboles q-aires sont donc :

tNKtdKNqN 2;21;1 min (III.18)



UHBC

Exemple

Déterminer le polynôme générateur d’un code de Reed-Solomon construit à partir

d’un corps de Galois à 16 éléments, ayant un pouvoir de correction de 2t erreurs.

La distance minimale de ce code est donc de 5min d . En prenant par exemple 1l ,

le polynôme générateur de ce code est donc de la forme :

d allant de 1 à 5.

432

21

...

xxxxxg

xxxxxg dljlll

En développant l’expression précédente, on obtient :

7342322

7342322

..

..

xxxxxg

xxxxxxxg

Polynôme primitif 14

743334

542

.1

.1

101012231273574

101023122123527374

772352 .

xxxxxg

xxxxxxxxxg

xxxxxg

En utilisant les représentations binaires des éléments du corps 16GF

1101

0110

1011

5

7

et

1100

1000

1111

1011

3

12

7

et

1000

0111

1111

10

12



UHBC

1101 correspond à 13 , 1100 correspond à 6 et 1000 correspond à 3

103263134 xxxxxg

III.7.3 Codes de Golay

Le code de Golay, comme le code de Hamming est un code matriciel généré à partir

d’un polynôme générateur.

Ce code a néanmoins quelques particularités par rapport aux codes de Hamming sur

lesquels il est basé. Tout d’abord, il s’agit d’un code correcteur dit cyclique, c’est-à-dire que

toute permutation circulaire d’un mot de code reste un mot de code (un mot de code

correspond à des données encodées par la matrice génératrice). Les codes cycliques ont aussi

une particularité concernant leur polynôme générateur : ils divisent le polynôme 𝑧𝑛 + 1 (ou

𝑧𝑛 − 1).

Le polynôme générateur du code correcteur binaire étendu de Golay (23,12,7) est:

𝐻 𝑧 = 𝑧11 + 𝑧10 + 𝑧6 + 𝑧5 + 𝑧4 + 𝑧2 + 1 (III.19)

En appliquant les divisions euclidiennes (pour connaître dans les détails ce type de

génération, voir le principe de fonctionnement du code de Hamming).

Pour obtenir le code de Golay (24,12,8) à partir du code de Golay (23,12,7), il suffit de

rajouter un bit de parité à la fin de la matrice génératrice obtenue. Pour obtenir ce bit de

parité, il suffit de faire la somme de tous les bits de la ligne considérée. Si cette somme est

égale à 0, alors le bit de parité ajouté sera 1. Si cette somme est égale à 1, ce bit sera égal à 0.

III.7.4 Codes pour détection d'erreurs en paquets

Les codes pour détection d'erreurs en paquets consistent à protéger des blocs de

données, appelés trames (frames en anglais). A chaque trame est associé un bloc de données,

appelé code de contrôle, Ce code contient des éléments redondants vis-à-vis de la trame,

permettant de détecter les erreurs, mais aussi de les réparer.



UHBC

Le principe des codes pour détection d'erreurs en paquets consiste à traiter les

séquences binaires comme des polynômes binaires, c'est-à-dire des polynômes dont les

coefficients correspondent à la séquence binaire.

III.8 Réalisation du codeur cyclique

Le schéma de principe d'un codeur cyclique est représenté sur la figure III.1.

Lorsque l'interrupteur I est en position 1, les K symboles du message M rentrent dans

le codeur qui effectue la division de 𝑋𝑁−𝑀𝑀 𝑋 par 𝑔 𝑋 . le reste de cette division se trouve

dans les registres 𝑅0 à 𝑅𝑛−𝑘−1. la division terminée l'interrupteur I passe en position 2 et on

vide le contenu des registres 𝑅0 à 𝑅𝑛−𝑘−1.

III.9 Décodage des codes cycliques- calcul de syndrome

Pour détecter la présence d'erreurs de transmission on va utiliser le polynôme

générateur 𝑔 𝑋 . on se rappelle que 𝑔 𝑋 divise les mots de code 𝐶 𝑋 , on va donc tester le

mot reçu 𝑅 𝑋 en le divisant par 𝑔 𝑋 . Le reste de la division de 𝑅 𝑋 par 𝑔 𝑋 s'appelle le

syndrome 𝑆 𝑋 .

𝑅 𝑋 = 𝑔 𝑋 𝑞 𝑋 + 𝑆 𝑋 = 𝐶 𝑋 + 𝑒 𝑋 (III.20)

2

1

I Entrée du codeur

Sortie

I

2

1

𝑔𝑛−𝑘 𝑔2 𝑔1 𝑔0

Horloge

𝑅0 𝑅1 𝑅𝑛−𝑘−1

Figure III.1. - Réalisation du codeur Cyclique

𝑔𝑖 = 1 𝑖𝑛𝑡𝑒𝑟𝑟𝑢𝑝𝑡𝑒𝑢𝑟 𝑓𝑒𝑟𝑚é 𝑔𝑖 = 0 𝑖𝑛𝑡𝑒𝑟𝑟𝑢𝑝𝑡𝑒𝑢𝑟 𝑜𝑢𝑣𝑒𝑟𝑡



UHBC

Ou 𝑒 𝑋 est le polynôme associé aux erreurs de transmission. Le syndrome 𝑆 𝑋

obtenu sous forme polynomiale est bien entendu identique au syndrome S obtenu

précédemment en multipliant le mot reçu R par la matrice de contrôle H.

- Si 𝑆 𝑋 = 0 il n'y a pas d'erreurs de transmission ou du moins d'erreurs détectables.

- Si 𝑆 𝑋 ≠ 0 il y a des erreurs de transmission.

Comme nous l'avons déjà vu la correction des erreurs suivant le critère du Maximum

de Vraisemblance demande la comparaison du mot reçu avec tous les mots de code soit 2𝐾

comparaisons. Le mot de code choisi étant celui qui est à la distance minimale du mot reçu.

Cette procédure de correction ne peut être appliquée que si le paramètre K est assez petit.

On peut utiliser le syndrome pour effectuer la correction des erreurs de transmission.

Le syndrome possède 2𝑁−𝐾 configurations. Nous allons utiliser dans notre raisonnement la

représentation vectorielle du syndrome.

Soit 𝑆𝑖 une configuration du syndrome correspondant à un vecteur d'erreur 𝑒𝑖 de poids

i (i erreurs de transmission).

𝑆𝑖 = 𝑒𝑖 𝐻𝑡 (III.21)

On sait que la matrice H possède au minimum 2𝑡 + 1 colonnes dépendantes.

Recherchons les configurations du vecteur d'erreurs qui donnent au syndrome la valeur

𝑆𝑖 .

𝑆𝑖 = 𝑒𝑗 𝐻𝑡 (III.22)

Si 𝑒𝑖 et 𝑒𝑗 donne la même valeur pour le syndrome cela signifie que 𝑖 + 𝑗 colonnes

de H sont nulles.

Ceci est possible si 𝑖 + 𝑗 ≥ 2𝑡 + 1 ⇒ 𝑗 ≥ 2𝑡 + 1 + 𝑖

Si le vecteur d'erreurs 𝑒𝑗 correspond à une configuration d'erreurs que le code ne peut

corriger.



UHBC

Enfin, on vérifiera facilement que deux vecteurs d'erreurs de même poids (inférieurs

ou égale à t) ne peuvent donner la même valeur pour i pour le syndrôme.


UHBC

Chapitre IV

Codes Convolutifs ___________________________________________________________________________

IV.1 Définition

Pour les codes convolutifs, chaque bloc de ns symboles binaires en sortie, dépend non

seulement des ne symboles binaires présents en entrée mais aussi des v blocs de ne symboles

binaires précédents. Par conséquent, ces codes introduisent un effet de mémoire d’ordre v.

Chaque code convolutif est défini par les paramètres suivants :

Rendement du code : se nnR ;

Longueur de contrainte : 1 vK

La figure IV.1 donne un exemple d’un code convolutif de rendement R=1/2 et de

longueur du contrainte K =3.

Un code convolutif est un circuit logique comprenant un registre à décalage formé de

K cellules, sn additionneurs modulo 2 (portes ou-exclusif), un ensemble de connexions entre

les additionneurs et les cellules du registre à décalage et du commutateur à sn positions.

ky

2kd

1kd kd

kx

T

T

Figure IV.1- Exemple d’un code convolutif

( 3,2,2/1,2,1 KvRnn se )

Chapitre IV- Codes Convolutifs


UHBC

IV.2 Principe de codage

Pendant un cycle d’horloge, la sortie du codeur va comporter la sortie de

l’additionneur supérieur suivi de celle de l’additionneur inférieur, ces sorties sont données par

la relation suivante :

2

0

1

j

jkjk dgx ,

2

0

2

j

jkjk dgy (modulo 2) (IV.1)

Où jig ,( 2,1i ) est la réponse du code définissant aussi les codes convolutifs, et

celle-ci est déterminée par :

Les séquences génératrices représentent l'ensemble des connexions entre les

additionneurs modulo 2 et les cellules du registre à décalage. Les séquences génératrices

peuvent être données par :

octalg 51011 , octalg 71112 (IV.2)

Les polynômes générateurs exprimés en fonction de la variable D (Delay)

équivalente à la variable Z-1

de la transformée en Z :

2

1 1 DDG , 2

2 1 DDDG (IV.3)

IV.3 Représentation des codes convolutifs

D’une façon générale, un code convolutif fonctionne de la manière suivante : l’état du

code (le contenu de registre à décalage) à l’instant k est représenté par l’état

vkkk ddd ,,, 21 . A chaque arrivée d’un symbole binaire kd , le contenu de registre à

décalage devient égal à vkkk ddd ,,, 1 , une sortie est donc générée. Ensuite, le registre fait

le décalage et le code passe à l’état suivant qui est 11 ,,, vkkk ddd . Avant que le processus

de codage ne débute, l’état du code est initialisé à zéro.

Ce fonctionnement est représenté par trois diagrammes équivalents mais différents :

l’arbre du code, le treillis du code et le diagramme d’états. Ce dernier représente les



UHBC

transitions entre les états tandis que le diagramme en arbre et celui en treillis représentent

l’évolution au cours du temps de ces états.

IV.3.1 Diagramme en treillis

Sur la figure IV.2 on va représenter le treillis du code convolutif de la figure IV.1.

Le treillis est formé de noeuds reliés par des branches : les noeuds représentent les

différents états (vne2 états) possibles du code, les branches représentent les différentes

transitions (v2 transitions) possibles d’un noeud à un autre (ou d’un état du code au suivant)

lors de l’arrivée d’un symbole d’entrée (transition en trait pointillé (resp. en trait plein) pour

l’arrivée d’un 0 (resp. d’un 1)).

La longueur du treillis représente la profondeur dans la séquence des bits d'information

(notion du temps) et sa largeur équivaut au nombre d'états du code. Les états sont identifiés

sur la colonne de gauche. La sortie du code est mentionnée sur chaque branche.

Après K décalages, quelque soit l’état initial du code, le motif du treillis se répète.

Figure IV.2- Diagramme en treillis associé au code convolutif de la figure IV.1

Sortie

kk yx

00 00 00 00

11 11 11 11

11 11

10 10 10

01 01 01

10 10

01 01

00 00

0 1 2 3 4

Temps k

Etat

21 kk dd

a : 00

b :01

c : 10

d :11

1kd

0kd



UHBC

Le fonctionnement temporel du code se traduit donc par le tracé d’une succession

d’états connectés par des branches. Cette suite connectée de branche est dite "chemin" à

laquelle correspond les suites des symboles d’information et des symboles codés.

Les chemins doivent être suffisamment distants les uns des autres pour avoir des

meilleures performances. Cette distinction est caractérisée par un paramètre important qui

caractérise les performances du code en terme de probabilité d’erreur, appelé distance libre.

IV.3.2 Diagramme en arbre

Sur la figure IV.3 on va représenter l’arbre du code convolutif de la figure IV.1.

Lorsque l’élément binaire à l’entrée du codeur est égal à « 0 » (respectivement à

« 1 »), le couple binaire en sortie du codeur est porté par une branche montante

(respectivement descendante) du diagramme en arbre. Ces branches se séparent en un point

est appelé nœud.

Figure IV.3- Diagramme en arbre associé au code convolutif de la figure IV.1



UHBC

IV.3.3 Diagramme d’état

Pour le diagramme d’état la notion du temps a disparu, et on ne représente que les

transitions qui existent entre les états. Ce diagramme est déduit du diagramme en arbre.

Sur la figure IV.4 on va représenter le diagramme d’état du code convolutif de la

figure IV.1.

IV.4 Décodage des codes convolutifs

Dans les communications numériques actuelles, il existe deux méthodes de décodage

pour les codes convolutifs :

La 1ère

méthode recherche le message le plus probable (décodage à entrée ferme ou

pondérée et à sortie ferme) ;

La 2ème

méthode estime les symboles d'informations les plus probables (décodage à

sortie pondérée).

Dans ce qui suit, on va décrire deux algorithmes de décodage à entrée et à sortie

ferme : algorithme de Viterbi et algorithme séquentiel

Figure IV.4- Diagramme d’état associé au code convolutif de la figure IV.1



UHBC

IV.4.1 Algorithme de Viterbi

L'algorithme de Viterbi a été présenté en 1967 par A. J. Viterbi. Le principe de cet

algorithme consiste à estimer les transitions, qui se sont produites dans la mémoire du code

convolutif pendant le codage. L'estimation se base sur le maximum de vraisemblance

(Maximum Likelihood). Le maximum de vraisemblance permet d'identifier la séquence la

plus probable par la comparaison des séquences transmises possibles pour une séquence

reçue.

L’algorithme de Viterbi utilise le treillis comme structure de données. Il est représenté

sur la figure 4.6. Supposons que la séquence reçue soit 11 00 11 11.

Il fonctionne comme suit :

A chaque transition et pour chacun des nœuds, on va faire une séquence d'opération

appelée Addition-Comparaison-Selection (ACS) :

Figure IV.6- Algorithme de Viterbi

(3)

(1)

(3)

(2)

(2)

(2)

(2)

(1)

(1)

(4)

(1)

(2)

(0)

(2)

Métrique de branche

00 (2) 00 (2) 00 (0) 00 (2)

11 (0) 11 (0) 11 (2) 11 (0)

11 (0) 11 (0)

10 (1) 10 (1) 10 (1)

01 (1) 01(1) 01 (1)

10 (1) 10 (1)

01 (1) 01 (1)

00 (2) 00 (2)

0 1 2 3 4

Temps k

Etat

21 kk dd

00

01

10

11

1kd

0kd

Métrique cumulée

Chemin le plus

vraisemblable



UHBC

1. Calcul de la métrique : à chaque instant, on calcule la métrique de branche

associée à chaque chemin dans le treillis : c’est-à-dire la distance entre le couple de bits reçus

et les couples de bits codés correspondant au branches. Plusieurs métriques sont à notre

disposition pour calculer cette distance. Les trois suivantes sont le plus souvent citées avec

l'algorithme de Viterbi :

La métrique de corrélation ;

La métrique euclidienne ;

La métrique de Hamming. C’est celle qui est utilisée ici.

Ces distances apparaissent entre parenthèse sur chaque branche concernée.

2. Addition : pour chaque nœud on calcule les métriques cumulées des chemins

aboutissant à ce nœud. Elles sont calculées par l’addition des métriques de branche et des

anciennes métriques cumulées correspond au même chemin.

Ces métriques apparaissent entre parenthèse sur chaque noeud concerné.

3. Comparaison-Selection : chaque noeud doit alors comparer les deux métriques

ainsi calculées pour choisir le chemin le plus probable : la plus petite pour la métrique de

Hamming ou la métrique euclidienne, la plus grande pour la métrique de corrélation. Ce

chemin est appelé le chemin survivant, l’autre est le chemin concurrent.

Si deux chemins sont aussi vraisemblables, un seul chemin est toutefois conservé et le

choix peut être arbitraire.

A la fin de l'opération de décodage, le chemin de métrique totale minimale correspond

alors à la séquence transmise la plus probable (représenté en gras sur la figure).

Il est évident que le décodeur de Viterbi est un décodeur à maximum de vraisemblance

car à chaque étape, il ne rejette que des chemins ne pouvant être meilleurs que les chemins

choisis.

Aucune modification de l’algorithme de Viterbi à entrée pondérée n’est nécessaire.

Une simple adaptation de la métrique de branche permet une prise en compte naturelle des

entrées pondérées.



UHBC

L’algorithme de Viterbi est une méthode optimale de décodage pour réduire au

minimum la probabilité d'erreur par séquence. Malheureusement, l’algorithme de Viterbi ne

peut pas calculer la décision pondérée pour chaque symbole décodé. Cet algorithme a été

modifié pour faire utiliser l’algorithme SOVA.

IV.4.2 Décodage séquentiel

La première méthode utilisée pour le décodage des séquences protégées par des codes

convolutifs, a été l’algorithme séquentiel proposé par ozencraft en 1957

Cette méthode a été repris e et modifiée par Fano. La stratégie adoptée par Fano

consiste en la recherche du chemin le plus probable à l'intérieur du diagramme en arbre, en

examinant une transition de mémoire à la fois. Ce type de recherche appartient au genre de

recherche depth-first. La recherche du chemin le plus prometteur est conduite à l'aide d'une

fonction de métrique PM adaptée à ce genre de recherche.

IV.5 Performances des codes convolutifs

La distance libre, est définie comme la plus petite distance de Hamming existant entre

deux chemins qui divergent puis convergent de nouveau.

Rappelons que la distance de Hamming entre deux chemins est égale au nombre de

symboles binaires codés différents entre les séquences associées à chacun des deux chemins.

La recherche de la distance libre bénéficie de la propriété de linéarité des codes

convolutifs, qui permet de se concentrer uniquement sur les distances entre les messages

potentiels et le message zéro. Le message "zéro" est le message codé contenant une séquence

infinie de zéros, générée par le codage d'une série infinie de bits d'informations 'zéro' (chemin

de poids nul).

De ce fait, la distance libre est aussi égale au poids minimal des chemins qui divergent

puis convergent vers le chemin de poids nul. Le poids d’une séquence est le nombre de bit

égal à 1.

Reprenons le treillis de la figure 4.2 et portons sur chaque branche le poids

correspondant. On obtiendra la figure 4.5.



UHBC

La distance libre de notre exemple de treillis est égale à 5. Elle correspond au chemin

(00-10-01-00) représenté en gras sur la figure IV.5.

IV.6 Quelques exemples des codes

IV.6.3 Codes catastrophiques

Il existe des codes pour lesquels un nombre fini d'erreurs de transmission risque de

produire un nombre infinie d'erreurs en sortie du décodeur. Ces codes sont appelés

catastrophiques (figure IV.6). Un code convolutif est catastrophique, s'il existe dans le

diagramme d'états un chemin fermé dont toutes les branches sont de poids nul.

Figure IV.5- Détermination de la distance libre du code de la figure IV.1

Chemin « nul »

Poids

0 1 2 3 4

Temps k

Etat

21 kk dd

00

01

10

11

1kd

0kd

2 2 2 2

2 2

1 1 1

1 1 1

1 1

1 1

0 0

Figure IV.6- Exemple d’un code convolutif catastrophique

ky

2kd

1kd kd

kx

T

T



UHBC

IV.6.2 Codes convolutifs poinçonnés

Plus le rendement est faible, plus le code est performant. Mais, plus le rendement est

faible, plus la largeur de bande nécessaire à la transmission doit être importante.

On cherche donc à construire des codes ayant un rendement le plus élevé possible

(pour des raisons de temps et de coût) et permettant une fiabilité arbitrairement grande.

Pour fabriquer des codes convolutifs de rendement supérieur, on utilise l’opérateur de

poinçonnage, placé à la sortie du code, permettant d’effacer, c’est-à-dire de ne pas

transmettre, certains symboles codés. En réception, un dispositif vient insérer un zéro

analogique en entrée du décodeur aux places correspondantes.

La figure IV.7 donne un exemple d’un code de rendement R=1/2 dont on supprime un

bit de sortie sur 4. Il devient un code de rendement R=2/3.

Sur la figure IV.7, le masque de poinçonnage indique la position des symboles à

effacer.

La technique de poinçonnage permet d'augmenter le rendement d'un code sans pour

autant augmenter la complexité du décodeur. Cette technique permet d’obtenir des codes

ayant des performances très voisines de celles obtenues avec des codes non-poinçonnés de

même rendement, tout en présentant l’avantage d’avoir une réduction de la complexité de

décodage.

Codeur poinçonné

de rendement

R=2/3 2

2

1

2

1

1

C

CC

2

2

2

1

1

2

1

1

CC

CC

21 dd

Codeur convolutif

de rendement

R=1/2

1 1

0 1

Masque de poinçonnage

1 : transmission

0 : effacement

Figure IV.7- Exemple de poinçonnage d’un code convolutif

de rendement R=1/2



UHBC

A l’aide de la technique de poinçonnage, le codeur et le décodeur sont identiques pour

l’ensemble des rendements de codage. Seule la fonction de poinçonnage est paramétrable en

fonction de rendement.

La technique de poinçonnage est placée à la sortie du codeur. Elle permet d’effacer,

c’est-à-dire de ne pas transmettre, certains symboles codés. En réception, un dispositif,

nommé dépoinçonnage, insère des zéros analogiques en entrée du décodeur aux places

correspondantes.

La figure IV.9 représente le schéma de principe d’un système de transmission utilisant

la technique de poinçonnage.

La technique de poinçonnage permet d’augmenter le rendement d’un code sans

augmenter la complexité de décodage.

Figure IV.9- Schéma d’un système de transmission numérique

utilisant le poinçonnage

Codeur

en bloc

Poinçon-

nage

Canal de transmission

Décodeur

en bloc

Dépoinçon-

nage


UHBC

Chapitre V

Codes Concaténés ___________________________________________________________________________

V.1 Codes concaténés à un niveau

Pour un code correcteur d’erreurs, la distance libre déterminant les performances du

code, augmente avec le degré des polynômes générateurs. Malheureusement, la complexité

d’un décodeur croit en fonction de ce degré. De ce fait, on combine des codes élémentaires de

faible complexité, tout en conservant des distances libres élevés.

La concaténation de codes est donc la combinaison de deux codes élémentaires, en

bloc ou convolutifs, de faible complexité afin d’obtenir un code puissant : c’est-à-dire un code

ayant une distance libre élevés. Ainsi, le décodeur est constitué de deux décodeurs

élémentaires de complexité modérée.

Les concaténations les plus célèbres sont : la concaténation parallèle, la concaténation

série. Il est possible de fabriquer des concaténations hybrides en combinant la concaténation

série et la concaténation parallèle. Les structures hybrides sont peu intéressantes car un très

grand gain en performance est déjà atteint par les structures classiques.

V.1.1 Concaténation série de codes

Le schéma de principe de la concaténation en série de deux codes est illustré sur la

figure V.1.

Dans ce schéma, un premier codeur, dit codeur extérieur, fournit un mot de code qui

est ensuite recodé par un deuxième codeur, dit codeur intérieur. Si les deux codes sont

systématiques, le code concaténé est lui-même systématique.

Le rendement global est : 21 RRRcs

Figure V.1- Codes concaténés en série (a) sans permutation (b) avec permutation

Chapitre V- Codes Concaténés


UHBC

Concaténation en série d’un code convolutif et un code de Reed-Solomon

Le code extérieur est le code de Reed-Solomon et le code intérieur est le code

convolutif. Le décodeur intérieur est un décodeur de Viterbi à décision douce et le décodeur

extérieur est un décodeur à décision dur. Le décodeur convolutif corrige des erreurs

indépendantes et les paquets d’erreurs sont corrigés par un décodeur de Reed-Solomon. Afin

de diminuer les paquets d’erreurs à l’entrée de décodeur RS, un entrelaceur est ajouté entre les

deux codes.

Les deux codes convolutifs travaillent en décision douce. Le décodage interne peut se

faire selon l’algorithme de Berrou-Add, tandis que le décodage externe utilise simplement

l’algorithme de Viterbi.

V.1.2 Concaténation parallèle de codes

La figure V.2 représente la structure d’une concaténation parallèle de rendement

global R=1/3, construit à partir de deux codes CSR élémentaires C1 et C2, de même longueur

de contrainte K=3 et de polynômes générateurs (5, 7) et (7, 5), séparés par un entrelaceur noté

introduisant de la diversité.

Pour un symbole d’entrée kd , les sorties du turbo-code kx et ky à l’instant kT sont

respectivement égales à kd (code systématique) et la sortie du code C1 : ky1 , ou la sortie du

code C2 : ky2 .

Puisque les deux codes élémentaires sont systématiques et opèrent la même séquence

de symboles d'entrée, on n’a pas besoin de transmettre l’entrée du deuxième code C2, et ceci

augmente le rendement du code global. Elle est utile seulement pour doubler la diversité en

présence d’évanouissements .



UHBC

Afin d'augmenter le rendement du code global, les deux séquences de parité ky1 et

ky2 peuvent être poinçonnées.

La concaténation parallèle de plus de deux codes de faible complexité (typiquement

v=2) donne des codes globaux à faibles rendements.

V.2 Code concaténés a un multiniveaux

La concaténation de codes est donc la combinaison de plusieurs codes élémentaires, en

bloc ou convolutifs, de faible complexité afin d’obtenir un code puissant : c’est-à-dire un code

ayant une distance libre élevés. Ainsi, le décodeur est constitué de plusieurs décodeurs


V.3 Technique d'entrelacement et de désentrelacement

L'entrelacement est une opération qui change l'ordre des symboles à l'émission pour

les remettre en ordre à la réception.

Le principe d'une chaine de transmission avec codage et entrelacement est présenté à

la figure V.3.

Figure V.2- Concaténation parallèle de rendement R=1/3, construit

à partir de deux codes CSR

kd kx

ky2

ky1

C2

C1



UHBC

On peux utiliser l'entrelacement avec un seul code correcteur d'erreurs dans la chaine

de transmission, et aussi dans la concaténation de codes.

L'entrelaceur a pour but d'espacer les symboles consécutifs et de transférer un canal à

erreurs indépendantes, et ceci augmente la capacité de correction de codes. Il existe deux type

d'entrelacement:

1- Entrelacement en bloc

Pour cet entrelacement, on écrit les symboles issus du codeur à l'émission dans une

matrice mémoire ligne par ligne et on les relit colonne par colonne. A la réception, l'opération

inverse est effectuée pour rétablir l'ordre initial. La famille d'entrelacement en bloc regroupe

plusieurs types d'entrelacement.

2- Entrelacement convolutionnel

A l'émission un retard different va être inséré dans chaque branche d'un commutateur.

A la réception, le retard inverse est appliqué de façon à ce que tous les signaux aient subit le

même retard

Exemple

Imaginons la suite de mots suivants:

Figure V.3- Schéma d’un système de transmission numérique avec

codage et entrelacement

Canal de transmission

kd̂

kd

Source

d’information

Codeur

de canal

Entrelaceur Modulateur

Milieu de

transmission

Démodulateur Désentrela-

ceur

Décodeur

de canal

Destinataire



UHBC

n i c h e

c h i e n

p o u l e

t a s s e

f o u r s

b a l l e s

v i d e o

a u d i o

p e t i t

p o r t e

Chaque mot est mis en mémoire horizontalement et relu verticalement. Ainsi, si on

relit les paquets depuis le de e niche, cela donne les mots suivants:

eeuaf nlsob esuav erlia sldup eedep soito

A la suite de la transmission, on reçoit la séquence suivante affectée d'erreurs

eeuaf nlsob esuav **lia s***p eedep soito

Après désentrelacement on retrouve les mots suivants:

... tass* fou*s bal*es vi*eo ...

On voit nettement que l'entrelacement a permis de repartir les erreurs sur plusieurs

mots. Seul une lettre par mot est affecté et le code peut facilement corriger ces erreurs. Sans

entrelacement, ce sont les mots complets qui auraient été affectées sans espoir de pouvoir les

récupérer.

V.4 Concaténation binaire

La concaténation binaire est la combinaison de plusieurs codes élémentaires binaires,

en bloc ou convolutifs, de faible complexité afin d’obtenir un code puissant : c’est-à-dire un

code ayant une distance libre élevés. Ainsi, le décodeur est constitué de plusieurs décodeurs



UHBC

Chapitre VI

Turbo-Codes ___________________________________________________________________________

VI.1 Définition

La preuve du théorème de Shannon sur la capacité d'un canal de transmission a été

apportée par le codage aléatoire. D’après une recherche exhaustive faite par les théoriciens du

codage, un code correcteur d’erreur baptisé turbo-code, a été introduit récemment, et il

satisfait à la preuve de Shannon.

Les turbo-codes sont des codes correcteurs d’erreurs qui permettent d’avoisiner la

limite théorique de correction. Ces codes, inventés à l’ENST de Bretagne, sont obtenus par la

concaténation parallèle, série ou hybride de deux ou plusieurs codes correcteurs d’erreurs de

faible complexité. Leur décodage fait appel à un processus itératif (ou turbo).

VI.2 Conception des turbo-codes

VI.2.1 Turbo-codeur

La figure VI.1 représente la structure d’un turbo-code à concaténation parallèle de

rendement global R=1/2, construit à partir de deux codes CSR élémentaires C1 et C2, de même

longueur de contrainte K=3 et de polynômes générateurs (5, 7) et (7, 5), séparés par un

entrelaceur noté introduisant de la diversité. Ce dernier doit permettre d’augmenter les

distances libres des codes concaténés.

Les deux codes élémentaires C1 et C2 utilisent les mêmes symboles d’entrées, mais

suivant des séquences différentes. Ceci est rendu possible par la présence de l’entrelaceur.

Pour un symbole d’entrée kd , les sorties du turbo-code kx et ky à l’instant kT sont

respectivement égales à kd (code systématique) et la sortie du code C1 : ky1 , ou la sortie du

code C2 : ky2 .

Puisque les deux codes élémentaires sont systématiques et opèrent la même séquence

de symboles d'entrée, on n’a pas besoin de transmettre l’entrée du deuxième code C2, et ceci

Chapitre VI- Turbo-Codes


UHBC

augmente le rendement de turbo-code. Elle est utile seulement pour doubler la diversité en

présence d’évanouissements.

Afin d'augmenter le rendement de turbo-code, les deux séquences de parité ky1 et

ky2 peuvent être poinçonnées. Des turbo-codes ont été proposés, appelés turbo-codes m-

binaire. Ils ont permis d’obtenir des rendements de codage naturellement élevés.

La concaténation parallèle de plus de deux codes de faible complexité (typiquement

v=2) donne des turbo-codes à faibles rendements.

Le choix des codes CSR, la concaténation parallèle et l’entrelaceur pour un turbo-code

se justifient par le fait que pour des petits SNR, ces composants permettent d’augmenter la

distance libre du code qui conditionne ces performances, donc le turbo-code à une grande

distance libre.

VI.2.2 Turbo-décodeur

Le turbo-décodage se fait selon le principe de décodage itératif ou turbo basé sur

l’utilisation de décodeurs à entrée et à sortie pondérée ou SISO (Soft-Input Soft-Output) qui

s’échangent des informations de fiabilité kZ , appelées informations extrinsèques, par le biais

d’une contre-réaction, afin d’améliorer la correction au fil des itérations.

Le terme TURBO (Toggle Until Regenerations Bring Optimality) vient de la notion de

bouclage semblable à celle utilisée dans les moteurs turbo.

Figure VI.1- Turbo-code à concaténation parallèle de rendement

R=1/2, construit à partir de deux codes CSR

ky

kd kx

ky2

ky1

C2

C1



UHBC

Dans un circuit électronique le processus turbo s’explique comme ceci :

On fait un premier traitement, les résultats ont été mis en mémoire et on reprend ce

traitement en faisant bénéficier le traitement en amont des résultats du traitement en aval. On

procède plusieurs fois ce type d’opération dans le cas du turbo-décodage.

Un turbo-décodeur parallèle présenté à la figure VI.2, est constitué de deux décodeurs

élémentaires SISO DEC1 et DEC2 associés respectivement au code C1 et C2 disposés en

parallèle, de deux entrelaceurs et d’un désentrelaceur.

Le turbo-décodeur reçoit les observations ''

kk yx en provenance du canal et estime le

message émis.

Les deux décodeurs DEC1 et DEC2 travaillent conjointement, de telle manière que le

décodeur DEC1 puisse tirer bénéfice de'

,2 ky et le décodeur DEC2 de'

,1 ky . Ils fournissent une

première estimation, chacun communique ses résultats à l’autre pour une nouvelle passe, ce

qui correspond à une itération complète. Ils fournissent ensuite une seconde estimation.

Après, chacun communique ses résultats à l’autre et ainsi de suite. Le décodage s’arrête au

bout d’un nombre fixe d’itération, et la décision finale peut venir du DEC1 ou du DEC2.

Le soustracteur placé à la sortie de chaque décodeur DEC1 et DEC2 est utilisé pour ne

garder que la contribution de chacun (information extrinsèque).

Figure VI.2- Turbo-décodeur parallèle

kZ1

kZ2

kd̂

'

2ky

'

1ky

'

ky

'

kx

1

DEC1

(SISO)

DEC2

(SISO)



UHBC

VI.3 Analyse des performances des turbo-codes

La présence de l’entrelaceur et de désentrelaceur 1 respectivement à la sortie du

décodeur DEC1 et celle du décodeur DEC2 ont pour rôle de décorréler les décisions pondérées

en sortie de chaque décodeur.

Plusieurs méthodes d’entrelacement sont possibles. Cependant, le choix de la structure

d'un entrelaceur est un facteur clé qui détermine les performances d'un turbo-code, dans le

sens qu’il modifie leur propriété de distance libre.

Afin que ce turbo-décodeur s’effectue correctement même après plusieurs itérations de

décodage, l’entrelacement et le désentrelacement doivent s’effectuer de manière pseudo-

aléatoire ou aléatoire.

Grâce à ces deux types d’entrelacement, les turbo-codes paraissent aléatoires au canal

(notons que les codes aléatoires sont ceux qui ont été utilisés par Shannon), ce qui constitue

une caractéristique dont le décodage peut tirer bénéfice.

VI.4 Décodage itératif

Les turbo-codes utilisent le concept de décodage itératif. Le circuit d’un turbo-

décodeur est constitué par la mise en cascade de P modules, correspondant aux P itérations,

de décodage identiques (figure VI.3). Sa structure est donc parfaitement modulaire.

L’entrée du émeP module est constituée des séquences reçues

1

'

Pkx et 1

'

Pky retardées

convenablement et de la séquence 1

'

PkZ de la contre-réaction générée par le èmeP 1

module.

1

'

Pky

1

'

Pkx

1

'

PkZ

Pkd

2kd

0

'

ky

0

'

kx

0

'

kZ

1

'

kx

1

'

ky

1

'

kZ Module

1

Module

2

Module

P

P

1kd

Figure VI.3- Structure modulaire d’un turbo-décodeur


UHBC

Chapitre VII

Modulation Codée en Treillis ___________________________________________________________________________

VII.1 Introduction

Les échanges d’information dans les systèmes de télécommunication s’effectuent à des

débits toujours plus élevés et dans des bandes de fréquences de plus en plus étroites. On

cherche par conséquent à maximiser le rapport débit utile sur bande, c’est-à-dire l’efficacité

spectrale des transmissions. Pour ce faire, il apparaît naturel de coupler des modulations

numériques à grand nombre de points avec des codes correcteurs d’erreurs à haut rendement.

Les études menées dans ce domaine font essentiellement appel à deux approches : les

modulations codées en treillis et les modulations codées pragmatiques.

Avant d'aborder les modulations codées rappelons brièvement quelques propriétés des

modulations numériques conventionnelles.

La transmission de l'information à travers un canal peut se faire de deux manières:

1. Soit en bande de base, c'est-à-dire que le message numérique issu du codeur de

canal est transformé en un signal (codage à signal), dont la densité spectrale de puissance de

ce signal est comprise dans une bande centrée sur zéro, qui émet dans le canal. La

transmission en bande de base n’est utilisable qu’à de courtes distances (< 5km).

2. Soit en bande infinie, pour des raisons de compatibilité avec le canal, il serait

souhaitable de translater en fréquence le signal précédent autour d'une fréquence f0. Pour

cela, on fait la multiplication du signal par tf02cos . Cette opération s'appelle la

modulation, c’est une fonction complémentaire du codage à signal.

Modulateur

Le modulateur est l'interface qui convertit l'information numérique en formes d'ondes

adaptées aux caractéristiques du canal. Il transpose la gamme de fréquence occupée par le

signal dans une autre bande propre à la transmission. Les formes d'ondes peuvent varier selon

leur amplitude (Modulation par Déplacement d’Amplitude (MDA)), leur phase (Modulation

Chapitre VII- Modulation Codée en Treillis


UHBC

par Déplacement de Phase (MDP)) ou la combinaison des deux (Modulation d’Amplitude de

deux porteuses en Quadrature (MAQ)), et selon leur fréquence (Modulation par Déplacement

de Fréquence (MDF)).

Les modulations qui translatent le spectre du signal vers la fréquence porteuse sans en

modifier la forme sont appelées modulations linéaires : MDA, MDP et MAQ. À l’opposé, les

modulations qui modifient la forme du spectre du signal en bande de base sont dites non

linéaires : MDF.

Plusieurs améliorations peuvent être apportées à la modulation :

1. Modulation multiporteuses, OFDM (Orthogona1 Frequency Division

Multiplexing), consiste à répartir l'information à transmettre sur un grand nombre de

porteuses chacune modulée à bas débit.

2. Modulation M-aire : plutôt que de coder chaque symbole indépendamment, on

les regroupe par bloc de m où m représente le nombre de symboles à transmettre (M = 2m). A

chaque bloc ainsi formé on fait correspondre un signal. C’est ce qu’on appelle les modulations

à M états.

Les modulations à M états utilisent un ensemble de M signaux )(tSi ( Mi ,,2,1 )

de durée T pour transmettre m symboles toutes les T secondes.

tfjetutS 02

(VII.1)

Où 0f désigne la fréquence de l’onde porteuse, tu le signal modulant (le signal en

bande de base) et l’ensemble de leurs échantillons mnnn uuu ,2,1, ,,, représente les m

symboles binaires à transmettre associés à ce signal tS .

Dans un espace à deux dimensions, ces M signaux sont représentés par un ensemble de

M points appelé constellation et ceci permet de différencier chaque type de modulation.

D’un point de vue théorique, l’opération de modulation à l’instant nT consiste donc à

faire correspondre un ensemble de m symboles à un point de la constellation repéré par son

abscisse na et son ordonnée nb .



UHBC

Où na et nb sont des symboles Q-aires, et le facteur est un paramètre permettant de

fixer l’énergie moyenne des signaux émis, c’est-à-dire l’énergie moyenne bE par symbole

binaire transmis.

Donc chaque ensemble des échantillons mnnn uuu ,2,1, ,,, de m symboles binaires est

associé à chaque instant nT à un couple de symboles Q-aires nn ba , . Après passage dans le

canal de transmission, l’observation relative au couple nn ba , est représentée par un couple

'' , nn ba .

Les symboles transmis vont mieux suivre un code binaire de type Gray, il permet

d’affirmer qu’il existe généralement un seul symbole erroné.

On va présenter dans la section suivante quelques exemples de constellation

concernant les modulations qui seront utilisées dans ce travail : Modulation par Déplacement

de Phase à M états (MDP-M) et Modulation d’Amplitude de deux porteuses en phase et en

Quadrature à M états (MAQ-M).

a- Modulation par déplacement de phase à M états (MDP-M)

Dans ce cas nna cos et nnb sin

20

21012

Msiou

MsiMnavecM

nn

(VII.2)

Où n représente la phase de l’onde porteuse.

La figure VII.1 représente quelques exemples de constellations de type circulaire

correspond à la modulation MDP-M.



UHBC

La disposition des symboles sur un cercle se traduit non seulement par enveloppe

constante, mais aussi, par une énergie identique mise en œuvre pour transmettre chaque

ensemble de m symboles.

La complexité de l’ensemble émission/réception de la MDP-M augmente avec M, mais

reste raisonnable, ce qui en fait une modulation fréquemment utilisée pour M allant de 2 à 16

avec de bonnes performances.

b- Modulation d’amplitude de deux porteuses en quadrature à M états

(MAQ-M)

Pour un nombre d’états M grand, la MAQ constitue une solution satisfaisante pour

utiliser efficacement l’énergie émise. C’est une modulation où les signaux n’ont pas la même

énergie, on peut parler de l’énergie moyenne mE ou bien l’énergie crête à crête cE .

Elle se fait par une combinaison de deux porteuses en phase et en quadrature modulées

en amplitude. Si m est un nombre pair la MAQ-M présente la particularité de pouvoir se

résumer à deux MDA-M indépendantes agissant sur deux porteuses en quadrature, tandis que

pour m impair la MAQ-M ne peut pas se résumer à deux modulations d’amplitude

indépendantes.

Pour la MAQ on a : 1,,3,1, Qba nn

La figure VII.2 représente quelques exemples de constellations de type carré et en

croix correspondant à la modulation MAQ-M.

Figure VII.1- Exemples de constellations correspondantes à

des modulations MDP-M.

MDP-16

MDP-8



UHBC

La constellation de la MAQ-M avec un nombre pair de symboles est carrée, et elle est

en croix pour un nombre impair de symboles.

Le choix de la répartition des points dépend des critères suivants :

1. Pour pouvoir distinguer deux ensembles de m symboles (par conséquent deux

signaux), il faut respecter une distance minimale mind entre les points représentatifs de ces

ensembles. Plus cette distance est grande et plus la probabilité d'erreur sera faible. La distance

minimale entre tous les ensembles de m symboles est :

ijji

dMind

min (VII.3)

T

jiji dttStSd0

22

, Mji ,,2,1, (VII.4)

Ceci est à rapprocher avec la définition de la distance de Hamming ou la distance

euclidienne.

2. A chaque ensemble de m symboles émis correspond un signal élémentaire et

par la même une énergie nécessaire à la transmission de cet ensemble. Dans la constellation,

la distance entre un point représentatif de cet ensemble et l'origine est proportionnelle à la

racine carrée de l'énergie qu'il faut fournir pendant l'intervalle de temps TnnT 1, pour

émettre cet ensemble.

Figure VII.3- Exemples de constellations

correspondantes à des modulations MAQ-M

MAQ-64

MAQ-32

MAQ-16



UHBC

Les deux critères évoqués ci-dessus sont opposés puisque l'on serait tenté d'une part

d'éloigner les ensembles de m symboles au maximum pour diminuer la probabilité d'erreur et

d'autre part, de les rapprocher de l'origine pour minimiser l'énergie nécessaire à la

transmission.

Les critères de choix d'une modulation sont :

1. La constellation qui suivant les applications mettra en évidence une faible

énergie nécessaire à la transmission ou une faible probabilité d'erreur.

2. L'occupation spectrale du signal modulé.

3. La simplicité de réalisation.

VII.2 Construction du code

Dans le but de diminuer la probabilité d'erreurs Ungerboeck a proposé d'introduire de

la corrélation entre les point d'une constellation. Le principe utilisé est indiqué sur la figure

VII.3.

A un ensemble de K symboles binaires appelé message on associé un mot de code

constitué de N symboles binaires. Chaque mot de code dépend de plusieurs messages. Le

codeur présente donc un effet de mémoire (comme les codes convolutifs) qui va régir la

correlation entre les points de la constellation. Le mot de code vient ensuite sélectionner le

signal qui sera émis parmi les M points de la constellation.

Le fonctionnement du modulateur peut être représenté par un diagramme en treillis

dont le nombre dont le nombre d'états est fonction de la mémoire du codeur. Chaque branche

de ce treillis est associé à un signal de la constellation. En réception la démodulation est faite

en utilisant l'algorithme de Viterbi.

Figure VII.3- Principe d'une modulation codée

Message

(K symboles)

Mot de code

(N symboles)

Codeur

de canal

Sélection du

signal à émettre



UHBC

VII.3 Analyse des performances

La probabilité d'erreurs est alors fonction de la distance minimale ou distance libre 𝑑𝑓

entre les chemin du treillis et non-plus de la distance minimale 𝑑0 entre les points de la

constellation.

le gain obtenu pour une modulation codée, en terme de rapport 𝐸𝑏 𝑁0 est

approximativement égal à:

𝐺𝑑𝐵 = 10𝑙𝑜𝑔 𝑑𝑓

𝑑0

2

(VII.5)


UHBC

TD No. 01

Exercice 1

Soit un code en bloc de matrice génératrice :

0111001

1110010

1011100

G

1) Trouver les mots de codes possibles utilisés par le codeur.

2) Calculer le poids de chaque mot de code.

3) Calculer la capacité de détection d’erreurs de ce code.

4) Calculer la capacité de correction d’erreurs de ce code.

5) Transformer la matrice G sous une forme systématique G’.

6) Déduire la matrice de contrôle de parité H.

Exercice 2

Soit la matrice de contrôle d’un code en bloc :

1000110

0100011

0010111

0001101

H

1) Calculer la distance minimale de ce code.

2) Calculer le syndrome du mot reçu 1111111R .

Exercice 3

Un code en bloc contient les quatre mots suivants :

1111111111

1111100000

0000011111

0000000000

1) Que vaut la distance minimale de ce code.

2) Combien d’erreurs peut-il détecter ? et combien d’erreurs peut-il corriger ?

3) Le récepteur reçoit le mot 1110000000, quel est le mot initial ?

Exercice 4

Soit un code en bloc qui au vecteur d'information i = (i1,i2,i3,i4) associe le mot de code

c= (i1,i2,i3,i4,c5,c6,c7) avec c5 = i1+i3+i4, c6 = i1+i2+i3, et c7 = i2+i3+i4.

1) Donner la matrice génératrice et la matrice de contrôle de ce code.

2) Soit i = (1 0 1 0), quel est le mot de code associé ?

3) Soit le message m = (1 1 1 1 0 0 1). Est-il un mot du code ?


UHBC

TD No. 02

Exercice 1

Un code linéaire a pour matrice de contrôle

1

0

0

0

1

0

0

0

1

0

0

1

1

1

0

0

1

1

H

1) Préciser la longueur n des mots de code et la longueur k des mots d'information.

2) Les messages suivants sont-ils des mots du code ?

m1 = (1 1 1 0 1 1)

m2 = (1 0 0 1 1 0)

3) Donner la matrice génératrice du code et le codage de chaque mot d'information.

Exercice 2

On considère un code en bloc de matrice génératrice G.

111111

001011

010101

G

1) Un code sous forme systématique est tel que les mots de code sont composés par les k bits

d’information suivis par (n −k) bits de redondance.

Ecrire la matrice génératrice du code permettant d’obtenir la forme systématique du code.

2) Donner tous les mots de code.

3) En déduire la distance minimale dmin de ce code. Combien d’erreurs peut-il corriger ?

4) Déterminer la matrice de contrôle du code, à partir de la matrice génératrice sous forme

systématique.

Exercice 3

1) Combien d'erreurs peuvent-elles être détectées grâce à un code de parité? Est-il possible de

corriger ces erreurs ?

2) Coder les messages suivants à l'aide d'un bit de parité :

1101011001

100

11111000111001111

3) Quels sont les rendements des trois messages ci-dessus ?

Exercice 4

Soit un code en bloc de matrice de contrôle

1100101

1011100

1010011

H

1) Donner le nombre de bits de redondance.

2) Soit m un message dont tous les bits sont égaux à 1. Est-ce un mot du code?

3) Montrer que le code est un code de Hamming.


UHBC

TD No. 03 Exercice 1

Soit le code cyclique C(2,4).

1) Donner un polynôme générateur du code C.

2) Donner un mot de code obtenu par codage non-systématique.

Exercice 2

Soit le polynôme 31 xxxg

1) Montrer que xg est un polynôme générateur d’un code cyclique de longueur 7.

2) Quelle est la dimension de ce code.

3) Déterminer la matrice génératrice G de ce code

Exercice 3

Soit 12 xxxg le polynôme générateur d’un code cyclique de longueur 6.

1) Quelle est la longueur des mots d'information ?

2) Montrer que xxxxc 23 est un polynôme de mot de code.

3) Donner tous les mots de code possible par codage systématique.

4) Déterminer la distance minimale de ce code.

5) Trouver une matrice génératrice systématique de ce code.

6) La matrice génératrice que vous avez trouvée garde-t-elle les mêmes correspondances entre

les mots d’information et les mots-codes que celles trouvées à la question 3.

Exercice 4

Soit un code cyclique de longueur 7 et de polynôme générateur 145 xxxxg

- Donner le polynôme de contrôle de parité.

Exercice 5

Le code binaire de matrice génératrice

00111

01110

11100

G

est-il cyclique.

Exercice 6

Soit le polynôme sur 2GF , 14678 xxxxxg

1) Montrer que xg et un polynôme générateur d’un code cyclique C de longueur 15.

2) Déterminer la longueur des mots d’information.

3) Montrer que C est un code BCH primitif.

4) Déterminer la distance construite de C

Exercice 7

Soit un code de Reed-Solomon C de longueur 7 et de distance minimale 5.

1) Déterminer les paramètres de C.

2) Déterminer le polynôme générateur de C.


UHBC

TD No. 04

Exercice 1

Soit le code convolutif suivant :

1) Déterminer le rendement, la longueur de contrainte et les polynômes générateurs de ce

code.

2) Déterminer les états de ce code.

Exercice 2

Soit un codeur convolutif représenté ci-dessous.

1) Déterminer le rendement et la longueur de contrainte de ce code.

2) Déterminer les polynômes générateur et les séquences génératrices de ce code.

3) Représenter le diagramme d'état de ce codeur.

Exercice 3

On considère le code convolutif de rendement ½ et de polynômes générateurs: 11 DG et

DDG 2

2

1. Représenter le code associé.

2. Représenter le diagramme en arbre.


UHBC

TD No. 05

Exercice 1

Soit un code convolutif de rendement 𝑅 = 12 , de longueur de contrainte 𝐾 = 3 et de

polynômes générateurs 7, 5 . 1) Représenter le code associé.

2) Déterminer la distance libre de ce code.

3) On suppose qu’on a émis la séquence suivante 1 1 0 1. On suppose que le registre du

codeur est initialisé par des zéros. Quel est alors le mot de code associé à cette séquence ?

4) La séquence reçue est 11 00 11 11. Déterminer la séquence émise la plus vraisemblable.

5) Représenter le code convolutif systématique récursif associé à ce code, et de polynômes

générateurs 1,7

5 .

Exercice 2

Soit le codeur convolutif suivant :

1) Ce codeur est il catastrophique ?

2) Le registre du codeur est initialisé par des zéros. L’entrée du codeur est constituée d’une

longue séquence de « 1 ». On suppose que le canal de transmission introduit une erreur aux

positions 1, 2 et 4 de la séquence codée. Déterminer la séquence estimée.

Exercice 3

Soit un code convolutif poinçonné de rendement 𝑅 = 23 , obtenu à partir d’un code de

rendement 𝑅 = 12 , de longueur de contrainte 𝐾 = et de polynômes générateurs 7, 5 .

1) Parmi les masques de poinçonnage suivants, choisir le masque correspondant à ce code

poinçonné:

11

01P ,

01011

10101P ,

000

001

111

P ,

011

101P

1) Pour une séquence 1 1 0, déterminer la séquence codée et poinçonnée

3) On suppose que le canal de transmission introduit une erreur à la position 4 de la séquence

poinçonnée. Calculer le TEB à la sorite du canal de transmission.

4) Déponçonner la séquence reçue.


UHBC

TD No. 07

Exercice 1 1)-a Coder la séquence de bits d'information suivante (1111) par un code convolutif C1 de

rendement 1/2, de longueur de contrainte 4 et de séquences génératrices g1=[1101] et

g2=[1110].

1)-b Représenter le schéma de ce codeur.

2)-a Recoder la sortie de ce codeur convolutif par un code en bloc C2 de matrice génératrice G

𝐺 = 1 0 00 1 00 0 1

0 1 11 0 11 1 0

111

2)-b Déterminer le rendement de ce code. Justifier

2)-c Déterminer sa distance libre. Déduire le nombre d’erreurs à détecter le nombre d’erreurs

à corriger par ce code.

3)-a Le code convolutif C1 et le code en bloc C2 sont concaténés. Quel est le type de cette

concaténation.

3)-b Déterminer le rendement globale de cette concaténation.

Exercice 2

Soit une concaténation parallèle de deux codes de rendement global R=1/2, construit à partir

de deux codes CSR élémentaires C1 et C2, de même longueur de contrainte K=3 et de

polynômes générateurs (1, 7/5) et (1, 7/5).

1) Représenter la structure de ce turbo-code

2) Coder la séquence (111) a l'aide de cette structure.

Exercice 3

Soit une modulation codée d'une distance libre 𝑑𝑓 = 5 entre les chemin du treillis et non-plus

de la distance minimale 𝑑0 = 2 entre les points de la constellation.

1) Calculer le gain obtenu pour une modulation codée, en terme de rapport 𝐸𝑏 𝑁0 .

70 Cours&Travaux Dirigés M2: Codage de Canal Latifa MOSTARI

UHBC

Conclusion Générale

__________________________________

L’objectif de ce cours était d’étudier les codes correcteurs d'erreurs et leurs différents

types. Et de donner des notions de base et donner une ouverture sur les techniques plus

récentes.

On a pour cela, au premier chapitre et sous forme introductive, identifié le principe de

détection et correction des erreurs de transmission et mesure de performances des codes

correcteurs d'erreurs. Ensuite, on a discuté les avantages et les inconvénients des codes

correcteurs d'erreurs .

Le deuxième, le troisième et le quatrième chapitre a été axé sur l'étude respectivement

en détail des codes en bloc, cycliques et des codes convolutifs.

Le chapitre cinq était orienté à l’étude de la concaténation des codes correcteurs

d'erreurs permettant d'améliorer les performances des codes correcteurs d'erreurs. Dans le

chapitre six, on a présenté les turbo-codes permettant d'approcher la limite de Shannon.

Les modulations codée en treillis sont présente dans le dernier chapitre, ces

modulations sont utilisés pour des transmission à haut débit dans une bande passante étroite.

70 Cours&Travaux Dirigés M2: Codage de Canal Latifa MOSTARI

UHBC

[1] Y. Jiang, “A Practical Guide to Error-Control Coding using MATLAB”, Artech House,

2010.

[2] Y. S. Cho, J. Kim, W. Y. Yang and C. G. Kang, “MIMO-OFDM Wireless

Communications with Matlab”, John Wiley & Sons (Asia) Pte Ltd, 2010.

[3] T. S. Rappaport, “Wireless Communications: Principles and Practice”, Second Edition,

2002.

[4] J. G. Proakis, “Digital Communications”, Fourth Edition, 2001.

[5] M. Weeks, “Digital Signal Processing using MATLAB”, Infinity Science Press LLC,

2006.

[6] Marco Baldi, “QC-LDPC Code-Based Cryptography”, Springer, 2014.

[7] J. C. Moreira and P. G. Farrell, “Essentials of Error-Control Coding”, John Wiley & Sons

Ltd, 2006.

[8] C. Berrou, “Codes et Turbo-Codes”, Springer, 2007.

[9] T. K. Moon, “Error Correction Coding Mathematical Methods and Algorithms”, A John

Wiley & Sons, Inc, 2005.

Documents

Codage de Canal - جامعة حسيبة بن بوعلي