Codes de base : ASCII, BCD, etc. | Exercices corrigés

Concepts & Exercices

\(\text{ASCII}(C) = \text{Code}_{7/8}\)

Codage ASCII

ASCII

7/8 bits

Code américain

BCD

4 bits/digit

Code décimal binaire

Gray

1 bit change

Code adjacent

🎯

Code ASCII : 7 bits pour 128 caractères (parfois 8 bits).

📋

Code BCD : Chaque chiffre décimal codé sur 4 bits.

🔍

Code Gray : Deux valeurs successives diffèrent d'un seul bit.

⚙️

Parité : Bit supplémentaire pour détecter les erreurs.

Exercice 1

Convertir des caractères ASCII en binaire

Exercice 2

Convertir des nombres en code BCD

Exercice 3

Comprendre le code Gray

Exercice 4

Calculer la parité d'un mot binaire

Exercice 5

Détecter les erreurs avec le checksum

Corrigé : Exercices 1 à 3

1 Code ASCII

Définition :

Code ASCII : American Standard Code for Information Interchange - norme de codage des caractères.

Méthode de codage ASCII :

Chaque caractère est affecté à un code numérique
Code sur 7 bits (0-127) ou 8 bits (0-255)
Les lettres majuscules commencent à 65 (A)
Les lettres minuscules commencent à 97 (a)

Codage ASCII de la lettre 'A' :

Code décimal : 65

Code binaire : 1000001 (sur 7 bits)

Code binaire : 01000001 (sur 8 bits)

Caractères de contrôle (0-31) :

Fin de ligne, tabulation, effacement...

Caractères imprimables (32-126) :

Espaces, ponctuation, chiffres, lettres

Caractères étendus (128-255) :

Accents, symboles internationaux

Relation majuscules/minuscules :

Minuscule = Majuscule + 32

Étape 1 : Identifier le caractère

'A' est la première lettre majuscule

Étape 2 : Trouver son code ASCII

'A' = 65, 'B' = 66, 'C' = 67...

Étape 3 : Convertir en binaire

65 = 64 + 1 = 2⁶ + 2⁰ = 1000001₂

'A' = 65 = 1000001₂

Réponse finale :

Caractère	Décimal	Binaire (7 bits)	Binaire (8 bits)
A	65	1000001	01000001
a	97	1100001	01100001
0	48	0110000	00110000

Règles appliquées :

• Chiffres 0-9 : Codes 48-57

• Majuscules A-Z : Codes 65-90

• Minuscules a-z : Codes 97-122

2 Code BCD

Définition :

Code BCD (Binary Coded Decimal) : Chaque chiffre décimal est codé séparément sur 4 bits.

Codage BCD du nombre 258 :

2 → 0010

5 → 0101

8 → 1000

Résultat : 0010 0101 1000

Chiffre 0 :

0000

Chiffre 1 :

0001

Chiffre 2 :

0010

Chiffre 3 :

0011

Chiffre 4 :

0100

Chiffre 5 :

0101

Chiffre 6 :

0110

Chiffre 7 :

0111

Chiffre 8 :

1000

Chiffre 9 :

1001

Étape 1 : Séparer chaque chiffre

258 → 2, 5, 8

Étape 2 : Convertir chaque chiffre en binaire

2 = 0010, 5 = 0101, 8 = 1000

Étape 3 : Assembler les groupes de 4 bits

0010 0101 1000

258₁₀ = 0010 0101 1000 BCD

Réponse finale :

258₁₀ = 0010 0101 1000 BCD

Soit 12 bits au total (3 chiffres × 4 bits)

Ne pas confondre avec la conversion purement binaire : 258₁₀ = 100000010₂

Règles appliquées :

• Chaque chiffre : Codé indépendamment sur 4 bits

• Valeurs valides : 0000 à 1001 (0 à 9)

• Utilisation : Afficheurs numériques, calculatrices

3 Code Gray

Définition :

Code Gray : Code binaire où deux valeurs successives ne diffèrent que d'un seul bit.

Séquence Gray sur 3 bits :

000 → 001 → 011 → 010 → 110 → 111 → 101 → 100

Chaque transition ne modifie qu'un seul bit

Décimal → Gray (3 bits) :

0=000, 1=001, 2=011, 3=010, 4=110, 5=111, 6=101, 7=100

Algorithme de conversion :

Gray[i] = binaire[i] ⊕ binaire[i+1]

Applications :

Encodeurs rotatifs, cartes de Karnaugh

Avantage :

Élimination des états transitoires parasites

Étape 1 : Conversion binaire → Gray

Gray[0] = binaire[0] (MSB identique)

Gray[i] = binaire[i] ⊕ binaire[i+1] pour i > 0

Étape 2 : Exemple avec 101₁₀ = 1100101₂

Gray = 1⊕0, 0⊕1, 1⊕0, 0⊕0, 0⊕1, 1⊕0, 0 = 1110010

Étape 3 : Vérification

Chaque paire de valeurs successives ne diffère que d'un bit

101₁₀ = 1100101₂ → 1110010 Gray

Réponse finale :

Code Gray : 1110010

Chaque transition ne modifie qu'un seul bit

Idéal pour les encodeurs mécaniques

Règles appliquées :

• Un seul bit change : Entre deux valeurs successives

• Élimination des parasites : Problèmes de synchronisation

• Applications : Encodeurs rotatifs, logique combinatoire

Corrigé : Exercices 4 à 5

4 Parité

Définition :

Bit de parité : Bit supplémentaire ajouté pour détecter les erreurs de transmission.

Calcul de la parité paire pour 1011010 :

Nombre de bits à 1 : 4

Parité paire : 0 (car 4 est pair)

Résultat : 10110100

Parité paire :

Nombre total de 1 est pair

Parité impaire :

Nombre total de 1 est impair

Détection d'erreur :

Un seul bit erroné est détecté

Limitation :

Ne peut pas corriger les erreurs

Étape 1 : Compter les bits à 1

1011010 → 1+0+1+1+0+1+0 = 4 bits à 1

Étape 2 : Appliquer la règle de parité

Parité paire : le total doit être pair → ajouter 0

Étape 3 : Former le mot complet

1011010 + 0 = 10110100

1011010 → 10110100 (parité paire)

Réponse finale :

Mot original : 1011010

Bit de parité paire : 0

Mot avec parité : 10110100

Règles appliquées :

• Simple à implémenter : XOR de tous les bits

• Détecte erreurs simples : Mais pas les doubles

• Utilisation : Mémoires RAM, transmissions série

5 Checksum

Définition :

Checksum : Somme des octets d'un message, utilisée pour la détection d'erreurs.

Calcul du checksum pour [45, 23, 78, 12] :

Somme = 45 + 23 + 78 + 12 = 158

Modulo 256 = 158

Checksum = 256 - 158 = 98

Calcul :

Somme des octets modulo 256

Vérification :

Checksum + données ≡ 0 (mod 256)

Limitation :

Moins robuste que CRC

Applications :

Protocoles IP, UDP, fichiers

Étape 1 : Sommer tous les octets

45 + 23 + 78 + 12 = 158

Étape 2 : Calculer le complément

Checksum = 256 - (somme % 256) = 256 - 158 = 98

Étape 3 : Vérification

45 + 23 + 78 + 12 + 98 = 256 ≡ 0 (mod 256) ✓

Checksum = 98

Réponse finale :

Données : [45, 23, 78, 12]

Checksum : 98

Vérification : 45+23+78+12+98 = 256 ≡ 0 (mod 256)

Règles appliquées :

• Simple mais limité : Moins efficace que CRC

• Détection d'erreurs : Basée sur la somme des données

• Utilisation : Protocoles réseau et fichiers

Cours bien détaillé

\(\text{Gray}[i] = \text{Binaire}[i] \oplus \text{Binaire}[i+1]\)

Conversion binaire → Gray

🎯

ASCII 7 bits : 128 caractères (0-127).

📋

ASCII 8 bits : 256 caractères (0-255) avec extension.

🔍

BCD : 4 bits par chiffre décimal (0000-1001).

⚙️

Code Gray : Changement d'un seul bit entre valeurs successives.

💡

Conseil : Mémoriser les codes ASCII des chiffres (48-57) et lettres (65-90, 97-122)

🔍

Attention : Le code BCD n'est pas une conversion binaire pure

⚡

Astuce : Le code Gray est idéal pour les encodeurs mécaniques

📋

Méthode : Toujours vérifier la parité en comptant les bits à 1

✅

Vérification : Le checksum + données doit être congruent à 0 (mod 256)

Types de codes :

ASCII : Codage des caractères alphanumériques
BCD : Codage décimal binaire pour les chiffres
Gray : Codage adjacent pour les transitions
Parité : Détection simple d'erreurs
Checksum : Somme de contrôle pour les erreurs

Règles importantes :

Le code ASCII est la base du codage des caractères dans les ordinateurs
Le BCD est utilisé pour les afficheurs numériques et les calculatrices
Le code Gray élimine les problèmes de synchronisation dans les encodeurs
La parité détecte mais ne corrige pas les erreurs
Le checksum est plus robuste que la parité mais moins que le CRC

Codes correcteurs :

Parité : Détecte une erreur simple
Checksum : Somme des données modulo 256
CRC : Cyclic Redundancy Check (plus robuste)
Hamming : Code qui peut corriger une erreur
Reed-Solomon : Utilisé dans les CD, DVD, QR codes

Comparaison des codes :

ASCII : 7/8 bits par caractère, universel
BCD : 4 bits par chiffre, facile à convertir
Gray : Changement minimal, pas de conversion directe
Parité : 1 bit supplémentaire, simple mais limité
Checksum : Plusieurs bits, meilleur que parité

Codes de base : ASCII, BCD, etc.Exercices corrigés

Codes de base : ASCII, BCD, etc.
Exercices corrigés