Master Systèmes de Communication et Informatique 2013 
OUALLA Soumia 
BELKADI Omayma 
LAGRINI Ahmed 
Mr. MOUSSAOUI Mohamed
MSCI 1 
INTRODUCTION 
L'évolution croissante des besoins en termes de débit de transmission et de qualité de service, moti...
MSCI 2 
1. Codes Correcteurs d’erreurs 
Le principe du codage correcteur d'erreurs (ou codage de canal) est d'ajouter aux ...
MSCI 3 
Un code C sur A est une partie non vide de l’espace de Hamming 퐴푛, n est appelé longueur du code, les éléments de ...
MSCI 4 
La représentation polynomiale consiste à écrire chaque mot non codé de taille K comme un polynôme 푈(푋) de degré 퐾−...
MSCI 5 
Soient 푔푖푗 pour 푖,푗∈[0,퐾−1],[0,푁−1] les éléments de la matrice G, chaque 푐푗 s'écrit alors comme combinaison linéai...
MSCI 6 
Figure 2: Exemple de codeur convolutif 
Les bits de sortie sont alors déterminés par : 푐푖 1=푢푖+푢푖−1+푢푖−2 et 푐푖 2=푢...
MSCI 7 
L'intérêt à utiliser la récursivité est qu'en pratique, les performances obtenues à faible rapport signal à bruit ...
MSCI 8 
 Diagramme d’état 
Les conventions adoptées : 
 Lorsque l’élément binaire d’entrée du codeur est égal à ‘0’ (res...
MSCI 9 
Figure 7: Exemple d'arbre 
Si par exemple la séquence d'information à coder est 1001 
le mot de code associé à "10...
MSCI 10 
Les conventions adoptées : 
 Lorsque l’élément binaire d’entrée du codeur est égal à ‘0’ (resp. ‘1’), le couple ...
MSCI 11 
problème qui correspond à l’estimation des symboles d’un modèle de chaîne de Markov cachée, représentable lui aus...
MSCI 12 
Premier étape (i=0) 
Deuxième étape (i=1) 
 On compare les bits de la séquence reçue avec les bits de transition...
MSCI 13 
 On continue à avancer dans le treillis on faisant des mises à jour 
 On construit les différents codes possibl...
MSCI 14 
 Après un certain nombre de transition on compare les poids des noeuds 
 Le chemin ayant le noeud extrême de po...
MSCI 15 
 Le Viterbi modifié afin de fournir une sortie souple (SOVA : Soft-Output Viterbi Algorithm) : à chacun des symb...
MSCI 16 
Pour encoder les données binaires avant les convertir en entiers pour la modulation, on insère le code suivant av...
MSCI 17 
L'étape finale consiste à stocker les chemins survivants ainsi obtenus et à les explorer en sens inverse, c'est-à...
MSCI 18 
Voici les résultats données par la simulation de notre application : 
On fera une comparaison entre le message gé...
MSCI 19 
L'opération de décodage dans ce projet, subit un retard, ce qui signifie que la sortie du décodeur accuse l'entré...
MSCI 20 
CONCLUSION 
En théorie de l’information, le théorème du codage canal établit que, pour tout canal de communicatio...
MSCI 21 
BIBLIOGRAPHIE 
 O. Pothier, Les codes convolutifs 
 Stéphanie CASTAN - SAHUGUÈDE, Thèse pour obtenir le grade d...
MSCI 22 
SOMMAIRE 
INTRODUCTION .............................................................................................
Prochain SlideShare
Chargement dans…5
×

Codage Convolutif sous MATLAB

3 153 vues

Publié le

Dans ce projet nous nous intéressons au codage convolutif qui forme une classe extrêmement souple et efficace de codes correcteurs d’erreurs. Les codes convolutifs sont les codes les plus utilisés dans les systèmes de télécommunications fixes et mobiles. Ils s’appliquent sur des séquences infinies de symboles d’information et génèrent des séquences infinies de symboles codés.

Publié dans : Formation
0 commentaire
8 j’aime
Statistiques
Remarques
  • Soyez le premier à commenter

Aucun téléchargement
Vues
Nombre de vues
3 153
Sur SlideShare
0
Issues des intégrations
0
Intégrations
10
Actions
Partages
0
Téléchargements
1
Commentaires
0
J’aime
8
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive

Codage Convolutif sous MATLAB

  1. 1. Master Systèmes de Communication et Informatique 2013 OUALLA Soumia BELKADI Omayma LAGRINI Ahmed Mr. MOUSSAOUI Mohamed
  2. 2. MSCI 1 INTRODUCTION L'évolution croissante des besoins en termes de débit de transmission et de qualité de service, motive la recherche de nouveaux moyens de communications, performants et peu coûteux. De plus, le développement des applications multimédia, nécessitant le transport simultané de plusieurs services différents, contribue à l'évolution de ces besoins. Le codage de canal est devenu un élément indispensable puisqu'il permet d'assurer la protection de l’information transmise, en contrôlant les erreurs de transmission. L’utilisation de techniques de traitement numérique du signal, et notamment le codage des informations à transmettre, permet la détection et/ou la correction d’éventuelles erreurs de transmission. Comme ces techniques permettent de contrôler les erreurs induites par le bruit du canal de transmission, elles sont nommées « codages de canal ». Parmi les principales techniques existantes, le codage en bloc et le codage convolutif sont prédominantes. Le codage convolutif est fortement diffusé dans les systèmes de communication numérique sans fil. Dans ce projet nous nous intéressons au codage convolutif qui forme une classe extrêmement souple et efficace de codes correcteurs d’erreurs. Les codes convolutifs sont les codes les plus utilisés dans les systèmes de télécommunications fixes et mobiles. Ils s’appliquent sur des séquences infinies de symboles d’information et génèrent des séquences infinies de symboles codés.
  3. 3. MSCI 2 1. Codes Correcteurs d’erreurs Le principe du codage correcteur d'erreurs (ou codage de canal) est d'ajouter aux données utiles, des données redondantes de manière à rendre plus fiable la transmission des données utiles. Ce principe peut être couplé avec du codage de source qui consiste à rendre l'information transmise la plus concise possible sans dégrader les performances du système. Généralement, le codage de source sert à compenser la redondance introduite par le codage de canal. Figure 1: La famille des codes correcteurs d'erreurs 1.1 Définitions Générales  Distance de Hamming Soient 퐴푛 l’ensemble des mots de longueur n sur A, 푥=(푥0,푥1,…,푥푛−1)∈퐴푛 et 푦= (푦0,푦1,…,푦푛−1)∈퐴푛. La distance de Hamming entre x et y est : 푑퐻(푥,푦)= |{푖|0≤푖≤푛−1,푥푖≠푦푖}| On vérifie que 푑퐻 est bien une métrique et on appelle alors espace de Hamming sur A l’ensemble 퐴푛 muni de la métrique 푑퐻 Si A est un groupe, le poids de Hamming 푤퐻(푥) d’un mot 푥∈퐴푛 est le nombre de ses coordonnées non nulles 푤퐻(푥)= 푑퐻(푥,0) où 0 est le mot de 퐴푛 ayant toutes ses coordonnées égales à l’élément neutre de A.
  4. 4. MSCI 3 Un code C sur A est une partie non vide de l’espace de Hamming 퐴푛, n est appelé longueur du code, les éléments de C sont appelés mots de code. Lorsque A = {0, 1} on parlera de code binaire. On appelle distance minimale d’un code C sur A, l’entier : 푑=푚푖푛{푑퐻(푥,푦)|푥,푦∈퐶,푥≠푦}  Rendement Le rendement R d'un code C (N,K) qui transforme un mot de K bits en un mot de N bits en ajoutant N-K bits de redondance est défini par : 푅= 퐾 푁 La redondance du code, généralement notée r est donnée par : 푟= 푁−퐾 퐾 ≈ 푁−퐾 푁 ≈1−푅 Tout mot de N bits obtenu en sortie du codeur à partir d'un mot de K bits s'appelle un mot de code. Si un mot reçu n'est pas un mot de code, c'est qu'il y a eu une erreur de transmission qui nécessite d'être corrigée. Cependant, si le mot reçu est un mot de code, il peut toutefois ne pas correspondre au mot émis, et donc comporter des erreurs, qui ne sont pas détectées. La distance de Hamming 푑퐻 entre deux mots de code est définie comme le nombre de symboles différents entre ces deux mots. Par exemple, les mots de symboles binaires suivants : 10001001 et 10110001 diffèrent de 3 bits. La distance de Hamming est donc 푑퐻=3. La distance de Hamming minimale 푑퐻푚푖푛 est définie comme la plus petite des distances de Hamming entre deux mots de code distincts. Le pouvoir de détection du code, correspondant au nombre maximal d'erreurs détectables dans un mot dépend directement de la distance de Hamming minimale. Il est déterminé par 푡=푑퐻푚푖푛−1 Le pouvoir de correction, défini comme le nombre maximal d'erreurs corrigibles dans un mot est donné par : ⌊ 푡 2⌋= ⌊ 푑퐻푚푖푛−12⌋ Où ⌊푥⌋ représente la partie entière par valeur inférieure de la quantité 푥. 1.2 Représentations polynomiales et matricielles Pour illustrer le principe de codage de l'information, deux représentations sont généralement utilisées : la représentation polynomiale et la représentation matricielle.
  5. 5. MSCI 4 La représentation polynomiale consiste à écrire chaque mot non codé de taille K comme un polynôme 푈(푋) de degré 퐾−1 en X : 푈(푋)=Σ푢푖푋푖 퐾−1 푖=0 Où les 푢푖 correspondent aux valeurs des différents symboles composant le mot 푈=[푢0푢1..푢퐾−1] Dans cette représentation, on définit de la même manière un polynôme générateur 퐺(푋) de degré 푁−퐾 tel que chaque mot de code 퐶(푋) puisse s'écrire comme le produit de 퐺(푋) avec n'importe quel mot non codé 푈(푋). La multiplication de ce polynôme par 퐺(푋) fournit le mot de code correspondant : 퐶(푋)=푈(푋).퐺(푋)= (Σ푢푗푋푗 퐾−1 푗=0).(Σ푔푖푋푖 푁−퐾 푖=0) Dans cette notation, les 푔푖 sont les coefficients associés au polynôme générateur 퐺(푋). Le mot en sortie du codeur C, de taille 푁 est équivalent à un polynôme de degré 푁−1 qui s'écrit d'une façon générale de la manière suivante : 퐶(푋)=Σ푐푖푋푖 푁−1 푖=0 Les coefficients 푐푖 de ce polynôme sont obtenus en développant le produit des sommes. Ils s'écrivent alors comme une combinaison linéaire des symboles d'information du mot en entrée du codeur. De plus, suivant la nature du code utilisé, les coefficients du polynôme générateur peuvent être eux-mêmes des combinaisons linéaires des mots d'information précédant le mot à coder. Ainsi, le mot codé s'écrit comme une combinaison linéaire des symboles d'informations du mot à coder et/ou des mots précédemment codés. Notons que dans la représentation polynomiale, toutes les opérations sont faites modulo 푋푁−1 si les mots de codes sont sur N bits. Dans certains cas, on préfèrera la notation matricielle où les mots à coder sont représentés sous forme de vecteurs de taille K et les mots codés sous forme de vecteurs de taille N. L'opération de codage s'effectue en multipliant le vecteur à coder par la matrice d'encodage G de taille 퐾×푁 . Si on note par exemple un mot à coder 푈=[푢0푢1..푢퐾−1]퐾 Le mot codé est obtenu par la multiplication matricielle suivante: 퐶=[푐0푐1..푐푁−1]푁=[푢0푢1..푢퐾−1]퐾 .퐺퐾×푁
  6. 6. MSCI 5 Soient 푔푖푗 pour 푖,푗∈[0,퐾−1],[0,푁−1] les éléments de la matrice G, chaque 푐푗 s'écrit alors comme combinaison linéaire des 푢푖 : 푐푗=Σ푢푖.푔푖푗 퐾−1 푖=0 Cette représentation est identique à la représentation polynomiale, mais est plus appropriée dans certains schémas de codage. De part la manière dont les informations sont codées au niveau de l'émetteur, deux grandes familles de codes correcteur d'erreurs sont à distinguer : les codes convolutifs et les codes en blocs. Quelle que soit la nature du code, il est dit systématique si on retrouve dans le mot codé C les K bits d'information correspondant au mot non codé U. Cela se traduit dans la représentation matricielle par le fait qu'une partie de la matrice génératrice est composée de la matrice identité. Cette représentation est appelée la forme systématique de la matrice génératrice. 2. Codes Convolutifs Le principe des codes convolutifs, inventes par Peter ELIAS en 1954, est de considérer des séquences semi-infinies 푎0푎1푎2… 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 construisent 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.1 Codage Le principe des codes convolutifs est de considérer le message à émettre comme une séquence semi-infinie de symboles. Le codage convolutif consiste à faire passer le mot à coder dans une succession de registres à décalage, dont le nombre m est appelé mémoire du code. Pour construire un bloc de N symboles en sortie du codeur à partir de K symboles d'entrée, cela signifie qu'il faut m blocs de K symboles en plus du bloc de symboles utiles. On dit aussi que la longueur de contrainte du code est de m+1. Un code convolutif est alors déterminé par trois paramètres: K le nombre de symboles d'information, N le nombre de symboles associés aux K symboles d'information, et m la mémoire du code. Un exemple de codeur convolutif de rendement 푅= 12 transformant un mot 푈= [푢0푢1..푢퐾−1] en un mot 퐶=[푐0푐1..푐푁−1]=[푐01푐02푐11푐12…푐퐾−11푐퐾−12] est représenté sur la figure au-dessous. La valeur 푢푖 correspond au bit qui parvient à l'entrée du codeur à l'instant i.
  7. 7. MSCI 6 Figure 2: Exemple de codeur convolutif Les bits de sortie sont alors déterminés par : 푐푖 1=푢푖+푢푖−1+푢푖−2 et 푐푖 2=푢푖+푢푖−2 (additions modulo 2). Supposons que les deux registres soient initialement à 0 et que le codeur reçoive le message 푈=[1011]. La figure suivante illustre le fait que la séquence codée devienne C = [11100001], et que les registres à la fin soient à l'état 1 1 (=푢3푢2) Figure 3: Exemple de codage d'information à travers un codeur convolutif Parmi les codes convolutifs, on distingue deux grandes catégories: les codes non systématiques (ou NSC : Non Systematic Convolutional codes) et les codes systématiques récursifs (ou RSC : Recursive Systematic Convolutional codes). Un code convolutif est dit systématique si l'un des bits de sortie est identique au bit d'entrée. En effet dans ce cas, les K bits d'information en entrée du codeur se retrouvent parmi les N bits du mot codé. Un mot de code en sortie d'un codeur non-systématique possède donc plus d'informations qu'en sortie d'un codeur systématique et conduit à de meilleures performances pour les mêmes paramètres caractéristiques N, K et m. Un code convolutif est dit récursif si la séquence passant dans les registres à décalage est alimentée par le contenu de ces registres comme sur l'exemple de la figure 4.
  8. 8. MSCI 7 L'intérêt à utiliser la récursivité est qu'en pratique, les performances obtenues à faible rapport signal à bruit sont meilleures que celles obtenues avec un code non récursif de taille identique. Figure 4: Exemple de codeur convolutif récursif C'est à partir de ces codes convolutifs récursifs qu'ont été inventés les turbo-codes basés sur les mêmes considérations. Les codes convolutifs sont d'autant plus performants que la mémoire du code m est élevée. La contrepartie est un délai d'autant plus important que la mémoire du code est longue. L'utilisation de codes en blocs permet de contourner ce problème de délai. 2.2 Représentation des codes convolutifs Chaque bloc de n éléments binaires en sortie du codeur dépend :  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. (On prend k = 1, n = 2, m = 2) Figure 5: codeur à 4 états Les quatre états possibles du codeur au-dessus sont : ‘00’ ‘01’ ‘10’ ‘11’
  9. 9. MSCI 8  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. Figure 6: Diagramme d'état 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.  Arbre Développement du diagramme d’état en fonction du temps discrétisé. Les conventions adoptées :  Le temps s’écoule de la gauche vers 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é noeud. Chaque noeud donne naissance à 2푘 branches.  Quel que soit l’état initial du codeur, après (m + 1) décalages à l’entrée du codeur, tous les états du codeur peuvent être atteints.
  10. 10. MSCI 9 Figure 7: Exemple d'arbre Si par exemple la séquence d'information à coder est 1001 le mot de code associé à "1001" est donc 11011111  Treillis L'inconvénient essentiel de l'arbre est que l'arborescence est multipliée par 2 à chaque bit supplémentaire et la représentation devient impossible à réaliser.
  11. 11. MSCI 10 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).  De chaque noeud partent 2푘 branches et en chaque noeud convergent 2푘 branches.  Les étiquettes de chaque branche correspondent aux sorties du codeur. Les remarques faites sur le nombre limité d'états possibles vont nous permettre de compacter ce graphe en attribuant à chaque instant un noeud à un état. Figure 8: Treillis 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 fie, cependant pour des contraintes pratiques la plupart des applications imposent une longueur maximal du mot. A cet effet, on ajoute m bits (dites bits de queue) nuls, on force ainsi le treillis à revenir à l'état S(0,L). 2.3 Algorithmes de décodage Nous décrivons dans cette partie un exemple l’algorithme de décodage applicable aux codes convolutifs. Les algorithmes de décodage effectuent leurs opérations sur un treillis, qui représente, dans le cas du décodage des codes convolutifs, la structure du code. Ils sont cependant applicables plus généralement à le recherche du chemin dans un treillis qui minimise un critère de distance additive. Ils sont donc aussi applicables au décodage des codes en bloc (par l’intermédiaire de leur représentation en treillis), à celui des modulations codées en treillis, où à la détection au maximum de vraisemblance sur un canal introduisant de l’interférence entre symboles,
  12. 12. MSCI 11 problème qui correspond à l’estimation des symboles d’un modèle de chaîne de Markov cachée, représentable lui aussi par un treillis. On prendra comme exemple l’algorithme de Viterbi en expliquant son déroulement.  Viterbi Il s’agit d’un algorithme de décodage à entrée ferme ou souple mais à sortie ferme (des décisions sont prises sur chaque transition du chemin choisi dans le treillis) qui calcule le chemin dont la vraisemblance est maximale (ML : Maximum Likelihood). Il s’agit donc d’un algorithme de décodage ML par séquence (chemin). Soit C un code convolutif binaire de rendement 푅= 푘 푛 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. 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 noeud.  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 noeud que le chemin le plus vraisemblable, appelé survivant.  Si deux chemins sont aussi vraisemblables, un seul chemin est arbitrairement conservé. Pour mieux comprendre l’algorithme on prend l’exemple suivant : Supposons que la séquence à l’entrée du codeur soit ‘1001’. Si le codeur est dans l’état ‘00’ à l’instant initial, la séquence correspondante en sortie du codeur est ’11 01 11 11’. Considérons un canal binaire symétrique introduisant une erreur en troisième bit. La séquence reçue à l’entrée du décodeur est ’11 00 11 11’ Voici le déroulement de l’algorithme de Viterbi :
  13. 13. MSCI 12 Premier étape (i=0) Deuxième étape (i=1)  On compare les bits de la séquence reçue avec les bits de transition  Le nombre de différences entre les deux est égal au poids qu’on affecte au noeud
  14. 14. MSCI 13  On continue à avancer dans le treillis on faisant des mises à jour  On construit les différents codes possibles à fur et à mesure Au moment où on obtient deux poids pour le même noeud on procède par élimination sur le critère de minimum de poids Si obtient sur un noeud deux poids égaux on élimine l’un d’eux au hasard :
  15. 15. MSCI 14  Après un certain nombre de transition on compare les poids des noeuds  Le chemin ayant le noeud extrême de poids le plus faible est élu.  Autres Algorithmes Il existe d’autres algorithmes de décodage citant les suivant :
  16. 16. MSCI 15  Le Viterbi modifié afin de fournir une sortie souple (SOVA : Soft-Output Viterbi Algorithm) : à chacun des symboles associés aux transitions du chemin choisi, il fait correspondre une information de fiabilité sous optimale.  Le Forward-Backward, fait l’objet d’un document séparé. Il calcule de manière exacte la probabilité a posteriori des symboles présents sur les branches. Il s’agit donc aussi d’un algorithme à entrée et sortie souples (SISO : Soft-Input Soft-Output) à décision MAP (Maximum A Posteriori) qui peut tenir compte d’une information probabiliste a priori disponible sur les symboles émis. Contrairement à l’algorithme de Viterbi, il s’agit d’une maximisation symbole par symbole. Les algorithmes de Viterbi, le SOVA et le Forward-Backward sont couramment utilisés dans les systèmes de transmission mobile et fixe à codage simple ou concaténé. 3. Application sous MATLAB Dans cette partie on ajoute le codage convolutif à notre application créée précédemment dans le projet QAM. On passera par les étapes suivantes afin d’accomplir cette tâche : D’abord il faut augmenter le nombre de symboles, le codage convolutif à cette valeur d’EbNo réduit le BER nettement. En conséquence, accumuler suffisamment d'erreurs pour calculer un BER fiable nécessite de traiter davantage de symboles. Remplaçant la définition du nombre de bits, n, de ce qui suit : Dans le code: % Number of bits to process n = 5e5; Le plus grand nombre de bits dans cet exemple lui fait prendre un nettement plus de temps à courir par rapport aux exemples des sections précédentes. On passe ensuite à coder les données binaires :
  17. 17. MSCI 16 Pour encoder les données binaires avant les convertir en entiers pour la modulation, on insère le code suivant avant la section « Bit-to-Symbol Mapping » : %% Encoder % Define a convolutional coding trellis and use it % to encode the binary data. t = poly2trellis([5 4],[23 35 0; 0 5 13]); % Trellis code = convenc(x,t); % Encode. coderate = 2/3; 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 : poly2treillis(Constraint_Length, Code_Generator) Son premier paramètre permet de définir la longueur de code. Dans notre modèle, nous mettons le nombre de registre calculé antécédemment 5 et 4. Le deuxième paramètre sert à saisir la matrice génératrice, ce modèle se caractérise par la matrice suivante comme indiqué sur le help de Matlab ( 233500513) L'étape suivante permet de coder le message par la fonction convenc(msg,treillis). Cette fonction encode le message binaire en utilisant l'encodeur convolutif dont la structure est en treillis. Apres cette étape on passe à appliquer le Bit-to-Symbol Mapping sur le signal codé. Le mappage de bits en symboles doit être appliqué au code du signal codé, pas sur les données originales non codées. Remplacer la première définition de xsym avec ce qui suit : % B. Do ordinary binary-to-decimal mapping. xsym = bi2de(reshape(code,k,length(code)/k).','left-msb'); Rappelons que k est égal à 4, le nombre de bits par symbole en 16-QAM. Conversion du rapport Eb/N0 pour le rapport signal-sur-bruit nous oblige à tenir compte du nombre de bits d'information par symbole. Auparavant, chaque symbole correspond à k bits. Maintenant, chaque symbole correspond à K*bits d'information (coderate). Plus concrètement, trois symboles correspondent à 12 bits codés en 16-QAM, ce qui correspond à 8 bits non codées (information non codée), de sorte que le rapport des symboles de bits d'information est 83=4×( 23)=푘×푐표푑푒푟푎푡푒 Par conséquent, modifier la définition du SNR (au sein de la section du canal) à la suivante : snr = EbNo + 10*log10(k*coderate)-10*log10(nsamp);
  18. 18. MSCI 17 L'étape finale consiste à 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. Cette étape, qui est celle qu'exécute le circuit de la présente invention, est couramment appelé « étape de traceback » dans la technique. 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 ». Pour décoder le code de convolutif avant de calculer le taux d'erreur, insérer ce qui suit avant la section de BER Computation : %% Decoder % Decode the convolutional code. tb = 16; % Traceback length for decoding z = vitdec(z,t,tb,'cont','hard'); % Decode La fonction que nous avons utilisée pour décoder le message est vitdec(code,treillis,tblen,opmode,dectype) C’est une fonction prédéfinie au Matlab, et voici que signifie ses arguments :  tblen: La mémoire de profondeur, on la prend égale à comme expliqué en haut.  opmod: ce paramètre prendra la valeur 'cont' designe que le codeur est censé avoir commencé à l'état tout-zeros. 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é apparait dans la sortie.  dectyp: 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 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, donc on remplace notre code précédent par le suivant : %% BER Computation % Compare x and z to obtain the number of errors and % the bit error rate. Take the decoding delay into account. % Decoder delay, in bits decdelay = 2*tb; number_of_errors,bit_error_rate] = ... biterr(x(1:end-decdelay),z(decdelay+1:end))
  19. 19. MSCI 18 Voici les résultats données par la simulation de notre application : On fera une comparaison entre le message généré et son code, ainsi une comparaison entre le signal reçu sans codage avec celui en codage:
  20. 20. MSCI 19 L'opération de décodage dans ce projet, subit un retard, ce qui signifie que la sortie du décodeur accuse l'entrée. Les informations de synchronisation n’apparaissent pas explicitement dans l'exemple, et la durée de la temporisation dépend des opérations spécifiques qui sont réalisées. Les retards se produisent dans diverses opérations de communication liées, y compris décodage convolutif, entrelacement convolutionnel / désentrelacement, l'égalisation et de filtrage.
  21. 21. MSCI 20 CONCLUSION En théorie de l’information, le théorème du codage canal établit que, pour tout canal de communication bruité, il est possible de transmettre de l’information sans erreur à condition de restreindre le débit utile. Plus précisément, quel que soit le débit utile de transmission inférieur à la limite de la capacité du canal bruité, il existe une technique de correction d’erreur qui permet de rendre la probabilité d’erreur de décodage du message par le récepteur arbitrairement faible. Un problème qui est resté non résolu pendant un demi-siècle a été celui de concevoir effectivement des codes correcteurs qui puissent approcher les résultats promis par Shannon, en effet, la démonstration de Shannon n’est pas constructive: elle repose sur des arguments purement statistiques. Notons que les premiers systèmes de communications numériques sont apparus bien après les travaux de Shannon et qu’ils se sont appuyés sur deux familles de codes (codes convolutifs, codes blocs algébriques) qui, s’ils ont fiabilisé les systèmes télécoms, n’approchaient pourtant pas les limites de fonctionnement prédites par la théorie. Il a fallu attendre le milieu des années 90 pour que les « Turbo-codes » soient les premiers codes à atteindre un demi-siècle après l’invention de la théorie de l’information, la limite prophétisée par Shannon. L’évaluation des performances des codes correcteurs en général, et des turbo-codes en particulier pose plusieurs problèmes. En général des formes analytiques exactes ne sont pas disponibles et il faut procéder à des simulations pour évaluer les performances de codes correcteurs et celles-ci restent lourdes. Par exemple, pour évaluer le rapport signal sur bruit nécessaire à un taux d’erreur cible d’un système télécoms de 109 (une erreur sur un milliard), il faut faire des mesures sur des centaines de milliards de données émises. Ces performances sont encore plus lourdes à mesurer dans le cas de turbo-codes car plusieurs itérations de décodage sont nécessaires pour approcher la limite de Shannon. De plus, dans le cas des turbo-codes, on ne sait pas encore prévoir à quel point l’effet turbo va se déclencher, ni quand les courbes de taux d’erreur vont saturer.
  22. 22. MSCI 21 BIBLIOGRAPHIE  O. Pothier, Les codes convolutifs  Stéphanie CASTAN - SAHUGUÈDE, Thèse pour obtenir le grade de DOCTEUR DE L'UNIVERSITÉ DE LIMOGES: Codage de canal pour les communications optiques  A. Migan, S. Argentieri: Les codes convolutifs  www.mathworks.com
  23. 23. MSCI 22 SOMMAIRE INTRODUCTION ...................................................................................................................... 1 1. CODES CORRECTEURS D’ERREURS ................................................................................... 2 1.1 Définitions Générales............................................................................................ 2  Distance de Hamming .............................................................................................. 2  Rendement ............................................................................................................... 3 1.2 Représentations polynomiales et matricielles ....................................................... 3 2. CODES CONVOLUTIFS ....................................................................................................... 5 2.1 Codage .................................................................................................................. 5 2.2 Représentation des codes convolutifs ................................................................... 7  Diagramme d’état .................................................................................................... 8  Arbre ........................................................................................................................ 8  Treillis ....................................................................................................................... 9 2.3 Algorithmes de décodage ................................................................................... 10  Viterbi..................................................................................................................... 11  Autres Algorithmes ................................................................................................ 14 3. APPLICATION SOUS MATLAB .......................................................................................... 15 CONCLUSION ........................................................................................................................ 20 BIBLIOGRAPHIE ..................................................................................................................... 21 SOMMAIRE ........................................................................................................................... 22

×