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

## Objectifs et prérequis **À la fin de ce chapitre, l’élève sera capable de :** - Identifier et nommer les différentes bases de numération utilisées en automatisme (binaire, octale, décimale, hexadécimale). - Effectuer le changement de base d’un nombre entier ou fractionnaire entre ces systèmes, avec ou sans calculatrice. - Vérifier l’équivalence de représentations numériques dans différentes bases et détecter les erreurs de conversion. - Appliquer ces compétences à des situations professionnelles : lecture de consignes sur un automate programmable, réglage de paramètres d’un variateur de fréquence, interprétation d’adresses mémoire dans un PLC. **Prérequis :** - Maîtrise des opérations élémentaires (addition, soustraction, multiplication, division) en base 10. - Connaissance des puissances de 2 jusqu’à \(2^{10}\) et de leurs valeurs décimales. - Notion de chiffre significatif et de poids positionnel. --- ## Introduction contextualisée Dans les installations industrielles camerounaises, les automates programmables (API) et les variateurs de vitesse utilisent fréquemment des représentations binaires ou hexadécimales pour économiser la mémoire et accélérer les traitements. Un technicien chargé de la maintenance d’une ligne de conditionnement de boissons au Douala doit, par exemple, lire l’état des entrées/sorties d’un API sous forme binaire pour diagnostiquer un défaut de capteur, puis convertir cette information en hexadécimal afin de la comparer avec les valeurs consignées dans le manuel du constructeur. Maîtriser les systèmes de numération et leurs conversions permet donc d’intervenir rapidement, de réduire les temps d’arrêt et de garantir la sécurité des opérations. --- ## I. Leçon 17 – Les bases ### 1. Définition d’une base de numération Une **base** (ou radix) \(b\) est un entier supérieur à 1 qui détermine le nombre de symboles distincts utilisés pour représenter les nombres. Chaque position d’un chiffre représente une puissance de \(b\). > **>** Une représentation en base \(b\) d’un entier \(N\) s’écrit : > $$N = \sum_{i=0}^{n} d_i \, b^{\,i}$$ > où \(d_i\) est le chiffre situé à la position \(i\) (de poids faible à fort) et \(0 \le d_i < b\). ### 2. Bases usuelles en automatisme | Base | Symboles utilisés | Domaine d’application typique | |------|-------------------|------------------------------| | 2 (binaire) | 0, 1 | États logiques d’entrées/sorties, registre interne d’un API | | 8 (octale) | 0‑7 | Représentation compacte de groupes de 3 bits (anciens systèmes) | | 10 (décimale) | 0‑9 | Consignes opérateurs, affichages humains | | 16 (hexadécimale) | 0‑9, A‑F | Adresses mémoire, codes d’erreur, paramètres de variateurs | ### 3. Propriétés de poids positionnel - Le poids du chiffre le plus à droite est \(b^{0}=1\). - Chaque déplacement d’une position vers la gauche multiplie le poids par \(b\). - Le nombre de chiffres nécessaires pour représenter un nombre \(N\) en base \(b\) est \(\left\lfloor \log_{b} N \right\rfloor +1\). > **>** En base 2, le poids du \(i^{\text{ème}}\) bit (en partant de 0) vaut \(2^{i}\). ### 4. Exemple d’atelier : lecture d’un entrée binaire Sur un API Modicon M221, l’entrée **IX0.0** est à l’état bas (0) et **IX0.1** à l’état haut (1). Le mot d’entrée **IX0** (8 bits) vaut donc : $$ \text{IX0}= (0\;0\;0\;0\;0\;0\;1\;0)_{2}=2_{10} $$ Le technicien lit cette valeur en décimal pour vérifier que le compteur d’incrémentation est bien à 2. --- ## II. Leçon 18 – Équivalence entre les bases ### 1. Principe d’équivalence Deux représentations de nombres sont **équivalentes** si elles expriment la même valeur décimale, indépendamment de la base utilisée. > **>** Deux représentations \( (N)_{b_1} \) et \( (N)_{b_2} \) sont équivalentes si : > $$\sum_{i} d_i^{(b_1)} b_1^{\,i}= \sum_{j} d_j^{(b_2)} b_2^{\,j}$$ ### 2. Table de correspondance binaire‑octale‑hexadécimale Comme \(2^{3}=8\) et \(2^{4}=16\), on peut regrouper les bits par paquets de 3 (pour l’octal) ou de 4 (pour l’hexadécimal). | Binaire (4 bits) | Hexadécimal | Binaire (3 bits) | Octal | |------------------|------------|------------------|-------| | 0000 | 0 | 000 | 0 | | 0001 | 1 | 001 | 1 | | 0010 | 2 | 010 | 2 | | 0011 | 3 | 011 | 3 | | 0100 | 4 | 100 | 4 | | 0101 | 5 | 101 | 5 | | 0110 | 6 | 110 | 6 | | 0111 | 7 | 111 | 7 | | 1000 | 8 | — | — | | 1001 | 9 | — | — | | 1010 | A | — | — | | 1011 | B | — | — | | 1100 | C | — | — | | 1101 | D | — | — | | 1110 | E | — | — | | 1111 | F | — | — | > **>** Pour convertir un nombre binaire en hexadécimal, on regroupe les bits par groupes de 4 en partant de la droite, en ajoutant des zéros de poids faible si nécessaire. ### 3. Conversion fractionnaire Les mêmes règles s’appliquent à la partie fractionnaire : on groupe les bits après la virgule par paquets de 3 ou 4, en ajoutant des zéros à droite si besoin. > **>** Exemple : \( (0,1011)_{2} = (0,B)_{16} \) car \(1011_{2}=B_{16}\). ### 4. Exemple de chantier : réglage d’un variateur de fréquence Un variateur Altivar 71 accepte la consigne de vitesse sous forme hexadécimale sur 16 bits. La consigne souhaitée est 1500 tr/min, correspondant à la valeur décimale 1500. 1. Conversion décimal → binaire : \(1500_{10}= (0101\;1101\;1100)_{2}\) (on complète à 16 bits : \(0000\;0101\;1101\;1100_{2}\)). 2. Regroupement par 4 : \(0000\;0101\;1101\;1100\) → \(0\;5\;D\;C\). 3. Résultat hexadécimal : **05DC**. Le technicien saisit donc **05DC** dans le terminal du variateur. --- ## III. Leçon 19 – Changement de bases ### 1. Méthode générale (décomposition en puissances) Pour convertir un entier \(N\) de la base \(b_1\) vers la base \(b_2\) : 1. Exprimer \(N\) en base 10 (ou directement en puissance de \(b_2\) si \(b_2\) est une puissance de \(b_1\)). 2. Effectuer les divisions successives par \(b_2\) pour obtenir les restes, qui forment les chiffres de la nouvelle base (du moins significatif au plus significatif). > **>** Algorithme de conversion décimal → base \(b\) : > - Tant que \(N>0\) : > - \(r = N \bmod b\) (reste) > - Chiffre = \(r\) > - \(N = \left\lfloor N / b \right\rfloor\) > - Lire les restes dans l’ordre inverse. ### 2. Conversion directe entre bases liées par une puissance Si \(b_2 = b_1^{k}\) (ex. \(2^{3}=8\), \(2^{4}=16\)), on regroupe les chiffres de \(b_1\) par paquets de \(k\). > **>** Exemple : \( (110\;101\;011)_{2} \) → groupes de 3 → \( (6\;5\;3)_{8} = (653)_{8}\). ### 3. Conversion de nombres fractionnaires - Partie entière : méthode ci‑dessus. - Partie fractionnaire : multiplier successivement par \(b_2\) et prendre la partie entière comme chiffre, puis répéter avec la partie fractionnaire restante. > **>** Exemple : convertir \(0,625_{10}\) en binaire : > \(0,625 \times 2 = 1,25\) → chiffre 1, reste 0,25 > \(0,25 \times 2 = 0,5\) → chiffre 0, reste 0,5 > \(0,5 \times 2 = 1,0\) → chiffre 1, reste 0 → fin. > Résultat : \(0,101_{2}\). ### 4. Tableau de conversion rapide (exemple d’atelier) | Décimal | Binaire (8 bits) | Octal | Hexadécimal | |---------|------------------|-------|-------------| | 0 | 00000000 | 00 | 00 | | 15 | 00001111 | 017 | 0F | | 255 | 11111111 | 377 | FF | | 1024 | 0000 0100 0000 0000 | 002000 | 0400 | > **>** Un octet (8 bits) peut représenter 256 valeurs différentes, de 0 à 255 en décimal, soit 00 à FF en hexadécimal. ### 5. Exemple professionnel : adressage mémoire d’un API Un API possède une zone de mémoire de 4 Ko (4096 octets) réservée aux paramètres de réglage. L’adresse de début est **0x0000** et celle de fin est **0x0FFF**. - Vérification : \(0x0FFF_{16}= (0\times16^{3}+0\times16^{2}+15\times16^{1}+15)_{10}= 4095_{10}\). - Ainsi les adresses vont de 0 à 4095, soit exactement 4096 emplacements, conformément à la taille de la zone. Le technicien, lorsqu’il doit écrire un paramètre à l’adresse **0x03A7**, convertit cette adresse en décimal pour la saisir dans le logiciel de programmation : \(0x03A7 = 3\times16^{2}+10\times16^{1}+7 = 3\times256+10\times16+7 = 768+160+7 = 935_{10}\). --- ## Synthèse du chapitre - **Base** : nombre de symboles utilisés ; poids positionnel \(b^{i}\). - **Bases usuelles** : 2 (binaire), 8 (octale), 10 (décimale), 16 (hexadécimale). - **Équivalence** : même valeur décimale → regroupement de bits (3→octal, 4→hexadécimal). - **Conversion entière** : divisions successives par la nouvelle base (reste = chiffre). - **Conversion fractionnaire** : multiplications successives, partie entière = chiffre. - **Applications** : lecture d’entrées/sorties API, réglage de variateurs, adressage mémoire, interprétation de codes d’erreur. - **Formule clé** : \(N = \sum d_i b^{i}\). - **Astuce** : pour \(b_2=b_1^{k}\), regrouper les chiffres de \(b_1\) par paquets de \(k\). --- ## Glossaire - **Base (radix)** : entier \(b>1\) définissant le système de numération. - **Chiffre** : symbole utilisé dans une base, compris entre 0 et \(b-1\). - **Poids positionnel** : valeur \(b^{i}\) associée à la position \(i\) d’un chiffre. - **Conversion** : opération permettant de passer d’une représentation en base \(b_1\) à une représentation en base \(b_2\). - **Regroupement** : technique de conversion directe lorsque la nouvelle base est une puissance de l’ancienne (ex. binaire → octale). - **Reste** : résultat de la division modulo utilisé pour obtenir les chiffres lors d’une conversion décimal → autre base. - **Partie fractionnaire** : partie d’un nombre située après la virgule dans une base donnée. - **Adresse mémoire** : localisation hexadécimale d’un octet ou d’un mot dans la mémoire d’un automate. --- ## Exercices d'application corrigés ### Exercice 1 – Lecture d’entrée API Un API possède 8 entrées disposées sur le mot **IX1**. L’état actuel des entrées est : ``` IX1.7 IX1.6 IX1.5 IX1.4 IX1.3 IX1.2 IX1.1 IX1.0 1 0 1 1 0 0 1 0 ``` **a)** Écrire cet état en binaire. **b)** Le convertir en décimal. **c)** Le convertir en hexadécimal. **Corrigé** a) Binaire : \(1\;0\;1\;1\;0\;0\;1\;0_{2}\). b) Décimal : \(1\times2^{7}+0\times2^{6}+1\times2^{5}+1\times2^{4}+0\times2^{3}+0\times2^{2}+1\times2^{1}+0\times2^{0}=128+0+32+16+0+0+2+0=178_{10}\). c) Hexadécimal : regrouper par 4 bits → \(1011\;0010\) → \(B\;2\) → **0xB2**. --- ### Exercice 2 – Réglage d’un variateur de vitesse Un variateur accepte la consigne de vitesse sur 16 bits en hexadécimal. La vitesse désirée est 1800 tr/min, sachant que la plage 0‑4095 correspond à 0‑3000 tr/min. **a)** Déterminer la valeur décimale à envoyer. **b)** Convertir cette valeur en binaire sur 16 bits. **c)** Donner la représentation hexadécimal finale. **Corrigé** a) Proportionnalité : \(\frac{1800}{3000}=0,6\). Valeur décimale = \(0,6 \times 4095 = 2457\) (arrondi à l’entier le plus proche). b) Conversion 2457 en binaire : \(2457_{10}=100110011001_{2}\). Sur 16 bits : \(0000\;1001\;1001\;1001_{2}\). c) Regroupement par 4 : \(0000\;1001\;1001\;1001\) → \(0\;9\;9\;9\) → **0x0999**. --- ### Exercice 3 – Adressage mémoire Une zone de mémoire d’un API commence à l’adresse **0x0200** et occupe 512 octets. **a)** Quelle est l’adresse de fin (inclus) en hexadécimal ? **b)** Vérifier que le nombre d’octets correspond bien à la différence d’adresse. **Corrigé** a) 512 octets = \(0x200\) en hexadécimal. Adresse de fin = \(0x0200 + 0x1FF = 0x03FF\). (Puisque l’adresse de début compte comme premier octet, on ajoute 511 = 0x1FF). b) Différence : \(0x03FF - 0x0200 + 1 = 0x200 = 512\) décimal. --- ## Erreurs fréquentes et règles de sécurité | # | Erreur fréquente | Conséquence | Règle de prévention / bonne pratique | |---|------------------|-------------|--------------------------------------| | 1 | Oublier d’ajouter des zéros de poids faible lors du regroupement binaire → hexadécimal (ex. \(101_{2}\) devenu \(5_{16}\) au lieu de \(05_{16}\)). | Lecture erronée d’une consigne, risque de surtension ou de sous‑alimentation d’un variateur. | Toujours compléter le groupe de bits à gauche avec des zéros jusqu’à obtenir un nombre de bits multiple de 3 (octal) ou 4 (hexadécimal). | | 2 | Confondre le sens de lecture des restes lors de la conversion décimal → autre base (lire les restes dans l’ordre de obtention au lieu de l’inverse). | Valeur totalement différente, pouvant entraîner un mauvais réglage de vitesse ou une adresse mémoire incorrecte. | Écrire les restes dans une colonne puis les lire de bas en haut après la fin des divisions. | | 3 | Interpréter un nombre signé en binaire comme non signé (ex. \(1111\;1111_{2}\) lu comme 255 au lieu de -1 en complément à deux). | Consigne négative interprétée comme forte positive → mouvement inattendu d’un moteur. | Vérifier la représentation utilisée (non signé, complément à deux, etc.) avant la conversion ; consulter le manuel de l’automate. | | 4 | Utiliser la virgule décimale au lieu de la virgule binaire lors de la conversion fractionnaire (ex. écrire \(0,101_{2}\) comme \(0,101_{10}\)). | Erreur de calcul de consigne analogique, pouvant mener à un dépassement de capacité d’un actionneur. | Toujours indiquer clairement la base lorsqu’on travaille avec une partie fractionnaire ; utiliser la notation \((x)_{b}\). | | 5 | Négliger de vérifier les limites d’adresse avant d’écrire dans la mémoire d’un API (écriture au‑delà de la zone réservée). | Corruption du programme ou des données critiques, arrêt de la ligne de production. | Avant toute écriture, calculer l’adresse finale et la comparer à la taille de la zone allouée ; utiliser les fonctions de vérification du logiciel de programmation. | | 6 | Effectuer une conversion à la main sans vérifier avec un outil (calculatrice, logiciel) lorsqu’il s’agit de grands nombres (plus de 4 chiffres hexadécimaux). | Risque d’erreur de transcription, surtout sous pression de temps. | Pour les valeurs > 0xFFFF, faire un contrôle croisé avec une calculatrice scientifique ou le tableau de conversion intégré au logiciel de programmation. | --- *Fin du cours.*