Tuesday, November 10, 2026

Bus CAN

CAN — Protocoles série — I²C, SPI, USART et CAN bus en un seul document

Bus CAN · bxCAN STM32 et MCP2515

CAN : deux fils, plusieurs nœuds, personne n’est le chef.

Le CAN est un bus différentiel multi-maître très utilisé en automobile et en industrie. Principe, arbitrage, bit stuffing, puis implémentation : bxCAN (HAL) et, pour la Black Pill F411, un MCP2515 en SPI.

1. Comment ça marche

Le bus est une paire différentielle CAN_H / CAN_L. Deux états : dominant (bit 0, la ligne est activement pilotée) et récessif (bit 1, ligne au repos). Un nœud n’a pas d’adresse : chaque message porte un identifiant qui indique son contenu et sa priorité.

Champ trame standardTailleRôle
SOF1Début (dominant)
Identifiant11Contenu et priorité (petit = prioritaire)
RTR, IDE, r03Données/remote, format, réservé
DLC4Nombre d’octets (0 à 8)
Données0–64Charge utile
CRC + délimiteur16Contrôle d’erreur (CRC-15)
ACK + délimiteur2Un autre nœud tire le bit ACK à dominant
EOF7Fin de trame

Trois règles

  • Arbitrage : pendant l’identifiant, chaque émetteur relit le bus ; celui qui envoie 1 mais lit 0 perd et se tait, sans corruption.
  • Bit stuffing : après 5 bits identiques, l’émetteur insère un bit opposé ; le récepteur le retire.
  • ACK : il vient d’un autre nœud ; sans ACK l’émetteur signale une erreur.
CâblageValeur
Terminaison120 Ω à chaque extrémité (≈ 60 Ω mesurés entre CAN_H et CAN_L)
DébitMême débit sur tous les nœuds (125 k, 250 k, 500 k, 1 Mbit/s)
TransceiverTJA1050 (5 V) ou SN65HVD230 (3,3 V) entre MCU et bus

2. Animation : trame, arbitrage et bit stuffing

CAN bus

Deux fils, plusieurs nœuds, et personne n'est le chef.

CAN n'a pas de maître. Chaque nœud peut démarrer une trame, et si deux le font en même temps, le bus arbitre le conflit bit à bit. Le secret : le bus est un ET câblé — un bit dominant l'emporte sur un bit récessif. Le nœud qui envoie l'identifiant le plus faible gagne, et l'autre se retire sans rien corrompre.

Couche physique
CAN_H / CAN_L — différentielle, paire torsadée
Logique
Dominant 0 l'emporte sur récessif 1
Trame
SOF → ID → données → CRC → ACK → EOF
Intégrité
CRC-15, bourrage de bits, trames d'erreur

Forme d'onde en direct

Une trame standard émise par le nœud A

REPOS

Le bus est récessif — les deux lignes sont à 2,5 V et aucun nœud ne parle.

CAN_H 3,5 / 2,5 V CAN_L 2,5 / 1,5 V
dominant — CAN_H 3,5 V, CAN_L 1,5 V récessif — les deux lignes à 2,5 V bit bourré, inséré par l'émetteur
bit 0 / 0
Niveau du busRÉCESSIF
Champ courant—
Bits bourrés0
Données reçues—
CRC-15—
Vérification CRC—

Comment lire l'oscillogramme

Trois règles sur le bus

La tête de lecture met en évidence la règle qui s'applique à cet instant précis.

  1. 1

    Le dominant l'emporte sur le récessif

    Un bit dominant tire CAN_H vers le haut et CAN_L vers le bas ; un bit récessif laisse les deux lignes à 2,5 V. Comme le bus est un ET câblé, un émetteur en récessif ne peut pas gagner contre un dominant. Cette règle unique fait fonctionner l'arbitrage, la détection d'erreurs et l'ACK sur les mêmes deux fils.

    CAN_H CAN_L DOMINANT 0 RÉCESSIF 1
    Dominant : 2 V de différentiel. Récessif : ~0 V, les deux lignes au même niveau.
  2. 2

    Cinq bits identiques d'affilée reçoivent un bit bourré

    Après cinq bits consécutifs de même polarité, l'émetteur insère un bit de polarité opposée. Le récepteur le retire ensuite. Cette règle empêche le bus de rester trop longtemps à un seul niveau — ce qui masquerait un bit inversé au contrôle d'erreur.

    bus bourré cinq bits dominants le bit bourré coupe la série ; le récepteur le retire ensuite
    Le bourrage s'applique du SOF à la fin du champ CRC. Le délimiteur, l'ACK et l'EOF en sont exemptés.
  3. 3

    L'ACK vient d'un autre nœud

    Dans le slot d'ACK, l'émetteur envoie un bit récessif et se tait. Tout nœud qui a bien reçu la trame passe ce slot à dominant, ce qui dit à l'émetteur « ta trame est arrivée et le CRC est bon ». Si le slot reste récessif, personne n'a accusé réception et l'émetteur signale une erreur.

    bus slot ACK — piloté par le nœud B le nœud A envoie récessif et écoute
    Un bit dominant dans le slot d'ACK signifie « reçu et vérifié ».

La couche physique

Terminaison, câblage, et les trois erreurs classiques

CAN est un bus différentiel conçu pour les environnements longs et bruités : une paire torsadée qui traverse une usine, un véhicule ou une machine. Sa résistance de terminaison est ce qu'il a de plus proche d'un pull-up — et elle a sa place en exactement deux endroits.

Terminaison : la règle des 120 Ω

Chaque transceiver CAN pilote le bus de façon différentielle : le bus se comporte donc comme une longue ligne de transmission. Une résistance de 120 Ω à chaque extrémité physique donne une charge continue bien définie ; les deux se voient en parallèle comme 60 Ω entre les fils. Mettez-les aux deux extrémités du bus — jamais au milieu, jamais trois.

Rterm = 120 Ω à chaque extrémité  →  60 Ω mesurés entre les fils  ·  P = Vrécessif² / 60 Ω  ·  Vrécessif ≈ VDD / 2 (2,5 V à 5 V, 1,65 V à 3,3 V)
120 Ω 120 Ω Nœud A transceiver GND pas de terminaison au milieu paire torsadée
TopologieTerminaisonPuissance dans les terminaisonsUsage
Bus court, 2 nœuds120 Ω aux deux extrémités≈ 45 mW chacune (5 V)Montage de paillasse, petits systèmes
Terminaison séparée60 Ω + 60 Ω et un condensateur 4,7 nF vers GNDmême DC, moins de résonance HFEnvironnements bruyants, CEM
Bus long120 Ω aux deux extrémités seulement≈ 18 mW chacune (3,3 V)Bus véhicules et industrie

Un transceiver CAN a besoin d'une plage de mode commun : les deux lignes doivent rester approximativement entre −2 V et +7 V par rapport à la masse, et une terminaison séparée avec condensateur aide à tenir cette contrainte malgré les décalages de masse entre nœuds.

Arbitrage

Deux nœuds, un gagnant, aucune corruption

Quand deux nœuds transmettent en même temps, chacun met un bit sur le bus. Le bit dominant est celui qui apparaît. Un nœud qui envoie du récessif alors que le bus montre du dominant a perdu : il arrête de transmettre et devient récepteur. Le nœud qui porte l'identifiant le plus faible continue, et la trame du perdant sera retransmise plus tard.

Nœud A · ID 0x123 Nœud B · ID 0x124 Nœud A Nœud B A envoie du dominant B envoie du récessif → A gagne le bus, B se retire
Panne A

Terminaison absente ou mal placée

Sans les 120 Ω aux deux extrémités, la ligne se comporte comme une ligne de transmission non terminée : chaque front se réfléchit et revient sur le bus. La superposition du front d'origine et de son écho peut faire franchir un seuil au récepteur au milieu d'un bit, ce qui se manifeste par une erreur de CRC ou une trame d'erreur aléatoire.

bus écho résonance chez le récepteur
Panne B

Deux nœuds à des débits différents

CAN se resynchronise sur les fronts : un nœud qui n'est pas d'accord sur la durée du bit échantillonne le bus aux mauvais instants. La trame est détruite, le récepteur lève une trame d'erreur, et l'émetteur recommence — jusqu'à ce que le compteur d'erreurs place le nœud en bus-off, où il est retiré du bus.

Nœud A · 500 kbit/s Nœud B · 250 kbit/s trame d'erreur → bus-off
Panne C

Aucun nœud n'accuse réception

Si aucun récepteur ne passe le slot d'ACK à dominant, l'émetteur conclut que sa trame n'a pas été reçue. Il signale une erreur, incrémente son compteur d'erreurs et recommence. Sur un bus où tous les nœuds sont en veille, désactivés ou mal câblés, c'est le symptôme que l'on observe réellement.

bus drapeau d'erreur le slot d'ACK est resté récessif — personne n'écoutait

Choisir le débit

Le débit est une propriété du bus entier, pas d'un appareil. Tous les nœuds doivent être d'accord, et le débit arbitre entre vitesse et longueur maximale de câble.

DébitLongueur de bus typiqueTerminaisonOù on la rencontre
1 Mbit/s≈ 40 m120 Ω aux deux extrémitésCAN FD, faisceaux courts
500 kbit/s≈ 100 m120 Ω aux deux extrémitésAutomatisation, automobile
250 kbit/s≈ 250 m120 Ω aux deux extrémitésInstrumentation, bâtiment
125 kbit/s≈ 500 m120 Ω aux deux extrémitésLignes industrielles longues

L'ancienne règle « 32 nœuds, 10 nœuds par segment » n'est qu'un repère : les vraies limites sont le débit, la longueur de câble et la charge de terminaison totale. Mesurez le bus — 60 Ω mesurés entre CAN_H et CAN_L, alimentation coupée, indiquent une terminaison correcte.

3. Matériel : bxCAN ou MCP2515

Attention : le STM32F411 (Black Pill) n’a pas de contrôleur CAN. Le bxCAN existe sur F405/F407/F446 et autres F4 plus gros. Avec une Black Pill F411, on ajoute un MCP2515 + transceiver sur le SPI.
OptionContrôleurLiaison au MCU
STM32F405/407/446bxCAN intégré (CAN1, CAN2)Broches CAN + transceiver 3,3 V
Black Pill F411MCP2515 externe (module TJA1050)SPI1 : PA5 SCK, PA6 MISO, PA7 MOSI, PA4 CS
CAN1 (bxCAN)RXTXAF
Option 1PA11PA12AF9
Option 2PB8PB9AF9

Temps de bit (bxCAN)

débit = PCLK1 / (Prescaler × (1 + BS1 + BS2)). Exemple 500 kbit/s avec PCLK1 = 42 MHz : Prescaler 6, BS1 = 11, BS2 = 2 → 14 tq, point d’échantillonnage = (1+11)/14 ≈ 86 %.

4. Les registres

bxCAN (F405/F407/F446, base CAN1 0x40006400)

RegistreRôle
CAN_MCRContrôle : INRQ (init), SLEEP, ABOM (bus-off auto), TXFP
CAN_MSRÉtat : INAK (init actif), SLAK
CAN_TSRÉmission : TME0-2 (boîtes libres), RQCP, TXOK
CAN_RF0RFIFO 0 : FMP0 (messages en attente), RFOM0 (libérer)
CAN_IERInterruptions : FMPIE0, TMEIE, ERRIE
CAN_ESRErreurs : EWGF, EPVF, BOFF, compteurs TEC/REC
CAN_BTRTiming : BRP, TS1, TS2, SJW, LBKM (loopback), SILM (silent)
CAN_TIxR / TDTxR / TDLxR / TDHxRBoîte d’émission : identifiant (STID), DLC, 8 octets, TXRQ
CAN_RIxR / RDTxR / RDLxR / RDHxRBoîte de réception FIFO
CAN_FMR, FM1R, FS1R, FFA1R, FA1R, FiR1/FiR2Filtres : init, mode masque/liste, 16/32 bits, FIFO, activation, valeurs

Séquence : INRQ=1 → attendre INAK → configurer CAN_BTR → INRQ=0 → attendre fin d’initialisation. Pour émettre : trouver une boîte TME, remplir TIxR/TDTxR/TDLxR/TDHxR, mettre TXRQ.

MCP2515 (SPI mode 0, jusqu’à 10 MHz)

Instruction SPICodeRôle
RESET0xC0Réinitialise, passe en configuration
READ0x03Lit à une adresse
WRITE0x02Écrit à une adresse
RTS0x80|nDemande d’envoi du buffer n
READ STATUS0xA0État rapide TX/RX
BIT MODIFY0x05Modifie des bits avec masque
RegistreAdresseRôle
CANSTAT0x0EMode courant
CANCTRL0x0FREQOP[7:5] : 000 normal, 010 loopback, 100 configuration
CNF3/CNF2/CNF10x28/0x29/0x2ATiming de bit
CANINTF0x2CDrapeaux : RX0IF (bit 0), TX0IF (bit 2)
TXB0CTRL0x30TXREQ (bit 3)
TXB0SIDH/SIDL0x31/0x32Identifiant 11 bits
TXB0DLC, D0…0x35, 0x36Longueur et données
RXB0CTRL0x60Masques/filtres du buffer 0
RXB0SIDH/SIDL, DLC, D00x61/0x62, 0x65, 0x66Message reçu
Pour un quartz de 8 MHz à 500 kbit/s, valeurs courantes : CNF1 = 0x00, CNF2 = 0x90, CNF3 = 0x82 (vérifier avec le quartz réellement monté sur le module).

5. La bibliothèque HAL (bxCAN)

FonctionRôle
HAL_CAN_Init(&hcan)Configure le timing et le mode
HAL_CAN_ConfigFilter(&hcan,&filtre)Règle un filtre de réception (obligatoire pour recevoir)
HAL_CAN_Start(&hcan)Quitte l’initialisation, rejoint le bus
HAL_CAN_AddTxMessage(&hcan,&hdr,data,&mbox)Dépose un message dans une boîte libre
HAL_CAN_GetRxMessage(&hcan,FIFO,&hdr,data)Lit un message reçu
HAL_CAN_GetRxFifoFillLevel(&hcan,FIFO)Nombre de messages en attente
HAL_CAN_ActivateNotification(&hcan,CAN_IT_RX_FIFO0_MSG_PENDING)Active l’interruption de réception
HAL_CAN_RxFifo0MsgPendingCallbackCallback de réception
HAL_CAN_GetError(&hcan)Code d’erreur
hcan1.Instance = CAN1;
hcan1.Init.Prescaler = 6;
hcan1.Init.Mode = CAN_MODE_NORMAL;           // CAN_MODE_LOOPBACK pour tester seul
hcan1.Init.SyncJumpWidth = CAN_SJW_1TQ;
hcan1.Init.TimeSeg1 = CAN_BS1_11TQ;
hcan1.Init.TimeSeg2 = CAN_BS2_2TQ;           // 42 MHz / (6 x 14) = 500 kbit/s
hcan1.Init.AutoBusOff = ENABLE;
HAL_CAN_Init(&hcan1);
/* MspInit : PA11 (RX), PA12 (TX), GPIO_AF9_CAN1, horloge CAN1 */

6. Exemples d’implémentation

bxCAN : filtre ouvert, émission et réception

CAN_FilterTypeDef f = {0};
f.FilterBank = 0;  f.FilterMode = CAN_FILTERMODE_IDMASK;
f.FilterScale = CAN_FILTERSCALE_32BIT;
f.FilterIdHigh = f.FilterIdLow = f.FilterMaskIdHigh = f.FilterMaskIdLow = 0; // accepte tout
f.FilterFIFOAssignment = CAN_RX_FIFO0;  f.FilterActivation = ENABLE;
HAL_CAN_ConfigFilter(&hcan1,&f);
HAL_CAN_Start(&hcan1);
HAL_CAN_ActivateNotification(&hcan1,CAN_IT_RX_FIFO0_MSG_PENDING);

CAN_TxHeaderTypeDef tx = { .StdId=0x123, .IDE=CAN_ID_STD, .RTR=CAN_RTR_DATA, .DLC=2 };
uint8_t d[2]={0x12,0x34}; uint32_t mbox;
HAL_CAN_AddTxMessage(&hcan1,&tx,d,&mbox);

void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *h){
  CAN_RxHeaderTypeDef rx; uint8_t r[8];
  HAL_CAN_GetRxMessage(h,CAN_RX_FIFO0,&rx,r);   // rx.StdId, rx.DLC, r[]
}

Black Pill F411 : MCP2515 sur SPI1 (CS = PA4)

static void mcp_write(uint8_t a, uint8_t v){
  uint8_t t[3]={0x02,a,v}; CS_BAS(); HAL_SPI_Transmit(&hspi1,t,3,10); CS_HAUT();
}
static uint8_t mcp_read(uint8_t a){
  uint8_t t[2]={0x03,a}, r; CS_BAS();
  HAL_SPI_Transmit(&hspi1,t,2,10); HAL_SPI_Receive(&hspi1,&r,1,10); CS_HAUT(); return r;
}
void mcp_init(void){
  uint8_t rst=0xC0; CS_BAS(); HAL_SPI_Transmit(&hspi1,&rst,1,10); CS_HAUT(); HAL_Delay(10);
  mcp_write(0x2A,0x00); mcp_write(0x29,0x90); mcp_write(0x28,0x82); // 500 kbit/s @ 8 MHz
  mcp_write(0x0F,0x00);                                              // mode normal
}
void mcp_send(uint16_t id, uint8_t *d, uint8_t n){
  mcp_write(0x31,id>>3); mcp_write(0x32,(id&7)<<5); mcp_write(0x35,n);
  for(uint8_t i=0;i<n;i++) mcp_write(0x36+i,d[i]);
  uint8_t rts=0x81; CS_BAS(); HAL_SPI_Transmit(&hspi1,&rts,1,10); CS_HAUT(); // RTS buffer 0
}
uint8_t mcp_recv(uint16_t *id, uint8_t *d){      // 1 si message reçu
  if(!(mcp_read(0x2C)&1)) return 0;               // RX0IF
  *id=(mcp_read(0x61)<<3)|(mcp_read(0x62)>>5);
  uint8_t n=mcp_read(0x65)&0x0F;
  for(uint8_t i=0;i<n;i++) d[i]=mcp_read(0x66+i);
  mcp_write(0x2C,mcp_read(0x2C)&~1);               // efface RX0IF
  return n+1;
}

7. Diagnostic

SymptômeCause probable
Aucune trame ne sortTerminaison absente, transceiver non alimenté, un seul nœud (pas d’ACK)
Erreurs en rafaleDébits différents entre nœuds, sample point mal réglé
Rien reçu (bxCAN)Filtre non configuré ou non activé, mauvais FIFO
Mesure ≠ 60 Ω entre CAN_H et CAN_LTerminaison manquante ou doublée
Bus-offTrop d’erreurs : activer AutoBusOff, vérifier câblage
MCP2515 muetMauvais quartz/CNF, SPI mauvais mode, mode non normal
Premier test : mode loopback (bxCAN CAN_MODE_LOOPBACK ou MCP2515 REQOP = 010) pour valider le logiciel sans bus.

8. Exercices

Débit avec PCLK1 = 36 MHz, prescaler 4, BS1 = 6, BS2 = 2

1 + 6 + 2 = 9 tq ; 36 MHz / (4 × 9) = 1 Mbit/s.

Qui gagne : id 0x120 contre id 0x100 ?

Les identifiants sont comparés bit à bit ; au premier bit différent, celui qui envoie 1 face à un 0 perd. 0x100 est plus petit, donc prioritaire : il gagne.

Bit stuffing de 00000111110

Cinq 0 d’affilée : on insère un 1. Ce bit bourré compte dans la série suivante : il forme avec les quatre premiers 1 de données une série de cinq 1, donc on insère un 0. Résultat : 0000011111010 (13 bits au lieu de 11).

À faire en TP : deux nœuds avec 120 Ω aux extrémités, mesure 60 Ω, test loopback puis bus réel, filtre sur un identifiant, capteur envoyant la température dans l’ID 0x200.

Autres protocoles : USART · SPI · I²C. Carte : Black Pill STM32F411 (BTS EII).