Systèmes de numération (partie 2/2)

## Objectifs et prérequis **Objectifs** : À la fin de ce chapitre, l’élève sera capable de - convertir un nombre exprimé dans une base quelconque (binaire, octale, décimale, hexadécimale) vers une autre base, en utilisant les méthodes de division successive et de groupe de bits ; - réaliser les quatre opérations arithmétiques (addition, soustraction, multiplication, division) directement dans les bases binaire, octale et hexadécimale, en appliquant les règles de retenue et de complément lorsqu’elles sont nécessaires ; - interpréter les résultats dans un contexte professionnel (automatisme, programmation d’automates, adressage mémoire, codage de couleurs, etc.) et vérifier la cohérence des conversions et des opérations. **Prérequis** : maîtrise de la numération décimale, connaissance des bases binaire (base 2), octale (base 8) et hexadécimale (base 16), ainsi que des notions de poids positionnel et de représentation des entiers naturels. --- ## Introduction contextualisée Dans les installations industrielles camerounaises (usines de transformation du cacao, centrales hydroélectriques de Nachtigal, ateliers de montage de véhicules à Douala), les automates programmables (API) et les systèmes de commande numérique travaillent principalement en binaire. Toutefois, pour faciliter la lecture, la programmation ou le dépannage, les techniciens utilisent souvent l’octal ou l’hexadécimal. Savoir passer rapidement d’une représentation à l’autre et effectuer des calculs directement dans ces bases permet de gagner du temps, de réduire les erreurs de saisie et d’assurer la sécurité des opérations (ex. : vérification d’adresses mémoire avant écriture d’un programme). Ce chapitre présente les méthodes éprouvées, les règles de métier et les exemples concrets tirés de la pratique locale. --- ## I. Passage d’un système de numération à un autre ### 1. Principes généraux de conversion Un nombre entier \(N\) exprimé en base \(b\) s’écrit : \[ N = \sum_{i=0}^{n} d_i \, b^{i} \] où \(d_i\) sont les chiffres (0 ≤ \(d_i\) < \(b\)). La conversion vers une autre base \(b'\) repose sur deux procédés complémentaires : - **Division successive** (de \(b\) vers \(b'\)) : on divise répétitivement le nombre par \(b'\) et on conserve les restes, lus de bas en haut. - **Regroupement de bits** (utile quand \(b'\) est une puissance de \(b\)) : on regroupe les chiffres de la représentation en base \(b\) par paquets de taille \(\log_{b} b'\) et on traduit chaque paquet directement. > Lorsque la destination est une puissance de la source (ex. : binaire → octal, binaire → hexadécimal), le regroupement de bits est la méthode la plus rapide et la moins sujette à erreur. ### 2. Conversion décimale → autre base **Méthode** : division successive par la base cible, reste = chiffre de poids faible. **Exemple professionnel** : convertir l’adresse mémoire décimale \(425\) en hexadécimal pour la programmation d’un automate Schneider Modicon. \[ \begin{aligned} 425 \div 16 &= 26 \text{ reste } 9 \\ 26 \div 16 &= 1 \text{ reste } 10\;(A)\\ 1 \div 16 &= 0 \text{ reste } 1 \end{aligned} \] Lecture des restes de bas en haut : \(425_{10}=1A9_{16}\). > Dans les ateliers de maintenance, on note toujours le résultat avec le préfixe « 0x » pour éviter toute ambiguïté (ex. : 0x1A9). ### 3. Conversion autre base → décimale **Méthode** : somme des produits chiffre × base\(^{position}\). **Exemple** : convertir le code binaire d’un capteur de température \(1101011_2\) en décimal pour l’interprétation sur un afficheur LCD. \[ \begin{aligned} 1\cdot2^{6}&+1\cdot2^{5}+0\cdot2^{4}+1\cdot2^{3}+0\cdot2^{2}+1\cdot2^{1}+1\cdot2^{0}\\ &=64+32+0+8+0+2+1=107_{10} \end{aligned} \] > Toute conversion doit être vérifiée par un second opérateur ou par un outil de vérification (calculatrice scientifique) afin d’éviter les erreurs de saisie. ### 4. Conversion entre bases non décimales (regroupement) Lorsque la base cible est une puissance de la source, on regroupe les chiffres. - **Binaire → Octal** : regrouper par 3 bits (puisque \(2^{3}=8\)). - **Binaire → Hexadécimal** : regrouper par 4 bits (puisque \(2^{4}=16\)). **Tableau de correspondance** (à retenir) | Binaire (3 bits) | Octal | Binaire (4 bits) | Hexadécimal | |------------------|-------|------------------|-------------| | 000 | 0 | 0000 | 0 | | 001 | 1 | 0001 | 1 | | 010 | 2 | 0010 | 2 | | 011 | 3 | 0011 | 3 | | 100 | 4 | 0100 | 4 | | 101 | 5 | 0101 | 5 | | 110 | 6 | 0110 | 6 | | 111 | 7 | 0111 | 7 | | – | – | 1000 | 8 | | – | – | 1001 | 9 | | – | – | 1010 | A | | – | – | 1011 | B | | – | – | 1100 | C | | – | – | 1101 | D | | – | – | 1110 | E | | – | – | 1111 | F | **Exemple** : convertir l’adresse binaire d’un entrée/sortie \(101110011010_2\) en octal et en hexadécimal. - Regroupement par 3 (de droite à gauche) : \(101\;110\;011\;010\) → \(5\;6\;3\;2\) → \(5632_{8}\). - Regroupement par 4 : \(1011\;1001\;1010\) → \(B\;9\;A\) → \(B9A_{16}\). > En pratique, on écrit souvent l’octal avec un zéro initial (ex. : 05632) pour rappeler qu’il s’agit d’une base 8. ### 5. Tableau récapitulatif des conversions rapides | De → Vers | Méthode principale | Exemple (valeur) | |-----------|-------------------|------------------| | Décimal → Binaire | Division successive par 2 | \(57_{10}=111001_{2}\) | | Décimal → Octal | Division successive par 8 | \(57_{10}=71_{8}\) | | Décimal → Hexadécimal | Division successive par 16 | \(57_{10}=39_{16}\) | | Binaire → Octal | Regroupement de 3 bits | \(110101_{2}=65_{8}\) | | Binaire → Hexadécimal | Regroupement de 4 bits | \(11010110_{2}=D6_{16}\) | | Octal → Binaire | Expansion chaque chiffre en 3 bits | \(72_{8}=111010_{2}\) | | Hexadécimal → Binaire | Expansion chaque chiffre en 4 bits | \(3F_{16}=00111111_{2}\) | ### 6. Table de retenue rapide pour l’addition hexadécimale | Somme (en décimal) | Résultat en hex | Retenue | |--------------------|----------------|---------| | 0‑15 | même valeur | 0 | | 16‑31 | valeur‑16 | 1 | --- ## II. Opérations arithmétiques dans les bases ### 1. Principes généraux Les règles de l’arithmétique (addition, soustraction, multiplication, division) sont identiques quelle que soit la base ; seules les tables de retenue changent. - **Addition** : on ajoute colonne par colonne, en portant la retenue lorsque la somme atteint ou dépasse la base. - **Soustraction** : on emprunte une unité de poids supérieur lorsque le chiffre du minuend est inférieur à celui du soustrait ; l’emprunt vaut la base. - **Multiplication** : on utilise la table de multiplication de la base (ou on convertit temporairement en décimal pour les tables peu familières). - **Division** : algorithme de longue division similaire au décimal, avec retenues exprimées dans la base. > Dans les automates, l’addition et la soustraction binaires sont implémentées directement par des portes logiques (half‑adder, full‑adder) ; connaître ces opérations permet de comprendre les schémas internes. ### 2. Addition binaire **Règle de retenue** : \(1+1 = 0\) avec retenue 1. **Exemple** : ajouter deux valeurs de compteur d’un convoyeur \(101101_{2}\) et \(110011_{2}\). ``` 1 0 1 1 0 1 + 1 1 0 0 1 1 ------------- 1 1 0 0 0 0 0 ``` Étape par étape (de droite à gauche) : - \(1+1=0\) retenue 1 - \(0+1+1(ret)=0\) retenue 1 - \(1+0+1(ret)=0\) retenue 1 - \(1+0+1(ret)=0\) retenue 1 - \(0+1+1(ret)=0\) retenue 1 - \(1+1+1(ret)=1\) retenue 1 → écriture du dernier 1. Résultat : \(1100000_{2}=96_{10}\). > Vérifier toujours le résultat en le convertissant en décimal (ou en hexadécimal) pour détecter une éventuelle erreur de retenue. ### 3. Soustraction binaire (méthode du complément à deux) Pour éviter les emprunts complexes, on utilise le complément à deux du soustrait. **Étapes** : 1. Déterminer le nombre de bits nécessaire (généralement la longueur du plus grand opérande). 2. Inverser tous les bits du soustrait (complément à un). 3. Ajouter 1 au résultat → complément à deux. 4. Additionner le minuend et le complément à deux. 5. Ignorer le bit de débordement éventuel. **Exemple** : soustraire \(01101_{2}\) de \(10100_{2}\) (5 bits). - Complément à un de \(01101\) → \(10010\). - Ajouter 1 → \(10011\) (complément à deux). - Addition : ``` 1 0 1 0 0 + 1 0 0 1 1 ----------- 1 0 0 1 1 1 ``` On ignore le bit de débordement (le sixième) → résultat \(00111_{2}=7_{10}\). > Le complément à deux est la représentation standard des entiers signés dans les automates PLC ; il permet d’effectuer soustractions et additions avec le même circuit. ### 4. Addition et soustraction octales Les tables de retenue sont basées sur 8. **Exemple d’addition** : \(357_{8}+642_{8}\). ``` 3 5 7 + 6 4 2 ------- 1 2 2 1 ``` - \(7+2=11_{10}=13_{8}\) → écrire 3, retenue 1. - \(5+4+1(ret)=12_{10}=14_{8}\) → écrire 4, retenue 1. - \(3+6+1(ret)=10_{10}=12_{8}\) → écrire 2, retenue 1 → écrire le dernier 1. Résultat : \(1221_{8}=657_{10}\). **Exemple de soustraction** : \(642_{8}-357_{8}\) (on peut utiliser le complément à huit, analogue au complément à deux). - Complément à sept de \(357\) → \(420\). - Ajouter 1 → \(421\) (complément à huit). - Addition : ``` 6 4 2 + 4 2 1 --------- 1 2 6 3 ``` Ignorer le débordement → \(263_{8}=179_{10}\). > En pratique, on travaille rarement directement en octal pour les opérations ; on préfère convertir en binaire, effectuer l’opération, puis reconvertir. ### 5. Addition et soustraction hexadécimales Les retenues se produisent à 16. **Table de retenue rapide** (à retenir) : | Somme | Résultat en hex | Retenue | |-------|----------------|---------| | 0‑F | même valeur | 0 | | 10‑1F | valeur‑10 | 1 | **Exemple d’addition** : \(2F_{16}+9B_{16}\). - \(F+B = 15+11 = 26_{10}=1A_{16}\) → écrire A, retenue 1. - \(2+9+1(ret)=12_{10}=C_{16}\) → écrire C. Résultat : \(CA_{16}=202_{10}\). **Exemple de soustraction** : \(9B_{16}-2F_{16}\) (on peut utiliser le complément à seize). - Complément à quinze de \(2F\) → \(D0\). - Ajouter 1 → \(D1\) (complément à seize). - Addition : ``` 9 B + D 1 ------ 1 6 C ``` Ignorer le débordement → \(6C_{16}=108_{10}\). > Lors de la programmation d’automates en langage ladder ou en texte structuré, les constantes hexadécimales sont fréquentes (ex. : adresses de registres, masques de bits). Maîtriser ces opérations évite les erreurs de masquage. ### 6. Multiplication et division (aperçu) Bien que moins utilisées couramment en atelier, il est utile de connaître le principe. - **Multiplication** : on peut convertir temporairement en décimal, multiplier, puis reconvertir, ou utiliser la méthode des produits partiels (comme en décimal) avec les tables de la base. - **Division** : même approche ; on utilise la soustraction répétée ou l’algorithme de longue division. **Exemple de multiplication binaire** : \(101_{2}\times11_{2}\). Produits partiels : ``` 1 0 1 × 1 1 -------- 1 0 1 (101 × 1) + 1 0 1 0 (101 × 1, décalé d’un rang) -------- 1 1 1 1 ``` Résultat : \(1111_{2}=15_{10}\). > En automatisme, la multiplication binaire est réalisée par des accumulateurs et des décalages ; connaître le principe aide à comprendre les temps d’exécution. ### 7. Tableau récapitulatif des opérations | Opération | Base | Retenue / Emprunt | Méthode privilégiée en atelier | |-----------|------|-------------------|--------------------------------| | Addition | 2 | 1 quand somme ≥2 | Full‑adder (porte logique) | | Soustraction | 2 | 1 quand minuend < soustrait | Complément à deux | | Addition | 8 | 1 quand somme ≥8 | Conversion → binaire → opération → reconversion | | Soustraction | 8 | 1 quand minuend < soustrait | Complément à huit (via binaire) | | Addition | 16 | 1 quand somme ≥16 | Conversion → binaire → opération → reconversion | | Soustraction | 16 | 1 quand minuend < soustrait | Complément à seize (via binaire) | | Multiplication | quelconque | – | Conversion décimal → multiplication → reconversion | | Division | quelconque | – | Conversion décimal → division → reconversion | --- ## Synthèse du chapitre - **Conversion de base** : - Décimale → autre base : division successive. - Autre base → décimale : somme pondérée. - Entre bases puissances de 2 : regroupement de bits (3→octal, 4→hexadécimal). - **Opérations arithmétiques** : mêmes règles que décimal, retenue égale à la base. - Binaire : retenue 1, complément à deux pour la soustraction. - Octal/Hexadécimal : retenue 8 ou 16, souvent traité via conversion binaire pour plus de sécurité. - **Applications professionnelles** : adressage mémoire, masquage d’entrées/sorties, réglage de timers, lecture de capteurs, programmation d’automates (Schneider, Siemens, Mitsubishi). - **Sécurité** : toujours vérifier les résultats par une seconde méthode (conversion croisée ou outil de calcul) avant de les injecter dans un automate afin d’éviter des écritures d’adresse erronées pouvant provoquer des arrêts de ligne ou des dommages matériels. --- ## Glossaire | Terme | Définition | |-------|------------| | Base | Nombre de symboles distincts utilisés dans un système de numération (ex. : base 2 = {0,1}). | | Poids positionnel | Valeur \(b^{i}\) associée au chiffre situé à la position \(i\) (en partant de la droite, \(i=0\)). | | Retenue | Valeur reportée à la colonne supérieure lorsqu’une opération dépasse la base. | | Complément à deux | Représentation d’un entier négatif en binaire : inverser les bits puis ajouter 1. | | Complément à huit | analogue du complément à deux pour la base 8 (inverser les bits sur 3 bits puis ajouter 1). | | Complément à seize | analogue du complément à deux pour la base 16 (inverser les bits sur 4 bits puis ajouter 1). | | Masque de bits | Mot binaire utilisé pour sélectionner ou modifier certains bits d’un registre (ex. : 0x0F pour les 4 bits de poids faible). | | Overflow (débordement) | Bit qui dépasse la capacité du registre lors d’une addition ou d’une soustraction. | | Automatisme programmable (API) | Dispositif électronique qui exécute un programme logique pour commander des processus industriels. | | Langage ladder | Langage de programmation graphique d’automates basé sur des contacts et des bobines. | | Registre | Zone de mémoire interne d’un automate utilisée pour stocker des données temporaires. | | Timer | Fonction d’automate qui mesure un intervalle de temps prédéterminé. | --- ## Exercices d'application corrigés ### Exercice 1 – Conversion d’adresse mémoire Un technicien doit configurer l’adresse de départ d’un bloc de données dans un automate Siemens S7‑1200. L’adresse fournie par le schéma électrique est \(2048_{10}\). **a)** Écrire cette adresse en hexadécimal (préfixe 0x). **b)** Écrire cette adresse en binaire. **c)** Vérifier que le re‑convertir en décimal donne bien 2048. **Corrigé** a) Division successive par 16 : \[ 2048 \div 16 = 128 \text{ reste } 0 \\ 128 \div 16 = 8 \text{ reste } 0 \\ 8 \div 16 = 0 \text{ reste } 8 \] Lecture des restes de bas en haut : \(800_{16}\). Préfixe : **0x800**. b) Conversion binaire de 0x800 : chaque chiffre hexa → 4 bits. \(8 = 1000\), \(0 = 0000\), \(0 = 0000\) → **1000 0000 0000\(_2\)**. c) Reconversion : \(1\cdot2^{11}+0\cdot2^{10}+…+0\cdot2^{0}=2^{11}=2048\). ✔️ --- ### Exercice 2 – Addition binaire avec retenue Deux compteurs d’une ligne de conditionnement de café contiennent respectivement les valeurs \(110101_{2}\) et \(101110_{2}\). **a)** Effectuer leur somme en binaire. **b)** Donner le résultat en décimal et en hexadécimal. **c)** Interpréter ce résultat comme le nombre total de paquets traités si chaque unité du compteur représente 5 paquets. **Corrigé** a) Addition : ``` 1 1 0 1 0 1 + 1 0 1 1 1 0 ------------- 1 1 0 0 0 1 1 ``` Résultat binaire : **1100011₂**. b) Décimal : \(1·2^{6}+1·2^{5}+0·2^{4}+0·2^{3}+0·2^{2}+1·2^{1}+1·2^{0}=64+32+0+0+0+2+1=99_{10}\). Hexadécimal : \(99_{10}=63_{16}\) (puisque \(6·16+3=99\)). c) Chaque unité = 5 paquets → total paquets = \(99 × 5 = 495\) paquets. --- ### Exercice 3 – Soustraction par complément à deux Un registre d’un automate contient la valeur binaire \(10100_{2}\) (20₁₀). On veut soustraire la valeur \(00111_{2}\) (7₁₀) pour obtenir le nouveau état après une commande. **a)** Réaliser la soustraction en utilisant le complément à deux du soustrait. **b)** Donner le résultat en binaire, décimal et hexadécimal. **Corrigé** a) Complément à deux de \(00111\) (sur 5 bits) : - Inversion : \(11000\) - Ajout 1 : \(11001\) Addition : ``` 1 0 1 0 0 + 1 1 0 0 1 ----------- 1 0 1 1 0 1 ``` Ignorer le bit de débordement (le sixième) → résultat **01101₂**. b) Décimal : \(0·2^{4}+1·2^{3}+1·2^{2}+0·2^{1}+1·2^{0}=8+4+0+0+1=13_{10}\). Hexadécimal : \(13_{10}=D_{16}\). --- ### Exercice 4 – Opération hexadécimale avec masque Dans un programme d’automate, on doit appliquer le masque \(0x0F\) au registre contenant la valeur \(0x3A\) pour n conserver que les 4 bits de poids faible. **a)** Effectuer l’opération ET logique entre \(0x3A\) et \(0x0F\). **b)** Donner le résultat en binaire, hexadécimal et décimal. **c)** Expliquer l’intérêt de cette opération en automatisme. **Corrigé** a) \(0x3A = 0011\;1010_{2}\) \(0x0F = 0000\;1111_{2}\) ET bit à bit : ``` 0011 1010 & 0000 1111 ----------- 0000 1010 ``` b) Résultat binaire : **0000 1010₂** → hexadécimal **0x0A** → décimal **10**. c) Cette opération permet d’isoler les quatre bits de poids faible, souvent utilisés pour encoder un état discret (ex. : sélection d’une recette parmi 16 possibilités) sans être affecté par les bits de poids fort qui peuvent contenir d’autres informations (flags, timers, etc.). --- ## Erreurs fréquentes et règles de sécurité | # | Erreur fréquente | Conséquence | Règle de prévention / bonne pratique | |---|------------------|-------------|--------------------------------------| | 1 | Oublier la retenue lors d’une addition binaire (ex. : \(1+1=0\) sans retenir 1). | Résultat faux → adresse mémoire incorrecte → écriture hors zone → arrêt de ligne. | Toujours vérifier la colonne de retenue ; utiliser la méthode du « carry » écrite en petit au-dessus de la colonne. | | 2 | Confondre le complément à un et le complément à deux lors d’une soustraction binaire. | Résultat décalé d’une unité → mauvaise valeur de compteur → dysfonctionnement d’un timer. | Rappeler que le complément à deux = complément à un + 1 ; vérifier en ajoutant le résultat au soustrait pour obtenir zéro (en ignorant le débordement). | | 3 | Effectuer une opération directement en octal ou hexadécimal sans convertir en binaire lorsqu’il y a risque de retenue croisée (ex. : addition \(7_{8}+7_{8}\)). | Erreur de retenue → valeur erronée → mauvaise configuration d’un masque de bits. | Préférer convertir en binaire, réaliser l’opération, puis reconvertir ; ou utiliser la table de retenue octale/hexadécimal avec vérification croisée. | | 4 | Négliger le bit de débordement lors d’une addition en registre de 8 bits (ex. : \(0xFF+0x01\)). | Le débordement est perdu → valeur revient à 0x00 → perte d’information critique (ex. : compteur de production). | Toujours tester le drapeau de débordement (carry flag) de l’API ; si nécessaire, utiliser un registre de plus grande largeur ou gérer le débordement explicitement. | | 5 | Utiliser un masque inadéquat (ex. : appliquer 0xF0 au lieu de 0x0F) pour isoler les bits de poids faible. | On conserve les bits de poids fort au lieu des bits voulus → commande erronée d’un actionneur. | Dessiner le masque en binaire avant de l’appliquer ; vérifier que les 1 du masque correspondent exactement aux bits à conserver. | | 6 | Ne pas consigner les conversions dans le cahier de charges ou le dossier de maintenance. | Perte de traçabilité → difficulté à diagnostiquer une panne ultérieure. | Imposer une règle de rédaction : chaque adresse ou constante utilisée dans le programme doit être accompagnée de sa représentation décimale, binaire et hexadécimale dans le document de spécification. | --- *Fin du cours.*