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 standard | Taille | Rôle |
|---|---|---|
| SOF | 1 | Début (dominant) |
| Identifiant | 11 | Contenu et priorité (petit = prioritaire) |
| RTR, IDE, r0 | 3 | Données/remote, format, réservé |
| DLC | 4 | Nombre d’octets (0 à 8) |
| Données | 0–64 | Charge utile |
| CRC + délimiteur | 16 | Contrôle d’erreur (CRC-15) |
| ACK + délimiteur | 2 | Un autre nœud tire le bit ACK à dominant |
| EOF | 7 | Fin 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âblage | Valeur |
|---|---|
| Terminaison | 120 Ω à chaque extrémité (≈ 60 Ω mesurés entre CAN_H et CAN_L) |
| Débit | Même débit sur tous les nœuds (125 k, 250 k, 500 k, 1 Mbit/s) |
| Transceiver | TJA1050 (5 V) ou SN65HVD230 (3,3 V) entre MCU et bus |
2. Animation : trame, arbitrage et bit stuffing
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.
Forme d'onde en direct
Une trame standard émise par le nœud A
Le bus est récessif — les deux lignes sont à 2,5 V et aucun nœud ne parle.
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
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.
Dominant : 2 V de différentiel. Récessif : ~0 V, les deux lignes au même niveau. -
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.
Le bourrage s'applique du SOF à la fin du champ CRC. Le délimiteur, l'ACK et l'EOF en sont exemptés. -
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.
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.
| Topologie | Terminaison | Puissance dans les terminaisons | Usage |
|---|---|---|---|
| Bus court, 2 nœuds | 120 Ω aux deux extrémités | ≈ 45 mW chacune (5 V) | Montage de paillasse, petits systèmes |
| Terminaison séparée | 60 Ω + 60 Ω et un condensateur 4,7 nF vers GND | même DC, moins de résonance HF | Environnements bruyants, CEM |
| Bus long | 120 Ω 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.
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.
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.
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.
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.
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ébit | Longueur de bus typique | Terminaison | Où on la rencontre |
|---|---|---|---|
| 1 Mbit/s | ≈ 40 m | 120 Ω aux deux extrémités | CAN FD, faisceaux courts |
| 500 kbit/s | ≈ 100 m | 120 Ω aux deux extrémités | Automatisation, automobile |
| 250 kbit/s | ≈ 250 m | 120 Ω aux deux extrémités | Instrumentation, bâtiment |
| 125 kbit/s | ≈ 500 m | 120 Ω aux deux extrémités | Lignes 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
| Option | Contrôleur | Liaison au MCU |
|---|---|---|
| STM32F405/407/446 | bxCAN intégré (CAN1, CAN2) | Broches CAN + transceiver 3,3 V |
| Black Pill F411 | MCP2515 externe (module TJA1050) | SPI1 : PA5 SCK, PA6 MISO, PA7 MOSI, PA4 CS |
| CAN1 (bxCAN) | RX | TX | AF |
|---|---|---|---|
| Option 1 | PA11 | PA12 | AF9 |
| Option 2 | PB8 | PB9 | AF9 |
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)
| Registre | Rôle |
|---|---|
| CAN_MCR | Contrô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_RF0R | FIFO 0 : FMP0 (messages en attente), RFOM0 (libérer) |
| CAN_IER | Interruptions : FMPIE0, TMEIE, ERRIE |
| CAN_ESR | Erreurs : EWGF, EPVF, BOFF, compteurs TEC/REC |
| CAN_BTR | Timing : BRP, TS1, TS2, SJW, LBKM (loopback), SILM (silent) |
| CAN_TIxR / TDTxR / TDLxR / TDHxR | Boîte d’émission : identifiant (STID), DLC, 8 octets, TXRQ |
| CAN_RIxR / RDTxR / RDLxR / RDHxR | Boîte de réception FIFO |
| CAN_FMR, FM1R, FS1R, FFA1R, FA1R, FiR1/FiR2 | Filtres : 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 SPI | Code | Rôle |
|---|---|---|
| RESET | 0xC0 | Réinitialise, passe en configuration |
| READ | 0x03 | Lit à une adresse |
| WRITE | 0x02 | Écrit à une adresse |
| RTS | 0x80|n | Demande d’envoi du buffer n |
| READ STATUS | 0xA0 | État rapide TX/RX |
| BIT MODIFY | 0x05 | Modifie des bits avec masque |
| Registre | Adresse | Rôle |
|---|---|---|
| CANSTAT | 0x0E | Mode courant |
| CANCTRL | 0x0F | REQOP[7:5] : 000 normal, 010 loopback, 100 configuration |
| CNF3/CNF2/CNF1 | 0x28/0x29/0x2A | Timing de bit |
| CANINTF | 0x2C | Drapeaux : RX0IF (bit 0), TX0IF (bit 2) |
| TXB0CTRL | 0x30 | TXREQ (bit 3) |
| TXB0SIDH/SIDL | 0x31/0x32 | Identifiant 11 bits |
| TXB0DLC, D0… | 0x35, 0x36 | Longueur et données |
| RXB0CTRL | 0x60 | Masques/filtres du buffer 0 |
| RXB0SIDH/SIDL, DLC, D0 | 0x61/0x62, 0x65, 0x66 | Message reçu |
5. La bibliothèque HAL (bxCAN)
| Fonction | Rô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_RxFifo0MsgPendingCallback | Callback 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ôme | Cause probable |
|---|---|
| Aucune trame ne sort | Terminaison absente, transceiver non alimenté, un seul nœud (pas d’ACK) |
| Erreurs en rafale | Dé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_L | Terminaison manquante ou doublée |
| Bus-off | Trop d’erreurs : activer AutoBusOff, vérifier câblage |
| MCP2515 muet | Mauvais quartz/CNF, SPI mauvais mode, mode non normal |
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.