Thursday, September 24, 2026

Protocoles de Communication

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

PANLANMANWAN WAN : pays, monde (Internet)MAN : ville, campus étenduLAN : maison, salle, bâtimentPAN : quelques mètres autour de soi
TypePortéeExemples
PAN≈ 10 mBluetooth, USB, liaison UART entre deux cartes
LANBâtimentEthernet, Wi-Fi, bus de terrain (Modbus RS485, CAN)
MANVilleRéseau fibre d’une ville, d’une université
WANPays, mondeInternet, réseau 4G/5G
UART, SPI et I2C sont des bus locaux : ils relient des composants sur une même carte ou entre cartes proches (quelques centimètres à quelques mètres).

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).

ProtocoleTopologieNœuds
UARTPoint à point2
SPIBus partagé + sélection CS (étoile)1 maître, n esclaves
I2CBusn maîtres, n esclaves (adresses)
CANBus (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èreParallèleSérie
Fils de données8, 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
DistanceCourte (déphasage entre fils)Longue
Coût et câblageCâble et connecteur volumineuxCâble réduit, peu de broches
ExemplesBus mémoire, ancien port imprimanteUART, 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.

Bits Code

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

CodeNiveauxTransitionsComposante continueHorloge récupérableBande passante
NRZ unipolaire2 (0 et V)Aux changements de bit seulementNon nulleNon (suites de bits identiques)Minimale
NRZ polaire2 (±V)Aux changements de bit seulementSelon les donnéesNonMinimale
NRZI2 (±V)À chaque 1Selon les donnéesSeulement avec les 1Minimale
RZ unipolaire2 (0 et V)À chaque 1Non nulleSeulement avec les 1Double
RZ polaire3À chaque bitFaibleOuiDouble
Manchester2 (±V)À chaque bitNulleOuiDouble
Manchester différentiel2 (±V)À chaque bitNulleOuiDouble
AMI3À chaque 1NulleSeulement avec les 1Minimale

Le lien avec les protocoles du cours

ProtocoleCodage utilisé
UART (TTL) et SPI, I2CNRZ ; SPI et I2C ont un fil d’horloge séparé, l’UART se synchronise sur le bit de start
RS232NRZ polaire en logique inversée (±12 V)
CANNRZ avec bit stuffing (chapitre 6)
USBNRZI avec bit stuffing (chapitre 6)
Ethernet 10BASE-TManchester
Token RingManchester différentiel
Lignes T1 / E1AMI / 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).

ApplicationPrincipe
Variateur de LEDLe rapport cyclique règle la luminosité moyenne
Vitesse d’un moteur à courant continuLa tension moyenne règle la vitesse
ServomoteurPériode 20 ms ; impulsion de 1 ms à 2 ms qui code l’angle
DAC simpleMLI rapide suivie d’un filtre RC passe-bas
Onduleur, amplificateur de classe DMLI 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).

fTIM (MHz) PSC ARR CCR

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

RS232RS422RS485
SignalAsymétrique (référence GND)DifférentielDifférentiel
LiaisonPoint à point1 émetteur, jusqu’à 10 récepteursMultipoint (32 unités et plus)
DuplexFullFull (4 fils)Half (2 fils) ou full (4 fils)
Distance maxenviron 15 menviron 1200 menviron 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.

NormeNiveau 1 (repos)Niveau 0
TTL3,3 V ou 5 V0 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

Caractère Parité

Déterminer le bit de parité. On compte les 1 dans les bits de données. Parité paire : le bit est choisi pour que le total de 1 (données + parité) soit pair. Parité impaire : pour que ce total soit impair.
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.

Appareil AAppareil B TXRXGND TXRXGND

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).

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

Maître SCLKMOSIMISO CS1CS2CS3

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

VCC Maître SDASCLRpRp

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éthodePrincipeDétecteUtilisée dans
Parité1 bit rend le nombre de 1 pair ou impairUn nombre impair de bits fauxUART
Somme de contrôleSomme (ou XOR) des octets, envoyée à la finErreurs simplesTrames GPS NMEA
CRCReste d’une division binaire par un polynômeRafales d’erreurs, très fiableCAN, 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.
ProtocoleRègle
CANAprès 5 bits identiques consécutifs, on insère le bit de valeur contraire (le bit inséré compte dans la suite suivante)
HDLC, PPPAprès 5 « 1 » consécutifs, on insère un 0
USBAprè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 :

  1. Après le bit d’entrée n° 5 : cinq bits identiques de valeur 0 → on insère 1.
  2. 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.

Bits à envoyer Règle

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.

  1. 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).
  2. On ajoute n zéros à droite de D.
  3. 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.
  4. 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).

Données Générateur Inverser le bit n° (0 = aucun)

Un CRC de n bits détecte toutes les erreurs sur 1 bit, toute rafale d’erreurs de longueur ≤ n et la quasi-totalité des autres. Réels : CRC-8 (capteurs, PMBus), CRC-15 (CAN), CRC-16 (Modbus, USB, cartes SD), CRC-32 (Ethernet).

Exercices : CRC

Exercice C1. Calcule le CRC des données 1001 avec G = 1011 (x³ + x + 1).

Exercice C2. Avec G = 1011, on reçoit les deux trames 11010011101100100 et 11010011101000100. Lesquelles sont valides ?

Exercice 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.

Matériel : 3 cartes Black Pill, un ST-Link V2 pour programmer, fils Dupont, 2 résistances 4,7 kΩ (I2C), un câble USB-série (PA2/PA3) pour afficher les messages. Les LED PC13 (active à 0) et le bouton PA0 sont déjà sur la carte. Attention : toutes les masses (GND) doivent être reliées, et tout reste en 3,3 V (une carte Arduino Uno en 5 V exige un adaptateur de niveau).

Le scénario

Commande (octet)Effet sur l’esclave
0x01Allumer la LED
0x02Éteindre la LED
0x03 / lectureRenvoyer 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)

  1. File > New > STM32 Project. Onglet « MCU/MPU Selector », tape STM32F411CEUx, sélectionne la ligne puis Next.
  2. Nom du projet : maitre_spi. Langage C, type Executable. Finish. Réponds « Yes » à « Initialize all peripherals with their default mode ».
  3. Pinout & Configuration > System Core > RCC : High Speed Clock (HSE) = Crystal/Ceramic Resonator.
  4. System Core > SYS : Debug = Serial Wire (sinon le ST-Link ne pourra plus reprogrammer la carte).
  5. 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.
  6. 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).
  7. 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.
  8. 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)

SignalCarte A (maître)Carte BCarte C
SCLKPA5PA5PA5
MOSIPA7PA7PA7
MISOPA6PA6PA6
CS1PB0PA4non relié
CS2PB1non reliéPA4
MasseGNDGNDGND

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

  1. 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.
  2. 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.
  3. 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

  1. 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.
  2. 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; par 0x30 << 1 pour B, et 0x31 << 1 pour C (deux projets, ou change la valeur avant chaque programmation).
  3. 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.
  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); }
  5. 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.
  6. 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ômeCause probable
Aucune réactionGND non commune ; esclaves non programmés ou non redémarrés (NRST) avant le maître
SPI : octets faux ou décalésCPOL/CPHA différents entre maître et esclave ; MISO et MOSI inversés ; fils trop longs
SPI : les deux LED réagissentCS1 et CS2 reliés ensemble ou au mauvais esclave
I2C : la fonction HAL ne retourne pas HAL_OKPas de pull-up ; adresse non décalée ; SDA et SCL inversés ; esclave sans interruptions I2C activées
I2C : deux esclaves répondentMê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

UARTSPII2C
Fils2 (TX, RX) + GND4 + 1 CS par esclave2 (SDA, SCL)
HorlogeAsynchroneSynchroneSynchrone
DuplexFullFullHalf
Interlocuteurs2 (point à point)1 maître, n esclavesn maîtres, n esclaves
SélectionAucuneLigne CSAdresse 7 bits
Vitesse typique9600 à 115200 bauds1 à 50 Mbit/s100 kHz à 1 MHz
Usage typiqueConsole, GPS, module BluetoothCarte SD, écran, flashCapteurs, 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.

Les calculs utilisent l’horloge interne de 16 MHz (HSI, réglage par défaut). Avec l’horloge de 100 MHz configurée au chapitre 7 : PCLK2 = 100 MHz (USART1, USART6, SPI1) et PCLK1 = 50 MHz (USART2, I2C1).

9.1 Niveaux électriques et câblage

NormeNiveauxRemarque
UART TTL 3,3 V0 V et 3,3 VNiveau du STM32
RS-232environ ±12 VAncien port série de PC : ne jamais brancher directement sur le STM32
RS-485Paire différentielleLongues 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ériqueTXRXFonction alternativeBus
USART1PA9PA10AF7APB2
USART2PA2PA3AF7APB1
USART6PA11PA12AF8APB2

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.
ErreurCause
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.

fck (MHz) Baud

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.

RegistreOffsetRôle
USART_SR0x00État
USART_DR0x04Donnée émise ou reçue
USART_BRR0x08Diviseur du baud rate
USART_CR10x0CContrôle principal
USART_CR20x10Bits de stop
USART_CR30x14DMA, contrôle de flux
Bit de SRNomSignification
7TXE1 : registre d’émission vide, on peut écrire un nouvel octet
6TC1 : transmission de la trame terminée
5RXNE1 : un octet reçu est disponible dans DR
3ORE1 : débordement
2NF1 : bruit détecté
1FE1 : erreur de trame
0PE1 : erreur de parité
Bit de CR1NomSignification
15OVER80 : suréchantillonnage par 16
13UE1 : active l’USART
12M0 : 8 bits de données ; 1 : 9 bits
10PCE1 : active la parité
9PS0 : parité paire ; 1 : parité impaire
7TXEIE1 : interruption quand TXE = 1
5RXNEIE1 : interruption quand RXNE = 1
3TE1 : active l’émetteur
2RE1 : 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

FonctionRô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_ITMême chose par interruption (non bloquant)
HAL_UART_Transmit_DMA / Receive_DMAMême chose avec le DMA
HAL_UART_TxCpltCallbackAppelée à la fin de l’émission
HAL_UART_RxCpltCallbackAppelée quand la réception demandée est terminée
HAL_UART_ErrorCallbackAppelé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 :

ChampRôleExemple
DébutDélimiter la trame$ ou l’octet 0xAA
Commande ou typeIdentifier le messageT (température)
DonnéesLa valeur27.3
Somme de contrôleDétecter les erreursXOR ou somme modulo 256
FinDé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 :

Texte entre $ et *

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ômeCause probable
Rien n’est reçuTX et RX non croisés, masse non commune, mauvaise broche ou mauvaise AF
Caractères incohérentsBaud rate différent, ou horloge système mal configurée
Premier caractère correct puis plus rienRéception par interruption non réarmée
Caractères perdusRéception trop lente : utiliser une interruption ou le DMA
Rien sur le PC mais la LED réagitMauvais 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.

Exercice 4 : écho en majuscules. Écrire un programme HAL qui renvoie chaque caractère reçu converti en majuscule.

Exercice 5 : commandes. Étendre l’exemple 5 avec BLINK n (la LED clignote n fois) et STATUS (réponse LED=ON ou LED=OFF).

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.

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.

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).

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.

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

SignalNom completSensRôle
SCK (SCLK)Serial Clockmaître → esclaveHorloge fournie par le maître
MOSIMaster Out Slave Inmaître → esclaveDonnées envoyées par le maître
MISOMaster In Slave Outesclave → maîtreDonnées renvoyées par l’esclave
CS (NSS, SS)Chip Selectmaître → esclaveSé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 :

MontagePrincipeRemarque
CS séparésUne broche CS par esclaveCas le plus courant
Chaînage (daisy chain)La sortie de l’esclave 1 alimente l’entrée de l’esclave 2Registres à 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.

ModeCPOLCPHAHorloge au reposÉchantillonnage
000BasFront montant
101BasFront descendant
210HautFront descendant
311HautFront 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) :

PCLK (MHz)
AvantagesLimites
Très rapide (jusqu’à plusieurs dizaines de MHz)4 fils au minimum, plus un CS par esclave
Full duplex, protocole simplePas d’adressage ni d’acquittement : le maître ne sait pas si l’esclave est présent
Pas de résistances de tiragePas de norme de trame : chaque composant a son protocole

10.2 Le SPI du STM32F411

PériphériqueSCKMISOMOSINSSAFBus
SPI1PA5PA6PA7PA4AF5APB2 (jusqu’à 100 MHz)
SPI2PB13PB14PB15PB12AF5APB1
SPI3PB3PB4PB5PA15AF6APB1

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 CR1NomSignification
0CPHAPhase de l’horloge
1CPOLPolarité de l’horloge
2MSTR1 : mode maître
5:3BRPrédiviseur (BR = 000 : /2 ; 001 : /4 ; … ; 111 : /256)
6SPE1 : active le SPI
7LSBFIRST0 : bit de poids fort en premier
8SSINiveau interne de NSS (à 1 avec SSM pour un maître)
9SSM1 : gestion logicielle de NSS
11DFF0 : trames de 8 bits ; 1 : 16 bits
Bit de SRNomSignification
0RXNE1 : un octet reçu est disponible dans DR
1TXE1 : registre d’émission vide
7BSY1 : SPI occupé
6OVR1 : é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 :

ModeCLKPolarityCLKPhase
0SPI_POLARITY_LOWSPI_PHASE_1EDGE
1SPI_POLARITY_LOWSPI_PHASE_2EDGE
2SPI_POLARITY_HIGHSPI_PHASE_1EDGE
3SPI_POLARITY_HIGHSPI_PHASE_2EDGE
FonctionRô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 / _DMAVersions par interruption et par DMA
HAL_SPI_TxCpltCallbackAppelé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.

BitNomValeur utiliséeSignification
15A/B0Sélection de la voie (une seule voie)
14BUF0Entrée Vref non bufferisée
13GA1Gain 1x (Vout max = Vref)
12SHDN1Sortie active
11:0D11…D0donnéeValeur 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 :

Valeur (0 à 4095) Vref (V)

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ômeCause probable
Tout reçu à 0xFFEsclave non sélectionné (CS), non alimenté, ou MISO non câblé
Tout reçu à 0x00MISO relié à la masse, ou esclave bloqué
Données décalées d’un bitMauvais mode (CPOL / CPHA)
Fonctionne lentement mais pas à haute vitesseFils trop longs, horloge trop rapide pour l’esclave
Les données arrivent mais le composant ne réagit pasCS 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 ?

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.

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.

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.

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 ».

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 ?

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.

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.

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

SignalRôle
SCLHorloge, générée par le maître
SDADonné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 :

Attention : le DS3231 et le MPU6050 ont tous deux l’adresse 0x68. Sur le même bus, relie la broche AD0 du MPU6050 à 3,3 V pour passer son adresse à 0x69.
ModeDébit maximal
Standard (Sm)100 kbit/s
Fast (Fm)400 kbit/s
Fast-mode Plus (Fm+)1 Mbit/s
ConditionDéfinition
STARTSDA passe de 1 à 0 pendant que SCL est à 1
STOPSDA passe de 0 à 1 pendant que SCL est à 1
Bit de donnéeSDA est stable quand SCL est à 1 ; SDA ne change que quand SCL est à 0
ACKAu 9e coup d’horloge, le récepteur tire SDA à 0 pour accuser réception
NACKAu 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

ConditionFormuleExemple
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.

VDD (V) Cbus (pF) tr (ns)

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ériqueSCLSDAFonction alternative
I2C1PB6 (ou PB8)PB7 (ou PB9)AF4
I2C2PB10PB3 ou PB9AF4 (SCL), AF9 (SDA)
I2C3PA8PB4AF4 (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.

RegistreOffsetRôle
I2C_CR10x00Contrôle : PE (bit 0), START (bit 8), STOP (bit 9), ACK (bit 10)
I2C_CR20x04FREQ[5:0] : fréquence de PCLK1 en MHz
I2C_DR0x10Donnée émise ou reçue
I2C_SR10x14SB (0), ADDR (1), BTF (2), RXNE (6), TXE (7), AF (10)
I2C_SR20x18État : MSL, BUSY…
I2C_CCR0x1CRéglage de la fréquence de SCL
I2C_TRISE0x20Temps de montée maximal

Mode standard (100 kHz) : CCR = fPCLK1 / (2 × fSCL) ; TRISE = fPCLK1(MHz) + 1 ; FREQ = fPCLK1 en MHz.

fPCLK1 (MHz) fSCL (kHz)

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.

FonctionRô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 ReceiveVersions par interruption et DMA
HAL_I2C_GetError(&hi2c)Code de l’erreur survenue
Attention : l’adresse passée à la HAL est l’adresse sur 7 bits décalée d’un bit vers la gauche : 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).

RegistreAdresseContenu
WHO_AM_I0x75Contient 0x68
PWR_MGMT_10x6BGestion de l’alimentation : écrire 0 pour le réveiller
ACCEL_XOUT_H0x3B6 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).

Décimal Octet BCD (hexadécimal)

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ômeCause probable
Aucun composant trouvé au scanPas de résistances de tirage, SDA et SCL inversés, composant non alimenté
Le composant répond à 0x34 au lieu de 0x68Confusion entre adresse 7 bits et adresse 8 bits (décalage)
HAL_BUSY ou blocage après une erreurUne 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 0xFFMauvaise adresse de registre, composant en veille
Deux composants identiques en conflitMême adresse : changer la broche d’adresse (A0) ou utiliser un second bus I2C
Communication instableRé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.

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.

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 ?

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 ?

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èreCAN (ISO 11898)
Fils2 (CAN_H, CAN_L), paire torsadée, plus la masse
TopologieBus en ligne, résistances de 120 Ω aux deux extrémités
AccèsMulti-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 trame0 à 8 octets (CAN FD : jusqu’à 64 octets)
CodageNRZ avec bit stuffing (chapitres 2 et 6)
ArbitrageNon destructif, par identifiant
Détection d’erreursCRC-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é).

NiveauBitCAN_HCAN_LTension différentielle
Récessif1≈ 2,5 V≈ 2,5 V≈ 0 V
Dominant0≈ 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 :

SegmentDuréeRôle
Sync_Seg1 tqLes fronts du signal doivent arriver ici
Prop_Seg1 à 8 tqCompense le temps de propagation sur le bus
Phase_Seg11 à 8 tqPeut être allongé à la resynchronisation
Phase_Seg21 à 8 tqPeut ê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 :

Horloge du contrôleur (MHz) Prédiviseur (tq = prédiviseur / horloge) Prop + PS1 (tq) PS2 (tq)

12.4 La trame de données (format standard)

ChampTailleRôle
SOF1 bit (dominant)Début de trame, synchronise les nœuds
Identifiant11 bitsContenu du message et priorité
RTR1 bit0 : trame de données ; 1 : demande de données (trame de requête)
IDE1 bit0 : identifiant standard (11 bits) ; 1 : format étendu (29 bits)
r01 bitRéservé
DLC4 bitsNombre d’octets de données (0 à 8)
Données0 à 64 bitsLes octets du message
CRC15 bitsContrôle d’erreurs
Délimiteur CRC1 bit (récessif)Sépare le CRC de l’acquittement
ACK1 bitL’émetteur envoie 1 ; les récepteurs qui ont bien reçu forcent 0
Délimiteur ACK1 bit (récessif)
EOF7 bits (récessifs)Fin de trame
IFS3 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.

Identifiant (hex) Données (octets hex séparés par des espaces) Débit kbit/s

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 :

Nœud A (hex) Nœud B Nœud C

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

ErreurDétection
Erreur de bitLe bit lu sur le bus n’est pas celui que l’émetteur a envoyé (hors arbitrage et case ACK)
Erreur de stuffingSix bits identiques consécutifs entre SOF et CRC
Erreur de CRCLe CRC calculé par le récepteur diffère du CRC reçu
Erreur de formeUn champ fixe (délimiteurs, EOF) n’a pas la bonne valeur
Erreur d’acquittementL’é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) :

ÉtatConditionComportement
Error activeTEC et REC < 128Fonctionnement normal, émet un drapeau d’erreur dominant
Error passiveTEC ou REC ≥ 128Émet un drapeau d’erreur récessif, plus discret
Bus-offTEC > 255Le 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.

TrameIdentifiantOctets de donnéesSignification
Requête0x7DF02 01 0C 00 00 00 00 00Mode 01 (données courantes), PID 0x0C : régime moteur
Réponse0x7E804 41 0C 1A F8 00 00 004 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 ?

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.

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)

Point important : le STM32F411 de la Black Pill n’a pas de contrôleur CAN intégré (pas de bxCAN : ce périphérique existe sur d’autres STM32 comme le F103, le F405 ou le F407). Pour faire du CAN avec la Black Pill F411, on ajoute un module MCP2515 (contrôleur CAN piloté en SPI) accompagné d’un transceiver TJA1050 (ou équivalent), qui produit les niveaux CAN_H / CAN_L. On réutilise donc le SPI du chapitre 10.

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.
Attention aux niveaux : beaucoup de modules MCP2515 + TJA1050 sont alimentés en 5 V ; leurs sorties SO et INT sont alors à 5 V. Vérifie dans la datasheet du STM32F411 que les broches utilisées (PA6, PB1) sont tolérantes 5 V ou intercale un adaptateur de niveau. Un module alimenté en 3,3 V (MCP2515 avec transceiver 3,3 V) évite le problème. Le quartz du module (souvent 8 MHz, parfois 16 MHz) est marqué sur le boîtier : il détermine le réglage du débit.
SignalBlack PillModule MCP2515
SélectionPA4 (sortie GPIO)CS
Horloge SPIPA5SCK
Données maître vers modulePA7 (MOSI)SI
Données module vers maîtrePA6 (MISO)SO
Interruption (facultatif)PB1 (entrée)INT
Alimentation5 VVCC
MasseGNDGND

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 :

InstructionOctetRôle
RESET0xC0Réinitialise le circuit (il passe en mode configuration)
READ0x03 + adresseLit un registre
WRITE0x02 + adresse + valeurÉcrit un registre
LOAD TX BUFFER0x40Écrit un message dans le tampon d’émission 0 (à partir de TXB0SIDH)
RTS0x81Demande l’envoi du tampon 0
READ RX BUFFER0x90Lit le tampon de réception 0 (à partir de RXB0SIDH) ; efface le drapeau RX0IF
READ STATUS0xA0Renvoie un octet d’état (bit 0 = message reçu dans le tampon 0)
RegistreAdresseRôle
CANSTAT0x0EMode actuel (bits 7:5 : 100 = configuration, 000 = normal, 010 = boucle)
CANCTRL0x0FMode demandé (bits 7:5)
CNF3, CNF2, CNF10x28, 0x29, 0x2ARéglage du temps binaire
RXB0CTRL0x60Filtres 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

  1. Câble les deux modules (CANH-CANH, CANL-CANL, masses, cavaliers de 120 Ω sur les deux).
  2. 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);
    }
  3. 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
    }
  4. 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ômeCause probable
CANSTAT ne vaut pas 0x80 après le resetSPI mal câblé (CS, SCK, SI, SO), module non alimenté, mauvais mode SPI
Le test en boucle échoueMauvaise valeur de CNF pour le quartz du module, can_init non appelée, délai trop court
Boucle réussie mais rien sur le busRé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-offPas d’autre nœud pour acquitter, ou débits différents : les erreurs s’accumulent
Trames reçues avec un mauvais identifiantDé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 quoiSortie 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.

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 ?

Newer Post Older Post Home