Maîtriser la communication CAN STM32 : Guide pratique pour la transmission et la réception de trames CAN

• Auteur: Johnny Liu (PDG de Dowway Vehicle | Spécialiste des systèmes automobiles)
• Publié : 1er juillet 2026
• Catégorie: Systèmes embarqués / Ingénierie automobile / Programmation de microcontrôleurs

TL;DR

Ce guide propose un tutoriel étape par étape sur la mise en œuvre Communication CAN (Controller Area Network) STM32 en utilisant le Bibliothèque HAL STM32 (bxCAN). Rédigé par un expert en électronique automobile, il couvre la configuration matérielle physique, le calcul précis du débit binaire avec les quanta de temps (TQ), les configurations « Accepter tout » sans filtre, la réception de messages pilotée par interruption et les directives de dépannage industriel du monde réel.

1. Introduction

Dans le domaine de l’ingénierie automobile et de l’automatisation industrielle, Réseau de zone de contrôleur (CAN) Le protocole CAN demeure la norme pour une communication robuste et tolérante au bruit. Dans nos précédents articles théoriques, nous avons exploré la couche physique CAN, le format de trame, l’arbitrage et les mécanismes de gestion des erreurs.

Il est temps à présent de passer de la théorie à la pratique. Comment écrire un code pratique et prêt pour la production permettant d’envoyer et de recevoir une seule trame CAN sur un microcontrôleur STM32 ?

Cet article se concentre sur le classique bxCAN périphérique utilisant le Bibliothèque HAL STM32 (Idéal pour les microcontrôleurs STM32F1, F4 et similaires). Que vous conceviez une carte de commande pour véhicule électrique ou un nœud de capteurs pour l’automatisation industrielle, ce guide de programmation étape par étape vous fournira une base fiable et évolutive.

2. Matériel essentiel pour la communication CAN STM32 (Pourquoi le logiciel ne suffit pas)

Contrairement à l’UART ou au SPI, où il suffit de connecter les broches RX/TX de deux microcontrôleurs pour effectuer des tests en laboratoire, La communication CAN nécessite un matériel émetteur-récepteur physique externe. Connexion du microcontrôleur CAN_TX et CAN_RX Connecter directement les broches entre elles sans émetteur-récepteur ne fonctionnera pas et pourrait endommager vos broches GPIO.

Composants clés d’un nœud CAN

Un nœud CAN fonctionnel se compose de cinq éléments principaux :

1. Contrôleur CAN interne : Intégré au sein du microcontrôleur STM32.
2. Émetteur-récepteur CAN externe : Convertit les niveaux logiques numériques du microcontrôleur (3,3 V) en signaux différentiels physiques (CAN_H et CAN_L). Les puces courantes incluent : TJA1050, TJA1051, SN65HVD230, ou MCP2551.
3. Lignes de bus physiques : Les fils à paires torsadées désignés comme $\text{CAN\_H}$ et $\text{CAN\_L}$ servent à supprimer les interférences électromagnétiques (EMI).
4. 120 $\Omega$ Résistances de terminaison : Doivent être placés aux deux extrémités physiques du bus pour éviter la réflexion du signal.
5. Circuits de protection (recommandés pour la production) : Suppresseurs de tension transitoire (diodes TVS) et isolation optoélectronique pour protéger contre les surtensions haute tension.

Référence de câblage matériel

Assurez-vous que votre prototype ou votre carte personnalisée est câblée exactement comme indiqué ci-dessous :

Broche du microcontrôleur STM32	Côté émetteur-récepteur	Côté bus de l’émetteur-récepteur	Ligne de bus CAN physique
STM32 CAN_TX	$\rightarrow$ TXD	CANH	$\rightarrow$ CAN_H (avec terminaison parallèle $120\Omega$)
STM32 CAN_RX	$\leftarrow$ RXD	CANL	$\rightarrow$ CAN_L (avec terminaison parallèle $120\Omega$)

3. Vue d’ensemble : Les 8 étapes de l’initialisation CAN

Pour établir une communication stable sur un STM32, le firmware doit exécuter ces 8 étapes dans l’ordre :

[1. Init CAN Parameters] ──> [2. Config Baud Rate] ──> [3. Config Working Mode]
                                                                  │
[6. Enable RX Interrupt] <── [5. Start CAN] <── [4. Config Hardware Filters]
         │
[7. Transmit CAN Frame] ──> [8. ISR / Callback Rx Handling]

1. Initialiser les paramètres périphériques CAN (allouer de la mémoire pour la poignée, mapper le multiplexage des broches).
2. Configurer le débit en bauds (réglage des prédiviseurs et des segments de phase).
3. Configurer le mode de fonctionnement (Mode normal pour la production, boucle de retour pour les essais à blanc).
4. Configurer les filtres matériels (configurer les filtres d’acceptation pour filtrer les identifiants indésirables au niveau matériel).
5. Démarrer le périphérique CAN (transition de l’état du matériel CAN de l’initialisation à l’état actif).
6. Activer les interruptions RX (demandez au NVIC d’écouter les messages CAN entrants).
7. Transmettre des trames CAN (charger les messages dans les boîtes aux lettres TX).
8. Réception des trames CAN dans l’ISR (traiter l’analyse des messages à l’intérieur du rappel d’interruption FIFO désigné).

Pièges courants en ingénierie : La plupart des problèmes rencontrés par les développeurs proviennent de configurations de temporisation du débit binaire incorrectes, de filtres non configurés (et donc bloquants) ou d’oublis d’appels. HAL_CAN_Start()ou en tentant de transmettre sans autre nœud actif sur le bus pour générer un signal d’accusé de réception (ACK).

4. Comprendre le débit en bauds et les quanta de temps (TQ) du CAN STM32

Une configuration incorrecte du débit de transmission CAN rendra votre nœud complètement silencieux ou déclenchera un flux continu de trames d’erreur sur le bus.

La formule mathématique

Le débit de transmission CAN est calculé à l’aide de l’horloge des périphériques et de la division de la durée d’un bit en petites unités appelées Quantums de temps (TQ):$$\text{Débit de bauds CAN} = \frac{\text{Horloge CAN}}{\text{Prédiviseur} \times \text{Nombre total de quanta de temps par bit}}$$

Le quantum de temps total par bit est défini par le segment de synchronisation et deux segments de phase : $$\text{Quantum de temps total par bit (TQ total)} = 1 \text{ (Segment de synchronisation)} + \text{BS1} + \text{BS2}$$

Où:

• Segment de synchronisation (Sync Segment de synchronisation) : Toujours fixé à 1 $\text{ TQ}$.
• BS1 (Segment temporel 1) : Définit l’emplacement du point d’échantillonnage. Il couvre le délai de propagation et le segment 1 du tampon de phase.
• BS2 (Segment temporel 2) : Segment tampon de phase 2, compensant les déphasages.

Exemple de calcul pratique

Calculons les paramètres pour un débit binaire cible de 500 kbit/s sur un STM32 où le périphérique CAN est mappé sur le Bus APB1 en circulation à 36 MHz :

1. Réglez le Prédiviseur jusqu’à 4 $.
2. Ensemble BS1 à 15 $\text{ TQ}$.
3. Ensemble BS2 à $2\text{ TQ}$.

Intégrons ces valeurs dans notre formule : $$\text{TQ total} = 1 + 15 + 2 = 18\text{ TQ}$$$$\text{Débit en bauds CAN} = \frac{36\text{ MHz}}{4 \times 18} = \frac{36 000 000}{72} = 500\text{ kbps}$$

Le calcul est parfaitement exact ! En environnement de production, assurez-vous toujours que votre Point d’échantillonnage (calculé comme $\frac{1 + \text{BS1}}{1 + \text{BS1} + \text{BS2}}$) est ciblé entre $75\%$ et 87,5 % pour une stabilité optimale du bus et une bonne résistance au bruit. Dans cet exemple, le point d’échantillonnage est d’environ 88,8 % (16/18), ce qui est très proche des profils automobiles standard.

5. Étape de codage 1 : Écriture du Initialisation MX_CAN() Fonction

La fonction d’initialisation configure les propriétés structurelles du contrôleur bxCAN à l’aide de CAN_HandleTypeDef poignée.

CAN_HandleTypeDef hcan;

/**
 * @brief  Initializes the CAN peripheral and sets basic operation parameters.
 * @note   This configuration targets a 500 kbps baud rate assuming a 36 MHz APB clock.
 * Always recalculate timing parameters if your system clock changes.
 * @retval None
 */
void MX_CAN_Init(void)
{
    hcan.Instance = CAN1;

    /* Baud Rate Configuration: 36MHz / 4 / (1 + 15 + 2) = 500 kbps */
    hcan.Init.Prescaler = 4;
    hcan.Init.Mode = CAN_MODE_NORMAL;
    hcan.Init.SyncJumpWidth = CAN_SJW_1TQ;
    hcan.Init.TimeSeg1 = CAN_BS1_15TQ;
    hcan.Init.TimeSeg2 = CAN_BS2_2TQ;
    
    /* Advanced Operating Modes */
    hcan.Init.TimeTriggeredMode = DISABLE;
    hcan.Init.AutoBusOff = ENABLE;        /* Automatically recover from Bus-Off state */
    hcan.Init.AutoWakeUp = DISABLE;
    hcan.Init.AutoRetransmission = ENABLE; /* Retransmit frames if arbitration is lost or an error occurs */
    hcan.Init.ReceiveFifoLocked = DISABLE; /* Overwrite oldest message when FIFO is full (instead of locking) */
    hcan.Init.TransmitFifoPriority = DISABLE; /* Priority determined by Identifier (lowest ID wins) */

    if (HAL_CAN_Init(&hcan) != HAL_OK)
    {
        /* Initialization Error Handling */
        Error_Handler();
    }
}

Analyse des paramètres d’initialisation critiques

• CAN_MODE_NORMAL contre BOUCLE CAN_MODE_BOOPBACKPour une véritable communication sur un bus transcepté, utilisez CAN_MODE_NORMAL. Pour les essais à blanc (tests de la logique interne sans connexion physique), activez cette option. BOUCLE CAN_MODE_BOOPBACK.
• AutoBusOff: Lorsqu’il est réglé sur ACTIVER, le matériel CAN récupère automatiquement et rejoint le réseau après être passé à l’état Bus-Off en raison de l’accumulation du nombre d’erreurs.
• Retransmission automatiqueEn cas de collision ou d’absence d’accusé de réception, le matériel tentera automatiquement de renvoyer la trame.
• RéceptionFifoLocked: Quand DÉSACTIVERLes nouvelles trames entrantes écraseront les trames non lues plus anciennes dans la FIFO. Si cette option est activée ACTIVER, la FIFO se bloque lorsqu’elle est pleine, rejetant les données entrantes suivantes.

6. Étape de codage 2 : Configuration du filtre (Problème « Pourquoi mon microcontrôleur ignore-t-il les messages ? »)

Par défaut, les filtres bxCAN des STM32 sont fermés. Si vous ne configurez pas explicitement un banc de filtres, Votre nœud rejettera tous les messages entrants..

Pour établir une initialisation système stable et vérifier que votre matériel fonctionne, configurez un Masque de filtre « Tout accepter ». Cela permet de contourner la vérification initiale d’identification et de laisser passer chaque paquet.

/**
 * @brief  Configures the CAN Hardware Acceptance Filters to accept all incoming frames.
 * @note   In production, narrow down filter masks to reduce CPU interrupt overhead.
 * @retval None
 */
void CAN_Filter_Config(void)
{
    CAN_FilterTypeDef filter;

    filter.FilterBank = 0;                         /* Select Filter Bank 0 */
    filter.FilterMode = CAN_FILTERMODE_IDMASK;     /* Mask Mode (versus Identifier list mode) */
    filter.FilterScale = CAN_FILTERSCALE_32BIT;    /* Single 32-bit register scale */
    
    /* Setting IDs and Masks to 0 accepts all standard and extended frames */
    filter.FilterIdHigh = 0x0000;
    filter.FilterIdLow = 0x0000;
    filter.FilterMaskIdHigh = 0x0000;
    filter.FilterMaskIdLow = 0x0000;
    
    filter.FilterFIFOAssignment = CAN_RX_FIFO0;    /* Route matched frames to Receive FIFO 0 */
    filter.FilterActivation = ENABLE;              /* Enable filter bank 0 */
    filter.SlaveStartFilterBank = 14;              /* Boundary for dual-CAN microcontrollers */

    if (HAL_CAN_ConfigFilter(&hcan, &filter) != HAL_OK)
    {
        /* Filter Configuration Error */
        Error_Handler();
    }
}

7. Étape de codage 3 : Démarrage du CAN et activation des interruptions

Une fois les paramètres d’initialisation et de filtrage flashés dans les registres, vous devez démarrer physiquement le périphérique et activer les lignes d’interruption appropriées.

/**
 * @brief  Starts the CAN peripheral and enables message-pending interrupts.
 * @retval None
 */
void CAN_Start(void)
{
    /* Start the CAN peripheral */
    if (HAL_CAN_Start(&hcan) != HAL_OK)
    {
        Error_Handler();
    }

    /* Activate the Notification for FIFO 0 Message Pending Interrupt */
    if (HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING) != HAL_OK)
    {
        Error_Handler();
    }
}

? Liste de vérification pour les développeurs : Si vous omettez HAL_CAN_Start(), le matériel CAN reste en mode d’initialisation. Si vous omettez HAL_CAN_ActiverNotification()Les messages entrants resteront en attente dans la file d’attente FIFO sans jamais déclencher votre fonction de rappel. Les deux erreurs présentent exactement le même symptôme : « Aucun message reçu ».

8. Étape de codage 4 : Transmission d’une trame CAN standard

L’envoi d’un message CAN nécessite la configuration d’un en-tête spécifiant les métadonnées (longueur de l’ID, format, identifiant) et le remplissage d’un tampon de charge utile pouvant atteindre 8 octets.

/**
 * @brief  Transmits a standard CAN frame over the bus.
 * @param  id: Standard 11-bit Frame Identifier (Range: 0x000 to 0x7FF)
 * @param  data: Pointer to the uint8_t array containing transmission payload
 * @param  len: Data length code (DLC) in bytes (Classic CAN range: 0 to 8)
 * @retval HAL_StatusTypeDef: Return status of HAL execution
 */
HAL_StatusTypeDef CAN_Send_StdData(uint16_t id, const uint8_t *data, uint8_t len)
{
    CAN_TxHeaderTypeDef tx_header;
    uint32_t tx_mailbox;
    uint8_t tx_data[8] = {0};

    /* Boundary Checks */
    if ((id > 0x7FFU) || (len > 8U))
    {
        return HAL_ERROR;
    }

    /* Safely copy transmission payload */
    for (uint8_t i = 0; i < len; i++)
    {
        tx_data[i] = data[i];
    }

    /* Formulate CAN Tx Header Struct */
    tx_header.StdId = id;                         /* 11-bit standard ID */
    tx_header.ExtId = 0;                          /* Extended identifier (unused) */
    tx_header.IDE = CAN_ID_STD;                   /* Configure frame type as Standard */
    tx_header.RTR = CAN_RTR_DATA;                 /* Configure frame type as Data Frame */
    tx_header.DLC = len;                          /* Set transmission payload size */
    tx_header.TransmitGlobalTime = DISABLE;

    /* Request Tx Mailbox transmission */
    return HAL_CAN_AddTxMessage(&hcan, &tx_header, tx_data, &tx_mailbox);
}

9. Étape de codage 5 : Réception et analyse des trames CAN via des interruptions

Lorsqu’une trame valide traverse le filtre et atteint la FIFO0, une interruption est déclenchée. Le microcontrôleur interrompt alors l’exécution standard pour exécuter la fonction de rappel HAL désignée.

Implémentation du rappel FIFO0

Votre fonction de rappel d’interruption doit récupérer immédiatement la trame pour vider la FIFO matérielle et minimiser la latence.

/**
 * @brief  Rx FIFO 0 message pending callback override.
 * Fires automatically whenever a new message lands in FIFO 0.
 * @param  hcan_ptr: Pointer to the active CAN peripheral handle
 * @retval None
 */
void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan_ptr)
{
    CAN_RxHeaderTypeDef rx_header;
    uint8_t rx_data[8];

    /* Fetch the message from the hardware FIFO */
    if (HAL_CAN_GetRxMessage(hcan_ptr, CAN_RX_FIFO0, &rx_header, rx_data) != HAL_OK)
    {
        return;
    }

    /* Sort by Frame Type and route parsing logic */
    if (rx_header.IDE == CAN_ID_STD)
    {
        CAN_Process_StdFrame(rx_header.StdId, rx_data, rx_header.DLC);
    }
    else
    {
        CAN_Process_ExtFrame(rx_header.ExtId, rx_data, rx_header.DLC);
    }
}

Meilleures pratiques architecturales : N’effectuez jamais de calculs lents et complexes ni de délais bloquants (comme Délai HAL()) dans une routine de service d’interruption (ISR) ou un rappel. Si vous le faites, vous risquez de manquer les trames suivantes. Pour les logiciels de production, copiez immédiatement les charges utiles entrantes dans un environnement thread-safe. Tampon annulaire ou File d’attente et décharger l’analyse syntaxique sur votre boucle principale ou sur une tâche RTOS.

10. Traitement des trames : Analyse des données entrantes par ID

Une fois acheminé vers CAN_Process_StdFrame(), analyser les octets de la charge utile en fonction de leur identifiant désigné. Cette structure est similaire aux matrices de messagerie automobile standard :

/**
 * @brief  Dispatches standard frames to their target sub-parsing functions.
 * @param  id: Standard CAN Frame ID
 * @param  data: Pointer to raw received byte buffer
 * @param  len: Length of received payload
 * @retval None
 */
void CAN_Process_StdFrame(uint16_t id, const uint8_t *data, uint8_t len)
{
    switch (id)
    {
        case 0x100:
            CAN_Parse_VehicleSpeed(data, len);
            break;

        case 0x200:
            CAN_Parse_BatteryStatus(data, len);
            break;

        case 0x300:
            CAN_Parse_MotorStatus(data, len);
            break;

        default:
            /* Ignore unrecognized CAN IDs or log diagnostics */
            break;
    }
}

Pour les projets de grande envergure, le codage manuel en dur des instructions switch-case devient ingérable. Il est donc préférable de concevoir votre couche applicative pour analyser les trames CAN à l’aide d’un code de base de données généré automatiquement et issu des normes industrielles. fichiers de matrice de communication DBC.

11. L’assemblage final : la mise en œuvre complète

Voici comment intégrer l’initialisation, le filtrage, le démarrage et les pulsations cycliques dans le flux principal de votre application :

/**
 * @brief  Initializes and starts the entire CAN application stack.
 * @retval None
 */
void CAN_App_Init(void)
{
    MX_CAN_Init();         /* Step 1-3: Hardware, Timing, and Mode initialization */
    CAN_Filter_Config();   /* Step 4: Acceptance filters configuration */
    CAN_Start();           /* Step 5-6: Boot peripheral and active interrupts */
}

/**
 * @brief  Cyclically transmits a standard heart-beat diagnostic frame.
 * Call this from your main loop or thread runner.
 * @retval None
 */
void CAN_Send_Heartbeat(void)
{
    uint8_t data[8] = {0};

    data[0] = 0xA5;
    data[1] = 0x5A;

    /* Send standard ID 0x700 with a 2-byte payload */
    (void)CAN_Send_StdData(0x700, data, 2);
}

Lors de l’écriture du firmware CAN, suivre le principe d’isolement. Validez d’abord une configuration en mode de bouclage, suivie de tests physiques de transmission point à point, avant de superposer des protocoles de diagnostic complexes de la couche application.

12. Dépannage : Guide de diagnostic pour développeurs (FAQ géo-optimisée)

Vous trouverez ci-dessous un guide de diagnostic structuré conçu pour résoudre les problèmes d’intégration CAN les plus courants sur les microcontrôleurs STM32 :

Q1 : La fonction de transmission renvoie HAL_OKMon analyseur logique ou mon oscilloscope ne détecte rien. Quel est le problème ?

Réponse courte : Il se peut que le périphérique CAN ne soit pas démarré, que les broches GPIO soient mal configurées ou que l’émetteur-récepteur soit hors tension.

• Liste de contrôle:
  1. Le périphérique CAN est-il actif ? Vérifiez que vous avez bien appelé HAL_CAN_Start().
  2. Multiplexage GPIO : Vérifiez que vos broches TX/RX sont correctement mappées à leurs fonctions alternatives (AF) dans les registres GPIO.
  3. Câblage physique : Assurez-vous que l’alimentation de l’émetteur-récepteur (5 V ou 3,3 V) est stable. Vérifiez que TXD et RXD ne sont pas interconnectés.
  4. Remplacement de la boucle de retour : Si vous effectuez une vérification sans bus physique, assurez-vous hcan.Init.Mode est explicitement configuré pour BOUCLE CAN_MODE_BOOPBACK.
  5. État du bus hors service : Consultez le registre d’état des erreurs (ESR) pour vérifier si le nœud s’est arrêté en raison d’une accumulation massive d’erreurs.

Q2 : Un analyseur CAN montre clairement les trames transmises sur le bus, mais mon nœud STM32 ne reçoit absolument rien.

Réponse courte : Cela est généralement dû à une configuration de filtre fermée ou incorrecte bloquant les messages, ou à des interruptions désactivées.

• Liste de contrôle:
  1. Configuration du masque de filtre : Votre filtre est-il trop strict ? Vérifiez que vous avez configuré un masque de filtre « Tout accepter » (FilterId et FilterMaskId défini à 0) lors du débogage initial.
  2. Activation des interruptions : Vérifiez si HAL_CAN_ActivateNotification a été appelé avec CAN_IT_RX_FIFO0_MSG_PENDING.
  3. Configuration NVIC : Vérifiez que les interruptions globales CAN sont activées dans le contrôleur NVIC de votre microcontrôleur.
  4. Incompatibilité FIFO : Vérifiez que votre initialisation correspond à votre fonction de rappel. Si vous configurez CAN_RX_FIFO0 dans vos filtres, mais implémentez HAL_CAN_RxFifo1MsgPendingCallback (FIFO1), l’interruption se déclenchera sans exécuter votre code.

Q3 : Pourquoi mon bus affiche-t-il continuellement des « erreurs ACK » lorsque j’essaie de transmettre ?

Réponse courte : Les erreurs ACK se produisent lorsqu’aucun autre nœud actif n’est en ligne pour accuser réception de votre trame, ou en cas d’incompatibilité physique du bus/débit en bauds.

• Liste de contrôle:
  1. Existe-t-il d’autres nœuds ? CAN est un bus collaboratif. Si aucun autre nœud n’est en ligne pour lire votre message et effectuer un basculement du bus de récessif à dominant pendant l’intervalle d’accusé de réception (ACK), le nœud émetteur signalera une erreur d’ACK.
  2. Inadéquation du débit en bauds : Si le nœud récepteur est configuré avec un débit binaire différent, il ne pourra pas lire la trame et ne pourra pas émettre d’accusé de réception (ACK).
  3. Résistances de terminaison : L’absence de résistances de terminaison (120 Ω aux deux extrémités) provoque une réflexion extrême du signal et une déformation des bords, ce qui empêche un échantillonnage ACK correct.

Q4 : Pourquoi mon nœud STM32 passe-t-il instantanément à l’état « Bus-Off » lorsqu’il est branché sur le réseau ?

Réponse courte : La coupure instantanée du bus est provoquée par une accumulation massive de trames d’erreur, généralement due à des débits de transmission incorrects ou à des courts-circuits physiques.

• Liste de contrôle:
  1. Divergence du débit de transmission : Un écart important de débit binaire provoque un flux continu de trames d’erreur, dépassant immédiatement le seuil de 255 du compteur d’erreurs de transmission (TEC).
  2. Courts métrages physiques : Utilisez un multimètre pour vérifier qu’il n’y a pas de court-circuit physique entre CAN_H et CAN_L ou à la terre.
  3. Tension de l’émetteur-récepteur : Une alimentation insuffisante de l’émetteur-récepteur peut entraîner de faibles niveaux de commande différentielle, déclenchant des alertes matérielles locales importantes.

13. Liste de vérification finale et prochaines étapes

La maîtrise de la communication CAN STM32 nécessite une compréhension synchronisée des automates d’état matériels et logiciels :

1. Établir des structures d’horlogerie exactes et calculer les segments de phase pour des synchronisations de débit binaire stables.
2. Débloquez vos filtres dégager les voies d’accès pour les tests de diagnostic du système.
3. Mettre en œuvre des routines de réception propres, légères et pilotées par interruption pour s’adapter aux réseaux complexes.

Dans notre prochain article, nous aborderons un autre sujet. Débogage avancé du bus CAN et diagnostics d’ingénierieComment analyser la distorsion du signal à l’aide d’un oscilloscope, isoler les trames d’erreur liées au bruit et implémenter des routines de récupération automatique robustes en cas de coupure de bus dans des environnements industriels extrêmes. Restez à l’écoute !