Microprocesseurs et systèmes embarqués

Il s'agit du huitième cours en génie électrique universitaire : microprocesseurs et systèmes embarqués**. EE03 a conçu la logique ; ce cours construit la machine qui exécute les programmes, et la discipline permettant à l'hardware et au logiciel de coexister.

• Unité 8.1 cartographie l'architecture : CPU, registres, mémoire, et le cycle fetch-décodage-exécution.
• Unités 8.2–8.3 le programment : C embarqué et assembleur, puis E/S mappées en mémoire.
• Les modules 8.4–8.5 ajoutent le temps : interruptions/montreuses et les protocoles série.
• Les modules 8.6–8.7 se terminent par des interfaces analogiques et une méthode de débogage.

L'histoire en cours est celle d'un petit produit : une sonde capteur alimentée par batterie avec un bouton, une DEL, un lien série et un capteur de 12 bits. Chaque unité ci-dessous fait avancer cette sonde, et chaque nombre est vérifié à la manière dont un ingénieur firmware le vérifie — par les largeurs et limites de bits (la valeur tient-elle ?), par l'horloge qu'il suppose (chaque temporisation converge contre 84 MHz), et par la traçabilité des changements d'état exacts de chaque fragment de code.

Pourquoi c'est important. Le thermostat mural, le contrôleur antipatinage et l'écouteur sur le bureau exécutent chacun l'un de ceux-ci : un ordinateur complet sur un puce de la taille d'un grain de riz, coûtant moins que le port qui l'expédie.

L'idée, avec une image. Un microcontrôleur intègre trois choses sur une seule puce : une mémoire flash contenant le programme, une SRAM contenant les données, et un CPU qui exécute le cycle fetch-décodage-exécution : compteur d'instructions (PC) contient l'adresse de l'instruction suivante, l'unité de contrôle la décode, l'unité exécutive l'exécute, et le PC incrémente (ou saute). Chaque transfert emprunte le bus — lignes d'adresse indiquant où, lignes de données transportant quoi, lignes de contrôle indiquant lecture ou écriture — séquentielles par l'horloge.

La dérivation. Les adresses sont des entiers non signés, donc un champ d'adresse de N bits adresse $2^{N}$ emplacements exactement. La carte mémoire entière suit :

Flash à 0x0000_0000 et SRAM à 0x2000_0000 ne se chevauchent jamais car leurs bits de poids fort diffèrent — le décodeur d'adresses regarde simplement les bits [31:16].

Exemple résolu 1 — dimensionnement de la carte mémoire. Le nœud possède 64 Ko de flash et 8 Ko de SRAM. Flash : $64\,\text{KB} = 2^{16}$ octets → 16 lignes d'adresse, donc il occupe 0x0000_0000–0x0000_FFFF. SRAM : $8\,\text{KB} = 2^{13}$ octets → 13 lignes, à 0x2000_0000–0x2000_1FFF. Vérification : toute adresse avec les bits [31:16] = 0x0000 et [15:0] ≤ 0xFFFF atterrit dans le flash ; 0x2000_… atterrit dans la SRAM ; les régions ne peuvent pas se chevaucher car leurs bits de poids fort diffèrent ✓.

Exemple résolu 2 — quelle est la vitesse de la boucle elle-même ? Le CPU du nœud fonctionne à 84 MHz avec une instruction nominale par cycle (un cœur de type Cortex-M) : $84 \times 10^{6}$ instructions par seconde, donc une instruction prend $\dfrac{1}{84 \times 10^{6}} = 11.9$ ns. Un passage de contrôle d'instruction 100 coûte donc 1.19 µs — et une boucle de contrôle 1 ms dispose d'environ 840 passes si rien d'autre n'intervient. L'arithmétique budgétaire qui commence ici est réutilisée dans chaque unité ultérieure.

Erreurs courantes. Mélanger les bits d'adresse avec les bits de données (les lignes d'adresse comptent les emplacements, les lignes de données leur largeur). Oublier que la carte est fixée dans le script de l'assembleur : la même puce s'amorce à n'importe quelle adresse que le fournisseur du matériel a choisie. Et citer la taille du programme en bits alors que les tailles de flash sont en octets — un facteur huit qui élimine le choix de la puce.

Résumé. Une puce : flash + SRAM + CPU effectuant des cycles de fetch, décodage, exécution. Un champ d'adresse N-bit adresse $2^{N}$ octets ; les régions aux bits de poids fort distincts ne peuvent pas se chevaucher ; l'horloge convertit le nombre d'instructions en secondes.

Pourquoi c'est important. Le micrologiciel du nœud compte quelques milliers de lignes de C touchant directement les registres matériels. Rien entre votre ligne de code et un transistor — ce qui explique exactement pourquoi la mappage de C vers la machine doit être précise.

L'idée, avec une image. Un registre mappé en mémoire est simplement une adresse ; C y accède via un pointeur volatile (volatile indique au compilateur : cette mémoire change hors de votre vue, touchez-la à chaque fois). Le compilateur transforme le C en charges, stores, arithmétique et branches ; assemblage est le même programme écrit selon ces instructions à la main, une ligne par instruction.

Dérivation. La lecture-modification-écriture est l'acte fondamental : modifier un broche sans perturber ses voisines, le CPU doit charger le registre, masquer Une implémentation illustrative de charge-incrémentation-stockage avec branchement trace transferts de bus : une lecture et une écriture. Cet exemple utilise un registre mot simple de lecture/écriture certains périphériques réels offrent également des registres atomiques de mise à zéro/mise à un :

volatile uint32_t *const GPIO_OUT = (uint32_t *)0x40000000u;
*GPIO_OUT |= (1u << 5);   // load, OR, store — set bit 5 only

Exemple résolu 1 — tracer le compteur. La boucle C

uint32_t count = 0;
while (1) { count = count + 1; }

Une implémentation illustrative de charge-incrémentation-stockage plus branchement trace $0, 1, 2, 3, \ldots$. Un compilateur peut plutôt conserver ce compteur non volatile dans un registre CPU. Vérifiez la limite : la valeur maximale est $2^{32} - 1 = 4\,294\,967\,295$ ; le prochain incrémente revient à zéro après $2^{32}$ incréments depuis zéro. En supposant quatre cycles d'horloge par itération à 84 MHz, le retournement dure $\dfrac{4\,294\,967\,296 \times 4}{84 \times 10^{6}} \approx 204$ s — calculs arithmétiques, pas trois minutes avec un chronomètre.

Exemple résolu 2 — le masque binaire, amplifié. Pour inverser les bits 5 et 6 et efface le bit 3 dans une seule expression : le masque est $(1 \ll 5) \,|\, (1 \ll 6) = 0x60$. Puis *GPIO_OUT = (*GPIO_OUT & ~0x08) ^ 0x60 efface le bit 3 et inverse 5 et 6 en une lecture-modification-écriture. Vérifier sur papier avec GPIO_OUT = 0xCE : 0xCE & ~0x08 = 0xC6, puis 0xC6 ^ 0x60 = 0xA6 — le bit 3 vaut maintenant 0 (était 1), les bits 6 et 5 ont basculé de 1, 0 vers 0, 1 ✓. Le contrôle hexadécimal sur le papier est le débogueur le plus rapide de cette unité.

Erreurs courantes. Omettre volatile (le compilateur met en cache le registre dans un registre CPU et votre boucle le lit indéfiniment). Supposer un ordre d'évaluation C entre deux écritures de registre alors que le matériel les nécessite séquentiellement — insérez une barrière ou une lecture de retour. Et écrire le bit 5 comme *GPIO_OUT = 0x20, ce qui efface tous les autres bits du port.

Résumé. Les registres sont des adresses ; volatile garde le compilateur honnête ; cet exemple simple mot-registre utilise chargement-masque-stockage. Tracez l'état sur papier en hexadécimal avant de faire confiance au silicium.

Pourquoi c'est important. Le bouton, la LED et le capteur du nœud se trouvent tous à l'extérieur du CPU. La façon dont ils sont connectés détermine si le firmware est un tableau propre d' adresses ou un amas de nombres magiques.

L'idée, avec une image. L'E/S mappée en mémoire fait qu'un registre périphérique ressemble exactement à une emplacement mémoire : lire un registre de données receut un octet ; l'écrire l'envoie. Un port GPIO possède deux tels registres — direction (entrée ou sortie, un bit par broche) et données (niveau de la broche) — pour configurer une fois, puis lire ou écrire indéfiniment.

La dérivation. Le polling est la référence honnête : le statut le bit de fin d'enregistrement est une lecture mémoire dans une boucle. Chaque tour coûte des instructions à la boucle ; attendre T secondes consomme des cycles CPU — chacun d'eux étant utilisé pour demander « c'est fait ? » à un périphérique qui ne répond qu'une fois. instructions ; attendre T secondes consomme

cycles CPU, ou environ $T f_{\text{clock}}/C$ tours complets lorsque chaque tour coûte $C$ cycles d'horloge. Le facteur $C$ modifie le nombre de vérifications, mais pas le temps CPU occupé par une boucle de surveillance continue. Détection et temporisation les tests sont quantifiés aux instants de vérification de la boucle.

Exemple résolu 1 — le coût de l'interrogation. Le nœud interroge un bit capteur-prêt à 84 MHz ; chaque tour de boucle dure 4 cycles (charge, ET logique, branchement, incrémentation), donc le CPU effectue $84 \times 10^{6}/4 = 21$ millions de tours par seconde. L'attente 1 ms correspondent à ~21 000 tours = 84 000 cycles : 100 % du CPU pour cette milliseconde, sans aucun travail utile.

Exemple résolu 2 — carte complète du nœud. Les périphériques du nœud sont situés à 0x4000_0000 (GPIO), 0x4001_0000 (UART), 0x4002_0000 (minuteur), 0x4003_0000 (ADC). Une table de constantes firmware associe chaque pilote à sa base ; une faute de frappe dans une entrée (0x4001_0000 au lieu de 0x4001_0004) se retrouve quatre octets plus loin, dans l'ensemble de registres de l'UART — c'est pourquoi chaque fichier pilote commence par des décalages nommés, jamais par des adresses brutes. La vérification : après l'initialisation, lire le registre d'identification de chaque périphérique ; une mauvaise base renvoie des données corrompues dès la première lecture.

Erreurs courantes. Oublier le registre de direction (la broche reste en entrée et l'écriture ne produit rien). Interrogation sans délai limite — un capteur défaillant met tout le produit en attente. Et confondre le numéro de bit d'un port avec le numéro de broche sur le boîtier : consulter le tableau des broches du datasheet, pas celui de l'en-tête. macro de commodité, c'est la vérité.

Résumé. Les périphériques sont une mémoire : base plus décalages nommés. Configurez une seule fois la direction, interrogez avec un délai d'attente, et laissez une vérification par lecture ID prouver le carte avant tout travail réel.

Pourquoi c'est important. Le nœud fonctionne sur pile pendant un an. L'interrogation consomme la pile en posant des questions ; les interruptions permettent au processeur de se mettre en veille jusqu'à ce que le monde ait besoin de lui — la différence entre une semaine et un an.

L'idée, avec une image. Une interruption suspend le programme principal à l'endroit où il se trouve : le matériel pousse l'état de retour, vectorise vers une routine de service d'interruption (ISR) choisie par le NVIC (le contrôleur d'interruptions vectorisées imbriquées, qui classe également les priorités), l'ISR s'exécute et revient. Un minuterie est simplement un compteur horlogé via un diviseur — le prédiviseur. Dans le compteur ascendant de style STM32 utilisé ici, un événement de mise à jour se produit lorsque CNT passe de ARR à zéro ; une interruption activée peut alors appeler le ISR. l'interruption peut alors appeler le ISR.

La dérivation. La fréquence de la minuterie est divisée deux fois :

où PSC et ARR sont les valeurs stockées dans les registres 16-bits, au maximum 65,535. est valide lorsque les valeurs stockées tiennent compte ET 65,536. est valide lorsque les valeurs stockées rentrent ET $PR=f_{\text{clock}}/f_{\text{interrupt}}$. Ici, ARR est non nul et le compteur fonctionne en continu.

Exemple résolu 1 — battement cardiaque de 1 Hz. De 84 MHz : facteur de division 8400 donne $84 \times 10^{6}/8400 = 10$ kHz ; un facteur de 10,000 donne exactement 1 Hz. Écrivez PSC = 8399 et ARR = 9999. Les deux valeurs stockées tiennent dans 16 bits, et $8400 \times 10\,000 = 84 \times 10^{6}$ ✓ ferme la conception. Un diviseur de facteur 84,000 nécessiterait PSC = 83,999, ce qui ne tient pas.

Worked example 2 — interrupt latency vs polling, priced. A GPIO interrupt with 12 cycles of entry, a 30-instruction ISR and 10 cycles of coût de retour $12 + 30 + 10 = 52$ cycles $= 0.62$ µs à 84 MHz — contre le 21 000 tours d'attente sondée consommés. Mais le coût de l'ISR est payé à chaque événement : à 1 kHz d'événements, cela représente 52 000 cycles/s = 0.06% du CPU ; à 1 MHz d'événements, c'est 62% — au-delà d'un certain débit, sonder un périphérique rapide est moins coûteux qu'utiliser une interruption. Le calcul de ce point de bascule est la décision de conception.

Erreurs courantes. Une ISR qui oublie de réinitialiser son indicateur d'interruption — le CPU revient et réentre immédiatement, indéfiniment. Longues ISRs (faites le minimum, positionnez un indicateur, laissez la boucle principale fonctionner). Et les conflits avec le timer : lire un timer 16-bits sur un bus 8-bits nécessite de lire le byte haut deux fois ou de le verrouiller, sinon un report entre les lectures corrompt la valeur.

Résumé. Interruption = vecteur + ISR courte + effacement de flag ; timer = $(PSC+1)(ARR+1)$ par rapport à l'horloge, avec les deux valeurs stockées dans leurs Enregistreurs. Les interruptions gagnent aux faibles fréquences d'événements ; le sondage (polling) l'emporte au-delà de ~1 MHz.

Pourquoi c'est important. Les relevés du nœud transitent par trois fils ou moins. Choisir entre UART, SPI ou I2C — et pondérer le coût des fils par rapport à la vitesse — relève d'une décision hebdomadaire en développement embarqué.

L'idée, avec une illustration. UART envoie asynchronement taux de bauds convenu par les deux extrémités. SPI partage une horloge : le maître pilote SCLK et chip-select, les données circulent sur MOSI en sortie et MISO en entrée — plein duplex. I8C nécessite deux fils (SDA données, SCL horloge), adresse les périphériques avec 2 bits, et les relie en open-drain pour qu'un seul périphérique puisse maintenir le bus bas. La dérivation. UART n'a pas de ligne d'horloge, donc les deux extrémités reconstruisent le temps 7 bits, et les câbles en open-drain pour que tout appareil puisse maintenir la ligne basse.

La dérivation. UART n'a pas de ligne d'horloge, donc les deux extrémités reconstruisent le temps à partir du baud agreed : un octet en formatage 8N1 occupe exactement 10 temps de bit,

SPI envoie un bit par cycle d'horloge complet, donc un octet prend 8 horloges plus setup : $T_{\text{byte}} \approx 8/f_{\text{SCLK}}$ — l'horloge est la vitesse.

Exemple résolu 1 — dimensionnement UART. À 115 200 baud, 8N1 : le débit utile est burst de $115\,200/10 = 11\,520$ octets (durée $10/115\,200 = 86.8$ ms) dépasse le budget — fractionner le transfert ou augmenter le taux de bauds. Le Par rapport au boucle de contrôle de 1 ms du nœud : 11 octets tiennent juste (0.95 ms) ✓ ; un éclat bloquant de 100 octets (8.68 ms) dépasse le budget — divisez-le ou augmentez le débit. Le La taille dicte, pas la préférence.

Worked example 2 — the three-way price. SPI at 10 MHz clocks a byte in $8/10\,\text{MHz} = 0.8$ µs — environ 108× plus rapide que UART ici — mais nécessite un fil de sélection de puce par périphérique. I2C à 400 kHz nécessite 9 horloges pour 8 bits de données plus ACK : $9/400\,\text{kHz} = 22.5$ µs, avant les surcoûts d'adresse, de démarrage et d'arrêt. (avec des variantes aux extrémités). Reconstruire chaque bande d'entrée à son point médian servent toute la carte (adresse de 7 bits = jusqu'à 112 dispositifs à 1 adresse par dispositif). Capteur sur I2C, flash sur SPI, console sur UART — la répartition standard, chacun tarifié selon cet arithmétique.

Erreurs courantes. Baud rate inadapté (la trame fonctionne toujours et les octets sont corrompus — vérifiez les calculs du diviseur par rapport à l'horloge périphérique, pas à l' horloge centrale). Lecture d'une adresse I2C comme 8 bits : l'adresse de 7 bits plus le bit lecture/écriture s'empilent dans un seul octet, et les fiches techniques citent les deux formes. Et oublier le mode SPI (polarité et phase de l'horloge) : les quatre modes existent parce que les dispositifs diffèrent ; le mauvais mode décale chaque octet d'un bit.

Résumé. UART : 10 temps de bit par octet, pas d'horloge, les deux extrémités s'accordent sur le taux de baud. SPI : un bit par horloge, un fil par dispositif. I2C : deux fils, adresses de 7 bits, open-drain. Évaluez le coût en octets par milliseconde par rapport au nombre de fils avant de choisir.

Pourquoi c'est important. Le monde physique parle en volts ; le CPU parle en nombres. La lecture de température du nœud n'est bonne que si le convertisseur et son câblage sont corrects — et les erreurs ici sont silencieuses, pas bruyantes.

L'idée, avec une image. Un DAC quantifie : un N-bit un convertisseur couvrant une tension de référence $V_{\text{ref}}$ a une résolution d'un seul LSB $= V_{\text{ref}}/2^{N}$. Le choix de N est le choix de la finesse avec laquelle le monde est mesuré ; le câblage détermine si cette finesse est préservée.

Dérivation. La quantification associe une tension au code dont la bande la contient : le code $= \lfloor V_{\text{in}}/V_{\text{ref}} \times 2^{N} \rfloor$ donne une borne idéale d'erreur de quantification d'une demi-LSB dans la plage d'entrée propres ; une entrée individuelle peut avoir zéro erreur. plage ; une entrée individuelle peut avoir une erreur nulle.

Exemple résolu 1 — le capteur 12 bits. Avec $V_{\text{ref}} = 3.3$ V, un LSB équivaut à $3.3/4096 = 0.806$ mV. Une entrée de 1.65 V affiche $1.65/3.3 \times 4096 = 2048$ — exactement à mi-échelle ✓. Si le nœud doit résoudre 0.1 °C et que le capteur fournit 10 mV/°C, il nécessite 1 mV de résolution — un convertisseur 12 bits (0.806 mV) convient, un convertisseur 10 bits (3.22 mV) échoue : c'est l'exigence, et non le catalogue, qui détermine N.

Exemple résolu 2 — le piège de l'impédance de source. L'échantillonnage-entretien de l'ADC condensateur ($\approx 7$ pF sur ce circuit intégré) se charge par la résistance de source et l'établissement à ½ LSB nécessite une durée d'échantillonnage d'au moins $R_{\text{source}} C \ln(2^{N+1})$. Pour une source de 50 kΩ, c'est $50\,000 \times 7\,\text{pF} \times 9.01 \approx 3.2$ µs pour un saut d'entrée pleine échelle dans ce modèle RC simple. Réduisez la fenêtre à 1 µs et la même limite n'autorise plus que $16$ kΩ. Un diviseur thermistancier 100 kΩ (50 kΩ Thevenin) nécessite donc au moins une fenêtre de 3.2 µs — ou divisez le diviseur Un DAC parcourt le même escalier en sens inverse : l'écriture de 2048 dans un DAC 12 bits avec une référence de $V_{\text{ref}} = 3.3$ V produit 1.650 V.

Erreurs courantes. Citer la résolution en bits et oublier la référence, (0.806 mV n'est vrai qu'à 3.3 V). Traiter l'entrée d'un convertisseur ADC comme un voltmètre : son courant d'échantillonnage charge les capteurs à haute impédance, comme le montre la limite RC ci-dessus. Et moyennner pour « acquérir » des bits : la moyenne de 16 échantillons de bruit blanc donne environ 2 bit de résolution effective, mais cela ne peut pas corriger un décalage systématique ni un échantillon affaissé.

Résumé. Un LSB = $V_{\text{ref}}/2^{N}$ ; la spécification détermine N. La reconstruction au milieu donne une limite d'erreur de quantisation de demi-LSB ; la limite RC $t_{s} \ge R C \ln(2^{N+1})$ met l'impédance de la source en balance avec le temps d'échantillonnage — l'impédance de source autorisée dépend du modèle et de la fenêtre d'acquisition.

Pourquoi c'est important. Le micrologiciel est testé en l'exécutant sur le matériel exact qui sera expédié, et chaque bug apparaît sous forme de rumeur (« il a gelé deux fois hier soir »). La méthode fait la différence entre le corriger et simplement lui donner un nom. nuit). La méthode consiste à corriger d'abord puis à renommer l'élément.

L'idée, avec une illustration. La boucle consiste à reproduire avec le minimum entrée ; diviser en deux la frontière entre le code de confiance et le code suspect (une DEL, un point d'arrêt ou une impression UART) ; corriger UNE chose ; re-vérifier. Un watchdog est le filet de sécurité qui redémarre un système bloqué — réinitialiser le compteur avant qu'il n'expire, sinon le produit redémarre par conception plutôt que de geler par accident.

La dérivation. La division en deux est l'algorithme : si le défaut se reproduit avec la sonde de frontière placée au milieu de la plage suspecte, le bug se trouve dans la première moitié ; sinon dans la seconde. Chaque sonde divise la plage par $\log_{2}(\text{suspicious instructions})$ probes suffice — ten probes for a mille instructions. Le même principe de division par deux qui fait fonctionner l'échelle ADC fait fonctionner la boucle de débogage.

Exemple résolu 1 — débounce par traçage d'état. Le bouton du nœud lit 1, 0, 0, 1 sur quatre échantillons de 10 ms (contact rebondissant). Règle : exiger deux lectures égales consécutives. Traçage : t = 0 ms lit 1 (aucun verdict) ; t = 10 ms lit 0 (une lecture, aucun verdict) ; t = 20 ms lit 0 à nouveau → stable 0 déclaré. Le 1 à t = 30 ms est une seule lecture, pas encore stable, et est correctement ignoré. Débounce = N échantillons consécutifs = une impulsion d'horloge + une lecture GPIO + une décision d'état : tout le cours en un seul traçage.

Worked example 2 — bisecting the freeze. The node freezes within an hour of a specific log sequence; the suspected region is 1 024 instructions du pilote de communication. Rendre l'instruction 512 allume la DEL : si le nœud gèle avec la DEL toujours éteinte, le bug se trouve dans la première moitié ; si la DEL s'allume before the freeze, it is in the second. Each run halves the region: 512 → 256 → 128 → … — ten runs bound it la recherche à une seule instruction. L'arithmétique explique pourquoi la bissection bat le réexamen code hoping to see it: $2^{10} = 1024$.

Erreurs fréquentes. Corriger deux éléments simultanément (l'un fonctionne, l'autre casse autre chose — il y a maintenant trois bugs). Déboguer sur une révision de carte différente de celle qui échoue. Et désactiver le watchdog « pour l'instant » : la défaillance terrain que le watchdog aurait dû survivre est exactement celle qui est expédiée. ships.

Summary. Reproduce, bisect, fix one, re-verify; $\log_{2}$ probes bound watchdog est la dernière ligne de défense : ne le réinitialiser que dans la boucle principale, jamais dans un ISR. Il s'agit du neuvième cours d'électricité de l'université : électricité