Rapport Code Convolutif & Egalisation Aveugle

24
Réalisé par : BELLITOU Ikram BENNANI Anas EL KHAMLICHI Yasser GUENNOUNI Hasnae LOUKILI Anouar Encadré par : M.Moussaoui Filière : GSTR Niveau : 3 ème année du Cycle Ingénieur Rapport : Code Convolutif & Egalisation Aveugle

Transcript of Rapport Code Convolutif & Egalisation Aveugle

Page 1: Rapport Code Convolutif & Egalisation Aveugle

Réalisé par : BELLITOU Ikram BENNANI Anas EL KHAMLICHI Yasser GUENNOUNI Hasnae LOUKILI Anouar MOUNIR Assia

Encadré par : M.Moussaoui Mohamed

Filière : GSTR

Niveau : 3ème année du Cycle Ingénieur

Année Universitaire : 2009-2010

Rapport :

Code Convolutif

&

Egalisation Aveugle

Page 2: Rapport Code Convolutif & Egalisation Aveugle
Page 3: Rapport Code Convolutif & Egalisation Aveugle

SommaireIntroduction...........................................................................................................................................2

I. Codes convolutifs...........................................................................................................................2

1. Généralités.................................................................................................................................2

2. Principe du codage convolutif....................................................................................................2

2.1. Encodeurs...........................................................................................................................2

2.1.1. Représentation des codes convolutifs............................................................................2

2.1.2. Diagramme d'état...........................................................................................................2

2.1.3. Arbre...............................................................................................................................2

2.1.4. Treillis.............................................................................................................................2

2.2. Décodage des Codes Convolutifs........................................................................................2

2.3. Algorithme de Viterbi.........................................................................................................2

3. Les étapes de la création du programme sous Matlab...............................................................2

3.1. La génération d’une séquence aléatoire.............................................................................2

3.2. L’opération du codage........................................................................................................2

3.3. La configuration du canal....................................................................................................2

3.4. Le décodage........................................................................................................................2

3.5. Calcul de BER......................................................................................................................2

3.6. Résultats.............................................................................................................................2

4. Le programme sous Matlab.......................................................................................................2

4.1. Code Matlab.......................................................................................................................2

4.2. Résultats.............................................................................................................................2

II. Turbo Code.....................................................................................................................................2

1. Principe des Turbo Codes...........................................................................................................2

2. Codeur........................................................................................................................................2

3. Décodeur....................................................................................................................................2

III. Egalisation Aveugle.....................................................................................................................2

Page 4: Rapport Code Convolutif & Egalisation Aveugle

IntroductionOn définit un canal de transmission comme un système physique permettant la transmission d’une information entre deux points distants. Le taux d’erreurs binaire (TEB) d’un message est le rapport du nombre de bits erronés par le nombre de bits du message.

En d’autres termes, on peut obtenir des transmissions aussi fiables que l’on veut, en utilisant des codes de taux plus petits que la capacité du canal. Cependant, ce théorème n’indique pas le moyen de construire de tels codes.

On cherche donc à construire des codes ayant un taux le plus élevé possible (pour des raisons de temps et de coût) et permettant une fiabilité arbitrairement grande.

Les codes classiques (Codes en blocs) ne permettent pas d’atteindre cette limite. On a donc développé d’autres systèmes de codages.

Page 5: Rapport Code Convolutif & Egalisation Aveugle

I. Codes convolutifs

1. Généralités

Le principe des codes convolutifs, inventés par ''Peter Elias'' en 1954, est de considérer des séquences semi-infinies a0a1a2… de symboles qui passent à travers une succession de registres à décalage, dont le nombre est appelé mémoire du code, et de générer des séquences semi-infinies.

Les codes convolutifs constituent une classe extrêmement flexible et efficace de codes correcteurs d'erreurs. Ce sont les codes les plus utilisés dans les communications fixes et mobiles.

2. Principe du codage convolutif2.1.Encodeurs

Le codeur qui génère un code convolutif comporte un effet mémoire: Le mot de code ne dépends pas que du bloc de k symboles entrants, mais aussi des m codes qui l'on précédé, stocké dans des registres.

2.1.1. Représentation des codes convolutifs

Chaque bloc de n éléments binaires en sortie du codeur dépend:

Page 6: Rapport Code Convolutif & Egalisation Aveugle

- Du bloc de k éléments binaires présents à son entrée,- Des m blocs de k éléments binaires contenus dans sa mémoire.

Ces m.k éléments binaires définissent l'état du codeur.

(k=1,n=2,m=2)

Les quatre états possibles du codeur sont : a=‘00’ ; b='01' ; c='10' ; d='11'

2.1.2. Diagramme d'état Les conventions adoptées :

- Lorsque l'élément binaire d'entrée du codeur est égal à '0' (resp. '1'), le couple binaire en sortie du codeur est porté par la branche rouge (resp. verte).

- Seules deux transitions sont possibles à partir de chacun des états.- Les étiquettes de chaque branche correspondent aux sorties du codeur.

Il représente la succession des états possibles. Ce sera donc une arborescence constituée des éléments de base précédents et dont la complexité sera croissante.

2.1.3. Arbre 

Développement du diagramme d’état en fonction du temps discrétisé.

Page 7: Rapport Code Convolutif & Egalisation Aveugle

Les conventions adoptées :

- Le temps s’écoule de la gauche à la droite.- Lorsque l’élément binaire d’entrée du codeur est égal à « 0 » (resp. « 1 »), le couple

binaire en sortie du codeur est porté par la branche supérieure (resp. inférieure)

Les branches se séparent en un point appelé nœud. Chaque nœud donne naissance à 2k

branches.

Quelque soit l’état initial du codeur, après (m+1) décalage à l’entrée du codeur, tous les états du codeur peuvent être atteints.

Si par exemple la séquence d’information à coder est : 1001

Le mot de code associé à ‘1001’ est donc 11011111

Page 8: Rapport Code Convolutif & Egalisation Aveugle

2.1.4. Treillis 

L'inconvénient essentiel de l'arbre du code est que l'arborescence est multipliée par 2 à chaque bit supplémentaire et la représentation devient vite impossible à réaliser. Les remarques faites sur le nombre limité d'états possibles va nous permettre de compacter ce graphe en attribuant à chaque instant un nœud à un état.

Un chemin complet commence à l’état S(0,0) et se termine à S(0,L).

Un mot de code convolutif n’a pas de longueur fixe, cependant pour des contraintes pratiques la plupart des applications imposent une longueur max du mot .

A cet effet, on ajoute m bits (dits bits de queue) nuls, on force ainsi le treillis à revenir à l’état S(0,L).

2.2.Décodage des Codes Convolutifs

La contrainte principale du décodage convolutif réside dans le fait que le mot de code est très long, ce qui a tendance à compliquer le circuit décodeur. Les algorithmes de décodage les plus répandus sont :

- Décodage séquentiel : introduit par WONZENCRAFT(1961) amélioré par FANO(1963) et ZIGANGOROV(1968)

- Décodage par Seuil : introduit par MASSEY (1963) basé sur la longueur de contrainte du bloc en cours de décodage plutôt que sur l’utilisation de toute la séquence reçue, ce qui conduit à des performances de décodage inférieures aux autres méthodes.

- Décodage VITERBI : basé sur le principe de max de vraisemblance ( Max Likelihood)

- Méthode optimale pour le décodage des codes convolutifs.

Page 9: Rapport Code Convolutif & Egalisation Aveugle

- Performances dépendantes de la qualité du canal.- Complexité croit exponentiellement avec (m+1)k (contrainte de code)

2.3.Algorithme de Viterbi 

L’algorithme de Viterbi entre dans le cadre du décodage à maximum de vraisemblance des codes convolutifs.

Soit C un code convolutif binaire de rendement R=k/n et de longueur de contrainte L. Le nombre de bits à l’entrée du codeur (respectivement en sortie) est égal à k (respectivement à n). L’algorithme de Viterbi est le moyen le plus répandu pour le décodage ML lorsque C possède un treillis de taille raisonnable, i.e. un nombre d’états inférieur ou égal à 256.Le décodage à maximum de vraisemblance correspond à chercher dans le treillis du code C le chemin le plus proche (le plus vraisemblable) de la séquence reçue.

- A chaque instant, deux branches appartenant à deux chemins différents, convergent vers chaque nœud.

- De ces deux chemins, l’un est plus vraisemblable, c’est-à-dire se trouve à une distance plus petite de la séquence reçue, que l’autre chemin.

- Les distances étant additives, il est possible de ne conserver en chaque nœud que le chemin le plus vraisemblable, appelé survivant.

- Si deux chemins sont aussi vraisemblables, un seul chemin est arbitrairement conservé.

Ex: Soit le treillis élémentaire d'un code convolutif :

On considère la séquence d’information suivante : 1001

La séquence codée est donc : 11 10 11 11

Une erreur survient dans la transmission du troisième bit.

La séquence reçue est donc : 11 00 11 11

Page 10: Rapport Code Convolutif & Egalisation Aveugle

On décode la séquence reçue en utilisant l’algorithme de Viterbi :

Page 11: Rapport Code Convolutif & Egalisation Aveugle
Page 12: Rapport Code Convolutif & Egalisation Aveugle

Remarque : Le poids du dernier nœud correspondant à la dernière séquence entrée indique le nombre d'erreur survenu dans la séquence.

La partie suivante sera consacrée pour développer un programme sous le logiciel Matlab qui met en œuvre la fonctionnalité du codage convolutif.

3. Les étapes de la création du programme sous Matlab

Le code Matlab « codeconvolutif.m » réalisé au long de ce TP se partage en six parties, à savoir la génération d’une séquence aléatoire, codage avec un code convolutif, configuration du canal, le décodage par algorithme de Viterbi pour la partie de la réception sans oublier de mettre en exergue l’efficacité de ce codage par la programmation du calcul de BER : nombre de bits décodés en erreur et finalement la visualisation des résultats par des images.

Nous choisissons que ce programme admet deux paramètres qui doivent être saisies afin que le programme fonctionne : L comme la Longueur de la séquence aléatoire mise en étude, et la probabilité du bruit subit au canal.

Nous nous basons sur ce type de codage convolutif illustré ci-dessous, et toutes les variables saisies sur le programme correspondent à ce type de l’image.

Page 13: Rapport Code Convolutif & Egalisation Aveugle

Les parties suivantes vont détailler chaque partie du programme mentionnée précédemment.

3.1.La génération d’une séquence aléatoire

Cette partie du programme a pour objectif de générer la séquence à étudier après avoir ajouté quelque bits contenant les zéros, Ils servent à agrandir la taille de la séquence pour qu’on puisse décaler la séquence à chaque itération.

d’après notre modèle on constate qu’on possède quatre registres pour le premier étage et trois pour le deuxième, alors on prend la variable r1=5, et r2=4, l’ajout de 1 pour chaque registre permet de prendre place aux bits d’excitations pour chaque étage.

3.2.L’opération du codage

Nous représentons notre modèle sous une forme de treillis. Matlab dispose d’une fonction prédéfinie servant à cette opération nommée : « poly2trellis(ConstraintLength,CodeGenerator) ».

Son premier paramètre permet de définir la longueur de code. Dans notre modèle, nous mettons le nombre de registre calculé antecedamment 5 et 4.

Le deuxième paramètre sert à saisir la matrice génératrice, ce modèle se caractérise par la

matrice suivantecomme ci indiqué sur le Help de Matlab : (23 350 5

¿0¿13)

L’étape suivante permet de coder le message par la fonction « convenc(msg,trellis) ». Cette fonction encode le message binaire en utilisant l'encodeur convolutifs dont la structure est en treillis.

Page 14: Rapport Code Convolutif & Egalisation Aveugle

3.3.La configuration du canal

Afin de configurer la canal, Matlab dispose de la fonction « bsc(data,p) » qui transmet les données binaires du signal d'entrée grâce à un canal symétrique binaire avec p la probabilité d'erreur.

3.4.Le décodage

L'étape finale de l'algorithme de Viterbi est celle consistant à stocker les chemins survivants ainsi obtenus et à les explorer en sens inverse, c'est-à-dire en partant de l'instant le plus récent pour aller vers les instants antérieurs, pour n'en retenir qu'un seul, qui correspondra à l'information recherchée (ou, plus exactement, à une estimation optimale - au sens du maximum du vraisemblance - de la séquence originelle émise).

Cette étape, qui est celle qu'exécute le circuit de la présente invention, est couramment appelé « étape de traceback » dans la technique.

Diverses réalisations, matérielles et logicielles, ont été proposées pour mettre en oeuvre cette fonction.

L'objet de la présente invention est de proposer une structure particulière de circuit permettant d'exécuter à grande vitesse, par matériel, cette étape de l'algorithme, permettant ainsi de traiter en temps réel un flux incident de données à débit élevé.

Le principe du traceback, en lui-même connu, implique de conserver en mémoire les chemins survivants précédemment déterminés, mais en ne conservant en fait ces chemins que sur le nombre de branches ou ils sont différents, ce nombre étant appelé « longueur de troncature » L.

En effet, comme les chemins survivants ne diffèrent en fait que sur leurs L dernières branches, si on les remonte au-delà d'un certain nombre de branches, ils convergent tous vers un chemin unique ne présentant aucune ambiguïté à lever.

Le stockage est effectué dans une mémoire de profondeur 3, contenant 3L mots de N bits (N = 2 ν étant le nombre d'états du treillis et L étant la longueur de troncature pour le code considéré).

Parmi ces trois blocs, l'un est utilisé en écriture et les deux autres en lecture ; lorsque le bloc en écriture est plein il passe en lecture, et celui des blocs en lecture qui est le plus ancien à avoir été rempli repasse en écriture, et ainsi de suite.

À chaque fois que l'on écrit un mot dans la mémoire, on en lit deux en même temps (c'est-à-dire que la lecture se fait deux fois plus vite que l'écriture), de sorte que le système de lecture des chemins remonte les chemins sur deux longueurs de troncature.

La fonction que nous avons utilisée pour décoder le message est : « vitdec(code,trellis,tblen,opmode,dectype)», c’est une fonction prédéfinie au Matlab.

- tblen : La mémoire de profondeur, on la prend égale à 3 comme expliqué en haut.

Page 15: Rapport Code Convolutif & Egalisation Aveugle

- opmod : ce paramètre prendra la valeur ‘cont’ désigne que Le codeur est censé avoir commencé à l’état tout-zéros. Le décodeur fait remonter de l'état avec la meilleure métrique. Un retard ressemble à tblen symboles s'écoule avant que le premier symbole décodé apparaît dans la sortie.

- dectype : Il s’agit de type de code qu’on va recevoir à la sortie. il prendra la valeur ‘hard’ désignant que la décision sera fermée.

3.5.Calcul de BER

Le calcul de BER permet de mettre en valeur le nombre de bits erronés lors de décodage. Il permet aussi de connaitre la robustesse du programme implémenté au cours de ce travail.

3.6.Résultats

Cette partie est consacrée pour faire une comparaison par image entre le message généré et son codage, ainsi une comparaison entre le signal reçu sans codage avec celui en codage.

4. Le programme sous Matlab4.1.Code Matlab

%------------------------Codes Convolutif --------------------------------- function codeconvolutif(L,prob_noise)%------------------------Génération de sequence aléatoire ----------------- m=L; %longueur de la sequence r1=5; % nombre de registres situés dans le premier étage r2=4; % nombre de registres situés dans le deuxième étage u=max(r1,r2)+1;% sert au decalage info=randint(1,m); %sequence aléatoire msg=[info zeros(1,u)]; %-------------------- Codage avec un code convolutif ------------------ %---Matrice génératrice G=[23 35 0;0 5 13]; % ---Treillis trellis = poly2trellis([5 4],G); % --- Codage code = convenc(msg,trellis); %------------------------ Canal ------------------------------------------- %--- paramètres du canal

Page 16: Rapport Code Convolutif & Egalisation Aveugle

y=bsc(code,prob_noise);%Message codé reçu après le canalz=bsc(msg,prob_noise);%Message non-codé reçu après le canal %-----------------------Reception : Decodage ------------------------------ tblen = 3; % Traceback lengths = vitdec(y,trellis,tblen,'cont','hard'); %----------------------- BitErreur ---------------------------------------- for i=1:m t(i)=msg(i); d(i)=s(i+u);end BER=sum(abs(t-d))/mBERpercent=BER*100 %----------------------Résultats-------------------------------------------figure(1); subplot(2,1,1);plot(msg); axis([0 m 0 1]);grid; title('Signal entrée'); subplot(2,1,2);plot(s); axis([u m+u 0 1]); title('Signal reçu avec codage');grid figure(2); subplot(2,1,1);plot(z); axis([0 m 0 1]);grid; title('Signal reçu sans codage'); subplot(2,1,2);plot(s); axis([u m+u 0 1]); title('Signal reçu avec codage');grid;

4.2.Résultats

Pour utiliser cette fonction, nous choisissons la valeur 100 comme la longueur de la séquence et 0.01 comme valeur de la probabilité d’erreur.

Les trois images suivantes résument les résultats obtenus.

Dans cet exemple, le décodage a été fait sans aucune erreur ce qu’il reflète la robustesse du

Page 17: Rapport Code Convolutif & Egalisation Aveugle

programme.

Figure(1)

0 10 20 30 40 50 60 70 80 90 1000

0.5

1Signal entrée

10 20 30 40 50 60 70 80 90 1000

0.5

1Signal reçu avec codage

Figure(2)

Page 18: Rapport Code Convolutif & Egalisation Aveugle

0 10 20 30 40 50 60 70 80 90 1000

0.5

1Signal reçu sans codage

10 20 30 40 50 60 70 80 90 1000

0.5

1Signal reçu avec codage

On prend un autre exemple pour illustrer juste une autre valeur de BER.

Dans cet exemple, nous constatons que nous avons 2% de bits décodés par erreur, et puisque la longueur égale à 100, alors nous pouvons dire que juste 2 bits parmi 100 qui ne sont pas bien décodés, ce qu’il reflète toujours la puissance du programme.

II. Turbo Code

Page 19: Rapport Code Convolutif & Egalisation Aveugle

Les turbo-codes ont été inventés en 1991, et présentés à la communauté scientifique en 1993, par une équipe de l’Ecole Nationale Supérieure des Télécommunications de Brest dirigée par Claude Berrou et Alain Glavieux dans le cadre d'un contrat de recherche avec France Télécom. Les spécialistes des codes correcteurs d’erreurs ont tout d’abord accueilli cette invention avec beaucoup de scepticisme, du fait des extraordinaires performances annoncées. Cependant, d’autres équipes, dans le monde entier, sont parvenues peu après aux mêmes résultats, ce qui a contribué au développement des turbo-codes. Ils ont été adoptés par toutes les agences spatiales mondiales, et seront utilisés dans la transmission des données du standard de téléphonie mobile UMTS.

1. Principe des Turbo Codes

Les Turbo Codes sont une forme révolutionnaire de codage correcteur d'erreur. Ils consistent à améliorer le décodage par un procédé itératif qui permet d'affiner progressivement le résultat. Pour cela, l'information est codée de deux manières différentes, en parallèle, au niveau de l'émetteur. Le décodage est quant à lui effectué en série, suivant l'un puis l'autre des codes élémentaires. Ce deuxième décodage constitue la grande originalité des Turbo Codes. Celui-ci permet en effet d'apporter des informations susceptibles d'améliorer le premier traitement des données. Celles-ci peuvent être ensuite exploitées pour relancer le processus. En itérant ce décodage, de plus en plus d'erreurs peuvent être corrigées. Cette particularité a d'ailleurs donné son nom à cette technologie : les informations échangées entre les décodeurs au cours des itérations améliorent les performances, comme une partie des gaz d'échappement favorise la combustion dans les moteurs turbo.

2. Codeur Le principe des turbo-codes est l’utilisation conjointe de deux codeurs convolutifs récursifs, non pas en série, comme cela était déjà fait depuis de nombreuses années, mais en parallèle.

L’entrelaceur permet ainsi de coder avec le même codeur deux séquences d’autant plus différentes que l’entrelacement sera chaotique. On constate sur le schéma représenté ci-dessus que le taux de codage R des turbo-codes est

de 13

: trois bits de sortie pour un bit d’entrée. On peut le ramener à 12

par un poinçonnage qui

consiste à ne garder à tout instant que l’un des bits Y1 ou Y2. Les turbo-codes peuvent ainsi être comparés aux codes convolutifs classiques, mais cette opération complexifie encore le décodage ; nous n’en tiendrons donc pas compte dans le paragraphe suivant.

Page 20: Rapport Code Convolutif & Egalisation Aveugle

3. Décodeur

Si le codage est relativement simple, le décodage est beaucoup plus complexe. Nous n’en présentons ici que le principe.

Les entrelaceurs et le désentrelaceur utilisent la même permutation que l’entrelaceur du codeur. Ils permettent par exemple la comparaison de la séquence X avec la séquence Y2, entrelacée au moment du codage. Cette procédure de décodage est itérée un certain nombre de fois fixé à l’avance. La décision n’intervient qu’après. A chaque étape, le décodeur dispose des probabilités calculées à l’étape précédente, et se base sur ces probabilités, et non sur une « pré-decision ». C’est ce qui a valu aux turbo-codes leur nom : comme dans un moteur turbo, les « gaz d’échappement » sont réutilisés pour augmenter les performances.

III. Egalisation Aveugle