Codes LDPC

Implmentation sur MATLAB et en C

B.

Delporte

, M.

El Ouardani

, R.

Keita

, S.

Poissy

Projet suivi par N.

Nadal

v1

v2

v3

v4

v5

v6

v7

v8

c1

c2

c3

c4

ST4-PROJ

ESIEE Paris Anne 2012

Table des matires

I
1

Codes LDPC : intrt, principe et fonctionnement

Proprits du canal de transmission et limite de

7
7

1.1 Modle de Shannon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2 Canal additif blanc gaussien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.3 Capacit du canal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1 Codes correcteurs d'erreurs . . . . . . . . . . . . 2.2 Codes en bloc linaires . . . . . . . . . . . . . . . 2.2.1 Codage . . . . . . . . . . . . . . . . . . . 2.2.2 Distance de Hamming et poids d'un code 2.2.3 Rception . . . . . . . . . . . . . . . . . . 2.2.4 Syndrme et correction . . . . . . . . . . 2.2.5 Dcodage . . . . . . . . . . . . . . . . . . 2.2.6 Lien entre les matrices G et H . . . . . . 2.2.7 Code systmatique . . . . . . . . . . . . . 2.2.8 Probabilit d'erreur et taux d'erreur . . . 3.1 Reprsentations possibles . . . . . . . 3.1.1 Matrice de contrle H . . . . . 3.1.2 Graphe de Tanner . . . . . . 3.2 Mapping . . . . . . . . . . . . . . . . . 3.3 Dcisions dures . . . . . . . . . . . . . 3.4 Dcisions souples . . . . . . . . . . . . 3.4.1 Mthode probabiliste . . . . . . 3.4.2 Logarithmic Likelihood Ratios
Implmentation
Test de Monte Carlo Implmentation sur MATLAB Codes LDPC Codes correcteurs d'erreurs

Shannon

7 8 8

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

10

10 10 11 11 11 12 12 13 13 14

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

15

15 15 15 16 16 18 18 19

II
4 5

23
23 23

5.1 5.2 5.3 5.4 5.5 5.6 5.7 5.8

Importation de la matrice H . . . . . . . . . . Construction de G . . . . . . . . . . . . . . . . Test de Monte Carlo . . . . . . . . . . . . . . . Gnration d'un message u alatoire . . . . . . Codage . . . . . . . . . . . . . . . . . . . . . . Mapping BPSK . . . . . . . . . . . . . . . . . . Canal Additif Blanc Gaussien . . . . . . . . . . Dcodage . . . . . . . . . . . . . . . . . . . . . 5.8.1 Dcisions dures . . . . . . . . . . . . . . 5.8.2 Dcisions souples, mthode probabiliste 5.8.3 Dcisions souples LLR . . . . . . . . . . 5.9 Courbes de rsultats . . . . . . . . . . . . . . . 5.10 Interface graphique . . . . . . . . . . . . . . . . 6.1 6.2 6.3 6.4
Implmentation en C

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

24 24 24 26 26 27 27 27 27 29 31 33 34 34 34 34 34 34

Environnement de dveloppement . . . . . . . . . . . . . . . Fonctions essentielles et primitives . . . . . . . . . . . . . . Gnration de nombres alatoires de distribution gaussienne Structure des donnes . . . . . . . . . . . . . . . . . . . . . 6.4.1 Format des donnes de H et G . . . . . . . . . . . . 3

34

6.4.2 Test de Monte Carlo . . . . . . . . . . . 6.4.3 Gnration d'un message u alatoire . . 6.4.4 Codage . . . . . . . . . . . . . . . . . . 6.4.5 Mapping BPSK . . . . . . . . . . . . . . 6.4.6 Canal Additif Blanc Gaussien . . . . . . 6.4.7 Dcodage . . . . . . . . . . . . . . . . . 6.4.8 Dcisions dures . . . . . . . . . . . . . . 6.4.9 Dcisions souples, mthode probabiliste 6.4.10 Dcisions souples, mthode LLR . . . . 6.4.11 Contrle de parit . . . . . . . . . . . . 6.5 Interface graphique . . . . . . . . . . . . . . . .
III

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

. . . . . . . . . . .

35 37 37 38 38 38 38 38 38 39 39
41

Analyses de performances, rsultats et interprtations

 Aime la vrit, mais pardonne l'erreur.  Voltaire, in Discours

en vers sur l'homme

Introduction
Le dveloppement sans cesse grandissant des nouvelles technologies ncessite la transmission de donnes toujours plus rapidement et en proportions toujours plus importantes. En plus des besoins d'accrotre la vitesse de transmission de donnes et la quantit de donnes, il est ncessaire de s'assurer que ces donnes seront transfres sans trop d'erreurs. Autrement dit, il faut viter le plus d'erreurs de transmission possibles, an que les donnes ne soient pas altres au point d'tre inutilisables et inexploitables. C'est pour cette raison que des mthodes de codage des donnes envoyer par l'metteur et de correction des donnes reues par le rcepteur ont t mises au point. Dans le cadre de l'unit de projet interne I4 du dpartement tlcommunications ST4-PROJ, nous avons tudi les codes LDPC et nous avons implment un systme codeur/canal de transmission/dcodeur sur MATLAB et en C, an d'valuer ensuite les performances de ce systme en terme de taux d'erreurs binaires. Dans une premire partie, nous allons nous interroger sur l'intrt des codes correcteurs en gnral, nous introduirons les codes en bloc linaires puis nous prsenterons les codes LDPC. Nous raliserons ensuite une tude thorique de ces codes LDPC et nous prsenterons les algorithmes principaux de dcodage de ces codes. Dans une deuxime partie, nous allons prsenter l'implmentation sur MATLAB que nous avons ralise lors du projet, les premires simulations sur MATLAB, puis l'implmentation en C et enn les premiers rsultats obtenus avec le programme C. Dans une troisime et dernire partie, nous tudierons plusieurs matrices de codes LDPC et nous analyserons les performances de ces codes.

 La vraie faute est celle qu'on ne corrige pas.  Confucius

Premire partie

Codes LDPC : intrt, principe et fonctionnement

Dans cette premire partie, nous allons prsenter les codes correcteurs puis nous introduirons les codes LDPC. Un systme de communication est un systme qui assure la transmission de donnes depuis un metteur vers un rcepteur. Ces donnes transitent dans un canal de transmission entre l'metteur et le rcepteur. Ce canal ajoute dans la plupart des cas du bruit aux donnes et engendre des erreurs ou des suppressions de donnes.
1
1.1

Proprits du canal de transmission et limite de

Modle de

Shannon
. Le schma 1 prsente

Shannon
Shannon

Un modle reprsentant un systme de communication a t propos par ce modle.

Message source

Codage source

Codage canal

Emetteur Modulateur

Bruit

Canal de propagation

Message nal

Decodage source

Decodage canal
Shannon

Recepteur Demodulateur

Figure

1  Modle de

d'un systme de communication

 Le message source peut tre un signal audio, de la vido, une image, du texte, des donnes brutes (raw), des donnes biomdicales...  Le codage source compresse les donnes an de rduire le nombre de bits transmettre. Ceci augmente l'ecacit, au sens o des motifs trop souvent rpts peuvent tre vits, ce qui rduit la taille des donnes transmettre sur le canal. On peut trouver de la compression sans pertes ou avec pertes. Le choix entre une compression sans pertes ou avec pertes dpend de l'application. Par exemple, une compression avec pertes pourra tre choisie pour de la diusion vido mais sera proscrite pour des donnes critiques.  Le codage canal doit protger les donnes contre les erreurs dues au canal de transmission.  L'metteur se charge de la modulation des donnes, par exemple avec une BPSK, une 16-QAM, etc., et les adapte au canal. Nous prendrons, dans notre cas, une modulation BPSK.  Le canal de transmission ajoute du bruit aux donnes qui y circulent. Ce bruit provient souvent de l'extrieur (appareils, environnement, etc.) mais il peut y avoir une inuence de la part d'un systme de transmission mal dimensionn, mal conu ou mal connect (rexions d'ondes, inversion de polarit, etc.).  Le rcepteur doit prendre des dcisions pour reconstituer les donnes qu'il a reues depuis le canal.  Le dcodage canal doit assurer la correction des erreurs des donnes. 7

 Le dcodage source eectue l'opration inverse du codage source, il dcompresse les donnes.  Le message nal est ainsi obtenu en sortie du dcodage source. Dans le meilleur des cas, il est identique au message source.
1.2 Canal additif blanc gaussien

Nous avons considr, dans la totalit du projet, et nous allons considrer galement, dans la totalit de ce rapport, un canal additif blanc gaussien (que nous noterons CABG mais qui est not AWGN en anglais, soit Additive White Gaussian Noise), qui est un canal de transmission qui  ajoute  aux donnes en transmission un bruit blanc gaussien de moyenne nulle et de variance 2 . La distribution de ce bruit suit donc une loi normale N (0, 2 ) et l'on considre que ce bruit a une densit spectrale de puissance constante de N0 sur la bande du 2 canal. Le schma 2 prsente le spectre suppos du bruit.
dens. spec. de puissance

N0 2

W
Figure

2  Spectre du bruit blanc gaussien

Le schma 3 prsente un modle du CABG.

canal entree sortie

N (0, 2 ) bruit
Figure

3  Modle d'un CABG

1.3

Capacit du canal

Le canal a une caractristique nomme la capacit. Note C , elle dsigne le dbit maximal de transmission dans le canal sans erreur. Cette capacit est donne par le thorme de Shannon-Hartley :
C = W log2 1 + P N

(1)

 W est la largeur de bande du canal en Hz. P  N est le rapport signal bruit (RSB) en linaire  P est l'nergie par symbole en W  N est l'nergie du bruit en W  C est en bits/s. A partir de l'quation (1), il est possible d'crire :
C P = log2 1 + W N

Or l'nergie du bruit est N = N0 W et l'nergie du signal est Eb = P Tb avec Tb le temps bit en secondes. On peut donc crire : 8

C W

= =

log2 1 + log2

P Tb N Tb Eb 1+ N0 W Tb

Si l'on pose le dbit binaire D =

1 Tb ,

on obtient :

C Eb D = log2 1 + W N0 W

Lorsque le dbit D atteint C la limite, on a :

Eb C C = log2 1 + W N0 W C Eb C 2W = 1 + N0 W C Eb C 2W 1 = N0 W Eb 2W 1 = C N0 W Eb eW = N0
C C

ln 2 C W

1
C

Eb e W ln 2 1 = ln 2 C N0 W ln 2

Enn, nous savons que limx0

ex 1 x

= 1, donc :

C W

lim

Eb N0

= ln 2

soit 1, 59 dB. Nous avons donc trouv

C W

Eb N0

min

= 1, 59 dB pour

C W

= 0.

E C est l'ecacit spectrale en bits/Hz/s. Il devient possible de tracer W en fonction de Nb . Il s'agit de la 0 courbe de la limite de Shannon sur la gure 4. La zone au-del de cette courbe n'est pas atteignable.

ZONE NON ATTEIGNABLE

Limite de Shannon

4 C/W (bits/s/Hz)

0 2 1,59 dB

4 Eb/N0 (dB)

10

12

Figure

4  Courbe de la limite de Shannon

Shannon arme qu'il existe des codes qui permettent de s'approcher le plus possible de la limite thorique dnie prcdemment, sans toutefois dnir ni caractriser ces codes. Depuis, dirents codes se sont dvelopps.

Codes correcteurs d'erreurs

Les codes correcteurs d'erreurs appartiennent au codage canal (il y a toutefois des codes qui peuvent assurer le codage source et le codage canal). Nous allons prsenter un panorama des codes correcteurs d'erreurs existants.
2.1 Codes correcteurs d'erreurs

On distingue gnralement trois grands types de codes :  Les codes linaires : ces codes ont une structure d'espace vectoriel. Parmi les codes linaires, les codes en bloc linaires, Hamming, LDPC  Les codes convolutifs : chaque bloc de sortie de n bits dpend des m blocs prcdents d'entre de k bits  Les codes cycliques, o toute permutation circulaire d'un mot de code est un mot de code :  CRC  Codes polynomiaux, Reed-Solomon, BCH  Les codes entrelacs, turbo-codes : plusieurs codes sont entrelacs et l'information d'un dcodeur est transmise au dcodeur suivant Nous allons nous intresser au cas particulier des codes en bloc linaires. La notion de bloc renvoie au fait que les donnes sont regroupes sous forme de blocs de plusieurs bits et l'on peut ainsi distinguer un bloc de message coder de taille k d'un bloc de message cod de dimension n.
2.2 Codes en bloc linaires

Considrons que le message source a dj subi l'eet du codage source. Le message u ainsi obtenu, vecteur de taille k, appartient l'espace vectoriel Fk . Le 2 indique que nous sommes dans le cas binaire. Tout au long 2 du rapport, nous ne considrerons que le cas binaire, donc toutes les oprations seront modulo 2. Le principe du codage canal est d'introduire une redondance pour protger le message contre les erreurs induites par le canal. Aprs le codage canal, nous devons obtenir un mot c du code, vecteur de taille n > k, qui appartient l'espace vectoriel Fn . 2 On caractrise un code en bloc linaire avec k et n : on dit que c'est un [n, k]-code. 10

Le rendement R du code est dni par le rapport entre k et n :

R= k n

Soit Eb l'nergie par bit utile (message coder) et soit Ec l'nergie par bit cod (message cod). On a :
kEb = nEc k Ec = Eb n

2.2.1 Codage

L'opration de codage, qui permet d'obtenir un mot du code partir d'un message, est eectue avec une application linaire : Fk Fn . On a : 2 2
c = (u)

C'est une application injective. Soit la matrice G associe cette application, de dimensions k n, appele matrice gnratrice. Le codage avec la matrice G s'eectue par l'opration suivante :
c = uG

On peut donc armer que les bits de c sont une combinaison linaire des bits de m. L'espace vectoriel Fn est divis en deux ensembles : 2  L'ensemble C des mots du code : u Fk , uG C ou, autrement dit : C = Im() o Im(.) dsigne 2 l'image de (.).  L'ensemble C , complmentaire de C .
2.2.2 Distance de

Hamming

et poids d'un code

La distance de Hamming entre deux mots d'un code (cas binaire) est le nombre de bits qui dirent deux deux entre les mots. Par exemple, la distance entre c1 = 1 0 0 1 1 et c2 = 0 1 0 1 1 est 2. Dans le cas binaire, c'est simplement le nombre de 1 dans le vecteur somme c1 c2 . Le poids d'un mot de code est le nombre de ses lments non nuls. Par exemple, c = 1 0 0 1 1 a un poids de 3. On caractrise souvent un code par sa distance minimale : il s'agit du poids le plus petit parmi les mots du code hormis le mot nul. On dira que l'on a un [n, k, d]-code. L'objectif d'un code performant est de maximiser la distance entre les mots du code.
2.2.3 Rception

C'est le mot c du code qui va tre envoy par l'metteur vers le canal de transmission. Le canal va bruiter le signal. Le rcepteur va recevoir ce signal, va prendre des dcisions et reconstituer le mot c qui, selon lui, a t envoy par l'metteur. Le mot c parvient au dcodage canal. Si c'est un mot du code, alors on peut considrer qu'il n'y a pas eu d'erreurs. Si ce n'est pas un mot du code, alors il y a eu au moins une erreur bit. Il convient de prciser tout de mme que si l'metteur envoie c1 et si le bruit additif est un mot du code c2 , le correcteur n'y verra que du feu car il croira que l'metteur a envoy c = c1 + c2 . En eet, la somme de deux mots du code est un mot du code :
(c1 , c2 ) C C , (c1 + c2 ) C

Il convient galement de prciser que le code ne sera capable de corriger que des mots dont la distance par rapport un mot de code est infrieure d (ou autrement dit infrieure ou gale d 1). Soit t le nombre d'erreurs maximal que le code peut corriger. On a :
t< d 2

11

d correspond galement au nombre de colonnes j de H linairement indpendantes, c'est--dire telles que j j j = 0 j = 0. Pour pouvoir corriger le maximum d'erreurs, le code en bloc doit maximiser le nombre de colonnes linairement indpendantes de la matrice de contrle H .

2.2.4

Syndrme et correction

Pour savoir si c est bien un mot du code ou s'il y a des erreurs, il faut utiliser une application linaire h : Fn Fnk qui permet de calculer le syndrome y , vecteur de taille n k . Soit la matrice H associe cette 2 2 application, de dimensions (n k) n, appele matrice de contrle ou matrice de parit. On a :
y = h() c

Le calcul du syndrme avec la matrice H s'eectue avec l'opration suivante :

y = cH T

o (.)T dsigne la matrice transpose de (.). Si le syndrme est le vecteur nul 0, alors on peut considrer qu'il n'y a pas d'erreur et l'on pose c = c. On peut crire : C = Ker(h) o Ker(.) dsigne le noyau de (.). Sinon, le syndrme permet de retrouver les erreurs en utilisant une table de dcodage standard. La table de dcodage se construit ainsi : 1. On construit un tableau de 2nk lignes et de 2k colonnes. Nous nommerons i = 1..2nk les lignes et j = 1..2k les colonnes. 2. Dans la ligne i = 1 du tableau, on crit tous les mots du code en commenant par le mot nul. 3. La ligne i = 2 commence par un mot qui n'appartient pas la premire ligne mais de poids le plus faible possible. Ensuite, dans toute case de coordonnes (i, j), on y inscrit la somme XOR (0 0 = 1 1 = 0 et 0 1 = 1 0 = 1) de la case (i, 1) et de la case (1, j). 4. La ligne i = 3 commence par un mot qui n'appartient pas aux lignes i = 1..2 mais de poids le plus faible possible. Ensuite, dans toute case de coordonnes (i, j), on y inscrit la somme XOR de la case (i, 1) et de la case (1, j). 5. On continue avec les lignes i = 4..2nk . Il faut rechercher c dans la table de dcodage standard. Lorsqu'on a trouv c dans la case de coordonnes (xc , yc ), on obtient c en eectuant la somme XOR c = (xc , yc ) (1, yc ). L'inconvnient majeur de cette mthode est l'augmentation de la taille de la table de dcodage standard avec k et n, ce qui augmente le temps de recherche de c. Nous pouvons imaginer sans dicults que pour k et n grands, les dimensions de la table, 2nk 2k , sont trs grandes !
2.2.5 Dcodage

Lorsque c a t trouv, il faut maintenant le dcoder. Pour cela, il faut utiliser la fonction 1 inverse de : 1 : Fn Fk . Soit : 2 2
u = 1 () c

On obtient ainsi le message nal u qui, dans le meilleur des cas, est identique u (s'il n'y a pas d'erreur). Le schma 5 prsente un rsum graphique des espaces vectoriels et des applications entrant en jeu dans le code en bloc linaire. 12

codage

Fk 2
u

1 c
decodage

C
c

Fn 2

0
y

h
calcul du syndrome

Fnk 2
Figure

5  Illustration des espaces vectoriels et des applications de codage, dcodage et calcul du syndrme
Shannon

Le schma 6 prsente le modle de pour illustrer nos propos.

et les dirents vecteurs dans le systme de communication

Message source

Codage source

Codage canal

Emetteur Modulateur

Bruit

Canal de propagation

Message nal

Decodage source

Decodage

canal

Recepteur Demodulateur

Figure

6  Modle de

Shannon

d'un systme de transmission et position des vecteurs

2.2.6

Lien entre les matrices

et

L'ide est de dnir l'ensemble des mots de n bits orthogonaux aux mots du code et de vrier si y est orthogonal cet ensemble. On forme donc l'ensemble des mots de longueur n orthogonaux aux mots du code. Cet ensemble forme un sous-espace vectoriel de dimension n k : il s'agit du code dual du code initial. Et, par dnition du code dual, on a la proprit GH T = 0. Tout mot du code est orthogonal aux vecteurs formant la base du code dual. Donc tout mot c du code vrie : GH T = 0. C'est cette relation qui permet de contrler qu'un mot appartient au code. Il faut donc que les matrices G et H respectent la relation GH T = 0. GH T est de dimensions k (n k).
2.2.7 Code systmatique

La matrice gnratrice du code doit tre une matrice dont les lignes sont des vecteurs de base du code. La matrice gnratrice du code G n'est pas unique : on peut permuter les lignes, les colonnes et faire des combinaisons linaires car l'ordre des bits dans les mots de code. 13

Il existe des codes en bloc particuliers appels codes systmatiques. Les mots de tels codes comportent le message lui-mme. Bien souvent, nous avons c = u r o les n k bits de r sont les bits de redondance. Dans ce cas, G = Ik P o Ik est la matrice identit de dimensions k k et P est une sous-matrice de dimensions k (n k) et H = P T Ink . On vrie aisment que GH T = 0 :
GH T = = Ik Ik P P PT P Ink Ink
T

1 ... 0 p11 = ... 1 ... ... 0 ... 1 p1k 2p11 = ... 2p1k = 0

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

p1(nk) ... pk(nk)

... ... 2p1(nk) ... ... ... ... ... 2pk(nk)

p11 ... p1k 1 ... ... 0

... ... ... ... 1 ... ...

... p1(nk) ... ... ... pk(nk) ... 0 ... ... 1 ... ... 1

Un code non systmatique peut tre mis sous forme systmatique par combinaisons linaires et par permutations de colonnes.
2.2.8 Probabilit d'erreur et taux d'erreur

Les performances sans codage en terme de taux d'erreurs binaires sont donnes par l'expression suivante :
2Ec N0 2 k Eb n N0

perfsans

codage

= =

Q Q

Il conviendra de tracer la courbe des performances sans codage et de la comparer avec les performances du code. On devra observer un certain gain de codage, comme le montre la gure 7. Plus le gain de codage est important, plus on se rapproche de la limite de Shannon.
BERlog

100 101 102 avec codage 103 gain de codage 104

Eb N0

sans codage Q
2Ec N0

dB

Figure

7  Gain de codage 14

Codes LDPC

Des codes correcteurs d'erreurs ecaces doivent avoir :  Un bon rendement, c'est--dire qu'ils doivent viter une trop grande quantit de bits transmettre pour ne pas gaspiller de l'nergie, il faudra donc viter que n soit trop suprieur k au point de ne plus tre ecace et d'augmenter la quantit d'erreurs possibles  Une bonne capacit de dtection et de correction d'erreurs, un t le plus grand possible  Une procdure de dcodage susamment simple et rapide, on vitera donc des tableaux de dcodage standard gargantuesques Les codes LDPC (Low Density Parity-check Code) sont des codes en bloc linaires qui orent de bonnes performances en satisfaisant de manire honorable les trois points ci-dessus. Ils ont t introduits par Gallager dans les annes 60 []. Ce n'est que dans les annes 90 que MacKay les a redcouverts []. L'intrt des codes LDPC est que la matrice H contient peu de 1 par rapport au nombre de 0, d'o la notion de faible densit. Les codes LDPC permettent de travailler avec des matrices H et G de grandes dimensions (k et n grands) tout en conservant une densit de 1 susamment faible. Ils permettent de s'approcher prs de la limite de Shannon (limite du canal de transmission) et leurs performances sont en concurrence avec celles des turbo-codes. Une particularit des codes LDPC est qu'ils ont dcodage dit itratif. ceci signie qu'il n'est pas question d'eectuer toutes les multiplications matricielles pour le dcodage. Le dcodage se fait par tapes, et l'on se rapproche de plus en plus de c chaque itration.
3.1 Reprsentations possibles
Tanner

Un code LDPC peut avoir deux reprsentations possibles : la matrice H et le diagramme de

3.1.1 Matrice de contrle

Il existe de nombreuses mthodes de construction de la matrice de contrle H , de dimensions (n k) n. Nous pouvons citer les exemples suivants :  Construction fonde sur une approche pseudo-alatoire  Construction fonde sur une approche combinatoire Il est galement ncessaire de prendre en compte des contraintes pour garantir des performances, un certain rendement, agir sur la complexit de la construction des matrices, construire un code systmatique ou non... Il peut exister, par exemple, des matrices dont la construction requiert une grande complexit et dont les performances sont moyennes, ou des matrices dont la construction est relativement simple et dont les performances sont bonnes, ou, tout au contraire, des matrices forte complexit et hautes performances... La notion de complexit et de performance ne trouve pas de dnition universelle, elle doit tre estime en fonction des contraintes que l'on xe et du cadre d'usage du code. Une dicult supplmentaire est pose par la construction de la matrice G partir de la matrice H pour satisfaire la condition GH T = 0. Il peut arriver que la construction de la matrice G soit d'une grande complexit. Gnralement (et dans notre cas), il est commun de commencer par la construction de H puis d'en dduire G.
3.1.2 Graphe de

Tanner

Il existe une reprsentation d'un code LDPC fonde sur les graphes bipartis. Cette reprsentation est appele graphe de Tanner. Un graphe de Tanner comporte des value nodes (v-nodes) et des check nodes (c-nodes). Dans notre rapport, nous allons reprsenter les v-nodes par des cercles et les c-nodes par des carrs. D'une part, on aligne les v-nodes et, d'autre part, on aligne les c-nodes. Ensuite, partir de la matrice H , on tablit des connexions entre les v-nodes et les c-nodes.  Il y a k v-nodes. Ils sont numrots i = 1..k.  Il y a (n k) c-nodes. Ils sont numrots j = 1..(n k).  Le v-node i est reli au c-node j si et seulement si l'lment hji de H la ligne j et la colonne i est gal 1. Un code LDPC est dit rgulier lorsque tous les v-nodes sont connects au mme nombre de c-nodes et rciproquement, lorsque tous les c-nodes sont connects au mme nombre de v-nodes. Du point de vue de H , un code LDPC est dit rgulier si toutes les colonnes de H ont le mme poids (nombre d'elements non nuls). 15

Nous allons prendre, par la suite, l'exemple d'un (8, 4)-code (pas LDPC car les dimensions sont faibles) avec la matrice H suivante :
0 1 H= 0 1 1 1 0 0 0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0 0 0 1 1 1 0 1 0

Le graphe de

Tanner

associ est le suivant :

v1

v2

v3

v4

v5

v6

v7

v8

c1
Figure

c2

c3

c4

8  Graphe de Tanner

Les vi sont les v-nodes et les cj sont les c-nodes. Nous allons maintenant prsenter trois algorithmes de dcodage itratifs.
3.2 Mapping

Avant toute chose, nous devons choisir une modulation. Nous prenons une modulation BPSK. Soit ci le bit mettre et soit si le signal associ. Prenons le mapping suivant :
si = 1 2ci

Nous obtenons la correspondance bit/signal suivante :

ci 0 1
3.3 Dcisions dures

si 1 1

Nous allons prsenter, dans un premier temps, un algorithme bas sur des dcisions dures (hard decision algorithm). Supposons que l'on reoit un signal si . Nous pouvons retrouver le bit ci ainsi :
ci = 1 signe(si ) 2

(2)

Nous obtenons la correspondance signal/bit suivante :

si <0 0 ci 1 0

L'algorithme 1 est l'algorithme bas sur des dcisions dures. 16

Algorithme 1

Algorithme avec dcisions dures 1. Initialisation. Les v-nodes utilisent les signaux reus si et utilisent l'quation (2) pour dterminer les bits correspondants ci . On construit le vecteur Pi de taille n qui comporte les bits ci . Les v-nodes construisent la matrice qij (1) initiale de dimensions (n k) n . L'lment (qij (1))ji la ligne j et la colonne i est le bit ci trouv. Les v-nodes envoient aux c-nodes les messages qij (1). 2. Les c-nodes construisent la matrice rji (1) de dimensions (n k) n. (a) Pour chaque c-node j : i. Pour chaque v-node i reli au c-node j : A. L'lment (rji (1))ji la ligne j et la colonne i est le bit qui satisfait la parit avec les bits des autres v-nodes relis au c-node j en excluant le v-node i (notion d'extrinsque). (b) Les c-nodes envoient aux v-nodes les messages rji (1). 3. Les v-nodes construisent la matrice qij (1) de dimensions (n k) n et le vecteur Qi (1) de taille n. (a) Pour chaque v-node i : i. Pour chaque c-node j reli au v-node i : A. L'lment (qij (1))ji la ligne j et la colonne i est issu du vote majoritaire du bit qui a le plus d'occurrences parmi les bits des c-nodes relis au v-node i en excluant le c-node j (extrinsque). ii. Le bit (Qi (1))i en position i est issu du vote majoritaire du bit qui a le plus d'occurrences parmi le bit ci et les bits des c-nodes relis au v-node i. Le v-node prend une dcision : si ci = (Qi (1))i . (b) Les v-nodes envoient aux c-nodes les messages qij (1). 4. Faire un test de parit y = cH T . Si y = 0 alors Fin sinon Revenir 2. Prenons un exemple avec la matrice H de la section 3.1.2 et les signaux reus suivants :
s= 1.1 0.6 0.8 0.9 1.2 0.6 0.7 0.8

Droulons l'algorithme.
Algorithme 2

Exemple d'excution de l'algorithme avec dcisions dures 1. Initialisation. On dtermine c partir de s et l'on obtient : c = 1 1 0 1 0 1 0 1 . 1 0 0 0 1 0 1 . La matrice qij (1) initiale est la suivante : qij (1) = 1 On pose Pi =
0 0 2. Les c-nodes construisent la matrice rji (1) = 0 1 v-nodes les messages rji (1). 0 1 0 1 1 1 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 1 0 . 1 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 0 . Les c-nodes envoient aux 1 0 0 et le vecteur Qi (1) = 1 0 1 . Les c-nodes 0 1 0 1

0 0 0 1 0 1 0 1 1 0 0 0 0 0 0 0 3. Les v-nodes construisent la matrice qij (1) = 0 0 0 0 0 1 0 1 1 0 0 1 0 0 0 0 1 1 0 1 0 1 0 1 . Le vecteur c est mis jour : c = 1 0 0 1 envoient aux v-nodes les messages rji (1). 4. On calcule le syndrme y = cH T = 0. Ainsi, le mot corrig c = 1 0 0 1

a t trouv.

17

3.4

Dcisions souples

Nous allons maintenant nous intresser deux algorithmes bass sur des dcisions souples.
3.4.1 Mthode probabiliste

Le premier algorithme souple repose sur des calculs de probabilits. Il est ncessaire de connatre a priori la distribution du bruit ajout par le canal. Comme nous avons suppos que le canal tait un CABG, la distribution du bruit suit une loi normale N (0, 2 ). Soit p(yi |si = 1) la vraisemblance .
p(yi |si = 1) = 1 (yi + 1)2 exp 2 2 2 2 1

De mme, pour p(yi |si = +1) :

p(yi |si = +1) = 1 (yi 1)2 exp 2 2 2 2 1

Rgle de Bayes
p(si = 1|yi ) = p(yi |si = 1) p(yi ) p(si = 1)

On dnit un vecteur Pi de taille n.

Pi =

1 1 + exp(2si / 2 )

L'algorithme 3 est l'algorithme bas sur des dcisions souples.

Algorithme 3

Algorithme avec dcisions dures 1 1. Initialisation. On construit le vecteur Pi de taille n : Pi = 1+exp(2si /2 ) . Les v-nodes construisent la matrice qij (1) initiale de dimensions (n k) n . L'lment (qij (1))ji la ligne j et la colonne i est Pi . Les v-nodes envoient aux c-nodes les messages qij (1). 2. Les c-nodes construisent la matrice rji (0) de dimensions (n k) n. (a) Pour chaque c-node j : i. Pour chaque v-node i reli au c-node j :
1 A. L'lment (rji (0))ji la ligne j et la colonne i est donn par : (rji (0))ji = 2 + 1 i Vj \{i} 2 (le i traduit une notion d'extrinsque : le produit s'eectue avec les messages provenant des v-nodes Vj relis au c-node j privs du v-node i).

(b) Les c-nodes envoient aux v-nodes les messages rji (0). 3. Les v-nodes construisent la matrice qij (1) de dimensions (n k) n et le vecteur Qi (1) de taille n. (a) Pour chaque v-node i : i. Pour chaque c-node j reli au v-node i : A. L'lment (qij (1))ji la ligne j et la colonne i est donn par : (qij (1))ji = Kij Pi j Ci \{j} (1 rj i (0)) (le j traduit une notion d'extrinsque : le produit s'eectue avec les messages provenant des c-nodes Ci relis au v-node i privs du c-node j ). ii. Le bit (Qi (1))i en position i est donn par : Ki Pi si (Qi (1))i 0.5 alors ci = 1 sinon ci = 0.
jCi

rji (1). Le v-node prend une dcision :

(b) Les v-nodes envoient aux c-nodes les messages qij (1).

4. Faire un test de parit y = cH T . Si y = 0 alors Fin sinon Revenir 2. 18

On remarquera la prsence de deux constantes de normalisation Kij et Ki . Il faut les calculer. Pour cela, prenons les expressions de qij (1) et qij (0) :
qij (1) = Kij Pi j Ci \{j} rj i (1) qij (0) = Kij (1 Pi ) j Ci \{j} rj i (0)

Or qij (1) + qij (0) = 1 et rj i (1) + rj i (0) = 1 , donc :

Kij Pi
j Ci \{j}

rj i (1) + Kij (1 Pi )

rj i (0) = 1
j Ci \{j} j Ci \{j} rj i (0) j Ci \{j} (1

Kij =

Pi Pi

1 Ci \{j} rj i (1) + (1 Pi ) 1 Ci \{j} rj i (1) + (1 Pi )

Kij =

rj i (1))

Prenons les expressions de Qi (1) et Qi (0) :

Qi (1) = Ki Pi jCi rji (1) Qi (0) = Ki (1 Pi ) jCi rji (0)

Or rji (1) + rji (0) = 1 Qi (1) + Qi (0) = 1, donc :

Ki Pi
jCi

rji (1) + Ki (1 Pi )

rji (0) = 1
jCi

Ki = Ki =
3.4.2

Ki P i Ki P i

1 jCi rji (1) + Ki (1 Pi ) jCi rji (0) = 1 1 jCi (1 rji (0)) + Ki (1 Pi ) jCi rji (0) = 1

Logarithmic Likelihood Ratios

Il existe un autre algorithme de dcisions souples, certes lui aussi fond sur des probabilits, mais cette fois il est bas sur des logarithmes de rapports de probabilits. Cet algorithme est nomm  Logarithmic Likelihood Ratios , que l'on peut traduire par  rapports de vraisemblance logarithmique . Soit un vecteur L(ci ) de taille n, dont l'expression est la suivante :
L(ci ) = ln 1 Pi Pi

Comme dans le paragraphe relatif l'algorithme propagation de croyance,Pi dsigne la probabilit que l'lment i du vecteur ci soit un 1. Une matrice L(qij ) de dimensions (n k) n comporte les messages envoys par les v-nodes vers les c-nodes. Elle est dnie ainsi :
L(qij ) = ln qij (0) qij (1)

Ainsi, si le v-node i envoie un message vers le c-node j , alors ce message est contenu dans [L(qij )]ij . Une matrice L(rij ) de dimensions (n k) n comporte les messages envoys par les c-nodes vers les v-nodes. Elle est dnie ainsi :
L(rji ) = ln rji (0) rji (1)

Ainsi, si le c-node j envoie un message vers le v-node i, alors ce message est contenu dans [L(rji )]ji . L'algorithme LLR ncessite l'utilisation de la fonction tangente hyperbolique. Cette fonction est dnie ainsi : 19

tanh(x)

= =

sinh(x) cosh(x) ex ex ex + ex

L'intrt de l'utilisation de cette fonction est li une proprit bien commode :

1 ln 2 p0 p1 e2 e2 =
1 1

ln ln

tanh

p0 p1 p0 p1 1 2

e +e

1 2 ln 1 2 ln

p0 p1 p0 p1

p0 p1 p0 p1

1 2

p0 p1 p0 p1

1 2 1 2

= =

+1 p0 p1 p0 + p1

p0 p1 p0 p1

Or, comme p0 + p1 = 1, il est possible d'crire :

tanh 1 ln 2 p0 p1 = p0 p1 = = (1 p1 ) p1 1 2p1

(3)

Penchons-nous d'abord sur le calcul de L(rji ). Il est possible d'crire l'quation (3) avec L(rji ), ce qui donne :
tanh 1 L(rji ) 2 = = 1 ln 2 1 2rji (1) tanh

rji (0) rji (1)

Or, le rsultat de Gallagher donne l'expression de rji (0) :

rji (0) = 1 1 + 2 2

Comme rji (1) = 1 rji (0), on peut crire :

tanh 1 L(rji ) 2 =

i Vj \{i}

(1 2qi j (1))

1 2 (1 rij (0)) 1 1 = 1 2 1 + 2 2
i Vj \{i}

i Vj \{i}

(1 2qi j (1))

(1 2qi j (1))

(4)

D'autre part, on peut aussi crire l'quation (3) avec, cette fois, L(qi j ) :
tanh
i Vj \{i}

1 L(qi j ) 2

=
i Vj \{i}

tanh

1 ln 2

qi j (0) qi j (1)

=
i Vj \{i}

(1 2qi j (1))

(5)

20

Les expressions (4) et (5) sont gales, il devient donc possible d'crire :
tanh 1 L(rji ) 2 =
i Vj \{i}

(1 2qi j (1))

(6)

On peut dcomposer chaque lment de L(qij ) en considrant d'une part son signe ij et d'autre part sa norme ij :
L(qij ) ij ij = ij ij = sign (L(qij )) = |L(qij )|

Ainsi, en reprenant l'quation (6) et en eectuant la dcomposition, on obtient :

tanh 1 L(rji ) 2 =
i Vj \{i}

i j

tanh
i Vj \{i}

1 i j 2

En notant tanh

la fonction rciproque de tanh, on peut crire :

i j 2 tanh1 1 i j 2 1 i j 2

L(rji )

=
i Vj \{i}

tanh
i Vj \{i}

De mme, en notant ln1 la fonction rciproque de ln, on a :

L(rji ) =
i Vj \{i}

On dnit une fonction dont l'expression est la suivante :

(x) = ln tanh = ln ex + 1 ex 1

i j 2 tanh1 ln1 ln

tanh

i Vj \{i}

x 2

L(rji )

=
i Vj \{i}

i j 2 tanh1 ln1 i j 2 tanh

1

ln tanh
i Vj \{i}

1 i j 2

=
i Vj \{i}

ln

1 i Vj \{i}

((i j ))

=
i Vj \{i}

Cette expression n'est pas encore trs commode. Nous pouvons encore chercher la simplier. Nous cherchons maintenant savoir si la fonction rciproque 1 de est bien la fonction elle-mme :
1 ((x)) = = = = = ln ln ln eln((e +1)/(e 1)) + 1 eln((ex +1)/(ex 1)) 1
ex +1 ex 1 ex +1 ex 1 x
x x

i j 2 tanh1 ln1

i Vj \{i}

(i j )

(7)

+1

2e 2 x ln(e ) x

21

La fonction rciproque de est donc elle-mme : 1 (x) = (x). Cette proprit nous est trs utile. En eet, grce elle, on a :
ln tanh( x ) 2 2

ln tanh tanh

=x

ln tanh( x ) 2 2

= ln1 (x)

ln tanh( x ) 2 = tanh1 ln1 (x) 2 x ln tanh( ) = 2 tanh1 ln1 (x) 2 2 tanh1 ln1 (x) = (x)

(8)

En utilisant l'galit (8) dans l'quation (7), on obtient :

L(rji ) =
i Vj \{i}

Maintenant, penchons-nous sur le calcul de L(qij ).

i j

i Vj \{i}

(i j )

L(qij )

= =

ln ln

Kij (1 Pi ) Kij Pi 1 Pi Pi 1 Pi Pi 1 Pi Pi

j Ci \{j} rj i (1)

j Ci \{j} rj i (0)

j Ci \{j} rj i (0) j Ci \{j} rj i (1)

= =

ln ln

+ ln +

j Ci \{j}

ln

j Ci \{j}

rj i (0) rj i (1)

rj i (0) rj i (1)

= L(ci ) +
j Ci \{j}

L(rj i )

L(Qi )

= =

ln ln

Ki (1 Pi ) Ki Pi 1 Pi Pi 1 Pi Pi 1 Pi Pi

jCi

rji (0)

jCi jCi jCi

rji (1) rji (0) rji (1) rji (0) rji (1)

= =

ln ln

+ ln +
jCi

jCi

ln

rji (0) rji (1)

= L(ci ) +
jCi

L(rji )

22

Deuxime partie

Implmentation
Dans cette partie, nous prsentons les tests de performances des codes LDPC et leurs implmentations sur MATLAB et en C.
4 Test de Monte Carlo

Nous allons valuer les performances des codes LDPC en calculant le taux d'erreurs binaires. Il existe plusieurs mthodes permettant d'estimer le taux d'erreurs binaires BER. Nous utiliserons la mthode Monte E E et, pour chaque Nb , des expriences sont Carlo. Elle consiste xer des pas rguliers entre des Nb 0 0 dB dB excutes jusqu' ce que le nombre nerr d'erreurs totales cumules atteigne (voire excde) un seuil d'erreurs maximales nerrmax. Ds que le seuil a t atteint, le BER correspondant est calcul. Il est donn par la formule suivante :
BER = nerr n nexp

 nerr dsigne le nombre d'erreurs bits totales cumules.  nexp est le nombre d'expriences totales cumules. L'algorithme 4 prsente l'algorithme de Monte Carlo.
Algorithme 4

Test de Monte Carlo

Eb N0 dB

1. Pour chaque

(a) Mettre le compteur d'erreurs bits cumules zro : nerr = 0 i. Mettre le nombre d'expriences zro nexp = 0 ii. Calculer 2 = 2k10(En/N0 )dB b iii. Tant que le nombre maximal d'erreurs cumules n'a pas t atteint, c'est--dire Tant que nerr nerrmax : A. B. C. D. E. F. G. H. Gnrer un u alatoire de longueur k bits Coder c = uG Faire le mappnig BPSK s = 1 2c Ajouter le bruit gaussien N (0, 2 ) : s = s + bruit Dcoder = corriger et trouver c Calculer le nombre d'erreurs bits, c'est--dire la distance entre c et c Ajouter le nombre d'erreurs bits au compteur d'erreurs bits cumules nerr Incrmenter nexp

iv. Calculer le BER Il devient possible de tracer les BER en fonction des
5 Implmentation sur MATLAB
Eb N0

dB

l'issue du test de Monte Carlo.

Dans un premier temps, nous implmentons un systme de codage/dcodage sur MATLAB. L'avantage principal de MATLAB est que les donnes sont traites sous forme de tableaux : des matrices et des vecteurs. Il est simple d'eectuer des oprations entre matrices et vecteurs (additions, multiplications, produits scalaires...) Il est galement possible d'eectuer une opration sur toutes les donnes d'un vecteur : signe, racine carre, logarithme, etc., ce qui facilite la programmation. Nous allons examiner, tour tour, les briques du projet sur MATLAB. 23

5.1

Importation de la matrice

Nous avons utilis les matrices de contrle du site de MacKay, dans sa base de donnes de codes LDPC, qui propose des matrices au format alist. Nous avons d utiliser une librairie permettant d'importer des matrices au format alist. Nous pouvons disposer de matrices H , mais comment faire pour trouver la matrice G correspondant chaque H et satisfaisant la condition GH T = 0 ?
5.2 Construction de

MacKay propose sur son site des scripts Perl qui permettent de dterminer G partir d'une matrice H que l'on fournit en entre. Or, pour utiliser ces scripts Perl, nous avons d installer l'environnement Cygwin (qui nous servira plus tard pour l'implmentation en C) et nous avons install l'interprteur Perl. MacKay propose les scripts suivants :  A2H.p : conversion d'un chier alist en chier contenant des 0 et des 1  G2H.p : permet de dterminer une matrice G partir d'une matrice H (le sens inverse est aussi possible) et cre un chier contenant des 0 et des 1 dcrivant la matrice G  raw2A.p : convertit un chier avec des 0 et des 1 en chier alist Nous avons crit des scripts pour automatiser le calcul des G pour direntes H . Il sut de disposer toutes les matrices H dans un rpertoire que nous appelons alist. Nous appelons ensuite nos scripts et ceux-ci permettent de stocker les G trouves dans un rpertoire que nous appelons sim. Code du script auto_mat.sh :

Code du script
#! / b i n / b a s h

alist_to_gh.sh

. /A2H . p < $1 > $2 / hbin . /G2H . p G f i l e=$2 / hbin writeH=$2 / g b i n . / raw2A . p < $2 / g b i n > $2 /$1_g . / raw2A . p < $2 / hbin > $2 /$1_h rm f $2 / .pbm $2 / b i n

Il sut d'appeler en console Cygwin :

. / auto_mat . sh a l i s t sim
alist2sparse

Ensuite, il faut que les matrices H et G soient exploitables sur MATLAB. Pour cela, il sut d'utiliser , une librairie.
Test de Monte Carlo

5.3

Le test de Monte Carlo, dcrit dans la section 4, a t implment sur MATLAB sous forme de script start_mc.m :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
%S t a r t s % %s t a r t _ m c ( h O b j e c t , % %h O b j e c t : %h a n d l e s : %t y p e : % % hObject handles = = ( from ( from GUI ) . GUI ) . m e s s a g e p a s s i n g . m e s s a g e p a s s i n g . logarithmic likelihood ratios . , , handles , type ) a MonteC a r l o test .

' hmp ' ' smp ' ' sllr '

= h a r d d e c i s i o n ,

d e c i s i o n s o f t d e c i s i o n
soft

function start_mc ( hObject , h a n d l e s , type ) set ( h a n d l e s . s t a t u s , ' S t r i n g ' , ' Busy ' ) ; if strcmp ( type , 'hmp ' ) == 1 set ( h a n d l e s . checkbox_hmp , ' Value ' , get ( h a n d l e s . checkbox_hmp , 'Max ' ) ) ; elseif strcmp ( type , ' smp ' ) == 1 set ( h a n d l e s . checkbox_smp , ' Value ' , get ( h a n d l e s . checkbox_smp , 'Max ' ) ) ; elseif strcmp ( type , ' s l l r ' ) == 1 set ( h a n d l e s . c h e c k b o x _ s l l r , ' Value ' , get ( h a n d l e s . c h e c k b o x _ s l l r , 'Max ' ) ) ; end
24

22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90

g u i d a t a ( hObject , h a n d l e s ) ;

pause ( 0 . 5 ) ;
H = h a n d l e s .H; G = h a n d l e s .G; [k, n] =

size (G) ;

itermax = str2double ( ( h a n d l e s . edit_itermax , ' S t r i n g ' ) ) ; expmax = s t r 2 d o u b l e ( ( h a n d l e s . edit_expmax , ' S t r i n g ' ) ) ; nerrmax = s t r 2 d o u b l e ( ( h a n d l e s . edit_nerrmax , ' S t r i n g ' ) ) ; ebn0min = s t r 2 d o u b l e ( ( h a n d l e s . edit_ebn0min , ' S t r i n g ' ) ) ; ebn0step = str2double ( ( handles . edit_ebn0step , ' S t r i n g ' ) ) ; ebn0max = s t r 2 d o u b l e ( ( h a n d l e s . edit_ebn0max , ' S t r i n g ' ) ) ; ebn0 = ebn0min : e b n 0 s t e p : ebn0max ; sigma2 = n . / ( 2 k 10 . ^ ( ebn0 . / 1 0 ) ) ;

get get get get get get

length ( sigma2 ) ; bermeans = zeros ( 1 , nsigma ) ; i t e r m e a n s = zeros ( 1 , nsigma ) ; t _ s t a r t _ t e s t = tic ( ) ; for i = 1 : nsigma
nsigma = nerrsum = 0 ; itersum = 0; nexp = 0 ;

while 1 if get ( h a n d l e s . r a d i o b u t t o n _ f i x e d n e r r m a x , ' Value ' ) == get ( h a n d l e s . r a d i o b u t t o n _ f i x e d n e r r m a x , 'Max ' ) if nerrsum >= nerrmax break ; end elseif get ( h a n d l e s . radiobutton_fixedexpmax , ' Value ' ) == get ( h a n d l e s . radiobutton_fixedexpmax , 'Max ' ) if nexp > expmax break ; end end
nexp = nexp + 1 ; msg = randmsg ( k ) ; code_msg = cod_msg (G, msg ) ; bpsk_sig = bpsk_map ( code_msg ) ; mod_sig = awgn_chan ( bpsk_sig , sigma2 ( i ) ) ;

if strcmp ( type , 'hmp ' ) == 1 [ i t e r , c o r r e c t e d ] = corr_hmp (H, mod_sig , i t e r m a x ) ; elseif strcmp ( type , ' smp ' ) == 1 [ i t e r , c o r r e c t e d ] = corr_smp (H, mod_sig , itermax , sigma2 ( i ) ) ; elseif strcmp ( type , ' s l l r ' ) == 1 [ i t e r , c o r r e c t e d ] = c o r r _ s l l r (H, mod_sig , itermax , sigma2 ( i ) ) ; end
n e r r = b i t _ e r r ( code_msg , c o r r e c t e d ) ;

end

nerrsum = nerrsum + n e r r ; itersum = itersum + i t e r ;

bermeans ( i ) = nerrsum / ( n nexp ) ; i t e r m e a n s ( i ) = i t e r s u m / nexp ;

25

91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112

end
ttot =

toc ( t _ s t a r t _ t e s t ) ;

p l o t _ n e r r _ i t e r ( ebn0 , bermeans , i t e r m e a n s , k , n ,

if strcmp ( type , 'hmp ' ) == 1 set ( h a n d l e s . checkbox_hmp , ' Value ' , get ( h a n d l e s . checkbox_hmp , ' Min ' ) ) ; elseif strcmp ( type , ' smp ' ) == 1 set ( h a n d l e s . checkbox_smp , ' Value ' , get ( h a n d l e s . checkbox_smp , ' Min ' ) ) ; elseif strcmp ( type , ' s l l r ' ) == 1 set ( h a n d l e s . c h e c k b o x _ s l l r , ' Value ' , get ( h a n d l e s . c h e c k b o x _ s l l r , ' Min ' ) ) ; end set ( h a n d l e s . s t a t u s , ' S t r i n g ' , s t r c a t ( num2str ( t t o t ) , ' s , N_1= ' , num2str ( nnz (H)
))); g u i d a t a ( hObject , h a n d l e s ) ;

type ) ;

/ (n (n k) )

load end
5.4

handel ; so undsc ( y ) ;

Gnration d'un message

alatoire

Une fonction de gnration d'une suite de bits alatoire a t crite. rand(1, n) permet de gnrer un vecteur de dimensions 1 n de nombres pseudo-alatoires uniformment rpartis dans [0, 1]. round permet d'arrondir les nombres du vecteur. S'ils sont infrieurs 0.5, on obtient 0, s'ils sont suprieurs 0.5, on obtient 1. Comme la distribution est uniforme, les 0 et les 1 peuvent tre considrs comme quirpartis.
1 2 3 4 5 6 7 8 9 10 11 12 13 14
%G e n e r a t e s % %[ b i t s ] % %n : % %R e t u r n s : %b i t s : vector of random bits . number of bits to generate . = randmsg ( n ) a vector of random bits .

function [ b i t s ] = randmsg ( n ) b i t s = round ( rand ( 1 , n ) ) ; end

5.5 Codage

Le codage c = uG s'eectue par une simple multiplication en modulo 2.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
%E n c o d e s % %[ c o d e ] % % G: % %R e t u r n s : %c o d e : encoded message . generator matrix . to be encoded . %m e s s a g e : message = cod_msg (G, message ) a message with a generator matrix .

function end

[ code ] = cod_msg (G, message )

code = mod( message G, 2 ) ;

26

5.6

Mapping BPSK

Le mapping BPSK s'eectue grce une opration ralise de manire vectorielle, bien pratique sur MATLAB.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
% BPSK mapping . %s = 1 % %b %0 %1 % %[ s y m b o l s ] % %b i t s : % %R e t u r n s : %s y m b o l s : vector of symbols . vector of bits . = bpsk_map ( b i t s )

> s > 1 > 1

function end
5.7

[ symbols ] = bpsk_map ( b i t s )

symbols = 1 2 b i t s ;

Canal Additif Blanc Gaussien

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Le canal additif blanc gaussien ajoute au signal un bruit blanc gaussien de norme nulle et de variance 2 . La fonction normrnd gnre des nombres pseudo-alatoires de distribution gaussienne (normale) et prend pour paramtres la moyenne, la dviation ( ) et les dimensions du vecteur de nombres alatoires gnrer (ici 1 longeur(signal)).
%S i m u l a t e s % %[ o u t ] % %i n : % %R e t u r n s : %o u t : output vector . input vector . %s i g m a 2 : variance . = awgn_chan ( i n , sigma2 ) an A G W N channel ( Additive White Gaussian Noise ) .

function end
5.8
5.8.1

[ out ] = awgn_chan ( in , sigma2 )

out = i n + normrnd ( 0 ,

sqrt ( sigma2 ) ,

1,

length ( i n ) ) ;

Dcodage
Dcisions dures
to perform with to be the an error in the detection case of and a correction of a coded message

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

%T r i e s

%r e c e i v e d %I n t e n d e d %s =12b . % %[ i t e r , % % : H

m e s s a g e p a s s i n g

algorithm

( h a r dd e c i s i o n ) . and a BPSK mapping

used

an A G W N channel

corrected ]

= corr_hmp (H,

sig_bpsk ,

itermax )

p a r i t y c h e c k signal max

matrix . received . of iterations .

%s i g _ b p s k : %i t e r m a x : % %R e t u r n s : %i t e r :

number

number

of

iterations message

performed . corrected .

%c o r r e c t e d :

coded

hypothetically

function

[ i t e r , c o r r e c t e d ] = corr_hmp (H, sig_bpsk , i t e r m a x )

27

17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

end

[ q i j 1 , Pi ] = qij_init_hmp (H, sig_bpsk ) ; par_chk (H, Pi ) == 0 iter = 0; c o r r e c t e d = Pi ; ;

if

return

while

iter = 0; i t e r < itermax iter = iter + 1; [ r j i 1 ] = c_to_v_hmp(H, q i j 1 ) ; [ q i j 1 , c o r r e c t e d ] = v_to_c_hmp(H, r j i 1 , sig_bpsk ) ; par_chk (H, c o r r e c t e d ) == 0 ;

end end
%

if break end

Initialisation
%Hard d e c i s i o n , %[ q i j 1 , % % : H % %R e t u r n s : %q i j 1 : %P i : intiialized matrix of q i j (1) . probabilities to have a 1. initialized vector p a r i t y c h e c k signal matrix . received . %s i g _ b p s k : Pi ] m e s s a g e p a s s i n g algorithm . Initializes the matrix q i j (1) . = q i j _ i n i t _ h m p (H, sig_bpsk )

function
qij1 = Pi =

[ q i j 1 , Pi ] = qij_init_hmp (H, sig_bpsk )

[ ncnodes , nvnodes ] =

for end end

zeros ( ncnodes , nvnodes ) ; ( 1 sign ( sig_bpsk ) ) . / 2 ; find (H( : ,

i));

size (H) ;

i = 1 : nvnodes ind_cnodes =

q i j 1 ( ind_cnodes , i ) = Pi ( i ) ;

Messages des v-nodes vers les c-nodes

%Hard d e c i s i o n , %M e s s a g e s % %[ q i j 1 , % % : H p a r i t y c h e c k matrix signal matrix . received . %r j i 0 : % %R e t u r n s : %q i j 1 : matrix q i j (1) . of decisions taken . %d e c i s i o n s : vector r j i (0) . decisions ] = v_to_c_hmp (H, rji1 , sig_bpsk ) from m e s s a g e p a s s i n g the V nodes to algorithm . C nodes . the

%s i g _ b p s k :

function
qij1 =

[ q i j 1 , d e c i s i o n s ] = v_to_c_hmp(H, r j i 1 , sig_bpsk )

[ ncnodes , nvnodes ] =

zeros ( ncnodes , nvnodes ) ; d e c i s i o n s = zeros ( 1 , nvnodes ) ;

28

size (H) ;

21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

for

i = 1 : nvnodes ind_cnodes =

find (H( : , sum(H( : ,

i), i);

nnzsum = r j i 1 ( ind_cnodes , i ) + ( 1 weightvnode = i)); + 1) / 2

sign ( sig_bpsk ( i ) ) )

/ 2;

if nnzsum > ( weightvnode decisions ( i ) = 1; else decisions ( i ) = 0; end for j = ind_cnodes if nnzext > qij1 (j , else qij1 (j , end

nnzext = nnzsum r j i 1 ( j , i ) ; weightvnode / 2 i ) = 1; i ) = 0;

end end

end

Messages des c-nodes vers les v-nodes

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
%Hard d e c i s i o n , %M e s s a g e s % %[ r j i 1 ] % % : H % %R e t u r n s : %r j i 1 : matrix r j i (1) . p a r i t y c h e c k matrix matrix . %q i j 1 : q i j (1) . = c_to_v_hmp (H, qij1 ) from m e s s a g e p a s s i n g the C nodes to algorithm . V nodes . the

function
rji1 =

[ r j i 1 ] = c_to_v_hmp(H, q i j 1 )

[ ncnodes , nvnodes ] =

for

zeros ( ncnodes ,

size (H) ;
nvnodes ) ;

j = 1 : ncnodes

find (H( j , : ) ) ; sumvnodes = sum ( q i j 1 ( j , ind_vnodes ) ) ;

ind_vnodes = r j i 1 ( j , ind_vnodes ) = mod( sumvnodes + q i j 1 ( j , ind_vnodes ) , 2 ) ;

end end
5.8.2 Dcisions souples, mthode probabiliste
to perform with to be the an error in the detection case of and a correction ( soft of a coded message %T r i e s %r e c e i v e d %I n t e n d e d %s =12b . % %[ i t e r , % % : H p a r i t y c h e c k matrix . corrected ] = corr_smp (H, sig_bpsk , itermax , sigma2 ) m e s s a g e p a s s i n g algorithm

1 2 3 4 5 6 7 8

d e c i s i o n ) .
and a BPSK mapping

used

an A G W N channel

29

9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

%s i g _ b p s k : %i t e r m a x : %s i g m a 2 : % %R e t u r n s : %i t e r :

signal max

received . of iterations .

number

variance .

number

of

iterations message

performed . corrected .

%c o r r e c t e d :

coded

hypothetically

function while

[ i t e r , c o r r e c t e d ] = corr_smp (H, sig_bpsk , itermax , sigma2 )

[ q i j 1 , Pi ] = qij_init_smp (H, sig_bpsk , sigma2 ) ; iter = 0; i t e r < itermax iter = iter + 1; [ r j i 0 ] = c_to_v_smp (H, q i j 1 ) ; [ q i j 1 , c o r r e c t e d ] = v_to_c_smp (H, Pi , r j i 0 , sig_bpsk ) ; par_chk (H, c o r r e c t e d ) == 0 ;

end end
%

if break end

Initialisation
%S o f t d e c i s i o n , %[ q i j 1 , % % : H p a r i t y c h e c k signal matrix . received . %s i g _ b p s k : %s i g m a 2 : % %R e t u r n s : %q i j 1 : %P i : intiialized matrix of q i j (1) . probabilities to have a 1. initialized vector Pi ] m e s s a g e p a s s i n g algorithm . Initializes the matrix q i j (0) . = q i j _ i n i t _ s m p (H, sig_bpsk , sigma2 )

variance .

function
qij1 = Pi = 1

[ q i j 1 , Pi ] = qij_init_smp (H, sig_bpsk , sigma2 )

[ ncnodes , nvnodes ] =

for end end

zeros ( ncnodes , . / ( 1 + exp ( ( 2 find (H( : ,

size (H) ;
nvnodes ) ; / sigma2 ^ 2 ) sig_bpsk ) ) ;

i = 1 : nvnodes qij1 ( i ) ) , i ) = Pi ( i ) ;

Messages des v-nodes vers les c-nodes

%S o f t d e c i s i o n , %M e s s a g e s % %[ L q i j , % % : H p a r i t y c h e c k vector matrix Lci . L( r j i ) . received . matrix . %L c i : %L r j i : % %R e t u r n s : %L q i j : matrix L( q i j ) . of decisions taken . %d e c i s i o n s : vector decisions ] = v _ t o _ c _ s l l r (H, Lci , Lrji , sig_bpsk ) from LLR the algorithm . to the C nodes . V nodes

%s i g _ b p s k :

signal

function

[ L q i j , d e c i s i o n s ] = v_to_c_sllr (H, Lci , L r j i , sig_bpsk )

[ ncnodes , nvnodes ] =

size (H) ;
30

18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

LQi = Lqij =

zeros ( 1 , nvnodes ) ; zeros ( ncnodes , nvnodes ) ; d e c i s i o n s = zeros ( 1 , nvnodes ) ; for i = 1 : nvnodes ind_cnodes = find (H( : , i ) ) ; sumcnodes = sum ( L r j i ( ind_cnodes ,
LQi ( i ) = L c i ( i ) + sumcnodes ;

i));

if LQi ( i ) > 0 decisions ( i ) = elseif LQi ( i ) < 0 decisions ( i ) = else decisions ( i ) = end end end

0; 1; (1

sign ( sig_bpsk ( i ) ) )

/ 2;

L q i j ( ind_cnodes , i ) = LQi ( i ) L r j i ( ind_cnodes , i ) ;

Messages des c-nodes vers les v-nodes

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
%S o f t d e c i s i o n , %M e s s a g e s % %[ L r j i ] % % : H % %R e t u r n s : %L r j i : matrix L( r j i ) . p a r i t y c h e c k matrix matrix . %L q i j : L( q i j ) . = c _ t o _ v _ s l l r (H, Lqij ) from LLR the algorithm . to the V nodes . C nodes

function
Lrji =

[ L r j i ] = c_to_v_sllr (H, L q i j )

[ ncnodes , nvnodes ] =

for

zeros ( ncnodes ,

size (H) ;
nvnodes ) ;

j = 1 : ncnodes ind_vnodes = a l p h a = sign ( L q i j ( j , ind_vnodes ) ) ; beta = abs ( L q i j ( j , ind_vnodes ) ) ; pdt1 = prod ( a l p h a ) ; sum2 = max(10^( 10) , sum ( l n t a n h ( beta ) ) ) ; L r j i ( j , ind_vnodes ) = ( pdt1 . / sign ( L q i j ( j , ( j , ind_vnodes ) ) ) ) ;

find (H( j ,

:) ) ;

ind_vnodes ) ) ) . l n t a n h ( sum2 l n t a n h (

abs ( L q i j

end end
5.8.3 Dcisions souples LLR
to perform with to be the an error in the detection case of and a correction ( soft of a coded message %T r i e s %r e c e i v e d %I n t e n d e d %s =12b . % %[ i t e r , corrected ] = c o r r _ s l l r (H, sig_bpsk , itermax , sigma2 ) m e s s a g e p a s s i n g algorithm

1 2 3 4 5 6

d e c i s i o n ) .
and a BPSK mapping

used

an A G W N channel

31

7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

% % : H p a r i t y c h e c k signal maximum variance . matrix . received . number of iterations . %s i g _ b p s k : %i t e r m a x : %s i g m a 2 : % %R e t u r n s : %i t e r : number of iterations message performed . corrected . %c o r r e c t e d : coded hypothetically

function while

[ i t e r , c o r r e c t e d ] = c o r r _ s l l r (H, sig_bpsk , itermax , sigma2 )

[ L q i j , L c i ] = q i j _ i n i t _ s l l r (H, sig_bpsk , sigma2 ) ; iter = 0; i t e r < itermax iter = iter + 1; [ L r j i ] = c_to_v_sllr (H, L q i j ) ; [ L q i j , c o r r e c t e d ] = v_to_c_sllr (H, Lci , L r j i , sig_bpsk ) ; par_chk (H, c o r r e c t e d ) == 0 ;

end end
%

if break end

Initialisation
%S o f t d e c i s i o n , %[ L q i j , % % : H p a r i t y c h e c k signal matrix . received . %s i g _ b p s k : %s i g m a 2 : % %R e t u r n s : %L q i j : %L c i : intiialized initialized matrix vector L( q i j ) . of ln ((1 Lci ] = LLR algorithm . Initializes sig_bpsk , the matrix L( q i j ) . q i j _ i n i t _ s l l r (H, sigma )

variance .

Pi )

./

Pi ) .

function
Lqij =

[ L q i j , L c i ] = q i j _ i n i t _ s l l r (H, sig_bpsk , sigma2 )

[ ncnodes , nvnodes ] =

zeros ( ncnodes , find (H( : ,

size (H) ;
nvnodes ) ;

L c i = ( 2 / sigma2 ) sig_bpsk ;

for end end

i = 1 : nvnodes Lqij ( i ) ) , i ) = Lci ( i ) ;

Messages des v-nodes vers les c-nodes

%S o f t d e c i s i o n , %M e s s a g e s % %[ L q i j , % % : H p a r i t y c h e c k vector matrix Lci . L( r j i ) . received . matrix . %L c i : %L r j i : % %R e t u r n s : %L q i j : matrix L( q i j ) . of decisions taken . %d e c i s i o n s : vector decisions ] = v _ t o _ c _ s l l r (H, Lci , Lrji , sig_bpsk ) from LLR the algorithm . to the C nodes . V nodes

%s i g _ b p s k :

signal

function

[ L q i j , d e c i s i o n s ] = v_to_c_sllr (H, Lci , L r j i , sig_bpsk )

32

16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

[ ncnodes , nvnodes ] = LQi = Lqij =

zeros ( 1 , nvnodes ) ; zeros ( ncnodes , nvnodes ) ; d e c i s i o n s = zeros ( 1 , nvnodes ) ; for i = 1 : nvnodes ind_cnodes = find (H( : , i ) ) ; sumcnodes = sum ( L r j i ( ind_cnodes ,
LQi ( i ) = L c i ( i ) + sumcnodes ;

size (H) ;

i));

if LQi ( i ) > 0 decisions ( i ) = elseif LQi ( i ) < 0 decisions ( i ) = else decisions ( i ) = end end end

0; 1; (1

sign ( sig_bpsk ( i ) ) )

/ 2;

L q i j ( ind_cnodes , i ) = LQi ( i ) L r j i ( ind_cnodes , i ) ;

Messages des c-nodes vers les v-nodes

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
%S o f t d e c i s i o n , %M e s s a g e s % %[ L r j i ] % % : H % %R e t u r n s : %L r j i : matrix L( r j i ) . p a r i t y c h e c k matrix matrix . %L q i j : L( q i j ) . = c _ t o _ v _ s l l r (H, Lqij ) from LLR the algorithm . to the V nodes . C nodes

function
Lrji =

[ L r j i ] = c_to_v_sllr (H, L q i j )

[ ncnodes , nvnodes ] =

for

zeros ( ncnodes ,

size (H) ;
nvnodes ) ;

j = 1 : ncnodes ind_vnodes = a l p h a = sign ( L q i j ( j , ind_vnodes ) ) ; beta = abs ( L q i j ( j , ind_vnodes ) ) ; pdt1 = prod ( a l p h a ) ; sum2 = max(10^( 10) , sum ( l n t a n h ( beta ) ) ) ; L r j i ( j , ind_vnodes ) = ( pdt1 . / sign ( L q i j ( j , ( j , ind_vnodes ) ) ) ) ;

find (H( j ,

:) ) ;

ind_vnodes ) ) ) . l n t a n h ( sum2 l n t a n h (

abs ( L q i j

end end
5.9 Courbes de rsultats

L'valuation des performances du code LDPC

1 2
%P l o t s % the results of a MonteC a r l o test .

33

3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

%p l o t _ n e r r _ i t e r ( e b n 0 , % %e b n 0 : %b e r : %k : %n : % vector means of of of of of SNR . of BER .

ber ,

itermeans )

%i t e r m e a n s : length length type

means a a

nu m b er s

of

iterations .

message . coded code message . = hard = m e s s a g e p a s s i n g , soft LLR) ' smp ' = soft ' sllr ' ( ' hmp '

%t y p e :

m e s s a g e p a s s i n g ,

function

p l o t _ n e r r _ i t e r ( ebn0 , ber , i t e r m e a n s , k , n ,

without_cod = q f u n c (

figure ( 1 ) ; subplot ( 1 , 2 , 1 ) ; plot ( ebn0 , ber , 'o ' ) ; hold on ; plot ( ebn0 , without_cod , ' r ' ) ; xlabel ( ' (Eb/N0)_{dB} ' ) ; ylabel ( 'BER ' ) ; title ( s t r c a t ( ' k= ' , num2str ( k ) , ' , n= ' , num2str ( n ) , ' , type= ' , type ) ) ; subplot ( 1 , 2 , 2 ) ; plot ( ebn0 , i t e r m e a n s , 'o ' ) ; xlabel ( ' (Eb/N0)_{dB} ' ) ; ylabel ( ' i t e r ' ) ; title ( s t r c a t ( ' k = ' , num2str ( k ) , ' , n= ' , num2str ( n ) , ' , type= ' , type ) ) ; figure ( 2 ) ; semilogy ( ebn0 , ber , 'o ' ) ; hold on ; semilogy ( ebn0 , without_cod , ' r ' ) ; xlabel ( ' (Eb/N0)_{dB} ' ) ; ylabel ( 'BER_{ ( l o g 1 0 ) } ' ) ; title ( s t r c a t ( ' k= ' , num2str ( k ) , ' , n= ' , num2str ( n ) , ' , type= ' , type ) ) ; end
5.10 Interface graphique

sqrt ( 2 )

10 . ^ (

sqrt ( k

type )

/ n ) ebn0 . / 2 0 ) ) ;

img interf
6
6.1

Implmentation en C
Environnement de dveloppement

Nous avons choisi d'utiliser l'environnement  UNIX-like  sur Windows nomm Cygwin. Les programmes ont t crits en C et la compilation a t assure avec le compilateur GNU GCC dans sa version 4.
6.2 6.3 Fonctions essentielles et primitives Gnration de nombres alatoires de distribution gaussienne

Algorithme de Box Muller

6.4
6.4.1

Structure des donnes

Format des donnes de

et

1 2 3 4 5 6

#include
/ / File

" f i l . h"
and saving a matrix / vector from / t o a file

Loading

>

sparse

matrix

34

7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

/ Loads char struct a sparse sm a t matrix nameof from the a file . which contains the matrix . matrix . filename : file

sparsematrix :

sparse

void

file_to_smat (

unsigned unsigned unsigned unsigned unsigned

char f i l e n a m e , struct int nrows ; int n c o l s ; int c t r e l t = 0 ; int c t r l i n e = 0 ; int e l t ;

smat s p a r s e m a t r i x )

FILE f i l e s m a t = f o p e n ( f i l e n a m e , " r " ) ; f s c a n f ( f i l e s m a t , "%d" , &nrows ) ; f s c a n f ( f i l e s m a t , "%d" , &n c o l s ) ; create_smat ( s p a r s e m a t r i x , nrows , n c o l s ) ;

while ( f s c a n f ( f i l e s m a t , if ( e l t == 0 ) {
}

"%d" , &e l t ) != EOF) {

c t r l i n e ++; ctrelt = 0;

else

if ( c t r e l t == 0 ) { if ( c t r l i n e <= nrows ) c r e a t e _ l s t (&( s p a r s e m a t r i x else

}

> rows [ c t r l i n e 1 ] ) , e l t ) ;

c r e a t e _ l s t (&( s p a r s e m a t r i x > c o l s [ c t r l i n e nrows 1]) , elt ) ;

else

if ( c t r l i n e else

<= nrows ) c h g _ l s t (&( s p a r s e m a t r i x > rows [ c t r l i n e 1 ] ) , c t r e l t , elt ) ; c h g _ l s t (&( s p a r s e m a t r i x > c o l s [ c t r l i n e nrows 1 ] ) , ctrelt , elt ) ;

} } c t r e l t ++;

} }
// void

fclose ( filesmat ) ;
file_to_smat ( char filename , struct sm at sparsematrix )

6.4.2

Test de Monte Carlo

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

#include
/ / / Performs

"mc . h"
test test

MonteC a r l o MonteC a r l o

/
and thread management

MonteC a r l o the

test

including of the the

the

generation

of and

random error

message ,

its

encoding , Thread

the

BPSK mapping , management char char char short short fileG : fileH : algo : int file file

simulation contains contains the output

an A G W N channel generator

the

correction .

included . which which of matrix . matrix . 3 = LLR . limit fixed by the number of p a r i t y c h e c k 2 = of the is soft

nameout :

name

file . m e s s a g e p a s s i n g , of errors , 2 = iterations . number fixed by

1 = hard itermax :

m e s s a g e p a s s i n g , maximum limit number by fixed

unsigned

limit_type : int

1 =

experiences . unsigned double double limit : SNR limit step whose in in dB . type limit_type . snrmin : snrstep : minimum SNR dB .

35

18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85

double

snrmax :

maximum SNR

in

dB .

void

char f i l e G , char f i l e H , char nameout , short a l g o , unsigned int itermax , short unsigned int l i m i t , double snrmin , double s n r s t e p , double snrmax ) unsigned int nerrsum ; unsigned int i t e r ; unsigned int i t e r s u m ; unsigned int nexp ; double s n r = snrmin ; double sigma2 ; struct vec message ; struct vec code_msg ; struct vec bpsk_sig ; struct vec mod_sig ; struct vec c o r r e c t e d ; struct smat G; f i l e _ t o _ s m a t ( f i l e G , &G) ; struct smat H;
start_mc ( limit_type , f i l e _ t o _ s m a t ( f i l e H , &H) ; FILE f i l e o u t ; f i l e o u t = f o p e n ( nameout , "w" ) ; f p r i n t f ( f i l e o u t , "6 %d %d %d\n" , G. nrows , G. n c o l s , a l g o ) ;

while ( s n r <= snrmax )

nerrsum = 0 ; iter = 0; itersum = 0; nexp = 0 ; sigma2 = (

double )G. n c o l s

/ (2.0 (

double )G. nrows

pow ( 1 0 . 0 , s n r / 1 0 . 0 ) ) ;

p r i n t f ( " s n r = %.15 f dB\n" , s n r ) ;

while ( 1 )

if ( l i m i t _ t y p e == 1 ) { if ( nerrsum > l i m i t ) break ; } else if ( l i m i t _ t y p e == 2 ) { if ( nexp > l i m i t ) break ;

} nexp++; randmsg(&message , G. nrows ) ; cod_msg (G, message , &code_msg ) ; bpsk_map ( code_msg , &bpsk_sig ) ; awgn_chan ( bpsk_sig , &mod_sig , sigma2 ) ;

switch ( a l g o ) case case case

{ 1:

break ;
2:

corr_hmp (H, mod_sig , itermax , &i t e r , &c o r r e c t e d ) ;

break
3:

corr_smp (H, mod_sig , itermax , sigma2 , &i t e r , & corrected ) ; ; c o r r _ s l l r (H, mod_sig , itermax , sigma2 , &i t e r , & corrected ) ; ;

break

36

86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111

default :
}

break ;

nerrsum += b i t _ e r r ( code_msg , c o r r e c t e d ) ; i t e r s u m += i t e r ; f r e e _ v e c (&message ) ; f r e e _ v e c (&code_msg ) ; f r e e _ v e c (& bpsk_sig ) ; f r e e _ v e c (&mod_sig ) ; f r e e _ v e c (& c o r r e c t e d ) ;

} nexp ;

f p r i n t f ( f i l e o u t , " %.15 f %.15 f %.15 f %.15 f %d %d\n" , snr , sigma2 , ( ) nerrsum / ( ) (G. n c o l s nexp ) , ( ) itersum / ( ) nexp , nerrsum , nexp ) ;

double

double

double

double

s n r += s n r s t e p ;

fclose ( fileout ) ; free_smat (&H) ; free_smat (&G) ;

// void short start_mc ( char limit_type , fileG , char int fileH , char nameout , short algo , unsigned double int itermax , unsigned limit , double snrmin , double snrstep , snrmax )

6.4.3

Gnration d'un message

alatoire

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

/ Generates struct unsigned unsigned a int int message message : n: with of random to to bits . the the message . to generate . seed . vec pointer pointer

number

elements

seed :

void

randmsg (

struct vec unsigned int k ; for ( k = 1

message ,

unsigned int

n)

c r e a t e _ v e c ( message , n ) ; ; k < n + 1 ; k++) chg_vec ( message , k , round ( (

vec message ,

//

void

randmsg ( s t r u c t

unsigned

double ) rand ( )
int n)

/ (

double )RAND_MAX) ) ;

6.4.4

Codage

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

/ Encodes struct struct struct a vec vec message by using message coded a generator to be m a t r i x G. sm a t G: generator matrix . encoded . message .

message :

code_msg :

void

cod_msg (

int j ; unsigned int unsigned int double sum0 ; for ( j

struct

smat G, index ; count ;

struct

vec message ,

struct

vec code_msg )

c r e a t e _ v e c ( code_msg , G. n c o l s ) ; = 0 ; j < G. n c o l s ; j ++) { sum0 = 0 ;

while ( ( i n d e x

count = 0 ;

= r e a d _ l s t (G. c o l s [ j ] , &count ) ) != 0 ) {

37

22 23 24 25 26 27

} }
// void

sum0 += read_vec ( message , i n d e x ) ;

chg_vec ( code_msg , j + 1 , (
cod_msg ( s t r u c t sm at G, struct

double ) ( ( unsigned int ) sum0 %

message , struct vec

2) ) ;

vec

code_msg )

6.4.5

Mapping BPSK

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

/ BPSK mapping . s = 1 b 0 1

> s > 1 > 1

struct struct

vec vec

bits :

bits . resulting symbols .

symbols :

void

bpsk_map (

struct unsigned int for ( k = 1

vec b i t s , k;

struct

vec symbols )

c r e a t e _ v e c ( symbols , b i t s . n ) ; ; k < b i t s . n + 1 ; k++) chg_vec ( symbols , k , 1 . 0 2 . 0 read_vec ( b i t s , k ) ) ;

vec bits , struct vec symbols )

//

void

bpsk_map ( s t r u c t

6.4.6

Canal Additif Blanc Gaussien

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

/ Simulates struct struct double vec vec an A G W N channel in : input data . data of with additive noise . the noise . out : output ( Additive White Gaussian Noise ) .

sigma2 :

variance

void

awgn_chan (

struct vec unsigned int k ; for ( k = 1

in ,

struct

vec out ,

double

sigma2 )

c r e a t e _ v e c ( out , i n . n ) ; ; k < i n . n + 1 ; k++) { chg_vec ( out , k , read_vec ( in , k ) + normrnd ( 0 , sigma2 ) ) ;

vec in , struct vec out , double sigma2 )

}
// void

awgn_chan ( s t r u c t

6.4.7

Dcodage

6.4.8

Dcisions dures

6.4.9

Dcisions souples, mthode probabiliste

6.4.10

Dcisions souples, mthode LLR

38

6.4.11

Contrle de parit

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

/ Performs struct struct the p a r i t y c h e c k code with to 0 be if a p a r i t y c h e c k checked . the p a r i t y c h e c k test is successful , 1 otherwise . matrix H. sm a t H : vec p a r i t y c h e c k short ) matrix .

code_msg :

Returns :

( unsigned

unsigned short par_chk ( struct smat H, struct { unsigned int i ; unsigned int count ; unsigned int i n d e x ; double sum0 ; for ( i = 0 ; i < H. nrows ; i ++) {
/

vec code_msg )

sum0 = 0 ;

while ( ( i n d e x
}

count = 0 ;

= r e a d _ l s t (H. rows [ i ] , &count ) ) != 0 ) { sum0 += read_vec ( code_msg , i n d e x ) ; != 0 )

} }
// unsigned

if ( ( unsigned int ) sum0 % 2 return 1 ;

0;
short par_chk ( s t r u c t s ma t H,

return

struct

vec

code_msg )

6.5

Interface graphique

Visual Studio sucks

39

40

Troisime partie

Analyses de performances, rsultats et interprtations Conclusion

41