Chapitre IV : Protection contre les erreurs

III.1. Introduction
Les rayonnements électromagnétiques, les perturbations propres au système (distorsions, bruit...) peuvent
modifier les informations transmises (bits erronés). Compte tenu de l’extension des réseaux et de l’utilisation
massive de la fibre optique, la perte de la synchronisation des horloges est, aujourd’hui, la principale source
d’erreurs.

III.2. Taux d’erreur binaire

On appelle taux d’erreur binaire ou BER (Bit Error Rate) le rapport entre le nombre d’informations (bits) erronées
reçues et le nombre d’informations (bits) transmises.

Teb = Nb des bits erronés/Nb des bits transmis

Exemple : Soit la transmission de la suite ‘011001001100100101001010’ qui est reçue

‘011001101100101101000010 ‘.
Le message reçu diffère de 3 bits du message émis. Le nombre de bits émis est de 24 bits.

Le taux d’erreur binaire (Teb) est de : Teb = 3/24 = 0, 125

Le taux d’erreur binaire varie en pratique de 10–4 (liaisons des Réseaux Téléphoniques Commutés Publiques) à
10–9 (réseaux locaux).

III.3. La détection d’erreur

On appelle détection d’erreur les mécanismes mis en œuvre pour que le système destinataire puisse vérifier la
validité des données reçues. La détection d’erreur repose sur l’introduction d’une certaine redondance dans
l’information transmise. Quatre techniques peuvent être mises en œuvre pour détecter et éventuellement corriger
les erreurs :

– La détection par écho, le récepteur renvoie en écho le message reçu à l’émetteur. Si le message est différent
de celui émis, l’émetteur retransmet le message. Cette technique est utilisée dans les terminaux asynchrones
(comme Telnet).
– La détection par répétition, chaque message émis est suivi de sa réplique. Si les deux messages sont
différents, le récepteur demande une retransmission. Cette technique est utilisée dans les milieux sécurisés très
perturbés et dans certaines applications dites temps réel.
Exemple : Envoyer 10010011001001 au lieu de 1001001 : Le récepteur détecte une erreur si les exemplaires ne
sont pas identiques.

1
Pour l’autocorrection : Le message envoyé doit être constitué du triple du message initial : Envoyer
100100110010011001001 au lieu de 1001001 : Le message correcte correspond aux 2 exemples identiques.
L’autocorrection nécessite plus de redondance que la simple détection.
– La détection d’erreur par clé calculée, une information supplémentaire (clé) déduite des informations
transmises est ajoutée à celles-ci (figure 5). En réception, le récepteur recalcule la clé, si le résultat obtenu
correspond à la clé reçue les données sont réputées exactes, sinon le récepteur ignore les données reçues et
éventuellement en demande la retransmission (reprise sur erreur).
– La détection et correction d’erreur par code, cette technique consiste à substituer aux caractères à
transmettre, une combinaison binaire différente du codage de base (code auto correcteur).
III.4. Définitions utiles :
• Un code (k, n) transforme tout bloc initial de k bits d’information en un bloc codé de n bits.

• le code introduit une redondance puisque n > k.

• On dit un code est systématique si les k premiers bits du bloc codé sont égaux aux bits du bloc initial. Alors
les r derniers bits (r=n-k) forment un champ de contrôle d’erreur.

• Le rendement d’un code (k, n) est R = k/n.

• On appelle mot du code, la suite de n bits obtenue après un codage (k, n).

• Le nombre n de bits qui composent un mot du code est appelé la longueur du code. La dimension k étant la
longueur initiale des mots.

• Le poids de Hamming d’un mot est le nombre de bits à 1 qu’il contient.

• La distance de Hamming : à deux suites de symboles de même longueur, elle associe l'entier désignant le
cardinal de l'ensemble des symboles de la première suite qui différent de la deuxième : la distance de Hamming
entre 1011101 et 1001001 est 2 (0 + 0 + 1 + 0 + 1 + 0 + 0 = 2)

III.5. Exemples de détection d’erreur par clé calculée

Dans les systèmes à clé calculée, une séquence de contrôle (CTL1) déduite d’une opération mathématique
appliquée au message à émettre est envoyée avec le message. Le récepteur effectue la même opération. Si le
résultat trouvé (CTL2) est identique à la clé calculée par la source (CTL1) le bloc est exact, dans le cas contraire
le bloc est rejeté.

2
III.5.1. Technique de bit de parité
La technique du bit de parité consiste à ajouter, à la séquence binaire à protéger, un bit, telle que la somme des
bits à 1 transmis (poids de Hamming du mot code) soit paire (bit de parité) ou impaire (bit d’imparité).
Le tableau ci-dessous fournit un exemple de calcul du bit de parité. Les caractères ASCII (7 bits) sont protégés
par l’introduction d’un 8ème bit : le bit de parité.
Caractère O S I
Bit 6 1 1 1
Bit 5 0 0 0
Bit 4 0 1 0
Bit 3 1 0 1
Bit 2 1 0 0
Bit 1 1 1 0
Bit 0 1 1 1
Bit de parité 1 0 1
Bit d’imparité 0 1 0
Figure 1. Exemple de calcul du bit de parité et d’imparité.
Cette technique, connue sous le nom de VRC (Vertical Redundancy Check), vérification par redondance verticale
ne permet de détecter que les erreurs portant sur un nombre impair de bits (elle ne détecte pas les erreurs en
nombre pair). Elle est, essentiellement, utilisée dans les transmissions asynchrones (figure 2).

Figure 2. Le contrôle de parité dans les transmissions asynchrones.

Dans les transmissions synchrones, les caractères sont envoyés en blocs (figure 4). La technique du bit de parité
est insuffisante, elle est complétée d’une autre information : le LRC (Longitudinal Redundancy Check).

Figure 3. Structure d’un bloc de caractères protégé par LRC.

Dans ce mode de contrôle dit de parité à deux dimensions, un caractère le LRC est ajouté au bloc transmis (figure
4). Chaque bit du caractère LRC correspond à la parité des bits de chaque caractère de même rang : le premier bit
du LRC est la parité de tous les premiers bits de chaque caractère, le second de tous les 2e bits... Le caractère
ainsi constitué est ajouté au message (figure 4). Le LRC est lui-même protégé par un bit de parité (VRC).
3
 H E L L O LRC ↓
Bit 0 0 1 0 0 1 0
Bit 1 0 0 0 0 1 1
Bit 2 0 1 1 1 1 0
Bit 3 1 0 1 1 1 0
Bit4 0 0 0 0 0 0
Bit 5 0 0 0 0 0 0
Bit 6 1 1 1 1 1 1
VRC → 0 1 1 1 1 0

1001000 0 1000101 1 1001100 1 1001100 1 1001111 1 1000010 0

H E L L O LRC
Figure 4. Transmission du mot « HELLO ».
Le bloc de données est disposé sous une forme matricielle (k= a.b).
On applique la parité (uniquement paire) sur chaque ligne et chaque colonne.
On obtient une matrice (a+1, b+1).
Le rendement est très faible : a.b/ (a+1).(b+1).
Dans ce type de codage une erreur simple modifie simultanément la parité d’une ligne et d’une colonne, alors
pour la corriger, il suffit d’inverser le bit situé à l’intersection de la ligne et de la colonne ayant une parité
incorrecte. Par contre, dans le cas d’une erreur double la parité de deux lignes sera modifiée. Alors, on peut
détecter qu’il y a une erreur mais on ne peut pas la localiser. En résumé, le code de parité à deux dimensions peut
détecter et corriger les erreurs simples et détecter sans pouvoir corriger les erreurs doubles.
III.5.2. Technique des codes cycliques
La méthode de contrôle par clé calculée considère le bloc de N bits à transmettre comme un polynôme de degré
N −1 : P(x). Ce polynôme est divisé par un autre, dit polynôme générateur G(x) selon les règles de l’arithmétique
booléenne ou arithmétique modulo 2. Le reste de cette division R(x) constitue le CRC parfois appelé aussi FCS
(Frame Check Sequence). Le CRC calculé est transmis à la suite du bloc de données (figure 5). En réception, le
destinataire effectue la même opération sur le bloc reçu. Le CRC calculé parle récepteur doit être nul, sinon une
erreur est signalée.

4
 Figure 5. Principe de la détection d’erreur par clé calculée.
Exemple :
On désire protéger le message « 110111 » par une clé calculée à l’aide du polynôme générateur :
G(x) = x2 + x + 1.
Le polynôme correspondant au message à envoyer est : M(x)=x5+x4+0+x2+x+1.
Le degré du polynôme générateur est 𝑛 = 2.
𝑃(𝑥) = 𝑥 𝑛 𝑚(𝑥) = 𝑥 7 + 𝑥 6 + 𝑥 4 + 𝑥 3 + 𝑥 2 .
CRC1 est le reste de la division de P(x) par G(x) : CRC1=x+1.
Le message à envoyer est :
P(x)+CRC1=𝑥 7 + 𝑥 6 + 𝑥 4 + 𝑥 3 + 𝑥 2 + 𝑥 + 1 ou 1101111.
A la réception : le récepteur calcule le CRC2qui est le reste de la division du message reçu (P(x)+CRC1) par G(x),
Si CRC2=0 alors les données sont correctes, sinon il y a une erreur et le récepteur refuse le bloc reçu.
Exemple d’utilisation du CRC :
La comité IEEE 802 (comité de l’IEEE créé en 1980 (80) au mois de février (2) d’où 802 qui est spécialisé dans
l’étude des réseaux locaux) emploie le polynôme suivant :
𝑥 32 + 𝑥 26 + 𝑥 23 + 𝑥 22 + 𝑥 16 + 𝑥12 + 𝑥10 + 𝑥 8 + 𝑥 7 + 𝑥 5 + 𝑥 4 + 𝑥 2 + 1.
III.6. Exemples de détection d’erreur par code
III.6.1. Code de Hamming
Il permet de détecter et corriger une erreur et seulement une erreur
–Ce procédé est donc valable pour des taux d'erreurs faibles.
On va découper l'information par tranche de N bits et on va rajouter t bits
–t sera le plus petit entier tel que 2t − 1 ≥ N + t.
–On aura donc au total N+t bits.
• Les bits rajoutés ne seront pas mis à la fin mais seront entrelacés avec la donnée initiale.
–Ainsi les N+t bits de la donnée finale seront notés fN+t fN+t-1 fN+t-2 ... f2 f1.
–Les t bits rajoutés, appelés bits de contrôle, seront ceux dont l'indice est une puissance de 2.
–Il y en a exactement t.
• La donnée initiale est 0110 1110
5
• N vaut donc 8.
–On cherche la plus petite valeur de t vérifiant 2t − 1 ≥ 8 + t.
–On trouve t=4.
–Il y a au total 12 bits.
• Les bits contrôle sont f1, f2, f4 et f8.
• Les bits qui ne sont pas des bits de contrôle s'obtiennent très facilement : il suffit de reporter la donnée initiale :
f12 f11 f10 f9 f8 f7 f6 f5 f4 f3 f2 f1
0 1 1 0 1 1 1 0
• Il nous reste donc à trouver la valeur des bits de contrôle.
– Pour les trouver nous allons former des ensembles de bits.
– Pour trouver les ensembles de bits il faut au préalable écrire les entiers de 1 à N+t en base 2 sur t bits.
• Sur notre exemple, N vaut 8 et t vaut 4 il faut donc écrire les entiers de 1 à 12 en base 2 sur 4 bits.
0001 ===> 1 0010 ===> 2 0011 ===> 3
0100 ===> 4 0101 ===> 5 0110 ===> 6
0111 ===> 7 1000 ===> 8 1001 ===> 9
1010 ===> 10 1011 ===> 11 1100 ===> 12
i = rang du bit, j = numéro de ligne
J\I 3 2 1 0
1 0 0 0 1
2 0 0 1 0
3 0 0 1 1
4 0 1 0 0
5 0 1 0 1
6 0 1 1 0
7 0 1 1 1
8 1 0 0 0
9 1 0 0 1
10 1 0 1 0
11 1 0 1 1
12 1 1 0 0

• Nous allons maintenant construire t ensembles de bits notés E1, E2 ... Et.

6
• Pour construire Ei, on regarde la colonne i à partir de la droite. S'il y a un 1 dans colonne i sur la ligne j alors le
bit fj appartiendra à l'ensemble Ei.
• Dans notre exemple, pour construire E1, nous allons regarder la colonne la plus à droite on trouve un 1 sur les
lignes 1, 3, 5, 7, 9 et 11.
– On trouve donc :
E1 = {f1, f3, f5, f7, f9, f11}
E2 = {f2, f3, f6, f7, f10, f11}
E3 = {f4, f5, f6, f7, f12}
E4 = {f8, f9, f10, f11, f12}
• Nous allons maintenant reporter dans chaque ensemble les valeurs que nous avions trouvées :
f12=0 f11=1 f10=1 f9=0 f7=1 f6=1 f5=1 f3=0
• On obtient :
E1 = {f1, 0, 1, 1, 0, 1}
E2 = {f2,0, 1, 1, 1, 1}
E3 = {f4,1, 1, 1, 0}
E4 = {f8,0, 1, 1, 0}
• On s'aperçoit que dans chaque ensemble il y a un et un seul bit inconnu : nous allons déterminer ce bit de manière
à ce que dans chaque ensemble de bits le nombre de bits à 1 soit pair.
• On trouve donc :
f1=1 f2=0 f4=1 f8=0
f12 f11 f10 f9 f8 f7 f6 f5 f4 f3 f2 f1
0 1 1 0 0 1 1 1 1 0 0 1

• Lorsqu'on récupère une donnée obtenue grâce au codage de Hamming, deux questions naturelles vont se poser:
– la donnée a-t-elle été altéré ?
– si oui, quelle est la correction proposée par le code de Hamming ?
• La méthode pour répondre à ces deux questions est la suivante :
1. construire les t ensembles de bits Ei.
2. Calculer t bits selon la règle suivante :
- ei=0 si le nombre de bits à 1 dans Ei est pair
- Sinon ei=1.
- Si aucune erreur ne s'est produite tous les bits ei doivent être nuls.
3. calculer E= (et ...e1) en base de 2.
4. Si E est nul alors on en déduit qu'il n'y a pas eu d'erreur.
7
5. Si E n'est pas nul, une erreur s'est produite et le code de Hamming propose la correction suivante : inverser la
valeur du bit fE.
6. On récupère ensuite aisément la valeur de la donnée initiale en supprimant les bits de contrôle.

• On suppose maintenant qu’on a reçu la donnée 0111 0111 1001, le bit en rouge signalant l'erreur.
On a donc :
f12 f11 f10 f9 f8 f7 f6 f5 f4 f3 f2 f1
0 1 1 1 0 1 1 1 1 0 0 1

• On construit les ensembles de bits :

E1 = {f1, f3, f5, f7, f9, f11} = {1, 0, 1, 1, 1, 1} ==> le nombre de 1 (5) est impair ==> e1=1
E2 = {f2, f3, f6, f7, f10, f11} = {0, 0, 1, 1, 1, 1} ==> le nombre de 1 (4) est pair ==> e2=0
E3 = {f4, f5, f6, f7, f12} = {1, 1, 1, 1, 0} ==> le nombre de 1 (4) est pair ==> e3=0
E4 = {f8, f9, f10, f11, f12} = {0 ,1, 1, 1, 0} ==> le nombre de 1 (5) est impair ==> e4=1
• E s'écrit donc en base 2 (e4e3e2e1) soit (1001).
– E vaut donc 9.
– Il y a donc eu une erreur
• la correction propose d'inverser la valeur de bit f9.
– f9 valait 1 : nous allons donc changer sa valeur en 0.
• La donnée corrigée est donc :
f12 f11 f10 f9 f8 f7 f6 f5 f4 f3 f2 f1
0 1 1 0 0 1 1 1 1 0 0 1

• En enlevant les bits f8, f4, f2 et f1, on obtient donc la donnée initiale après correction soit 0110 1110
• Ce codage est intéressants mais n’est pas adaptés à toutes les situations
– lorsqu'il n'y a que peu d'erreurs et que ces erreurs sont isolées, ce code peut être intéressant.
• Mais dès qu'il y a un grand nombre d'erreurs et que ces erreurs arrivent groupées, alors ce codage devient de
moins en moins performant.