Les protocoles de communication série
Cours pour BTS EII, 2ème année : réseaux et topologies, codage de l’information (NRZ, Manchester, MLI…), UART/RS232, SPI, I2C, fiabilité des trames (bit stuffing, CRC), le bus CAN, puis pratique et implémentation USART, SPI, I2C, CAN sur STM32F4 Black Pill. Chaque animation a ses boutons Lecture, Pause et Reset.
Chapitre 1 : Les réseaux et les protocoles
Qu’est-ce qu’un réseau ?
Un réseau est un ensemble d’équipements appelés nœuds (ordinateur, microcontrôleur, capteur, imprimante…) reliés par un support (câble, fibre, ondes radio) pour échanger des données. Il faut donc trois ingrédients : des nœuds, un support et des règles communes (le protocole). Chaque nœud est identifié par une adresse.
Types de réseaux selon la taille
| Type | Portée | Exemples |
|---|---|---|
| PAN | ≈ 10 m | Bluetooth, USB, liaison UART entre deux cartes |
| LAN | Bâtiment | Ethernet, Wi-Fi, bus de terrain (Modbus RS485, CAN) |
| MAN | Ville | Réseau fibre d’une ville, d’une université |
| WAN | Pays, monde | Internet, réseau 4G/5G |
Les topologies
La topologie décrit la manière dont les nœuds sont reliés : topologie physique (le câblage réel) ou logique (le chemin suivi par les données). Chaque topologie ci-dessous a sa définition, son animation expliquée étape par étape (point jaune = le message), ses avantages et ses limites.
1. Topologie point à point
Définition : Deux nœuds reliés directement l’un à l’autre par une liaison dédiée : ce que l’un envoie, l’autre le reçoit.
Avantages : Simple, rapide, aucune collision, pas besoin d’adresse.
Limites : Limité à 2 nœuds ; relier n nœuds deux à deux demande n(n−1)/2 liaisons.
Exemples : UART, RS232, câble USB entre un PC et une carte.
2. Topologie bus
Définition : Tous les nœuds sont branchés sur un même câble commun, le bus.
Avantages : Peu de câble, ajout facile d’un nœud, faible coût.
Limites : Un seul nœud peut émettre à la fois (collisions possibles, arbitrage nécessaire) ; le débit est partagé ; une coupure du câble divise le réseau.
Exemples : I2C, CAN, RS485, Modbus.
3. Topologie en étoile
Définition : Chaque nœud est relié par son propre câble à un équipement central (hub, switch ou maître).
Avantages : Une panne de câble n’isole qu’un nœud ; ajout et diagnostic faciles.
Limites : Si le centre tombe en panne, tout le réseau s’arrête ; beaucoup de câble ; le centre peut saturer.
Exemples : Ethernet avec switch, Wi-Fi avec box, SPI (le maître est relié à chaque esclave par sa ligne CS).
4. Topologie anneau
Définition : Chaque nœud est relié à ses deux voisins et la chaîne se referme sur elle-même ; les messages circulent dans un sens.
Avantages : Accès régulier pour tous, pas de collision (jeton), bon comportement sous forte charge.
Limites : La panne ou la coupure d’un nœud bloque l’anneau (sauf double anneau) ; ajouter un nœud interrompt le réseau.
Exemples : Token Ring, FDDI, SPI en daisy chain.
5. Topologie arbre
Définition : Plusieurs étoiles reliées hiérarchiquement : un nœud racine, des niveaux intermédiaires, des feuilles.
Avantages : Extensible, organisé par niveaux, isolation par branche.
Limites : La panne d’un nœud haut isole toute sa branche ; la racine est critique.
Exemples : Réseau d’entreprise (cœur, étages, postes), arborescence de hubs USB.
6. Topologie maillée
Définition : Chaque nœud est relié à plusieurs autres ; dans un maillage complet, tous les nœuds sont reliés entre eux.
Avantages : Très fiable : plusieurs chemins de secours, tolère les pannes.
Limites : Câblage et coût élevés (n(n−1)/2 liaisons en maillage complet), routage complexe.
Exemples : Internet, Zigbee, Wi-Fi mesh.
7. Topologie hybride
Définition : Combinaison de plusieurs topologies, par exemple deux étoiles reliées entre elles par un bus.
Avantages : Souple, adaptée aux grandes installations, pannes limitées à une zone.
Limites : Conception et câblage plus complexes, coût plus élevé.
Exemples : Réseau d’un bâtiment (un switch par étage), usine avec îlots RS485 reliés en Ethernet.
Qu’est-ce qu’un protocole ?
Un protocole est l’ensemble des règles qui permettent à deux équipements de se comprendre : format des données (la trame), vitesse, niveaux électriques, adresses, ordre des échanges, détection d’erreurs. C’est comme une conversation : même langue, même rythme, tour de parole respecté. Il définit la syntaxe (format), la sémantique (sens des champs) et la synchronisation (timing).
| Protocole | Topologie | Nœuds |
|---|---|---|
| UART | Point à point | 2 |
| SPI | Bus partagé + sélection CS (étoile) | 1 maître, n esclaves |
| I2C | Bus | n maîtres, n esclaves (adresses) |
| CAN | Bus (paire différentielle) | n nœuds égaux (multi-maîtres), identifiants |
Chapitre 2 : Notions fondamentales de la communication série
Série et parallèle
Une communication parallèle envoie plusieurs bits en même temps, chacun sur son propre fil. Une communication série envoie les bits un par un sur un seul fil de données.
| Critère | Parallèle | Série |
|---|---|---|
| Fils de données | 8, 16, 32… | 1 (ou 2 en full duplex) |
| Vitesse par cycle | Élevée (tout l’octet d’un coup) | Faible, compensée par une fréquence élevée |
| Distance | Courte (déphasage entre fils) | Longue |
| Coût et câblage | Câble et connecteur volumineux | Câble réduit, peu de broches |
| Exemples | Bus mémoire, ancien port imprimante | UART, SPI, I2C, USB |
Synchrone et asynchrone
En synchrone, un fil d’horloge accompagne les données : le récepteur lit un bit à chaque front d’horloge (SPI, I2C). En asynchrone, il n’y a pas d’horloge : émetteur et récepteur se mettent d’accord à l’avance sur la vitesse (baud rate) et chaque octet est encadré par un bit de start et un bit de stop (UART).
Simplex, half duplex, full duplex
- Simplex : un seul sens, toujours le même (radio FM, télécommande).
- Half duplex : les deux sens, mais pas en même temps (talkie-walkie, RS485 sur 2 fils, I2C).
- Full duplex : les deux sens en même temps (téléphone, UART avec TX et RX séparés, SPI).
Le codage de l’information (codage en ligne et MLI)
Pour transmettre des bits sur un fil, il faut décider comment représenter un 0 et un 1 par des niveaux de tension : c’est le codage en ligne (ou codage en bande de base). Le choix du code agit sur trois points :
- La synchronisation : le récepteur retrouve le rythme (l’horloge) grâce aux transitions du signal. Un code sans transition pendant une longue suite de bits identiques lui fait perdre le rythme.
- La composante continue : si la valeur moyenne du signal n’est pas nulle, elle ne traverse pas les transformateurs ni les liaisons couplées en alternatif.
- La bande passante : plus il y a de transitions par bit, plus la fréquence du signal est élevée.
Vocabulaire : le débit D (bit/s) est le nombre de bits transmis par seconde ; la rapidité de modulation R (bauds) est le nombre de niveaux (symboles) émis par seconde. Avec un niveau par bit, D = R ; avec le Manchester (deux niveaux par bit), R = 2 × D.
Outil animé : coder une suite de bits
Saisis des bits, choisis un code et avance avec « Étape suivante » : chaque bit est codé selon la règle du code, expliquée sous le schéma. La bande jaune marque le bit en cours.
Comparaison : tous les codes sur la même séquence
Les huit codes s’affichent pour les bits saisis ci-dessus. Observe, dans le tableau, le nombre de transitions, la valeur moyenne (composante continue) et la plus longue durée sans transition : c’est elle qui décide si le récepteur peut garder son rythme.
Les codes un par un
Chaque schéma montre la séquence 1 0 1 1 0 0 1 0 codée avec le code décrit.
1. NRZ unipolaire
Principe : NRZ = Non Return to Zero : le niveau reste constant pendant toute la durée du bit. Le 1 est codé V, le 0 est codé 0 V.
Avantages : Très simple, bande passante minimale.
Limites : Aucune transition pendant une suite de bits identiques (perte de synchronisation) ; composante continue non nulle.
Utilisation : UART en niveaux TTL (le STM32), SPI et I2C (l’horloge est sur un fil séparé).
2. NRZ polaire (NRZ-L)
Principe : Le 1 est codé +V et le 0 est codé −V pendant tout le bit.
Avantages : Simple ; niveaux symétriques.
Limites : Même défaut de synchronisation que le NRZ unipolaire ; composante continue non nulle si les 0 et les 1 ne sont pas équilibrés.
Utilisation : RS232 (en logique inversée : 1 = −12 V, 0 = +12 V), CAN (avec bit stuffing).
3. NRZI (NRZ inversé)
Principe : Le 1 provoque un changement de niveau au début du bit ; le 0 laisse le niveau inchangé. (USB utilise la convention inverse : le 0 provoque le changement.)
Avantages : L’information est dans les transitions : insensible à l’inversion des deux fils.
Limites : Une longue suite de bits sans transition fait perdre le rythme : on lui associe le bit stuffing.
Utilisation : USB (avec bit stuffing), liaisons optiques.
4. RZ unipolaire
Principe : RZ = Return to Zero : le niveau revient à 0 au milieu du bit. Le 1 est codé V pendant la première moitié du bit puis 0 ; le 0 reste à 0.
Avantages : Une impulsion pour chaque 1, ce qui aide la synchronisation.
Limites : Une suite de 0 ne contient aucune transition ; bande passante double du NRZ.
Utilisation : Liaisons infrarouge (IrDA), fibres optiques.
5. RZ polaire
Principe : Le 1 est codé +V puis 0 ; le 0 est codé −V puis 0 (retour à zéro au milieu du bit).
Avantages : Chaque bit contient au moins une transition.
Limites : Trois niveaux, bande passante double du NRZ.
Utilisation : Certaines liaisons optiques et de télécommunication.
6. Manchester (IEEE 802.3)
Principe : Il y a toujours une transition au milieu du bit : le 1 est un front montant (bas puis haut), le 0 un front descendant (haut puis bas). Une autre convention, celle de G. E. Thomas, inverse les deux.
Avantages : Code auto-synchronisant (l’horloge est contenue dans le signal) et composante continue nulle.
Limites : La rapidité de modulation est double du débit (R = 2 × D), donc une bande passante double.
Utilisation : Ethernet 10BASE-T, étiquettes RFID.
7. Manchester différentiel
Principe : Il y a toujours une transition au milieu du bit (horloge). L’information est dans le début du bit : le 0 provoque une transition au début du bit, le 1 n’en provoque pas.
Avantages : Auto-synchronisant, composante continue nulle, insensible à l’inversion des fils.
Limites : Bande passante double, décodage un peu plus complexe.
Utilisation : Token Ring (IEEE 802.5).
8. AMI (Alternate Mark Inversion)
Principe : Le 0 est codé 0 V ; les 1 sont codés alternativement +V et −V. Deux impulsions consécutives de même polarité constituent une violation, donc une erreur détectée.
Avantages : Composante continue nulle, détection d’erreurs simple, trois niveaux seulement.
Limites : Une longue suite de 0 ne contient aucune transition : le code HDB3 remplace 4 zéros consécutifs par une violation volontaire.
Utilisation : Lignes téléphoniques numériques T1 et E1 (HDB3).
Synthèse des codes en ligne
| Code | Niveaux | Transitions | Composante continue | Horloge récupérable | Bande passante |
|---|---|---|---|---|---|
| NRZ unipolaire | 2 (0 et V) | Aux changements de bit seulement | Non nulle | Non (suites de bits identiques) | Minimale |
| NRZ polaire | 2 (±V) | Aux changements de bit seulement | Selon les données | Non | Minimale |
| NRZI | 2 (±V) | À chaque 1 | Selon les données | Seulement avec les 1 | Minimale |
| RZ unipolaire | 2 (0 et V) | À chaque 1 | Non nulle | Seulement avec les 1 | Double |
| RZ polaire | 3 | À chaque bit | Faible | Oui | Double |
| Manchester | 2 (±V) | À chaque bit | Nulle | Oui | Double |
| Manchester différentiel | 2 (±V) | À chaque bit | Nulle | Oui | Double |
| AMI | 3 | À chaque 1 | Nulle | Seulement avec les 1 | Minimale |
Le lien avec les protocoles du cours
| Protocole | Codage utilisé |
|---|---|
| UART (TTL) et SPI, I2C | NRZ ; SPI et I2C ont un fil d’horloge séparé, l’UART se synchronise sur le bit de start |
| RS232 | NRZ polaire en logique inversée (±12 V) |
| CAN | NRZ avec bit stuffing (chapitre 6) |
| USB | NRZI avec bit stuffing (chapitre 6) |
| Ethernet 10BASE-T | Manchester |
| Token Ring | Manchester différentiel |
| Lignes T1 / E1 | AMI / HDB3 |
La MLI (modulation de largeur d’impulsion, PWM)
La MLI n’est pas un code binaire : le signal n’a que deux niveaux (0 et Vmax) mais l’information est dans la largeur des impulsions. On appelle rapport cyclique α = durée à l’état haut / période T. La valeur moyenne du signal vaut α × Vmax : un signal logique peut ainsi produire une tension « analogique » réglable (on lisse avec un filtre RC, ou la charge elle-même — LED, moteur — fait la moyenne).
| Application | Principe |
|---|---|
| Variateur de LED | Le rapport cyclique règle la luminosité moyenne |
| Vitesse d’un moteur à courant continu | La tension moyenne règle la vitesse |
| Servomoteur | Période 20 ms ; impulsion de 1 ms à 2 ms qui code l’angle |
| DAC simple | MLI rapide suivie d’un filtre RC passe-bas |
| Onduleur, amplificateur de classe D | MLI sinusoïdale : la largeur varie comme un sinus |
La MLI sinusoïdale (comparaison avec une triangle)
On compare un signal de référence sinusoïdal à une porteuse triangulaire de fréquence plus élevée : la sortie est à l’état haut quand le sinus est au-dessus de la triangle. Les impulsions sont larges quand le sinus est élevé et étroites quand il est bas ; après filtrage, on retrouve le sinus.
La MLI sur le STM32F411
Un timer compte de 0 à ARR. La sortie est à l’état haut tant que le compteur est inférieur à CCR : fPWM = fTIM / ((PSC + 1) × (ARR + 1)) et α = CCR / (ARR + 1).
CubeMX : Timers > TIM1, Clock Source = Internal Clock, Channel1 = PWM Generation CH1 (broche PA8), Prescaler = 99, Counter Period (ARR) = 999, Pulse (CCR) = 300. Câblage : PA8 vers une résistance de 330 Ω, une LED, puis GND (avec l’horloge de 100 MHz du chapitre 7, le timer TIM1 reçoit 100 MHz).
HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1); // démarre la MLI (30 %)
__HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, 500); // CCR = 500 : rapport cyclique 50 %
/* LED qui s'allume progressivement */
for (uint16_t ccr = 0; ccr < 1000; ccr += 10)
{
__HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, ccr);
HAL_Delay(10);
}
Exercices : codage de l’information
Exercice K1. Code la suite 1 0 1 1 0 0 1 0 en NRZ polaire, en NRZI (transition sur 1), en Manchester (IEEE 802.3) et en AMI. On suppose le niveau initial bas et la première impulsion AMI positive.
Exercice K2 (décodage). Le chronogramme ci-dessous est codé en Manchester (IEEE 802.3 : front montant = 1). Retrouve les 8 bits.
Exercice K3 (décodage AMI). Le chronogramme est codé en AMI. Retrouve les 8 bits. Quelle propriété permet de détecter une erreur ?
Exercice K4. Une liaison Ethernet 10BASE-T envoie 10 Mbit/s en Manchester. Quelle est la durée d’un bit ? La rapidité de modulation ? Combien de transitions par bit, au minimum et au maximum ? Dans quelle plage se situe la fréquence du signal ?
Exercice K5. Quel code garantit une transition à chaque bit ? Lequel a une composante continue nulle ? Lequel est auto-synchronisant et sans composante continue ?
Exercice K6. Pourquoi associe-t-on le NRZI au bit stuffing dans le bus USB ?
Exercice K7 (MLI). Un signal MLI de 3,3 V a un rapport cyclique de 25 %, puis de 60 %. Quelle est sa valeur moyenne ? Avec TIM1 à 100 MHz, PSC = 99 et ARR = 999 : quelle fréquence de MLI ? Quel CCR pour 30 % ? Pour un servomoteur (période 20 ms), quel PSC, ARR et CCR donnent une impulsion de 1,5 ms ?
Chapitre 3 : Liaison RS232 et UART
Les liaisons RS232, RS422, RS485
| RS232 | RS422 | RS485 | |
|---|---|---|---|
| Signal | Asymétrique (référence GND) | Différentiel | Différentiel |
| Liaison | Point à point | 1 émetteur, jusqu’à 10 récepteurs | Multipoint (32 unités et plus) |
| Duplex | Full | Full (4 fils) | Half (2 fils) ou full (4 fils) |
| Distance max | environ 15 m | environ 1200 m | environ 1200 m |
| Tension | ±3 à ±15 V | ±2 à ±6 V | ±1,5 à ±6 V |
L’UART
L’UART (Universal Asynchronous Receiver Transmitter) est le circuit intégré au microcontrôleur qui transforme un octet en trame série asynchrone (et inversement). Il utilise deux broches, TX et RX. Un protocole de communication est l’ensemble des règles communes à l’émetteur et au récepteur : format de la trame, vitesse, niveaux de tension, ordre des bits.
Les deux normes de niveaux
Sur la carte (STM32, Arduino), l’UART sort en niveaux TTL (0 V / 3,3 V ou 5 V). Pour une liaison RS232 il faut un circuit comme le MAX232 qui convertit vers des tensions inversées : le 1 logique devient une tension négative.
| Norme | Niveau 1 (repos) | Niveau 0 |
|---|---|---|
| TTL | 3,3 V ou 5 V | 0 V |
| RS232 | −3 à −15 V (typique −12 V) | +3 à +15 V (typique +12 V) |
La trame UART
La ligne est au repos à 1. Une trame contient : un bit de start (0) qui réveille le récepteur, les bits de données (5 à 9, le plus souvent 8, envoyés bit de poids faible D0 en premier), un bit de parité optionnel pour détecter une erreur, et 1 ou 2 bits de stop (1) qui ramènent la ligne au repos.
La configuration s’écrit 9600 8N1 : 9600 bauds, 8 bits de données, parité None, 1 bit de stop. Durée d’un bit : 1/9600 ≈ 104 µs. Une trame 8N1 fait 10 bits, soit environ 1,04 ms.
Outil : construire une trame
Exemple : 'A' = 0x41 = 01000001 contient deux 1. Parité paire : bit = 0. Parité impaire : bit = 1.
Câblage
Les deux appareils se croisent : le TX de l’un va au RX de l’autre, et les masses sont reliées.
Chronogramme d’une trame UART
Trame 8E1 de la lettre « A » à 9600 bauds. Chaque bit dure 1/9600 ≈ 104 µs, la trame entière 11 × 104 µs ≈ 1,15 ms. Les bits sont lus de gauche à droite dans l’ordre d’envoi : D0 en premier.
Exercices UART
Exercice U1. Donne le bit de parité paire et le bit de parité impaire de « S » (0x53) et de « C » (0x43).
« C » = 0x43 = 01000011 : 3 bits à 1 → parité paire 1, parité impaire 0.
Exercice U2 (chronogramme). La trame ci-dessous est en 8E1 à 9600 bauds. Retrouve le caractère ASCII, vérifie la parité et calcule la durée de la trame.
Exercice U3. Combien de temps faut-il pour envoyer « HELLO » en 9600 8N1 ? Quel est le débit utile ? Même question en 8E1.
Exercice U4. Un récepteur 8E1 reçoit : start 0, D0…D7 = 1 0 0 0 0 0 1 0, parité 1, stop 1. La trame est-elle correcte ?
Exercice U5. Une carte est réglée à 9600 8N1 et l’autre à 115200 8N1. Que se passe-t-il ?
Chapitre 4 : Protocole SPI
Le SPI (Serial Peripheral Interface) est un bus synchrone, full duplex, où un maître pilote un ou plusieurs esclaves. Principe : maître et esclave contiennent chacun un registre à décalage ; à chaque impulsion d’horloge, ils s’échangent un bit.
- SCLK : horloge, fournie par le maître.
- MOSI : Master Out Slave In, données maître vers esclave.
- MISO : Master In Slave Out, données esclave vers maître.
- CS (ou SS) : sélection de l’esclave, actif à 0. Un CS par esclave.
Avantages : très rapide (plusieurs dizaines de Mbit/s), simple, full duplex. Inconvénients : une ligne CS par esclave, pas d’acquittement, pas d’adresse, courte distance.
Câblage : 1 maître et 3 esclaves
Mode daisy chain (chaîne)
Maître MOSI ──► [Esclave 1] ──► [Esclave 2] ──► [Esclave 3] ──┐ Maître MISO ◄─────────────────────────────────────────────────┘ SCLK et CS communs aux trois esclaves
Un seul CS suffit, mais les données traversent tous les esclaves : il faut envoyer 3 octets pour atteindre le dernier.
Les 4 modes (CPOL, CPHA)
CPOL est le niveau de repos de l’horloge. CPHA indique si l’échantillonnage se fait sur le 1er front (CPHA=0) ou le 2ème front (CPHA=1). Les traits rouges marquent l’échantillonnage. Maître et esclave doivent utiliser le même mode.
Échange bit par bit
Exemple concret : lire un capteur ou une mémoire. Le maître abaisse CS, envoie une commande de lecture (par exemple 0x03 pour une mémoire flash) puis des octets 0x00 ; pendant ce temps l’esclave répond sur MISO. Le maître relève CS pour terminer.
Chronogramme d’un échange complet
Mode 0, un octet : CS descend, 8 impulsions SCLK, MOSI et MISO sont échantillonnés sur chaque front montant (traits rouges).
Exercices SPI
Exercice S1. Combien de fils de signal faut-il pour 1 maître et 4 esclaves avec une ligne CS par esclave ?
Exercice S2. Le maître contient 0xA5 et l’esclave 0x3C. Que contiennent-ils après 8 impulsions d’horloge ?
Exercice S3 (chronogramme). Lis le chronogramme : quel octet envoie le maître ? Quel octet répond l’esclave ? Quel est le mode SPI ?
Exercice S4 (chronogramme). Même question pour ce second chronogramme.
Exercice S5. Une horloge SPI à 1 MHz. Durée d’un octet ? de 4 octets ? Même calcul pour la Black Pill avec SPI1 à 100 MHz et un prescaler de 128.
Chapitre 5 : Protocole I2C
L’I2C (Inter-Integrated Circuit) est un bus synchrone, half duplex, à 2 fils seulement : SDA (données) et SCL (horloge, fournie par le maître). Chaque esclave possède une adresse sur 7 bits : plus besoin de ligne CS. Les sorties sont en collecteur ouvert : le bus ne peut être tiré qu’à 0 par un composant. Les résistances de pull-up (souvent 4,7 kΩ) ramènent SDA et SCL à 1 au repos.
Avantages : 2 fils pour de nombreux esclaves, acquittement (ACK). Inconvénients : plus lent que SPI (100 kHz, 400 kHz, 1 MHz), half duplex, risque de conflit d’adresses.
Câblage : 1 maître et 3 esclaves
La trame I2C (écriture)
Le maître envoie : START (SDA passe à 0 pendant que SCL est à 1), l’adresse sur 7 bits, le bit R/W (0 écriture, 1 lecture), puis l’esclave répond par un ACK (il tire SDA à 0). Viennent les octets de données, chacun suivi d’un ACK, et enfin la condition STOP (SDA passe à 1 pendant que SCL est à 1). Ci-dessous : écriture de 0xA5 à l’adresse 0x48. Les données ne changent que quand SCL est à 0.
Écriture et lecture d’un registre
Écriture : S | adr+W | ACK | n° registre | ACK | donnée | ACK | P Lecture : S | adr+W | ACK | n° registre | ACK | Sr | adr+R | ACK | donnée | NACK | P
Pour lire, on écrit d’abord le numéro du registre, puis on envoie un RESTART (Sr) avec le bit R/W à 1. À la fin de la lecture, le maître répond NACK pour dire « j’arrête ».
Exemple concret : le capteur de température TMP102 a l’adresse 0x48. Pour lire la température : S, 0x90 (0x48 puis W), registre 0x00, Sr, 0x91 (0x48 puis R), deux octets reçus, P.
Chronogramme : écriture dans un registre
Le maître écrit 0x1F dans le registre 0x00 de l’esclave 0x48 : START, adresse + W, ACK, numéro de registre, ACK, donnée, ACK, STOP. SDA (en haut) ne change que quand SCL (en bas) est à 0.
Exercices I2C
Exercice I1. Une mémoire EEPROM a l’adresse 7 bits 0x50. Quels octets le maître envoie-t-il pour écrire, puis pour lire ?
Exercice I2 (chronogramme). Lis la trame : quelle est l’adresse ? Est-ce une écriture ou une lecture ? Quelle donnée est transmise ? Qui envoie le dernier bit à 1 ?
Exercice I3 (chronogramme). Décode cette trame : adresse, sens, contenu des deux octets suivants.
Exercice I4. À 100 kHz, combien de temps pour envoyer l’adresse puis 2 octets de données ? Et à 400 kHz ?
Exercice I5. Deux capteurs ont la même adresse 0x48 : que faire ?
Chapitre 6 : Fiabilité des trames : parité, bit stuffing et CRC
Sur un fil, le bruit électrique (moteurs, relais, câbles longs) peut inverser un bit. Les protocoles ajoutent donc des bits de contrôle : le récepteur les recalcule et, s’ils ne correspondent pas, la trame est rejetée ou redemandée.
| Méthode | Principe | Détecte | Utilisée dans |
|---|---|---|---|
| Parité | 1 bit rend le nombre de 1 pair ou impair | Un nombre impair de bits faux | UART |
| Somme de contrôle | Somme (ou XOR) des octets, envoyée à la fin | Erreurs simples | Trames GPS NMEA |
| CRC | Reste d’une division binaire par un polynôme | Rafales d’erreurs, très fiable | CAN, Ethernet, Modbus, cartes SD, USB |
Le bit stuffing (bourrage de bits)
Le bit stuffing consiste à insérer automatiquement un bit supplémentaire dans la trame quand une suite de bits identiques devient trop longue. Le récepteur reconnaît ces bits et les retire (destuffing). Deux raisons :
- Resynchronisation : sans fil d’horloge (CAN, USB), le récepteur recale son horloge sur les changements de niveau. Une longue suite de bits identiques ne contient aucun front et il perd le rythme.
- Délimitation : en HDLC, le fanion 01111110 marque le début et la fin de la trame ; il ne doit jamais apparaître dans les données.
| Protocole | Règle |
|---|---|
| CAN | Après 5 bits identiques consécutifs, on insère le bit de valeur contraire (le bit inséré compte dans la suite suivante) |
| HDLC, PPP | Après 5 « 1 » consécutifs, on insère un 0 |
| USB | Après 6 « 1 » consécutifs (codage NRZI), on insère un 0 |
Exemple expliqué (règle CAN)
Données : 00000111110. On parcourt les bits un par un en comptant les bits identiques :
- Après le bit d’entrée n° 5 : cinq bits identiques de valeur 0 → on insère 1.
- Après le bit d’entrée n° 9 : cinq bits identiques de valeur 1 → on insère 0.
Trame émise : 0000011111010 (bits insérés en rouge). Le récepteur applique la même règle : après 5 bits identiques, le bit suivant est un bit de stuffing, il le supprime et retrouve 00000111110.
Essaie ta propre séquence : l’animation montre chaque bit traité, le compteur et l’insertion.
Exercices : bit stuffing
Exercice B1 (CAN). Applique le bit stuffing CAN à la séquence 1111100000111.
Exercice B2 (HDLC). Applique le bit stuffing HDLC (après cinq 1, insérer un 0) à 0111110111111101.
Exercice B3 (destuffing CAN). Un récepteur CAN reçoit 100000111110110. Retrouve les données d’origine.
Exercice B4. Pourquoi le fanion HDLC 01111110 ne peut-il jamais apparaître dans les données après stuffing ?
Le CRC (contrôle de redondance cyclique)
Le CRC est un reste de division binaire. L’émetteur calcule le CRC des données et l’envoie à la suite ; le récepteur refait le calcul sur la trame complète. Le CRC ne corrige rien : il détecte les erreurs.
- Les données forment un nombre binaire D. On choisit un polynôme générateur G de n+1 bits (par exemple x⁴ + x + 1 s’écrit 10011, avec n = 4).
- On ajoute n zéros à droite de D.
- On divise par G avec la division binaire sans retenue : la soustraction est un XOR. Si le bit de tête vaut 1, on fait le XOR avec G ; sinon on décale d’un bit. Le reste de n bits est le CRC.
- On émet D suivi du CRC. À la réception on divise la trame complète par G : reste nul = aucune erreur détectée, reste non nul = erreur.
Exemple expliqué
Données D = 1101011011, générateur G = 10011 (n = 4) : on divise 11010110110000 par 10011.
Dividende 11010110110000
Générateur 10011
10011 XOR
01001110110000
10011 XOR
00000010110000
10011 XOR
00000000101000
10011 XOR
00000000001110
Reste 1110
Reste = 1110. Trame émise : 1101011011 1110. Vérification à la réception : on divise la trame complète, le reste doit être nul.
Dividende 11010110111110
Générateur 10011
10011 XOR
01001110111110
10011 XOR
00000010111110
10011 XOR
00000000100110
10011 XOR
00000000000000
Reste 0000
Le reste est 0000 : aucune erreur détectée. Si un seul bit change, le reste devient non nul : essaie avec l’outil ci-dessous (anime la division étape par étape et permet d’inverser un bit).
Exercices : CRC
Exercice C1. Calcule le CRC des données 1001 avec G = 1011 (x³ + x + 1).
Dividende 1001000
Générateur 1011
1011 XOR
0010000
1011 XOR
0000110
Reste 110CRC = 110, trame émise = 1001110.Exercice C2. Avec G = 1011, on reçoit les deux trames 11010011101100100 et 11010011101000100. Lesquelles sont valides ?
Dividende 11010011101100100
Générateur 1011
1011 XOR
01100011101100100
1011 XOR
00111011101100100
1011 XOR
00010111101100100
1011 XOR
00000001101100100
1011 XOR
00000000110100100
1011 XOR
00000000011000100
1011 XOR
00000000001110100
1011 XOR
00000000000101100
1011 XOR
00000000000000000
Reste 000Trame 2 : le reste vaut 111 (non nul) → erreur détectée, un bit a été inversé.Dividende 11010011101000100
Générateur 1011
1011 XOR
01100011101000100
1011 XOR
00111011101000100
1011 XOR
00010111101000100
1011 XOR
00000001101000100
1011 XOR
00000000110000100
1011 XOR
00000000011100100
1011 XOR
00000000001010100
1011 XOR
00000000000001100
1011 XOR
00000000000000111
Reste 111Exercice C3. Le générateur x⁸ + x² + x + 1 s’écrit 100000111. Combien de bits fait le CRC et combien de zéros ajoute-t-on aux données ?
Exercice C4 (avec l’outil). Calcule le CRC de 11110000 avec x⁴ + x + 1, puis inverse le bit n° 3 de la trame. Que constates-tu ?
Chapitre 7 : Pratique avec la STM32F4 Black Pill
Objectif : faire communiquer une Black Pill (STM32F411, maître) avec deux esclaves (deux autres Black Pill, ou toute carte 3,3 V), en SPI puis en I2C.
Le scénario
| Commande (octet) | Effet sur l’esclave |
|---|---|
| 0x01 | Allumer la LED |
| 0x02 | Éteindre la LED |
| 0x03 / lecture | Renvoyer le compteur de messages reçus |
A. Communication SPI : maître et 2 esclaves
CubeMX, maître : SPI1 « Full-Duplex Master », 8 bits, MSB first, Prescaler 128 (≈ 780 kHz, prudent sur breadboard), CPOL Low, CPHA 1 Edge (mode 0), NSS Software. PB0 et PB1 en sortie GPIO, niveau initial haut (CS inactifs). CubeMX, esclave : SPI1 « Full-Duplex Slave », mêmes paramètres, NSS « Hardware Input » (PA4), interruption SPI1 activée, PC13 en sortie, niveau initial haut (LED éteinte).
Observe la transaction complète avec les boutons « Étape suivante » et « Étape précédente » : chaque étape est expliquée sous le schéma. Elle contient deux écritures de commande puis une lecture, comme la fonction spi_send du code ci-dessous.
/* ===== MAÎTRE ===== */
uint8_t spi_send(GPIO_TypeDef *p, uint16_t cs, uint8_t cmd){
uint8_t tx[2] = {cmd, 0}, rx[2];
HAL_GPIO_WritePin(p, cs, GPIO_PIN_RESET); // CS bas
HAL_SPI_TransmitReceive(&hspi1, tx, rx, 2, 100);
HAL_GPIO_WritePin(p, cs, GPIO_PIN_SET); // CS haut
return rx[1];
}
spi_send(GPIOB, GPIO_PIN_0, 0x01); // LED ON, esclave 1
spi_send(GPIOB, GPIO_PIN_1, 0x03); HAL_Delay(1); // demande compteur, esclave 2
uint8_t n = spi_send(GPIOB, GPIO_PIN_1, 0x00); // lecture de la réponse
/* ===== ESCLAVE ===== */
uint8_t rx[2], tx[2] = {0, 0}, cnt = 0;
/* dans main : HAL_SPI_TransmitReceive_IT(&hspi1, tx, rx, 2); */
void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *h){
if(rx[0] == 0x01) HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET); // LED allumée
if(rx[0] == 0x02) HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_SET);
cnt++; tx[1] = cnt; // renvoyé à l’échange suivant
HAL_SPI_TransmitReceive_IT(h, tx, rx, 2); // on se ré-arme
}
B. Communication I2C : maître et 2 esclaves
CubeMX, maître : I2C1 (PB6 SCL, PB7 SDA), Standard Mode 100 kHz. CubeMX, esclaves : I2C1 identique, avec l’adresse propre 0x30 (esclave 1) ou 0x31 (esclave 2) et les interruptions I2C1 (événement et erreur) activées. Dans le code HAL, l’adresse 7 bits est décalée d’un bit : 0x30 << 1. Une seule paire de pull-up 4,7 kΩ sur tout le bus.
/* ===== MAÎTRE ===== */
#define ESC1 (0x30 << 1)
#define ESC2 (0x31 << 1)
uint8_t cmd = 0x01, r;
HAL_I2C_Master_Transmit(&hi2c1, ESC1, &cmd, 1, 100); // LED ON, esclave 1
HAL_I2C_Master_Receive (&hi2c1, ESC2, &r, 1, 100); // compteur de l’esclave 2
/* ===== ESCLAVE (0x30 ou 0x31) ===== */
uint8_t rx, cnt = 0;
/* dans main : HAL_I2C_EnableListen_IT(&hi2c1); */
void HAL_I2C_AddrCallback(I2C_HandleTypeDef *h, uint8_t dir, uint16_t addr){
if(dir == I2C_DIRECTION_TRANSMIT) HAL_I2C_Slave_Seq_Receive_IT (h, &rx, 1, I2C_FIRST_AND_LAST_FRAME);
else HAL_I2C_Slave_Seq_Transmit_IT(h, &cnt, 1, I2C_FIRST_AND_LAST_FRAME);
}
void HAL_I2C_SlaveRxCpltCallback(I2C_HandleTypeDef *h){
if(rx == 1) HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET);
if(rx == 2) HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_SET);
cnt++;
}
void HAL_I2C_ListenCpltCallback(I2C_HandleTypeDef *h){ HAL_I2C_EnableListen_IT(h); }
C. Guide pas à pas : du matériel au premier test
Rien n’est supposé connu. Suis les étapes dans l’ordre et ne continue qu’après avoir validé chaque « Vérification ».
Étape 1 : matériel et logiciels
- 3 cartes Black Pill STM32F411CEU6. Colle une étiquette : A (maître), B (esclave 1), C (esclave 2).
- 1 ST-Link V2 avec ses fils (3,3 V, GND, SWDIO, SWCLK), 1 breadboard, des fils Dupont, 2 résistances 4,7 kΩ, 3 câbles USB (un par carte, pour l’alimenter).
- Le logiciel gratuit STM32CubeIDE (site st.com) ; il installe aussi le pilote du ST-Link.
Vérification : STM32CubeIDE démarre et demande un « workspace » : accepte le dossier proposé.
Étape 2 : créer le projet du maître (SPI)
- File > New > STM32 Project. Onglet « MCU/MPU Selector », tape STM32F411CEUx, sélectionne la ligne puis Next.
- Nom du projet : maitre_spi. Langage C, type Executable. Finish. Réponds « Yes » à « Initialize all peripherals with their default mode ».
- Pinout & Configuration > System Core > RCC : High Speed Clock (HSE) = Crystal/Ceramic Resonator.
- System Core > SYS : Debug = Serial Wire (sinon le ST-Link ne pourra plus reprogrammer la carte).
- Onglet Clock Configuration : HSE = 25 MHz ; PLL Source Mux = HSE ; System Clock Mux = PLLCLK ; écris 100 dans HCLK puis Entrée, accepte la proposition de CubeMX.
- Clique sur les broches PB0, PB1, PC13 et choisis GPIO_Output. Dans System Core > GPIO, mets « GPIO output level » à High pour les trois (CS inactifs, LED éteinte).
- Connectivity > SPI1 : Mode = Full-Duplex Master ; Hardware NSS Signal = Disable. Parameter Settings : Data Size 8 bits, First Bit MSB First, Baud Rate Prescaler 128, Clock Polarity Low, Clock Phase 1 Edge.
- Vérifie que PA5, PA6, PA7 affichent SPI1_SCK, SPI1_MISO, SPI1_MOSI. Ctrl+S : CubeMX propose de générer le code, accepte.
Vérification : le marteau « Build » donne 0 erreur.
Étape 3 : créer le projet des esclaves (SPI)
Même procédure (nom esclave_spi), avec ces différences : pas de PB0 ni PB1 ; PC13 en GPIO_Output niveau High ; SPI1 : Mode = Full-Duplex Slave, Hardware NSS Signal = Hardware NSS Input Signal (PA4 devient SPI1_NSS), mêmes paramètres 8 bits, MSB, CPOL Low, CPHA 1 Edge ; onglet NVIC Settings du SPI1 : coche SPI1 global interrupt. Le même programme sert pour B et C.
Étape 4 : écrire le code
Écris uniquement entre les lignes /* USER CODE BEGIN ... */ et /* USER CODE END ... */ de main.c, sinon CubeMX effacera ton code à la prochaine génération.
Maître (main.c) :
/* USER CODE BEGIN PFP */
uint8_t spi_send(GPIO_TypeDef *p, uint16_t cs, uint8_t cmd);
/* USER CODE END PFP */
/* USER CODE BEGIN 2 */
HAL_Delay(1000); // laisse les esclaves démarrer
spi_send(GPIOB, GPIO_PIN_0, 0x01); // LED ON de l’esclave 1
HAL_Delay(1000);
spi_send(GPIOB, GPIO_PIN_0, 0x02); // LED OFF de l’esclave 1
spi_send(GPIOB, GPIO_PIN_1, 0x03); HAL_Delay(1); // demande le compteur de l’esclave 2
uint8_t n = spi_send(GPIOB, GPIO_PIN_1, 0x00); // lit la réponse
for(uint8_t i = 0; i < n; i++){ // la LED du maître clignote n fois
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET); HAL_Delay(300);
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_SET); HAL_Delay(300);
}
/* USER CODE END 2 */
/* USER CODE BEGIN 4 */
uint8_t spi_send(GPIO_TypeDef *p, uint16_t cs, uint8_t cmd){
uint8_t tx[2] = {cmd, 0}, rx[2] = {0, 0};
HAL_GPIO_WritePin(p, cs, GPIO_PIN_RESET);
HAL_SPI_TransmitReceive(&hspi1, tx, rx, 2, 100);
HAL_GPIO_WritePin(p, cs, GPIO_PIN_SET);
return rx[1];
}
/* USER CODE END 4 */
Esclave (main.c) :
/* USER CODE BEGIN PV */
uint8_t rx[2], tx[2] = {0, 0}, cnt = 0;
/* USER CODE END PV */
/* USER CODE BEGIN 2 */
HAL_SPI_TransmitReceive_IT(&hspi1, tx, rx, 2); // prêt à recevoir 2 octets
/* USER CODE END 2 */
/* USER CODE BEGIN 4 */
void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *h){
if(rx[0] == 0x01) HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET); // LED allumée
if(rx[0] == 0x02) HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_SET); // LED éteinte
cnt++; tx[1] = cnt;
HAL_SPI_TransmitReceive_IT(h, tx, rx, 2);
}
/* USER CODE END 4 */
Étape 5 : câbler le SPI (cartes hors tension)
| Signal | Carte A (maître) | Carte B | Carte C |
|---|---|---|---|
| SCLK | PA5 | PA5 | PA5 |
| MOSI | PA7 | PA7 | PA7 |
| MISO | PA6 | PA6 | PA6 |
| CS1 | PB0 | PA4 | non relié |
| CS2 | PB1 | non relié | PA4 |
| Masse | GND | GND | GND |
Chaque ligne du tableau est un fil qui relie toutes les broches indiquées. Alimente chaque carte par son propre câble USB et ne relie jamais les 3,3 V entre cartes : seules les masses sont communes.
Étape 6 : programmer et tester le SPI
- Branche le ST-Link sur la carte B (3,3 V, GND, SWDIO, SWCLK vers les 4 broches de programmation ; ne relie pas le fil 3,3 V du ST-Link si la carte est déjà alimentée par USB). Ouvre esclave_spi, clique le marteau puis la flèche verte Run. Répète pour la carte C.
- Programme la carte A avec maitre_spi de la même façon. Appuie sur NRST des cartes B et C, puis sur NRST de A.
- Résultat attendu : après 1 s la LED de B s’allume, 1 s plus tard elle s’éteint, puis la LED de A clignote 1 fois (n = 1). La LED de C ne bouge jamais.
Étape 7 : refaire en I2C
- Débranche les fils SPI. Crée maitre_i2c et esclave_i2c avec les mêmes réglages RCC, SYS, horloge et PC13 qu’avant. Active I2C1 (Mode I2C), vérifie que les broches sont PB6 (SCL) et PB7 (SDA) (sinon clique sur la broche et choisis I2C1_SCL / I2C1_SDA), Speed Mode Standard, 100000 Hz.
- Esclave : onglet NVIC Settings de l’I2C1, coche I2C1 event interrupt et I2C1 error interrupt. Après génération, ouvre Core/Src/i2c.c et remplace
hi2c1.Init.OwnAddress1 = 0;par0x30 << 1pour B, et0x31 << 1pour C (deux projets, ou change la valeur avant chaque programmation). - Code esclave : variables
uint8_t rx, cnt = 0;dans USER CODE BEGIN PV,HAL_I2C_EnableListen_IT(&hi2c1);dans USER CODE BEGIN 2, et les 3 fonctions callback de la partie B dans USER CODE BEGIN 4. - Code maître, dans USER CODE BEGIN 2 :
uint8_t c = 1, n = 0; HAL_Delay(1000); HAL_I2C_Master_Transmit(&hi2c1, 0x30 << 1, &c, 1, 100); // LED ON esclave 1 HAL_Delay(1000); c = 3; HAL_I2C_Master_Transmit(&hi2c1, 0x31 << 1, &c, 1, 100); // commande « compteur » HAL_I2C_Master_Receive (&hi2c1, 0x31 << 1, &n, 1, 100); // lecture : n doit valoir 1 for(uint8_t i = 0; i < n; i++){ HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET); HAL_Delay(300); HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_SET); HAL_Delay(300); } - Câblage (cartes hors tension) : SCL = PB6 de A, B, C reliées ensemble ; SDA = PB7 de A, B, C reliées ensemble ; une résistance 4,7 kΩ entre SDA et 3,3 V de la carte A, une entre SCL et 3,3 V de la carte A ; GND commun.
- Programme B, C, puis A, et appuie sur NRST. Résultat attendu : la LED de B s’allume après 1 s, puis la LED de A clignote 1 fois.
Si ça ne marche pas
| Symptôme | Cause probable |
|---|---|
| Aucune réaction | GND non commune ; esclaves non programmés ou non redémarrés (NRST) avant le maître |
| SPI : octets faux ou décalés | CPOL/CPHA différents entre maître et esclave ; MISO et MOSI inversés ; fils trop longs |
| SPI : les deux LED réagissent | CS1 et CS2 reliés ensemble ou au mauvais esclave |
| I2C : la fonction HAL ne retourne pas HAL_OK | Pas de pull-up ; adresse non décalée ; SDA et SCL inversés ; esclave sans interruptions I2C activées |
| I2C : deux esclaves répondent | Même adresse sur B et C |
D. Projet final
Un appui sur le bouton PA0 du maître bascule les LED des deux esclaves : l’esclave 1 par SPI, l’esclave 2 par I2C. Le maître relit ensuite le compteur de l’esclave 2 et l’affiche sur le PC. Dans CubeMX du maître, ajoute PA0 en GPIO_Input avec Pull-up, et USART2 en Asynchronous (PA2/PA3, 115200 bauds, 8 bits, sans parité, 1 stop). Relie un adaptateur USB-série : RX de l’adaptateur sur PA2, GND commun, puis ouvre un terminal à 115200.
#include <stdio.h>
static uint8_t on = 0;
while(1){
if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET){ // bouton appuyé
on ^= 1; uint8_t c = on ? 1 : 2, n; char t[24];
spi_send(GPIOB, GPIO_PIN_0, c); // esclave 1 : SPI
HAL_I2C_Master_Transmit(&hi2c1, ESC2, &c, 1, 100); // esclave 2 : I2C
HAL_I2C_Master_Receive (&hi2c1, ESC2, &n, 1, 100); // lire son compteur
int l = sprintf(t, "cnt=%u\r\n", n);
HAL_UART_Transmit(&huart2, (uint8_t*)t, l, 100); // affichage sur le PC
HAL_Delay(300); // anti-rebond
}
}
Pour aller plus loin : ajoute un troisième esclave, change l’adresse d’un esclave, ou passe le SPI en mode 3 sur les deux cartes et vérifie le résultat.
Chapitre 8 : Synthèse
| UART | SPI | I2C | |
|---|---|---|---|
| Fils | 2 (TX, RX) + GND | 4 + 1 CS par esclave | 2 (SDA, SCL) |
| Horloge | Asynchrone | Synchrone | Synchrone |
| Duplex | Full | Full | Half |
| Interlocuteurs | 2 (point à point) | 1 maître, n esclaves | n maîtres, n esclaves |
| Sélection | Aucune | Ligne CS | Adresse 7 bits |
| Vitesse typique | 9600 à 115200 bauds | 1 à 50 Mbit/s | 100 kHz à 1 MHz |
| Usage typique | Console, GPS, module Bluetooth | Carte SD, écran, flash | Capteurs, RTC, EEPROM |
QCM : 18 questions
Exercices de synthèse
Exercice F1. Un capteur doit être lu par un STM32 avec le minimum de fils, avec 5 composants sur le même bus. Quel protocole choisir ?
Exercice F2. Calcule le temps pour envoyer 100 octets en 115200 bauds 8N1.
Exercice F3. Un écran SPI à 20 MHz reçoit 1024 octets. Quelle durée ?
Exercice F4. Associe chaque protocole à sa topologie : UART, SPI, I2C.
Chapitre 9 : L’USART sur STM32 (Black Pill F411)
L’USART est la liaison série la plus courante : elle relie un microcontrôleur à un PC, un module GPS, un module Bluetooth ou un autre microcontrôleur. Ce chapitre présente le câblage, les registres, la HAL, des exemples complets, un protocole de trames, le diagnostic et des exercices.
9.1 Niveaux électriques et câblage
| Norme | Niveaux | Remarque |
|---|---|---|
| UART TTL 3,3 V | 0 V et 3,3 V | Niveau du STM32 |
| RS-232 | environ ±12 V | Ancien port série de PC : ne jamais brancher directement sur le STM32 |
| RS-485 | Paire différentielle | Longues distances, bus multipoints, circuit d’interface nécessaire |
Câblage : TX d’un appareil vers RX de l’autre (croisement) et masse commune. Pour relier la Black Pill à un PC, utilise un adaptateur USB-série 3,3 V (CP2102, CH340, FT232) et un terminal série (PuTTY, TeraTerm ou le terminal de STM32CubeIDE).
Test en boucle locale (loopback) : un simple fil entre PA9 (TX) et PA10 (RX) permet de vérifier que tout octet envoyé est reçu.
9.2 Les USART du STM32F411
| Périphérique | TX | RX | Fonction alternative | Bus |
|---|---|---|---|---|
| USART1 | PA9 | PA10 | AF7 | APB2 |
| USART2 | PA2 | PA3 | AF7 | APB1 |
| USART6 | PA11 | PA12 | AF8 | APB2 |
9.3 Trame, durée et erreurs
Au repos la ligne est à 1. Envoi de la lettre « A » (0x41) en 8N1 : start (0), puis D0 à D7 = 1 0 0 0 0 0 1 0 (poids faible d’abord), puis stop (1).
- Durée d’un bit : Tbit = 1 / baud. À 9600 bauds : 104 µs.
- Trame 8N1 : 10 bits, soit 1,04 ms à 9600 bauds.
- Débit utile : 8 bits sur 10 = 80 %. À 115 200 bauds : 11 520 octets par seconde.
| Erreur | Cause |
|---|---|
| Parité (PE) | Un bit a été modifié pendant la transmission |
| Trame (FE) | Le bit de stop n’est pas à 1 : mauvais baud rate ou parasite |
| Débordement (ORE) | Un octet arrive avant que le précédent n’ait été lu |
| Bruit (NE) | Perturbation détectée pendant l’échantillonnage |
Si les deux appareils n’ont pas le même baud rate, le texte reçu est du charabia : c’est la première chose à vérifier.
9.4 Calcul du baud rate (USART_BRR)
Le registre USART_BRR contient un diviseur de l’horloge du périphérique fck (PCLK2 pour USART1 et USART6, PCLK1 pour USART2), avec suréchantillonnage par 16 :
USARTDIV = fck / (16 × baud) BRR = (partie entière << 4) | (partie fractionnaire × 16, arrondie)
Exemple : fck = 16 MHz, baud = 115 200 : USARTDIV = 8.6806 ; mantisse = 8 ; fraction = 0.6806 × 16 ≈ 11 ; BRR = (8 << 4) + 11 = 0x8B ; baud réel = 115107 bauds, erreur de -0.08 %. Au-delà de 2 % d’erreur environ, la communication devient peu fiable.
9.5 Les registres (programmation sans HAL)
USART1 est à l’adresse 0x40011000 (USART2 : 0x40004400, USART6 : 0x40011400). Horloge : bit 4 de RCC_APB2ENR pour USART1, bit 17 de RCC_APB1ENR pour USART2.
| Registre | Offset | Rôle |
|---|---|---|
| USART_SR | 0x00 | État |
| USART_DR | 0x04 | Donnée émise ou reçue |
| USART_BRR | 0x08 | Diviseur du baud rate |
| USART_CR1 | 0x0C | Contrôle principal |
| USART_CR2 | 0x10 | Bits de stop |
| USART_CR3 | 0x14 | DMA, contrôle de flux |
| Bit de SR | Nom | Signification |
|---|---|---|
| 7 | TXE | 1 : registre d’émission vide, on peut écrire un nouvel octet |
| 6 | TC | 1 : transmission de la trame terminée |
| 5 | RXNE | 1 : un octet reçu est disponible dans DR |
| 3 | ORE | 1 : débordement |
| 2 | NF | 1 : bruit détecté |
| 1 | FE | 1 : erreur de trame |
| 0 | PE | 1 : erreur de parité |
| Bit de CR1 | Nom | Signification |
|---|---|---|
| 15 | OVER8 | 0 : suréchantillonnage par 16 |
| 13 | UE | 1 : active l’USART |
| 12 | M | 0 : 8 bits de données ; 1 : 9 bits |
| 10 | PCE | 1 : active la parité |
| 9 | PS | 0 : parité paire ; 1 : parité impaire |
| 7 | TXEIE | 1 : interruption quand TXE = 1 |
| 5 | RXNEIE | 1 : interruption quand RXNE = 1 |
| 3 | TE | 1 : active l’émetteur |
| 2 | RE | 1 : active le récepteur |
Exemple 1 : émission et réception en registres (115 200 bauds, fck = 16 MHz)
#define USART1_BASE 0x40011000UL
#define USART1_SR (*(volatile uint32_t *)(USART1_BASE + 0x00))
#define USART1_DR (*(volatile uint32_t *)(USART1_BASE + 0x04))
#define USART1_BRR (*(volatile uint32_t *)(USART1_BASE + 0x08))
#define USART1_CR1 (*(volatile uint32_t *)(USART1_BASE + 0x0C))
void uart_init(void)
{
RCC_AHB1ENR |= (1UL << 0); // horloge GPIOA
RCC_APB2ENR |= (1UL << 4); // horloge USART1
/* PA9 (TX) et PA10 (RX) en fonction alternative AF7 */
GPIOA_MODER &= ~((3UL << 18) | (3UL << 20));
GPIOA_MODER |= ((2UL << 18) | (2UL << 20));
GPIOA_AFRH &= ~((0xFUL << 4) | (0xFUL << 8));
GPIOA_AFRH |= ((7UL << 4) | (7UL << 8));
USART1_BRR = 0x8B; // 115 200 baud à 16 MHz
USART1_CR1 = (1UL << 13) | (1UL << 3) | (1UL << 2); // UE, TE, RE
}
void uart_putc(char c)
{
while (!(USART1_SR & (1UL << 7))); // attend TXE
USART1_DR = c;
}
char uart_getc(void)
{
while (!(USART1_SR & (1UL << 5))); // attend RXNE
return (char)USART1_DR;
}
void uart_puts(const char *s) { while (*s) uart_putc(*s++); }
Programme d’écho : while (1) uart_putc(uart_getc());. Animation de l’envoi d’un octet par uart_putc :
9.6 L’USART avec la HAL
| Fonction | Rôle |
|---|---|
| HAL_UART_Init(&huart) | Configure l’USART (appelle HAL_UART_MspInit) |
| HAL_UART_Transmit(&huart, buf, len, timeout) | Envoie len octets (bloquant) |
| HAL_UART_Receive(&huart, buf, len, timeout) | Reçoit len octets (bloquant) |
| HAL_UART_Transmit_IT / Receive_IT | Même chose par interruption (non bloquant) |
| HAL_UART_Transmit_DMA / Receive_DMA | Même chose avec le DMA |
| HAL_UART_TxCpltCallback | Appelée à la fin de l’émission |
| HAL_UART_RxCpltCallback | Appelée quand la réception demandée est terminée |
| HAL_UART_ErrorCallback | Appelée en cas d’erreur |
Les fonctions bloquantes ont un délai maximal (timeout, en ms ; HAL_MAX_DELAY pour attendre indéfiniment). La configuration MX_USART1_UART_Init() est générée par CubeMX : USART1, Asynchronous, 115200 bauds, 8 bits, sans parité, 1 stop.
Exemple 2 : message de démarrage et écho (scrutation)
char msg[] = "Bonjour STM32\r\n";
HAL_UART_Transmit(&huart1, (uint8_t *)msg, sizeof(msg) - 1, 100);
uint8_t c;
while (1)
{
if (HAL_UART_Receive(&huart1, &c, 1, 1000) == HAL_OK)
HAL_UART_Transmit(&huart1, &c, 1, 100); // renvoie le caractère reçu
}
Exemple 3 : utiliser printf
#include <stdio.h>
int _write(int fd, char *ptr, int len)
{
HAL_UART_Transmit(&huart1, (uint8_t *)ptr, len, HAL_MAX_DELAY);
return len;
}
/* Ensuite : */
printf("Compteur = %lu\r\n", HAL_GetTick());
Pour afficher des nombres à virgule (%f), il faut activer « Use float with printf from newlib-nano » dans Properties > C/C++ Build > Settings > MCU Settings de CubeIDE.
Exemple 4 : réception par interruption
La scrutation bloque le programme. Avec l’interruption, chaque octet reçu déclenche un callback.
uint8_t octet_recu;
/* Armer la réception d'un octet (une fois, dans main) */
HAL_UART_Receive_IT(&huart1, &octet_recu, 1);
/* stm32f4xx_it.c */
void USART1_IRQHandler(void) { HAL_UART_IRQHandler(&huart1); }
/* main.c */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *h)
{
if (h->Instance == USART1)
{
HAL_UART_Transmit(h, &octet_recu, 1, 10); // écho
HAL_UART_Receive_IT(h, &octet_recu, 1); // réarmer pour l'octet suivant
}
}
Oublier de réarmer la réception est l’erreur la plus fréquente : un seul octet est alors reçu. Il faut aussi activer l’interruption : HAL_NVIC_SetPriority(USART1_IRQn, 1, 0); HAL_NVIC_EnableIRQ(USART1_IRQn); (ou cocher USART1 global interrupt dans CubeMX).
Exemple 5 : un interpréteur de commandes
Le PC envoie LED ON ou LED OFF suivi de la touche Entrée. Le callback accumule les caractères et la boucle principale analyse la ligne.
#include <string.h>
#define TAILLE 32
uint8_t octet;
char ligne[TAILLE];
uint8_t idx = 0;
volatile uint8_t ligne_prete = 0;
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *h)
{
if (octet == '\r' || octet == '\n')
{
if (idx > 0) { ligne[idx] = '\0'; ligne_prete = 1; idx = 0; }
}
else if (idx < TAILLE - 1) ligne[idx++] = (char)octet;
HAL_UART_Receive_IT(h, &octet, 1);
}
/* Boucle principale */
HAL_UART_Receive_IT(&huart1, &octet, 1);
while (1)
{
if (ligne_prete)
{
ligne_prete = 0;
if (strcmp(ligne, "LED ON") == 0)
{
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET); // LED allumée
HAL_UART_Transmit(&huart1, (uint8_t *)"OK\r\n", 4, 100);
}
else if (strcmp(ligne, "LED OFF") == 0)
{
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_SET);
HAL_UART_Transmit(&huart1, (uint8_t *)"OK\r\n", 4, 100);
}
else HAL_UART_Transmit(&huart1, (uint8_t *)"ERREUR\r\n", 8, 100);
}
}
Exemple 6 : émission avec le DMA
char texte[] = "Message long envoye en DMA\r\n";
HAL_UART_Transmit_DMA(&huart1, (uint8_t *)texte, sizeof(texte) - 1);
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *h)
{
/* émission terminée : on peut préparer le message suivant */
}
Le tableau texte doit rester valide pendant toute l’émission (variable globale ou statique, pas une variable locale d’une fonction qui se termine).
9.7 Concevoir un protocole sur l’USART
Une liaison série transporte des octets : à toi de définir leur sens. Une bonne trame comporte :
| Champ | Rôle | Exemple |
|---|---|---|
| Début | Délimiter la trame | $ ou l’octet 0xAA |
| Commande ou type | Identifier le message | T (température) |
| Données | La valeur | 27.3 |
| Somme de contrôle | Détecter les erreurs | XOR ou somme modulo 256 |
| Fin | Délimiter la trame | \r\n |
Exemple en texte : $T,27.3*60\r\n, où 60 est le XOR des caractères entre $ et * (principe des trames NMEA des modules GPS). Calcule-le avec l’outil :
uint8_t checksum(const uint8_t *data, uint8_t len)
{
uint8_t cs = 0;
for (uint8_t i = 0; i < len; i++) cs ^= data[i]; // XOR de tous les octets
return cs;
}
9.8 Diagnostic d’une liaison série
| Symptôme | Cause probable |
|---|---|
| Rien n’est reçu | TX et RX non croisés, masse non commune, mauvaise broche ou mauvaise AF |
| Caractères incohérents | Baud rate différent, ou horloge système mal configurée |
| Premier caractère correct puis plus rien | Réception par interruption non réarmée |
| Caractères perdus | Réception trop lente : utiliser une interruption ou le DMA |
| Rien sur le PC mais la LED réagit | Mauvais port COM sélectionné dans le terminal |
Outil précieux : un analyseur logique ou un oscilloscope sur la ligne TX permet de mesurer la durée d’un bit et de vérifier le baud rate.
9.9 Exercices USART
Exercice 1 : trame. Dessiner la trame UART de la lettre « K » (0x4B) en 8N1, puis en 8E1 (parité paire). Calculer la durée de la trame à 19 200 bauds.
Exercice 2 : débit. Un capteur envoie 20 octets toutes les 100 ms en 8N1. Quel baud rate minimal normalisé (9600, 19200, 38400, 57600, 115200) faut-il choisir ? Justifier.
Exercice 3 : baud rate. Calculer USART_BRR pour 9600 bauds avec fck = 16 MHz, puis pour 115 200 bauds avec fck = 50 MHz. Donner l’erreur dans chaque cas.
115 200 bauds, 50 MHz : USARTDIV = 27.1267, mantisse 27, fraction 0.1267 × 16 ≈ 2, BRR = 0x1B2, baud réel 115207.4, erreur 0.006 %. Les deux erreurs sont très inférieures à 2 %.
Exercice 4 : écho en majuscules. Écrire un programme HAL qui renvoie chaque caractère reçu converti en majuscule.
uint8_t c;
while (1)
{
if (HAL_UART_Receive(&huart1, &c, 1, 1000) == HAL_OK)
{
if (c >= 'a' && c <= 'z') c -= 32; // minuscule -> majuscule
HAL_UART_Transmit(&huart1, &c, 1, 100);
}
}
Exercice 5 : commandes. Étendre l’exemple 5 avec BLINK n (la LED clignote n fois) et STATUS (réponse LED=ON ou LED=OFF).
int n;
if (sscanf(ligne, "BLINK %d", &n) == 1)
{
for (int i = 0; i < n; i++)
{
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET); HAL_Delay(200);
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_SET); HAL_Delay(200);
}
HAL_UART_Transmit(&huart1, (uint8_t *)"OK\r\n", 4, 100);
}
else if (strcmp(ligne, "STATUS") == 0)
{
if (HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_13) == GPIO_PIN_RESET)
HAL_UART_Transmit(&huart1, (uint8_t *)"LED=ON\r\n", 8, 100);
else
HAL_UART_Transmit(&huart1, (uint8_t *)"LED=OFF\r\n", 9, 100);
}
(inclure <stdio.h>). Rappel : la LED de la Black Pill est allumée quand PC13 vaut 0.Exercice 6 : trame avec somme de contrôle. Envoyer chaque seconde la trame $A,<valeur ADC>*<XOR en hexadécimal>\r\n, puis écrire la fonction de réception qui valide la somme et rejette les trames erronées.
/* émission */
char corps[16], trame[24]; uint8_t cs = 0;
int n = sprintf(corps, "A,%u", valeur_adc);
for (int i = 0; i < n; i++) cs ^= (uint8_t)corps[i];
sprintf(trame, "$%s*%02X\r\n", corps, cs);
HAL_UART_Transmit(&huart1, (uint8_t *)trame, strlen(trame), 100);
/* validation : renvoie 1 si la trame "$...*HH" est correcte */
int trame_valide(const char *t)
{
if (t[0] != '$') return 0;
uint8_t cs = 0; const char *p = t + 1;
while (*p && *p != '*') cs ^= (uint8_t)*p++;
if (*p != '*') return 0;
return cs == (uint8_t)strtol(p + 1, NULL, 16);
}
Exercice 7 : test en boucle locale. Relier PA9 à PA10 par un fil. Envoyer les octets de 0 à 255 et vérifier qu’ils sont tous reçus identiques. Compter les erreurs.
uint8_t tx, rx; uint16_t erreurs = 0;
for (uint16_t i = 0; i < 256; i++)
{
tx = (uint8_t)i;
HAL_UART_Transmit(&huart1, &tx, 1, 10);
if (HAL_UART_Receive(&huart1, &rx, 1, 10) != HAL_OK || rx != tx) erreurs++;
}
/* erreurs doit valoir 0 */
Si erreurs > 0, vérifier le fil et la configuration (même baud rate en émission et en réception, puisque c’est le même USART).Exercice 8 : USART en registres. Sans la HAL, écrire uart_printf_entier(int n) qui envoie un entier en décimal avec uart_putc (sans printf).
void uart_printf_entier(int n)
{
char b[12]; int i = 0;
if (n < 0) { uart_putc('-'); n = -n; }
if (n == 0) b[i++] = '0';
while (n > 0) { b[i++] = '0' + n % 10; n /= 10; } // chiffres en ordre inverse
while (i > 0) uart_putc(b[--i]);
}
Exercice 9 : temps réel d’un bit. Mesurer à l’oscilloscope la durée d’un bit sur PA9 à 9600, 57600 et 115200 bauds. Comparer avec la théorie.
Exercice 10 : travaux pratiques. Créer un « terminal de contrôle » : ADC donne la tension de PA1, LED ON / LED OFF commandent la LED, HELP liste les commandes. Documenter le protocole.
| Commande (PC → STM32) | Réponse (STM32 → PC) |
|---|---|
| ADC | V=1.65\r\n (tension de PA1 en volts) |
| LED ON / LED OFF | OK\r\n |
| HELP | ADC, LED ON, LED OFF, HELP\r\n |
| autre chose | ERREUR\r\n |
Chapitre 10 : Le bus SPI sur STM32 (Black Pill F411)
Le SPI est une liaison série synchrone rapide, utilisée pour les mémoires flash, les écrans, les convertisseurs (ADC, DAC), les cartes SD et de nombreux capteurs. Ce chapitre contient le principe, les registres, la HAL, des exemples câblés et des exercices.
10.1 Principe du bus SPI
| Signal | Nom complet | Sens | Rôle |
|---|---|---|---|
| SCK (SCLK) | Serial Clock | maître → esclave | Horloge fournie par le maître |
| MOSI | Master Out Slave In | maître → esclave | Données envoyées par le maître |
| MISO | Master In Slave Out | esclave → maître | Données renvoyées par l’esclave |
| CS (NSS, SS) | Chip Select | maître → esclave | Sélection de l’esclave, actif à l’état bas |
À chaque coup d’horloge, un bit part du maître vers l’esclave et, en même temps, un bit part de l’esclave vers le maître : les deux registres à décalage forment un anneau. Une transmission SPI est donc toujours un échange (full duplex). Pour lire un esclave, le maître envoie un octet sans importance (souvent 0xFF ou 0x00) et récupère la réponse.
Plusieurs esclaves
Chaque esclave a sa propre ligne CS ; SCK, MOSI et MISO sont partagées. Le maître met à 0 la ligne CS de l’esclave choisi ; les autres laissent leur sortie MISO en haute impédance. Exemple : une mémoire flash (CS sur PA4) et un DAC (CS sur PB0) sur SPI1 :
| Montage | Principe | Remarque |
|---|---|---|
| CS séparés | Une broche CS par esclave | Cas le plus courant |
| Chaînage (daisy chain) | La sortie de l’esclave 1 alimente l’entrée de l’esclave 2 | Registres à décalage 74HC595, MAX7219 |
Les quatre modes (CPOL et CPHA)
CPOL : niveau de repos de l’horloge (0 = bas, 1 = haut). CPHA : 0 = échantillonnage sur le premier front, 1 = sur le second front. Le mode est imposé par l’esclave (datasheet) ; un mauvais mode donne des données décalées d’un bit ou incohérentes. Les modes 0 et 3 sont les plus fréquents.
| Mode | CPOL | CPHA | Horloge au repos | Échantillonnage |
|---|---|---|---|---|
| 0 | 0 | 0 | Bas | Front montant |
| 1 | 0 | 1 | Bas | Front descendant |
| 2 | 1 | 0 | Haut | Front descendant |
| 3 | 1 | 1 | Haut | Front montant |
Chronogramme du mode 0 pour l’octet 0xA5 (MISO = 0x00) : chaque bit est présent sur MOSI avant le front montant de SCK, et l’esclave le lit sur ce front.
Débit et durée
La fréquence de SCK est choisie par le maître : fSCK = fPCLK / prédiviseur (de 2 à 256). Un octet demande 8 périodes : Toctet = 8 / fSCK. À 1 MHz : 8 µs par octet, 125 000 octets par seconde. Saisis la fréquence de PCLK du SPI (APB2 pour SPI1) :
| Avantages | Limites |
|---|---|
| Très rapide (jusqu’à plusieurs dizaines de MHz) | 4 fils au minimum, plus un CS par esclave |
| Full duplex, protocole simple | Pas d’adressage ni d’acquittement : le maître ne sait pas si l’esclave est présent |
| Pas de résistances de tirage | Pas de norme de trame : chaque composant a son protocole |
10.2 Le SPI du STM32F411
| Périphérique | SCK | MISO | MOSI | NSS | AF | Bus |
|---|---|---|---|---|---|---|
| SPI1 | PA5 | PA6 | PA7 | PA4 | AF5 | APB2 (jusqu’à 100 MHz) |
| SPI2 | PB13 | PB14 | PB15 | PB12 | AF5 | APB1 |
| SPI3 | PB3 | PB4 | PB5 | PA15 | AF6 | APB1 |
Dans ce cours la broche CS est pilotée par logiciel (sortie GPIO ordinaire) : on peut ainsi gérer plusieurs esclaves et garder CS à 0 pendant plusieurs octets.
10.3 Les registres (programmation sans HAL)
SPI1 est à l’adresse 0x40013000. Horloge : bit 12 de RCC_APB2ENR. Registres : SPI_CR1 (0x00, configuration), SPI_CR2 (0x04), SPI_SR (0x08, état), SPI_DR (0x0C, donnée).
| Bit de CR1 | Nom | Signification |
|---|---|---|
| 0 | CPHA | Phase de l’horloge |
| 1 | CPOL | Polarité de l’horloge |
| 2 | MSTR | 1 : mode maître |
| 5:3 | BR | Prédiviseur (BR = 000 : /2 ; 001 : /4 ; … ; 111 : /256) |
| 6 | SPE | 1 : active le SPI |
| 7 | LSBFIRST | 0 : bit de poids fort en premier |
| 8 | SSI | Niveau interne de NSS (à 1 avec SSM pour un maître) |
| 9 | SSM | 1 : gestion logicielle de NSS |
| 11 | DFF | 0 : trames de 8 bits ; 1 : 16 bits |
| Bit de SR | Nom | Signification |
|---|---|---|
| 0 | RXNE | 1 : un octet reçu est disponible dans DR |
| 1 | TXE | 1 : registre d’émission vide |
| 7 | BSY | 1 : SPI occupé |
| 6 | OVR | 1 : écrasement d’une donnée reçue |
Exemple 1 : SPI1 maître, mode 0, 1 MHz (PCLK2 = 16 MHz, prédiviseur 16)
#define SPI1_BASE 0x40013000UL
#define SPI1_CR1 (*(volatile uint32_t *)(SPI1_BASE + 0x00))
#define SPI1_SR (*(volatile uint32_t *)(SPI1_BASE + 0x08))
#define SPI1_DR (*(volatile uint32_t *)(SPI1_BASE + 0x0C))
void spi_init(void)
{
RCC_AHB1ENR |= (1UL << 0); // horloge GPIOA
RCC_APB2ENR |= (1UL << 12); // horloge SPI1
/* PA5, PA6, PA7 en fonction alternative AF5 */
GPIOA_MODER &= ~((3UL << 10) | (3UL << 12) | (3UL << 14));
GPIOA_MODER |= ((2UL << 10) | (2UL << 12) | (2UL << 14));
GPIOA_AFRL &= ~((0xFUL << 20) | (0xFUL << 24) | (0xFUL << 28));
GPIOA_AFRL |= ((5UL << 20) | (5UL << 24) | (5UL << 28));
/* PA4 : sortie logicielle pour CS, au repos à 1 */
GPIOA_BSRR = (1UL << 4);
GPIOA_MODER &= ~(3UL << 8);
GPIOA_MODER |= (1UL << 8);
/* maître, mode 0, prédiviseur 16, NSS logiciel, puis SPI actif */
SPI1_CR1 = (1UL << 2) | (3UL << 3) | (1UL << 9) | (1UL << 8);
SPI1_CR1 |= (1UL << 6); // SPE
}
uint8_t spi_echange(uint8_t octet)
{
while (!(SPI1_SR & (1UL << 1))); // attend TXE
SPI1_DR = octet;
while (!(SPI1_SR & (1UL << 0))); // attend RXNE
return (uint8_t)SPI1_DR;
}
#define CS_BAS() (GPIOA_BSRR = (1UL << (4 + 16)))
#define CS_HAUT() (GPIOA_BSRR = (1UL << 4))
Dans SPI_CR1, (3UL << 3) donne BR = 011, soit le prédiviseur 16.
10.4 Le SPI avec la HAL
SPI_HandleTypeDef hspi1;
void MX_SPI1_Init(void)
{
hspi1.Instance = SPI1;
hspi1.Init.Mode = SPI_MODE_MASTER;
hspi1.Init.Direction = SPI_DIRECTION_2LINES;
hspi1.Init.DataSize = SPI_DATASIZE_8BIT;
hspi1.Init.CLKPolarity = SPI_POLARITY_LOW; // CPOL = 0
hspi1.Init.CLKPhase = SPI_PHASE_1EDGE; // CPHA = 0 : mode 0
hspi1.Init.NSS = SPI_NSS_SOFT;
hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
hspi1.Init.CRCPolynomial = 10;
if (HAL_SPI_Init(&hspi1) != HAL_OK) Error_Handler();
}
#define CS_BAS() HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET)
#define CS_HAUT() HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET)
HAL_SPI_MspInit (générée par CubeMX) active les horloges SPI1 et GPIOA, configure PA5, PA6, PA7 en fonction alternative AF5 (push-pull, vitesse très haute) et PA4 en sortie GPIO mise à 1 (CS au repos). Pour changer de mode, on modifie CLKPolarity et CLKPhase :
| Mode | CLKPolarity | CLKPhase |
|---|---|---|
| 0 | SPI_POLARITY_LOW | SPI_PHASE_1EDGE |
| 1 | SPI_POLARITY_LOW | SPI_PHASE_2EDGE |
| 2 | SPI_POLARITY_HIGH | SPI_PHASE_1EDGE |
| 3 | SPI_POLARITY_HIGH | SPI_PHASE_2EDGE |
| Fonction | Rôle |
|---|---|
| HAL_SPI_Transmit(&hspi, buf, len, timeout) | Envoie len octets (ignore ce qui revient) |
| HAL_SPI_Receive(&hspi, buf, len, timeout) | Reçoit len octets (le maître envoie des octets sans importance) |
| HAL_SPI_TransmitReceive(&hspi, tx, rx, len, timeout) | Échange len octets dans les deux sens |
| HAL_SPI_Transmit_IT / _DMA | Versions par interruption et par DMA |
| HAL_SPI_TxCpltCallback | Appelée à la fin de l’émission en IT ou DMA |
Exemple 2 : test en boucle locale (loopback)
Relie PA7 (MOSI) à PA6 (MISO) par un fil : l’octet envoyé doit revenir identique.
uint8_t tx = 0xA5, rx = 0; CS_BAS(); HAL_SPI_TransmitReceive(&hspi1, &tx, &rx, 1, 100); CS_HAUT(); if (rx == tx) HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET); // test réussi : LED allumée
Exemple 3 : DAC externe MCP4921 (12 bits)
Le MCP4921 est un DAC 12 bits à une voie (mode 0 ou 3, jusqu’à 20 MHz). Il reçoit un mot de 16 bits, poids fort en premier, CS à 0 pendant toute la trame.
| Bit | Nom | Valeur utilisée | Signification |
|---|---|---|---|
| 15 | A/B | 0 | Sélection de la voie (une seule voie) |
| 14 | BUF | 0 | Entrée Vref non bufferisée |
| 13 | GA | 1 | Gain 1x (Vout max = Vref) |
| 12 | SHDN | 1 | Sortie active |
| 11:0 | D11…D0 | donnée | Valeur 12 bits |
Le mot à envoyer vaut 0x3000 | (valeur & 0x0FFF) et Vout = Vref × valeur / 4096. Essaie avec l’outil, puis observe l’échange étape par étape :
void dac_ecrire(uint16_t valeur)
{
uint16_t mot = 0x3000 | (valeur & 0x0FFF);
uint8_t trame[2] = { mot >> 8, mot & 0xFF }; // octet de poids fort d'abord
CS_BAS();
HAL_SPI_Transmit(&hspi1, trame, 2, 10);
CS_HAUT(); // la sortie change quand CS remonte
}
dac_ecrire(2048); // Vref = 3,3 V : 1,65 V
/* Signal triangulaire */
while (1)
{
for (uint16_t v = 0; v < 4095; v += 64) dac_ecrire(v);
for (uint16_t v = 4095; v > 0; v -= 64) dac_ecrire(v);
}
Câblage : VDD et VREF à 3,3 V, VSS à GND, CS sur PA4, SCK sur PA5, SDI sur PA7 (MOSI), LDAC à GND.
Exemple 4 : lire l’identifiant d’une mémoire flash (W25Qxx)
Les mémoires flash série (Winbond W25Q64, W25Q32…) répondent à la commande 0x9F (JEDEC ID) par 3 octets : fabricant, type, capacité. Pour la W25Q64 on attend 0xEF 0x40 0x17.
uint8_t cmd = 0x9F; uint8_t id[3]; CS_BAS(); HAL_SPI_Transmit(&hspi1, &cmd, 1, 10); // envoi de la commande HAL_SPI_Receive(&hspi1, id, 3, 10); // lecture de 3 octets CS_HAUT(); /* id[0] = 0xEF (Winbond) si le câblage et le mode SPI sont corrects */
Si les trois octets valent 0x00 ou 0xFF, vérifier : l’alimentation, CS, le mode SPI, le câblage MOSI et MISO.
Exemple 5 : émission en DMA
uint8_t buffer[256];
HAL_SPI_Transmit_DMA(&hspi1, buffer, sizeof(buffer));
void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *h)
{
CS_HAUT(); // fin du transfert : libérer l'esclave
}
Avec le DMA, CS ne doit remonter qu’après le callback, pas juste après l’appel de la fonction.
Exemple 6 : registre à décalage 74HC595 (8 LED)
Un 74HC595 reçoit un octet en SPI ; le CS joue le rôle de la ligne de verrouillage RCLK : les sorties changent quand CS remonte.
10.5 Diagnostic d’un bus SPI
| Symptôme | Cause probable |
|---|---|
| Tout reçu à 0xFF | Esclave non sélectionné (CS), non alimenté, ou MISO non câblé |
| Tout reçu à 0x00 | MISO relié à la masse, ou esclave bloqué |
| Données décalées d’un bit | Mauvais mode (CPOL / CPHA) |
| Fonctionne lentement mais pas à haute vitesse | Fils trop longs, horloge trop rapide pour l’esclave |
| Les données arrivent mais le composant ne réagit pas | CS remonté trop tôt ou trame incomplète |
Outil précieux : un analyseur logique avec décodage SPI montre CS, SCK, MOSI et MISO et permet de lire directement les octets échangés.
10.6 Exercices SPI
Exercice 1 : chronogramme. Dessiner le chronogramme (CS, SCK, MOSI) de l’envoi de l’octet 0x3C en mode 0, poids fort en premier. Refaire le dessin en mode 3.
Exercice 2 : mode d’un composant. La datasheet d’un capteur indique : « SCK est au repos à l’état haut, les données sont lues sur le front montant ». Donner CPOL, CPHA et le numéro du mode.
Exercice 3 : débit. PCLK2 = 100 MHz. Donner fSCK pour chaque prédiviseur de 2 à 256. Quel prédiviseur pour un composant limité à 10 MHz ? Durée de l’envoi de 2 octets ?
| Prédiviseur | fSCK |
|---|---|
| 2 | 50 MHz |
| 4 | 25 MHz |
| 8 | 12.5 MHz |
| 16 | 6.25 MHz |
| 32 | 3.125 MHz |
| 64 | 1.5625 MHz |
| 128 | 0.78125 MHz |
| 256 | 0.390625 MHz |
Exercice 4 : valeurs pour le DAC. Calculer le mot de 16 bits (hexadécimal) pour obtenir 1,0 V avec Vref = 3,3 V. Calculer la tension obtenue avec le mot 0x37FF.
0x37FF : valeur = 0x7FF = 2047, Vout = 3,3 × 2047 / 4096 ≈ 1.6492 V.
Exercice 5 : initialisation en registres. Écrire la configuration de SPI_CR1 pour un maître en mode 3, prédiviseur 8, NSS logiciel, poids fort en premier. Donner la valeur hexadécimale.
Configuration : 0x001 + 0x002 + 0x004 + 0x010 + 0x100 + 0x200 = 0x0317. Puis on active SPE (bit 6, 0x40) : 0x0357.
Exercice 6 : générateur de signaux. Avec le MCP4921, générer un sinus de 50 points par période. Mesurer la fréquence obtenue et la comparer au calcul.
uint16_t sinus[50]; for (int k = 0; k < 50; k++) sinus[k] = 2048 + (uint16_t)(2047.0f * sinf(2.0f * 3.14159265f * k / 50.0f)); while (1) for (int k = 0; k < 50; k++) dac_ecrire(sinus[k]);Fréquence calculée : f = 1 / (50 × Téchantillon), où Téchantillon est la durée d’un appel à dac_ecrire (octets SPI + temps de la HAL + CS). À mesurer à l’oscilloscope : la fréquence maximale est limitée surtout par le temps de la HAL, bien plus que par l’horloge SPI (16 bits à 6,25 MHz = 2,56 µs).
Exercice 7 : identifiant d’un composant. Lire l’identifiant d’une mémoire W25Q (exemple 4) et l’envoyer sur l’USART sous la forme « ID = EF 40 17 ».
printf("ID = %02X %02X %02X\r\n", id[0], id[1], id[2]); // _write redirigé vers l'USART
Exercice 8 : plusieurs esclaves. Deux esclaves partagent SPI1 : une flash (CS sur PA4) et un DAC (CS sur PB0). Écrire deux macros CS_FLASH_BAS() et CS_DAC_BAS() et le code qui lit l’identifiant de la flash puis écrit une valeur dans le DAC. Pourquoi ne faut-il jamais mettre les deux CS à 0 en même temps ?
#define CS_FLASH_BAS() HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET)
#define CS_FLASH_HAUT() HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET)
#define CS_DAC_BAS() HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_RESET)
#define CS_DAC_HAUT() HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_SET)
uint8_t cmd = 0x9F, id[3];
CS_FLASH_BAS(); HAL_SPI_Transmit(&hspi1, &cmd, 1, 10); HAL_SPI_Receive(&hspi1, id, 3, 10); CS_FLASH_HAUT();
uint16_t mot = 0x3000 | 2048; uint8_t t[2] = { mot >> 8, mot & 0xFF };
CS_DAC_BAS(); HAL_SPI_Transmit(&hspi1, t, 2, 10); CS_DAC_HAUT();
Avec les deux CS à 0, les deux esclaves seraient actifs : tous deux interpréteraient les mêmes bits (la commande de la flash serait lue comme une donnée par le DAC) et les deux pourraient piloter MISO en même temps : conflit électrique sur la ligne.Exercice 9 : chenille avec un 74HC595. Écrire une chenille lumineuse : une LED allumée qui se déplace de gauche à droite toutes les 200 ms.
uint8_t led = 0x80;
while (1)
{
CS_BAS();
HAL_SPI_Transmit(&hspi1, &led, 1, 10);
CS_HAUT(); // le front montant de CS verrouille la sortie (RCLK)
HAL_Delay(200);
led >>= 1;
if (led == 0) led = 0x80;
}
Exercice 10 : analyse d’un échange. On observe : CS à 0, MOSI = 0x9F, puis MISO = 0xEF 0x40 0x17, puis CS à 1. Identifier le composant et la commande. Écrire le code HAL en une seule transaction de 4 octets.
uint8_t tx[4] = { 0x9F, 0, 0, 0 }, rx[4];
CS_BAS();
HAL_SPI_TransmitReceive(&hspi1, tx, rx, 4, 10);
CS_HAUT();
/* rx[0] : octet reçu pendant la commande (ignoré) ; rx[1..3] = EF 40 17 */
Chapitre 11 : Le bus I2C sur STM32 (Black Pill F411)
L’I2C relie un maître à de nombreux composants avec seulement deux fils : capteurs, EEPROM, horloges temps réel, écrans, convertisseurs. Ce chapitre contient le principe, les registres, la HAL, des exemples câblés et des exercices.
11.1 Principe du bus I2C
| Signal | Rôle |
|---|---|
| SCL | Horloge, générée par le maître |
| SDA | Données, bidirectionnelles |
Les deux lignes sont de type open-drain : chaque composant ne sait que tirer la ligne vers 0. Le niveau 1 est obtenu par une résistance de tirage (pull-up) reliée à VDD, placée sur chaque ligne (une seule paire de résistances pour tout le bus). Plusieurs composants peuvent ainsi partager les lignes sans court-circuit. Chaque esclave possède une adresse de 7 bits (de 0x08 à 0x77 en pratique). Exemple de bus avec quatre composants :
| Mode | Débit maximal |
|---|---|
| Standard (Sm) | 100 kbit/s |
| Fast (Fm) | 400 kbit/s |
| Fast-mode Plus (Fm+) | 1 Mbit/s |
| Condition | Définition |
|---|---|
| START | SDA passe de 1 à 0 pendant que SCL est à 1 |
| STOP | SDA passe de 0 à 1 pendant que SCL est à 1 |
| Bit de donnée | SDA est stable quand SCL est à 1 ; SDA ne change que quand SCL est à 0 |
| ACK | Au 9e coup d’horloge, le récepteur tire SDA à 0 pour accuser réception |
| NACK | Au 9e coup d’horloge, SDA reste à 1 : pas d’acquittement |
Une trame d’écriture
START | adresse (7 bits) + R/W=0 | ACK | octet 1 | ACK | octet 2 | ACK | STOP
Le premier octet contient l’adresse sur 7 bits et le bit R/W (0 : le maître écrit ; 1 : le maître lit). Chaque octet est suivi d’un bit d’acquittement envoyé par le récepteur. Les bits partent poids fort en premier. Exemple : MPU6050 d’adresse 0x68 : octet d’adresse en écriture = 0x68 << 1 = 0xD0, en lecture = 0xD1. Chronogramme de l’écriture de 0x00 dans le registre 0x6B :
Une trame de lecture avec adresse de registre
Pour lire un registre, le maître écrit d’abord l’adresse du registre, puis recommence avec un START répété (Sr) et lit :
START | adr+W | ACK | adresse_registre | ACK | START répété | adr+R | ACK | donnée | NACK | STOP
Le maître envoie un NACK après le dernier octet lu pour dire à l’esclave d’arrêter, puis un STOP.
Étirement d’horloge (clock stretching)
Un esclave lent peut maintenir SCL à 0 pour obliger le maître à attendre. Le maître doit surveiller SCL avant de poursuivre.
Choisir les résistances de tirage
| Condition | Formule | Exemple |
|---|---|---|
| Valeur minimale (courant du composant au niveau bas) | Rmin = (VDD − 0,4 V) / 3 mA | (3,3 − 0,4) / 3 mA = 967 Ω |
| Valeur maximale (temps de montée tr) | Rmax = tr / (0,8473 × Cbus) | Fm : tr = 300 ns, Cbus = 100 pF : 3,5 kΩ |
Valeurs usuelles : 4,7 kΩ pour 100 kHz, 2,2 kΩ à 3,3 kΩ pour 400 kHz. Sans résistances de tirage, le bus ne fonctionne pas.
Durée d’un transfert
Chaque octet demande 9 périodes d’horloge (8 bits plus l’ACK). Écriture de l’adresse, d’un registre et d’une donnée à 100 kHz : 3 octets × 9 = 27 périodes = 270 µs, plus les conditions START et STOP.
11.2 L’I2C du STM32F411
| Périphérique | SCL | SDA | Fonction alternative |
|---|---|---|---|
| I2C1 | PB6 (ou PB8) | PB7 (ou PB9) | AF4 |
| I2C2 | PB10 | PB3 ou PB9 | AF4 (SCL), AF9 (SDA) |
| I2C3 | PA8 | PB4 | AF4 (SCL), AF9 (SDA) |
Les broches se configurent en fonction alternative open-drain avec résistance de tirage. Les résistances internes (environ 40 kΩ) sont trop fortes : ajoute des résistances externes de 4,7 kΩ.
11.3 Les registres (programmation sans HAL)
I2C1 est à l’adresse 0x40005400. Horloge : bit 21 de RCC_APB1ENR.
| Registre | Offset | Rôle |
|---|---|---|
| I2C_CR1 | 0x00 | Contrôle : PE (bit 0), START (bit 8), STOP (bit 9), ACK (bit 10) |
| I2C_CR2 | 0x04 | FREQ[5:0] : fréquence de PCLK1 en MHz |
| I2C_DR | 0x10 | Donnée émise ou reçue |
| I2C_SR1 | 0x14 | SB (0), ADDR (1), BTF (2), RXNE (6), TXE (7), AF (10) |
| I2C_SR2 | 0x18 | État : MSL, BUSY… |
| I2C_CCR | 0x1C | Réglage de la fréquence de SCL |
| I2C_TRISE | 0x20 | Temps de montée maximal |
Mode standard (100 kHz) : CCR = fPCLK1 / (2 × fSCL) ; TRISE = fPCLK1(MHz) + 1 ; FREQ = fPCLK1 en MHz.
Exemple 1 : écrire un octet dans un registre d’un esclave (registres)
#define I2C1_BASE 0x40005400UL
#define I2C1_CR1 (*(volatile uint32_t *)(I2C1_BASE + 0x00))
#define I2C1_CR2 (*(volatile uint32_t *)(I2C1_BASE + 0x04))
#define I2C1_DR (*(volatile uint32_t *)(I2C1_BASE + 0x10))
#define I2C1_SR1 (*(volatile uint32_t *)(I2C1_BASE + 0x14))
#define I2C1_SR2 (*(volatile uint32_t *)(I2C1_BASE + 0x18))
#define I2C1_CCR (*(volatile uint32_t *)(I2C1_BASE + 0x1C))
#define I2C1_TRISE (*(volatile uint32_t *)(I2C1_BASE + 0x20))
void i2c_init(void)
{
RCC_AHB1ENR |= (1UL << 1); // horloge GPIOB
RCC_APB1ENR |= (1UL << 21); // horloge I2C1
/* PB6 (SCL) et PB7 (SDA) : AF4, open-drain */
GPIOB_MODER &= ~((3UL << 12) | (3UL << 14));
GPIOB_MODER |= ((2UL << 12) | (2UL << 14));
GPIOB_OTYPER |= ((1UL << 6) | (1UL << 7));
GPIOB_AFRL &= ~((0xFUL << 24) | (0xFUL << 28));
GPIOB_AFRL |= ((4UL << 24) | (4UL << 28));
I2C1_CR2 = 16; // PCLK1 = 16 MHz
I2C1_CCR = 80; // 100 kHz
I2C1_TRISE = 17;
I2C1_CR1 |= 1; // PE : active l'I2C
}
void i2c_ecrire(uint8_t adresse7, uint8_t reg, uint8_t valeur)
{
I2C1_CR1 |= (1UL << 8); // START
while (!(I2C1_SR1 & (1UL << 0))); // attend SB
I2C1_DR = adresse7 << 1; // adresse + R/W = 0
while (!(I2C1_SR1 & (1UL << 1))); // attend ADDR
(void)I2C1_SR1; (void)I2C1_SR2; // lire SR1 puis SR2 efface ADDR
while (!(I2C1_SR1 & (1UL << 7))); // attend TXE
I2C1_DR = reg;
while (!(I2C1_SR1 & (1UL << 7)));
I2C1_DR = valeur;
while (!(I2C1_SR1 & (1UL << 2))); // attend BTF : octet envoyé
I2C1_CR1 |= (1UL << 9); // STOP
}
Ce code illustre le principe. Sur le STM32F4 l’I2C a des cas particuliers difficiles (gestion de l’ACK en lecture, erreurs) : en pratique on utilise la HAL.
11.4 L’I2C avec la HAL
I2C_HandleTypeDef hi2c1;
void MX_I2C1_Init(void)
{
hi2c1.Instance = I2C1;
hi2c1.Init.ClockSpeed = 100000; // 100 kHz
hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;
hi2c1.Init.OwnAddress1 = 0;
hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
hi2c1.Init.OwnAddress2 = 0;
hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
if (HAL_I2C_Init(&hi2c1) != HAL_OK) Error_Handler();
}
HAL_I2C_MspInit (générée par CubeMX) active les horloges GPIOB et I2C1 et configure PB6 (SCL) et PB7 (SDA) en GPIO_MODE_AF_OD, avec AF4 : la résistance interne étant faible, ajoute des 4,7 kΩ externes.
| Fonction | Rôle |
|---|---|
| HAL_I2C_Master_Transmit(&hi2c, adr, buf, len, timeout) | Envoie len octets à l’esclave |
| HAL_I2C_Master_Receive(&hi2c, adr, buf, len, timeout) | Reçoit len octets |
| HAL_I2C_Mem_Write(&hi2c, adr, reg, taille_reg, buf, len, timeout) | Écrit dans les registres d’un composant (adresse de registre incluse) |
| HAL_I2C_Mem_Read(&hi2c, adr, reg, taille_reg, buf, len, timeout) | Lit des registres (avec START répété) |
| HAL_I2C_IsDeviceReady(&hi2c, adr, essais, timeout) | Vérifie qu’un esclave répond à son adresse |
| HAL_I2C_Master_Transmit_IT / _DMA et Receive | Versions par interruption et DMA |
| HAL_I2C_GetError(&hi2c) | Code de l’erreur survenue |
adresse7 << 1. Pour le MPU6050 (0x68) on passe 0x68 << 1 = 0xD0. C’est l’erreur n°1 avec l’I2C. La taille de l’adresse de registre se règle avec I2C_MEMADD_SIZE_8BIT (la plupart des capteurs) ou I2C_MEMADD_SIZE_16BIT (grosses EEPROM).Exemple 2 : scanner du bus (trouver les composants)
#include <stdio.h>
printf("Scan du bus I2C...\r\n");
for (uint8_t a = 1; a < 128; a++)
{
if (HAL_I2C_IsDeviceReady(&hi2c1, a << 1, 1, 10) == HAL_OK)
printf("Composant trouve a l'adresse 0x%02X\r\n", a);
}
printf("Fin du scan.\r\n");
L’affichage passe par l’USART grâce à la fonction _write du chapitre 9. C’est le premier test à faire quand un composant ne répond pas : s’il n’apparaît pas, le problème est dans le câblage ou l’alimentation, pas dans le programme.
Exemple 3 : identité et accélération d’un MPU6050
Le MPU6050 (accéléromètre et gyroscope) a l’adresse 0x68 (broche AD0 à GND).
| Registre | Adresse | Contenu |
|---|---|---|
| WHO_AM_I | 0x75 | Contient 0x68 |
| PWR_MGMT_1 | 0x6B | Gestion de l’alimentation : écrire 0 pour le réveiller |
| ACCEL_XOUT_H | 0x3B | 6 octets : X, Y, Z (poids fort puis poids faible) |
#define MPU_ADR (0x68 << 1) uint8_t id; HAL_I2C_Mem_Read(&hi2c1, MPU_ADR, 0x75, I2C_MEMADD_SIZE_8BIT, &id, 1, 100); /* id doit valoir 0x68 */ uint8_t zero = 0; HAL_I2C_Mem_Write(&hi2c1, MPU_ADR, 0x6B, I2C_MEMADD_SIZE_8BIT, &zero, 1, 100); // réveil uint8_t d[6]; HAL_I2C_Mem_Read(&hi2c1, MPU_ADR, 0x3B, I2C_MEMADD_SIZE_8BIT, d, 6, 100); int16_t ax = (int16_t)((d[0] << 8) | d[1]); int16_t ay = (int16_t)((d[2] << 8) | d[3]); int16_t az = (int16_t)((d[4] << 8) | d[5]); float gx = ax / 16384.0f; // en g : 16384 LSB/g pour l'échelle de ±2 g
Une carte posée à plat doit donner az proche de 16384, soit 1 g.
Exemple 4 : lire l’heure d’une horloge DS3231
Le DS3231 (adresse 0x68) stocke l’heure en BCD (chaque chiffre décimal sur 4 bits) aux registres 0x00 (secondes), 0x01 (minutes), 0x02 (heures).
uint8_t h[3]; HAL_I2C_Mem_Read(&hi2c1, (0x68 << 1), 0x00, I2C_MEMADD_SIZE_8BIT, h, 3, 100); uint8_t sec = (h[0] >> 4) * 10 + (h[0] & 0x0F); // conversion BCD vers décimal uint8_t min = (h[1] >> 4) * 10 + (h[1] & 0x0F); uint8_t heu = (h[2] >> 4) * 10 + (h[2] & 0x0F); // mode 24 h : bits 4 et 5 = dizaines
L’octet 0x45 signifie 45 en décimal (4 dizaines et 5 unités), et non 69. Pour régler l’heure, on écrit en BCD : ((v / 10) << 4) | (v % 10).
Exemple 5 : mémoire EEPROM 24C02
Une EEPROM 24C02 (2 kbits, soit 256 octets) a l’adresse 0x50 (A0, A1, A2 à GND). Page de 8 octets, temps d’écriture d’environ 5 ms.
#define EE_ADR (0x50 << 1) uint8_t val = 42; HAL_I2C_Mem_Write(&hi2c1, EE_ADR, 0x10, I2C_MEMADD_SIZE_8BIT, &val, 1, 100); while (HAL_I2C_IsDeviceReady(&hi2c1, EE_ADR, 1, 10) != HAL_OK); // attend la fin de l'écriture interne uint8_t lu; HAL_I2C_Mem_Read(&hi2c1, EE_ADR, 0x10, I2C_MEMADD_SIZE_8BIT, &lu, 1, 100);
Pendant son cycle d’écriture interne l’EEPROM ne répond plus (NACK) : la boucle IsDeviceReady attend la fin.
Exemple 6 : DAC externe MCP4725 (12 bits)
Le MCP4725 (adresse 0x60, selon A0) est un DAC 12 bits. En mode écriture rapide, deux octets suffisent : les 4 bits de poids fort (précédés de deux bits de mode à 0), puis les 8 bits de poids faible.
void dac_i2c(uint16_t valeur) // 0 à 4095
{
uint8_t trame[2];
trame[0] = (valeur >> 8) & 0x0F; // bits de mode à 0 + 4 bits de poids fort
trame[1] = valeur & 0xFF;
HAL_I2C_Master_Transmit(&hi2c1, (0x60 << 1), trame, 2, 100);
}
dac_i2c(2048); // Vout = 3,3 V × 2048 / 4096 = 1,65 V
11.5 Diagnostic d’un bus I2C
| Symptôme | Cause probable |
|---|---|
| Aucun composant trouvé au scan | Pas de résistances de tirage, SDA et SCL inversés, composant non alimenté |
| Le composant répond à 0x34 au lieu de 0x68 | Confusion entre adresse 7 bits et adresse 8 bits (décalage) |
| HAL_BUSY ou blocage après une erreur | Une ligne est restée à 0 : réinitialiser l’I2C (HAL_I2C_DeInit puis HAL_I2C_Init) |
| SDA reste à 0 (esclave bloqué) | Envoyer jusqu’à 9 impulsions sur SCL en mode GPIO pour libérer l’esclave |
| Lecture toujours à 0x00 ou 0xFF | Mauvaise adresse de registre, composant en veille |
| Deux composants identiques en conflit | Même adresse : changer la broche d’adresse (A0) ou utiliser un second bus I2C |
| Communication instable | Résistances de tirage trop fortes, câbles trop longs, capacité du bus trop élevée |
Outils : le scanner d’adresses, un oscilloscope sur SCL et SDA (vérifier la montée des fronts), un analyseur logique avec décodage I2C (adresses, ACK et octets).
11.6 Exercices I2C
Exercice 1 : trame. Dessiner la trame complète (START, adresse, ACK, données, STOP) de l’écriture de la valeur 0x5A dans le registre 0x1F d’un composant d’adresse 0x40. Donner les octets envoyés sur le bus.
Exercice 2 : adresses. Un composant a pour adresse 7 bits 0x3C. Donner l’octet d’adresse en écriture et en lecture, puis la valeur à passer à HAL_I2C_Master_Transmit. Un autre composant est documenté « adresse 0xA0 en écriture » : quelle est son adresse sur 7 bits ?
Exercice 3 : résistances de tirage. Cbus = 150 pF, VDD = 3,3 V, mode rapide (tr = 300 ns). Calculer Rmin et Rmax. 4,7 kΩ convient-elle ? Et 2,2 kΩ ?
Exercice 4 : temps de transfert. Calculer la durée de la lecture de 6 octets d’un MPU6050 à partir du registre 0x3B, à 100 kHz et à 400 kHz (compter adresse en écriture, adresse du registre, adresse en lecture et 6 octets, en négligeant START et STOP).
Exercice 5 : décoder un échange. Un analyseur affiche : S 0xD0 ACK 0x75 ACK Sr 0xD1 ACK 0x68 NACK P. Identifier le composant, l’opération, le registre lu et la valeur obtenue.
Exercice 6 : scanner. Réaliser le scanner d’adresses et envoyer le résultat sur l’USART. Débrancher un composant et vérifier qu’il disparaît de la liste. Retirer une résistance de tirage : que se passe-t-il ?
Exercice 7 : BCD. Écrire bcd_vers_dec et dec_vers_bcd. Vérifier avec 0x59, 0x23, et avec 17 et 40.
uint8_t bcd_vers_dec(uint8_t b) { return (b >> 4) * 10 + (b & 0x0F); }
uint8_t dec_vers_bcd(uint8_t d) { return ((d / 10) << 4) | (d % 10); }
Vérifications : 0x59 → 59 ; 0x23 → 23 ; 17 → 0x17 ; 40 → 0x40.Exercice 8 : inclinomètre. Avec un MPU6050, calculer l’angle autour de l’axe X : angle = atan2f(ay, az) × 180 / π. Allumer la LED PC13 au-dessus de 30 degrés.
#include <math.h> float angle = atan2f((float)ay, (float)az) * 180.0f / 3.14159265f; HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, angle > 30.0f ? GPIO_PIN_RESET : GPIO_PIN_SET); // LED active à 0
Exercice 9 : mémoire EEPROM. Écrire un compteur de démarrages dans l’EEPROM 24C02 : à chaque mise sous tension, lire la valeur à l’adresse 0, l’incrémenter, la réécrire et l’afficher sur l’USART. Pourquoi ne pas écrire en boucle rapide ?
uint8_t n;
HAL_I2C_Mem_Read(&hi2c1, EE_ADR, 0, I2C_MEMADD_SIZE_8BIT, &n, 1, 100);
n++;
HAL_I2C_Mem_Write(&hi2c1, EE_ADR, 0, I2C_MEMADD_SIZE_8BIT, &n, 1, 100);
while (HAL_I2C_IsDeviceReady(&hi2c1, EE_ADR, 1, 10) != HAL_OK);
printf("Demarrage n %u\r\n", n);
Une EEPROM supporte un nombre limité de cycles d’écriture (de l’ordre du million d’après les datasheets) et chaque écriture prend environ 5 ms : une écriture en boucle rapide use la mémoire en quelques minutes et bloque le programme.Exercice 10 : station de mesure. Le DS3231 donne l’heure, le MPU6050 l’inclinaison, l’ADC la tension d’un potentiomètre. Envoyer chaque seconde « hh:mm:ss ax=… V=… » sur l’USART. Quelle différence de rôle entre les trois bus ou périphériques ?
printf("%02u:%02u:%02u ax=%d V=%.2f\r\n", heu, min, sec, ax, v); (une fois par seconde avec HAL_Delay(1000)).Rôles : l’I2C est un bus partagé à adresses qui relie des composants externes (heure, accéléromètre) ; l’ADC est un périphérique interne qui convertit une tension analogique, ce n’est pas un bus ; l’USART est la liaison série asynchrone qui envoie les résultats vers le PC.
Chapitre 12 : Le bus CAN (Controller Area Network)
Le CAN, créé par Bosch dans les années 1980 et normalisé par l’ISO 11898, est le bus de l’automobile et de nombreuses machines industrielles. Un bus à deux fils (une paire différentielle CAN_H et CAN_L) relie des nœuds égaux : il n’y a pas de maître. Chaque message est diffusé à tous les nœuds ; il porte un identifiant qui indique son contenu et sa priorité (ce n’est pas l’adresse d’un destinataire). Chaque nœud ne garde que les identifiants qui l’intéressent.
12.1 Caractéristiques
| Critère | CAN (ISO 11898) |
|---|---|
| Fils | 2 (CAN_H, CAN_L), paire torsadée, plus la masse |
| Topologie | Bus en ligne, résistances de 120 Ω aux deux extrémités |
| Accès | Multi-maîtres : tout nœud peut émettre quand le bus est libre |
| Débit et longueur (valeurs usuelles) | 1 Mbit/s jusqu’à 40 m ; 500 kbit/s ≈ 100 m ; 250 kbit/s ≈ 250 m ; 125 kbit/s ≈ 500 m |
| Données par trame | 0 à 8 octets (CAN FD : jusqu’à 64 octets) |
| Codage | NRZ avec bit stuffing (chapitres 2 et 6) |
| Arbitrage | Non destructif, par identifiant |
| Détection d’erreurs | CRC-15 et quatre autres mécanismes ; retransmission automatique |
Pourquoi le CAN dans une voiture ? Il résiste au bruit (signal différentiel), il relie des dizaines de calculateurs avec seulement deux fils, le message le plus urgent passe toujours en premier, et toute erreur est détectée puis corrigée par retransmission.
12.2 La couche physique : dominant et récessif
Sur le bus, un bit 0 est dominant et un bit 1 est récessif. Si un nœud émet un bit dominant, le bus est dominant, quoi que fassent les autres : le bus se comporte comme un ET logique (câblé).
| Niveau | Bit | CAN_H | CAN_L | Tension différentielle |
|---|---|---|---|---|
| Récessif | 1 | ≈ 2,5 V | ≈ 2,5 V | ≈ 0 V |
| Dominant | 0 | ≈ 3,5 V | ≈ 1,5 V | ≈ 2 V |
Le récepteur ne regarde que la différence CAN_H − CAN_L : un parasite qui touche les deux fils de la même façon s’annule. Animation (bits 1 0 0 1 1 0 1) :
Câblage du bus
Le bus est une ligne : une résistance de 120 Ω à chaque extrémité (et seulement là) évite les réflexions. Hors tension, une mesure à l’ohmmètre entre CAN_H et CAN_L donne environ 60 Ω (deux résistances de 120 Ω en parallèle). Les dérivations vers les nœuds doivent rester courtes.
12.3 Le temps binaire (bit timing)
Chaque bit est découpé en quanta de temps (tq). Le temps de tq vient de l’horloge du contrôleur divisée par un prédiviseur. Un bit contient :
| Segment | Durée | Rôle |
|---|---|---|
| Sync_Seg | 1 tq | Les fronts du signal doivent arriver ici |
| Prop_Seg | 1 à 8 tq | Compense le temps de propagation sur le bus |
| Phase_Seg1 | 1 à 8 tq | Peut être allongé à la resynchronisation |
| Phase_Seg2 | 1 à 8 tq | Peut être raccourci à la resynchronisation |
Le point d’échantillonnage se situe à la fin de Phase_Seg1 : point d’échantillonnage = (1 + Prop_Seg + Phase_Seg1) / (nombre de tq par bit), souvent entre 75 % et 87,5 %. Tous les nœuds doivent avoir le même débit. Les nœuds se resynchronisent sur les fronts, d’où l’intérêt du bit stuffing qui garantit un front au moins tous les 5 bits. Calcule un réglage :
12.4 La trame de données (format standard)
| Champ | Taille | Rôle |
|---|---|---|
| SOF | 1 bit (dominant) | Début de trame, synchronise les nœuds |
| Identifiant | 11 bits | Contenu du message et priorité |
| RTR | 1 bit | 0 : trame de données ; 1 : demande de données (trame de requête) |
| IDE | 1 bit | 0 : identifiant standard (11 bits) ; 1 : format étendu (29 bits) |
| r0 | 1 bit | Réservé |
| DLC | 4 bits | Nombre d’octets de données (0 à 8) |
| Données | 0 à 64 bits | Les octets du message |
| CRC | 15 bits | Contrôle d’erreurs |
| Délimiteur CRC | 1 bit (récessif) | Sépare le CRC de l’acquittement |
| ACK | 1 bit | L’émetteur envoie 1 ; les récepteurs qui ont bien reçu forcent 0 |
| Délimiteur ACK | 1 bit (récessif) | |
| EOF | 7 bits (récessifs) | Fin de trame |
| IFS | 3 bits (récessifs) | Espace inter-trame |
Longueur sans stuffing : 44 + 8 × n bits jusqu’à EOF (n = nombre d’octets de données), soit 108 bits pour 8 octets. À 500 kbit/s, un bit dure 2 µs : 216 µs pour 108 bits. Le stuffing s’applique de SOF jusqu’à la fin du CRC (98 bits pour 8 octets) et peut ajouter au plus 24 bits : la trame la plus longue fait 132 bits, plus 3 bits d’IFS. Le format étendu remplace l’identifiant par 29 bits (11 + 18) ; la trame de requête (RTR = 1) n’a pas de champ de données.
Outil : construire une trame
Saisis un identifiant (hexadécimal, 11 bits) et jusqu’à 8 octets : l’outil calcule le CRC-15, applique le bit stuffing et dessine la trame. Avance étape par étape : chaque champ est expliqué sous le schéma.
La trame sur le bus (avec bit stuffing)
Les bits de stuffing sont sur fond rouge ; le niveau haut est récessif (1), le niveau bas est dominant (0).
12.5 L’arbitrage : le plus prioritaire passe sans perte
Quand le bus est libre, plusieurs nœuds peuvent commencer à émettre en même temps. Chaque émetteur compare, bit par bit, ce qu’il envoie à ce qu’il lit sur le bus. Un nœud qui envoie un 1 (récessif) mais lit un 0 (dominant) sait qu’un nœud plus prioritaire émet : il perd l’arbitrage, arrête d’émettre et devient récepteur. Le plus petit identifiant (le plus de 0 en tête) gagne, et sans retard ni destruction du message (contrairement à Ethernet qui détecte une collision). Modifie les identifiants et observe :
12.6 Bit stuffing, CRC et acquittement
- Bit stuffing : après 5 bits identiques consécutifs, l’émetteur insère un bit de valeur contraire (de SOF à la fin du CRC). Le récepteur le retire. Six bits identiques de suite sont donc une erreur. Voir l’outil du chapitre 6.
- CRC-15 : polynôme x¹⁵ + x¹⁴ + x¹⁰ + x⁸ + x⁷ + x⁴ + x³ + 1 (en binaire 1100010110011001), calculé sur les bits de SOF jusqu’aux données (avant stuffing). L’outil CRC du chapitre 6 propose ce générateur.
- Acquittement : dans la case ACK, l’émetteur envoie 1 ; tout récepteur qui a reçu une trame correcte envoie 0. L’émetteur qui lit 0 sait qu’au moins un nœud l’a reçue.
12.7 La gestion des erreurs
| Erreur | Détection |
|---|---|
| Erreur de bit | Le bit lu sur le bus n’est pas celui que l’émetteur a envoyé (hors arbitrage et case ACK) |
| Erreur de stuffing | Six bits identiques consécutifs entre SOF et CRC |
| Erreur de CRC | Le CRC calculé par le récepteur diffère du CRC reçu |
| Erreur de forme | Un champ fixe (délimiteurs, EOF) n’a pas la bonne valeur |
| Erreur d’acquittement | L’émetteur ne lit aucun dominant dans la case ACK |
Le nœud qui détecte une erreur émet une trame d’erreur (6 bits dominants, puis 8 bits récessifs) : toute la trame est rejetée et l’émetteur la retransmet automatiquement. Chaque nœud compte ses erreurs d’émission (TEC) et de réception (REC) :
| État | Condition | Comportement |
|---|---|---|
| Error active | TEC et REC < 128 | Fonctionnement normal, émet un drapeau d’erreur dominant |
| Error passive | TEC ou REC ≥ 128 | Émet un drapeau d’erreur récessif, plus discret |
| Bus-off | TEC > 255 | Le nœud se déconnecte du bus |
12.8 Exemple réel : le diagnostic OBD-II d’une voiture
La prise de diagnostic utilise le CAN à 500 kbit/s avec des identifiants de 11 bits. Le testeur envoie la requête sur l’identifiant 0x7DF ; le calculateur moteur répond sur 0x7E8.
| Trame | Identifiant | Octets de données | Signification |
|---|---|---|---|
| Requête | 0x7DF | 02 01 0C 00 00 00 00 00 | Mode 01 (données courantes), PID 0x0C : régime moteur |
| Réponse | 0x7E8 | 04 41 0C 1A F8 00 00 00 | 4 octets utiles, réponse au mode 01, PID 0x0C, A = 0x1A, B = 0xF8 |
Régime = (256 × A + B) / 4 = (256 × 26 + 248) / 4 = 1726 tr/min.
12.9 Exercices CAN
Exercice N1 (arbitrage). Trois nœuds émettent en même temps les identifiants 0x1A0, 0x180 et 0x1B0. Lequel gagne l’arbitrage ? À quel bit les autres perdent-ils ?
Nœud B : 0x180 = 00110000000
Nœud C : 0x1B0 = 00110110000
Le nœud A perd au bit b5 (il émet 1 alors que le bus est à 0). Le nœud C perd au bit b5 (il émet 1 alors que le bus est à 0).
Le nœud B (0x180, le plus petit identifiant) gagne et poursuit sa trame.
Exercice N2 (longueur). Une trame standard transporte 2 octets de données. Combien de bits avant stuffing, jusqu’à EOF ? Quelle durée à 500 kbit/s ? Quelle durée maximale avec stuffing, IFS compris ?
Exercice N3 (bit stuffing). Applique le bit stuffing CAN aux 19 premiers bits d’une trame d’identifiant 0x000 et de DLC 0 (SOF, identifiant, RTR, IDE, r0, DLC : tous à 0). Puis retire le stuffing de la suite reçue 100001111100000101.
Suite reçue 100001111100000101 : on supprime le bit qui suit chaque suite de 5 bits identiques. Données d’origine : 1000011111000001.
Exercice N4 (décoder). Voici les bits d’une trame avant stuffing, de SOF jusqu’aux données : 0 | 01010100101 | 0 | 0 | 0 | 0001 | 00001111. Donne l’identifiant, le type de trame et les données.
Exercice N5 (CRC). Quel est le CRC-15 de la trame d’identifiant 0x123 portant 1 octet 0xA5 (SOF, identifiant, RTR = IDE = r0 = 0, DLC = 1, donnée) ? Utilise l’outil CRC (générateur CRC-15 du bus CAN) pour vérifier.
Exercice N6 (temps binaire). Un bus à 125 kbit/s, un contrôleur cadencé à 16 MHz. Propose un réglage avec un point d’échantillonnage de 87,5 %.
Exercice N7 (niveaux). Quelle tension mesure-t-on entre CAN_H et CAN_L bus au repos ? Pendant un bit dominant ? Que mesure un ohmmètre entre CAN_H et CAN_L bus éteint, et pourquoi ?
Exercice N8 (OBD-II). Le calculateur répond 04 41 0C 1B 58 au PID 0x0C. Quel est le régime moteur ? Quel PID aurait donné la température du liquide de refroidissement (PID 0x05, valeur = A − 40) si A = 0x78 ?
Exercice N9 (débit utile). À 500 kbit/s, combien de trames de 8 octets par seconde au maximum ? Quel est le rendement (données utiles / bits sur le bus) ?
Exercice N10 (erreur). Un récepteur reçoit une trame dont le CRC ne correspond pas à celui qu’il calcule. Que se passe-t-il ?
Chapitre 13 : Le bus CAN sur STM32 (Black Pill F411 + MCP2515)
13.1 Matériel et câblage
- 2 cartes Black Pill (A et B) et 2 modules MCP2515 + TJA1050 (l’un peut rester seul pour le test en boucle).
- Fils Dupont ; ST-Link V2 pour programmer.
- Un câble à deux fils (idéalement une paire torsadée) pour CAN_H et CAN_L.
| Signal | Black Pill | Module MCP2515 |
|---|---|---|
| Sélection | PA4 (sortie GPIO) | CS |
| Horloge SPI | PA5 | SCK |
| Données maître vers module | PA7 (MOSI) | SI |
| Données module vers maître | PA6 (MISO) | SO |
| Interruption (facultatif) | PB1 (entrée) | INT |
| Alimentation | 5 V | VCC |
| Masse | GND | GND |
Pour le test sur bus, relie CANH de A à CANH de B, CANL de A à CANL de B, et les masses. Chaque module porte souvent un cavalier de 120 Ω : laisse-le en place sur les deux modules aux extrémités du bus, et seulement là.
13.2 Le MCP2515
Le MCP2515 gère la trame CAN (arbitrage, stuffing, CRC, acquittement) ; le STM32 ne fait que lire et écrire ses registres en SPI (mode 0, jusqu’à 10 MHz). Ses instructions SPI :
| Instruction | Octet | Rôle |
|---|---|---|
| RESET | 0xC0 | Réinitialise le circuit (il passe en mode configuration) |
| READ | 0x03 + adresse | Lit un registre |
| WRITE | 0x02 + adresse + valeur | Écrit un registre |
| LOAD TX BUFFER | 0x40 | Écrit un message dans le tampon d’émission 0 (à partir de TXB0SIDH) |
| RTS | 0x81 | Demande l’envoi du tampon 0 |
| READ RX BUFFER | 0x90 | Lit le tampon de réception 0 (à partir de RXB0SIDH) ; efface le drapeau RX0IF |
| READ STATUS | 0xA0 | Renvoie un octet d’état (bit 0 = message reçu dans le tampon 0) |
| Registre | Adresse | Rôle |
|---|---|---|
| CANSTAT | 0x0E | Mode actuel (bits 7:5 : 100 = configuration, 000 = normal, 010 = boucle) |
| CANCTRL | 0x0F | Mode demandé (bits 7:5) |
| CNF3, CNF2, CNF1 | 0x28, 0x29, 0x2A | Réglage du temps binaire |
| RXB0CTRL | 0x60 | Filtres de réception (0x60 : accepte tous les messages) |
| TXB0SIDH, TXB0SIDL, TXB0DLC, TXB0D0… | 0x31, 0x32, 0x35, 0x36… | Tampon d’émission : identifiant, longueur, données |
| RXB0SIDH, RXB0SIDL, RXB0DLC, RXB0D0… | 0x61, 0x62, 0x65, 0x66… | Tampon de réception |
Réglage du débit à 500 kbit/s avec un quartz de 8 MHz : CNF1 = 0x00, CNF2 = 0x90, CNF3 = 0x02 (tq = 250 ns, 8 tq par bit, point d’échantillonnage 62,5 %). Avec un quartz de 16 MHz, les valeurs usuelles pour 500 kbit/s sont CNF1 = 0x00, CNF2 = 0xF0, CNF3 = 0x86. Vérifie ces valeurs dans la datasheet du MCP2515 pour ton quartz et ton débit.
13.3 CubeMX
- Même base que le chapitre 7 : RCC en cristal, SYS en Serial Wire, horloge à 100 MHz.
- SPI1 : Full-Duplex Master, 8 bits, MSB first, Prescaler 128 (≈ 780 kHz, prudent sur fils volants), CPOL Low, CPHA 1 Edge (mode 0), NSS désactivé.
- PA4 : GPIO_Output, niveau initial High (CS inactif). PC13 : GPIO_Output, niveau initial High (LED éteinte). PB1 : GPIO_Input (facultatif).
13.4 Le code
Dans main.c, entre les lignes USER CODE BEGIN et USER CODE END correspondantes :
#define CS_BAS() HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET)
#define CS_HAUT() HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET)
void mcp_reset(void)
{
uint8_t c = 0xC0;
CS_BAS(); HAL_SPI_Transmit(&hspi1, &c, 1, 10); CS_HAUT();
HAL_Delay(10);
}
void mcp_write(uint8_t reg, uint8_t v)
{
uint8_t t[3] = { 0x02, reg, v };
CS_BAS(); HAL_SPI_Transmit(&hspi1, t, 3, 10); CS_HAUT();
}
uint8_t mcp_read(uint8_t reg)
{
uint8_t t[2] = { 0x03, reg }, r;
CS_BAS(); HAL_SPI_Transmit(&hspi1, t, 2, 10); HAL_SPI_Receive(&hspi1, &r, 1, 10); CS_HAUT();
return r;
}
/* mode : 0x00 = normal, 0x40 = boucle (test sans bus) */
void can_init(uint8_t mode)
{
mcp_reset(); // le circuit passe en configuration
mcp_write(0x28, 0x02); mcp_write(0x29, 0x90); mcp_write(0x2A, 0x00); // CNF3, CNF2, CNF1 : 500 kbit/s, quartz 8 MHz
mcp_write(0x60, 0x60); // RXB0CTRL : accepte tous les messages
mcp_write(0x0F, mode); // CANCTRL : mode demandé
}
void can_send(uint16_t id, const uint8_t *d, uint8_t n)
{
uint8_t t[14] = { 0x40, (uint8_t)(id >> 3), (uint8_t)((id & 7) << 5), 0, 0, n };
for (uint8_t i = 0; i < n; i++) t[6 + i] = d[i];
CS_BAS(); HAL_SPI_Transmit(&hspi1, t, 6 + n, 10); CS_HAUT(); // charge le tampon 0
uint8_t r = 0x81;
CS_BAS(); HAL_SPI_Transmit(&hspi1, &r, 1, 10); CS_HAUT(); // RTS : demande l'envoi
}
int can_recv(uint16_t *id, uint8_t *d, uint8_t *n)
{
uint8_t c = 0xA0, st;
CS_BAS(); HAL_SPI_Transmit(&hspi1, &c, 1, 10); HAL_SPI_Receive(&hspi1, &st, 1, 10); CS_HAUT();
if (!(st & 0x01)) return 0; // rien reçu
uint8_t b[13], r = 0x90;
CS_BAS(); HAL_SPI_Transmit(&hspi1, &r, 1, 10); HAL_SPI_Receive(&hspi1, b, 13, 10); CS_HAUT();
*id = ((uint16_t)b[0] << 3) | (b[1] >> 5); // identifiant sur 11 bits
*n = b[4] & 0x0F; if (*n > 8) *n = 8;
for (uint8_t i = 0; i < *n; i++) d[i] = b[5 + i];
return 1;
}
Animations : initialiser, envoyer, recevoir
13.5 Pas à pas : du test en boucle au bus à deux nœuds
Étape 1 : vérifier le SPI (cartes hors tension, un seul module câblé)
Câble le module sur la carte A, programme-la avec le code ci-dessous, puis ouvre le débogueur ou regarde la LED : si CANSTAT vaut 0x80 après le reset, le SPI fonctionne.
mcp_reset(); uint8_t stat = mcp_read(0x0E); // CANSTAT : 0x80 = configuration (SPI correct) if (stat == 0x80) HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET); // LED allumée
Vérification : la LED s’allume. Sinon : CS, SCK, SI, SO, alimentation, mode SPI.
Étape 2 : test en boucle (loopback), sans bus
En mode boucle, le MCP2515 reçoit ses propres messages sans avoir besoin de bus ni d’acquittement : il teste le contrôleur et le SPI.
can_init(0x40); // mode boucle
uint8_t tx[2] = { 0xAA, 0x55 }, rx[8], n;
uint16_t id;
can_send(0x123, tx, 2);
HAL_Delay(10);
if (can_recv(&id, rx, &n) && id == 0x123 && n == 2 && rx[0] == 0xAA)
HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET); // test réussi : LED allumée
Vérification : la LED s’allume. Sinon vérifie le quartz et les valeurs de CNF.
Étape 3 : deux nœuds sur le bus
- Câble les deux modules (CANH-CANH, CANL-CANL, masses, cavaliers de 120 Ω sur les deux).
- Carte A (émettrice) :
can_init(0x00); // mode normal uint8_t cpt = 0; while (1) { uint8_t d[1] = { cpt++ }; can_send(0x123, d, 1); HAL_Delay(500); } - Carte B (réceptrice) :
can_init(0x00); uint8_t rx[8], n; uint16_t id; while (1) { if (can_recv(&id, rx, &n) && id == 0x123) HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13); // la LED bascule à chaque message } - Programme B puis A (ou appuie sur NRST). Résultat attendu : la LED de B bascule deux fois par seconde. Retire le fil CANH : plus rien n’arrive ; remets-le : la communication reprend.
13.6 Si ta carte possède un contrôleur CAN (bxCAN)
Sur un STM32F103, F405 ou F407 (avec un transceiver externe), la HAL pilote directement le contrôleur : le temps binaire se règle dans CubeMX (prédiviseur, BS1, BS2) et un filtre doit être configuré pour recevoir.
CAN_FilterTypeDef f = {0};
f.FilterBank = 0; f.FilterMode = CAN_FILTERMODE_IDMASK; f.FilterScale = CAN_FILTERSCALE_32BIT;
f.FilterFIFOAssignment = CAN_RX_FIFO0; f.FilterActivation = ENABLE; // masque à 0 : accepte tout
HAL_CAN_ConfigFilter(&hcan1, &f);
HAL_CAN_Start(&hcan1);
CAN_TxHeaderTypeDef h = { .StdId = 0x123, .IDE = CAN_ID_STD, .RTR = CAN_RTR_DATA, .DLC = 2 };
uint8_t d[2] = { 0xAA, 0x55 }; uint32_t boite;
HAL_CAN_AddTxMessage(&hcan1, &h, d, &boite); // envoi
CAN_RxHeaderTypeDef rh; uint8_t r[8];
if (HAL_CAN_GetRxFifoFillLevel(&hcan1, CAN_RX_FIFO0) > 0)
HAL_CAN_GetRxMessage(&hcan1, CAN_RX_FIFO0, &rh, r); // réception
13.7 Diagnostic
| Symptôme | Cause probable |
|---|---|
| CANSTAT ne vaut pas 0x80 après le reset | SPI mal câblé (CS, SCK, SI, SO), module non alimenté, mauvais mode SPI |
| Le test en boucle échoue | Mauvaise valeur de CNF pour le quartz du module, can_init non appelée, délai trop court |
| Boucle réussie mais rien sur le bus | Résistances de 120 Ω absentes, CANH et CANL inversés, masse non commune, débits différents entre les deux nœuds |
| Le nœud devient bus-off | Pas d’autre nœud pour acquitter, ou débits différents : les erreurs s’accumulent |
| Trames reçues avec un mauvais identifiant | Décalage de bits dans le calcul de l’identifiant (SIDH sur 8 bits, SIDL bits 7:5) |
| Le microcontrôleur se bloque ou lit n’importe quoi | Sortie SO à 5 V sur une broche non tolérante : vérifier la tolérance 5 V |
13.8 Exercices pratiques
Exercice Q1. Le module porte un quartz de 16 MHz. Quelles valeurs de CNF1, CNF2, CNF3 faut-il écrire pour 500 kbit/s ? Que se passe-t-il si on garde les valeurs prévues pour 8 MHz ?
Exercice Q2. Combien de temps dure la lecture d’une trame par can_recv (READ STATUS puis READ RX BUFFER de 13 octets) avec SPI1 à 100 MHz / 128 ? Quelle durée met la trame elle-même à passer sur le bus (8 octets, 500 kbit/s, sans stuffing) ?
Exercice Q3. Modifie le programme de la carte B pour qu’elle allume sa LED seulement si l’octet reçu est pair, et pour qu’elle ne traite que l’identifiant 0x123.
if (can_recv(&id, rx, &n) && id == 0x123 && n >= 1)
{
if ((rx[0] & 1) == 0) HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET); // pair : LED allumée
else HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_SET); // impair : LED éteinte
}
Le test sur l’identifiant fait office de filtre logiciel ; on pourrait aussi configurer les filtres matériels du MCP2515 (registres RXF et RXM).Exercice Q4 (arbitrage réel). Deux cartes émettent en même temps, la carte A avec l’identifiant 0x200 et la carte B avec 0x100. Que reçoit un troisième nœud ? Quelle carte retransmet son message ?