STM32 CAN-Kommunikation meistern: Ein praktischer Leitfaden zum Senden und Empfangen von CAN-Frames

• Autor: Johnny Liu (CEO bei Dowway Vehicle | Spezialist für Automobilsysteme)
• Veröffentlicht: 1. Juli 2026
• Kategorie: Eingebettete Systeme / Automobiltechnik / Mikrocontroller-Programmierung

TL;DR

Diese Anleitung bietet eine schrittweise Anleitung zur Implementierung STM32 CAN (Controller Area Network) Kommunikation unter Verwendung der STM32 HAL-Bibliothek (bxCAN). Das Buch wurde von einem Experten für Automobilelektronik verfasst und behandelt die Einrichtung der physischen Hardware, die präzise Baudratenberechnung mit Time Quanta (TQ), Zero-Filter-„Accept-All“-Konfigurationen, den interruptgesteuerten Nachrichtenempfang sowie praxisnahe Richtlinien für die Fehlersuche in der Industrie.

1. Einleitung

Im Automobilbau und der industriellen Automatisierung Controller Area Network (CAN) bleibt der Standard für robuste, störungsunempfindliche Kommunikation. In unseren vorherigen theoretischen Artikeln haben wir die CAN-Physikschicht, das Rahmenformat, die Arbitrierung und die Fehlerbehandlungsmechanismen untersucht.

Nun gilt es, die Lücke zwischen Theorie und Praxis zu schließen. Wie schreiben wir praktischen, produktionsreifen Code, um einen einzelnen CAN-Frame auf einem STM32-Mikrocontroller zu senden und zu empfangen?

Dieser Artikel konzentriert sich auf den Klassiker bxCAN Peripheriegeräte unter Verwendung der STM32 HAL-Bibliothek (Ideal für STM32F1, F4 und ähnliche Serien). Egal, ob Sie eine Steuereinheit für ein Elektrofahrzeug oder einen Sensorknoten für die Fabrikautomation entwickeln – dieses schrittweise Codierungsframework bietet Ihnen eine zuverlässige und skalierbare Grundlage.

2. Essenzielle Hardware für die STM32 CAN-Kommunikation (Warum Software allein nicht ausreicht)

Im Gegensatz zu UART oder SPI, wo man für Benchtests einfach die RX/TX-Pins zweier Mikrocontroller miteinander verbinden kann, Die CAN-Kommunikation erfordert externe physische Transceiver-Hardware.. Anschluss des Mikrocontrollers CAN_TX Und CAN_RX Eine direkte Verbindung von Pins ohne Transceiver führt zu einem Fehler und kann Ihre GPIO-Pins beschädigen.

Hauptkomponenten eines CAN-Knotens

Ein funktionsfähiger CAN-Knoten besteht aus fünf Kernelementen:

1. Interner CAN-Controller: Integriert in den STM32-Mikrocontroller.
2. Externer CAN-Transceiver: Übersetzt die digitalen Logikpegel des Mikrocontrollers (3,3 V) in die physikalischen Differenzsignale des Busses (CAN_H und CAN_L). Gängige Chips sind: TJA1050, TJA1051, SN65HVD230, oder MCP2551Die
3. Physische Buslinien: Verdrillte Adernpaare, die als $\text{CAN\_H}$ und $\text{CAN\_L}$ bezeichnet werden, um elektromagnetische Störungen (EMI) zu unterdrücken.
4. $120\Omega$ Abschlusswiderstände: Um Signalreflexionen zu vermeiden, müssen sie an beiden physischen Enden des Busses angebracht werden.
5. Schutzschaltungen (Empfohlen für die Produktion): Überspannungsschutzdioden (TVS-Dioden) und optoelektronische Isolation zum Schutz vor Überspannungen.

Die Hardware-Verdrahtungsreferenz

Stellen Sie sicher, dass Ihr Prototyp oder Ihre kundenspezifische Platine genau wie unten dargestellt verdrahtet ist:

STM32 MCU Pin	Transceiver-Seite	Transceiver Busseite	Physische CAN-Bus-Leitung
STM32 CAN_TX	$\rightarrow$ TXD	CANH	$\rightarrow$ CAN_H (mit 120 Ω paralleler Terminierung)
STM32 CAN_RX	$\leftarrow$ RXD	CANL	$\rightarrow$ CAN_L (mit 120 Ω paralleler Terminierung)

3. Überblick auf hoher Ebene: Die 8 Schritte zur CAN-Initialisierung

Um eine stabile Kommunikation auf einem STM32-Mikrocontroller herzustellen, muss die Firmware diese 8 Schritte nacheinander ausführen:

[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. CAN-Peripherieparameter initialisieren (Speicher für den Handle zuweisen, Pin-Multiplexing zuordnen).
2. Konfigurieren Sie die Baudrate (Voreinstellungen und Phasensegmente festlegen).
3. Arbeitsmodus konfigurieren (Normalmodus für die Produktion, Loopback-Modus für Testläufe).
4. Hardwarefilter konfigurieren (Akzeptanzfilter konfigurieren, um unerwünschte IDs auf Hardwareebene herauszufiltern).
5. CAN-Peripheriegerät starten (Übergang des CAN-Hardwarezustands von Initialisierung auf aktiv).
6. RX-Interrupts aktivieren (weisen Sie das NVIC an, eingehende CAN-Nachrichten zu empfangen).
7. CAN-Frames senden (Nachrichten in TX-Postfächer laden).
8. Empfange CAN-Frames im ISR (Die Nachrichtenanalyse erfolgt innerhalb der dafür vorgesehenen FIFO-Interrupt-Callback-Funktion).

Häufige Fallstricke im Ingenieurwesen: Die meisten Probleme von Entwicklern entstehen durch falsche Baudraten-Timing-Konfigurationen, nicht konfigurierte (und daher blockierende) Filter oder das Vergessen, einen Aufruf zu tätigen. HAL_CAN_Start()oder der Versuch, ohne einen anderen aktiven Knoten auf dem Bus zu senden, der ein Bestätigungssignal (ACK) erzeugen kann.

4. STM32 CAN Baudrate und Zeitquanten (TQ) verstehen

Eine falsche Konfiguration der CAN-Baudrate führt dazu, dass Ihr Knoten entweder gar keine Signale mehr ausgibt oder kontinuierlich Fehlerframes auf dem Bus ausgelöst werden.

Die mathematische Formel

Die CAN-Baudrate wird mithilfe des Peripheriegerätetakts und der Aufteilung eines einzelnen Bits in kleine Einheiten berechnet, die als Bitzeit bezeichnet werden. Zeitquanten (TQ):$$\text{CAN-Baudrate} = \frac{\text{CAN-Takt}}{\text{Vorteiler} \times \text{Gesamtzeitquanten pro Bit}}$$

Die Gesamtzahl der Zeitquanten pro Bit wird durch das Synchronisationssegment und zwei Phasensegmente definiert:$$\text{Gesamtzahl der Zeitquanten pro Bit (Gesamt-TQ)} = 1 \text{ (Sync Seg)} + \text{BS1} + \text{BS2}$$

Wo:

• Sync Seg (Synchronisationssegment): Immer auf $1\text{ TQ}$ festgelegt.
• BS1 (Zeitabschnitt 1): Definiert die Position des Abtastpunkts. Es umfasst die Laufzeitverzögerung und das Phasenpuffersegment 1.
• BS2 (Zeitabschnitt 2): Phasenpuffersegment 2, zum Ausgleich von Phasenverschiebungen.

Praktisches Berechnungsbeispiel

Lassen Sie uns die Parameter für eine Zielbaudrate von 500 kbps auf einem STM32 berechnen, wobei das CAN-Peripheriegerät auf die folgende Schnittstelle abgebildet ist: Der APB1-Bus fährt um $36\text{ MHz}$:

1. Stellen Sie die Vorregler bis zu 4 Dollar.
2. Satz BS1 bis $15\text{ TQ}$.
3. Satz BS2 bis $2\text{ TQ}$.

Setzen wir diese Werte in unsere Formel ein: $$\text{Total TQ} = 1 + 15 + 2 = 18\text{ TQ}$$$$\text{CAN Baud Rate} = \frac{36\text{ MHz}}{4 \times 18} = \frac{36.000.000}{72} = 500\text{ kbps}$$

Die Berechnung stimmt perfekt! Stellen Sie in Produktionsumgebungen immer sicher, dass Ihre Probenahmepunkt (berechnet als $\frac{1 + \text{BS1}}{1 + \text{BS1} + \text{BS2}}$) wird auf einen Wert zwischen $75\%$ angestrebt. Und 87,5 % für optimale Busstabilität und Störfestigkeit. In diesem Beispiel liegt der Abtastpunkt bei ca. 88,8 % (16/18), was sehr nahe an Standardprofilen der Automobilindustrie liegt.

5. Codierungsschritt 1: Schreiben des Codes MX_CAN_Init() Funktion

Die Initialisierungsfunktion konfiguriert die strukturellen Eigenschaften des bxCAN-Controllers mithilfe des CAN_HandleTypeDef handhaben.

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 kritischer Initialisierungsparameter

• CAN_MODE_NORMAL vs CAN_MODE_LOOPBACKFür die tatsächliche Kommunikation über einen übertragenen Bus verwenden Sie CAN_MODE_NORMAL. Für Trockenläufe (internes Testen der Logik ohne physische Verkabelung) aktivieren Sie diese Option. CAN_MODE_LOOPBACKDie
• AutoBusOffWenn eingestellt auf AKTIVIERENDie CAN-Hardware erholt sich automatisch und verbindet sich wieder mit dem Netzwerk, nachdem sie aufgrund einer Fehleranzahl in den Bus-Off-Zustand gewechselt ist.
• Automatische NeuübertragungWenn es zu einer Kollision kommt oder eine Bestätigung (ACK) ausbleibt, versucht die Hardware automatisch, den Frame erneut zu senden.
• ReceiveFifoLocked: Wann DEAKTIVIERENNeue eingehende Frames überschreiben ältere, ungelesene Frames im FIFO. Wenn diese Option aktiviert ist AKTIVIERENDer FIFO-Speicher blockiert, sobald er voll ist, und verwirft nachfolgend eingehende Daten.

6. Codierungsschritt 2: Konfiguration des Filters (Das Problem „Warum ignoriert mein Mikrocontroller Nachrichten?“)

Standardmäßig sind die bxCAN-Filter von STM32-Mikrocontrollern geschlossen. Wenn Sie keine Filterbank explizit konfigurieren, Ihr Knoten wird jede einzelne eingehende Nachricht ablehnen.Die

Um eine stabile Systeminitialisierung zu gewährleisten und die Funktionsfähigkeit Ihrer Hardware zu überprüfen, konfigurieren Sie ein Filtermaske “Alle akzeptieren”. Dadurch wird die anfängliche ID-Prüfung umgangen und jedes Datenpaket kann ungehindert durchgelassen werden.

/**
 * @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. Codierungsschritt 3: CAN starten und Interrupts aktivieren

Sobald die Initialisierungs- und Filtereinstellungen in die Register geschrieben wurden, müssen Sie das Peripheriegerät physisch starten und die entsprechenden Interruptleitungen aktivieren.

/**
 * @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();
    }
}

? Checkliste für Entwickler: Wenn Sie weglassen HAL_CAN_Start()Die CAN-Hardware bleibt im Initialisierungsmodus. Wenn Sie dies weglassen HAL_CAN_ActivateNotification()Eingehende Nachrichten verbleiben stumm im FIFO, ohne Ihre Callback-Funktion auszulösen. Beide Fehler weisen exakt dasselbe Symptom auf: „Keine Nachrichten empfangen“.

8. Codierungsschritt 4: Übertragung eines Standard-CAN-Frames

Das Senden einer CAN-Nachricht erfordert das Einrichten eines Headers, der Metadaten (ID-Länge, Format, Kennung) angibt, und das Füllen eines bis zu 8 Byte großen Nutzdatenpuffers.

/**
 * @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. Codierungsschritt 5: Empfangen und Parsen von CAN-Frames über Interrupts

Wenn ein gültiger Frame den Filter passiert und in FIFO0 gelangt, wird ein Interrupt ausgelöst. Der Mikrocontroller unterbricht die Standardausführung, um die entsprechende HAL-Callback-Funktion auszuführen.

Implementierung des FIFO0-Callbacks

Ihre Interrupt-Callback-Funktion sollte den Frame sofort abrufen, um den Hardware-FIFO zu leeren und die Latenz minimal zu halten.

/**
 * @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);
    }
}

Architektonische Best Practices: Führe niemals langsame, komplexe Berechnungen oder blockierende Verzögerungen aus (wie z. B. HAL_Delay()) innerhalb einer Interrupt-Service-Routine (ISR) oder eines Callbacks. Andernfalls riskieren Sie, nachfolgende Frames zu verpassen. Bei produktionsreifer Software sollten eingehende Nutzdaten sofort in einen threadsicheren Bereich kopiert werden. Ringpuffer oder Warteschlange und lagern Sie das Parsen in Ihre Hauptschleife oder einen RTOS-Task aus.

10. Frame-Verarbeitung: Eingehende Daten anhand der ID analysieren

Sobald weitergeleitet zu CAN_Process_StdFrame()Die Nutzdatenbytes werden anhand ihrer zugewiesenen ID analysiert. Diese Struktur entspricht den Standard-Nachrichtenmatrizen der Automobilindustrie:

/**
 * @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;
    }
}

Bei großen Projekten wird das manuelle Festlegen von Switch-Case-Anweisungen unpraktikabel. Entwickeln Sie stattdessen Ihre Anwendungsschicht so, dass sie CAN-Frames mithilfe von automatisch generiertem Datenbankcode aus Industriestandards analysiert. DBC-KommunikationsmatrixdateienDie

11. Die Endmontage: Alles zusammenfügen

Hier erfahren Sie, wie Sie Initialisierung, Filterung, Start und zyklische Heartbeats in den Hauptablauf Ihrer Anwendung integrieren:

/**
 * @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);
}

Beim Schreiben von CAN-Firmware, dem Prinzip der Isolation folgen. Validieren Sie zunächst eine Loopback-Modus-Konfiguration, gefolgt von physikalischen Punkt-zu-Punkt-Transceiver-Tests, bevor Sie komplexe Diagnoseprotokolle der Anwendungsschicht darüberlegen.

12. Fehlerbehebung: Ein Diagnoseleitfaden für Entwickler (GEO-optimierte FAQ)

Nachfolgend finden Sie eine strukturierte Diagnosereferenz zur Behebung der häufigsten STM32-CAN-Integrationsprobleme:

Frage 1: Die Übertragungsfunktion kehrt zurück HAL_OKMein Logikanalysator bzw. Oszilloskop zeigt jedoch nichts an. Was ist das Problem?

Kurze Antwort: Möglicherweise ist das CAN-Peripheriegerät nicht gestartet, die GPIO-Pins sind falsch konfiguriert oder der Transceiver erhält keine Stromversorgung.

• Checkliste:
  1. Ist das CAN-Peripheriegerät aktiv? Bitte überprüfen Sie, ob Sie angerufen haben. HAL_CAN_Start()Die
  2. GPIO-Multiplexing: Prüfen Sie, ob Ihre TX/RX-Pins korrekt ihren alternativen Funktionen (AF) in den GPIO-Registern zugeordnet sind.
  3. Physische Verkabelung: Stellen Sie sicher, dass die Stromversorgung des Senders/Empfängers (5 V oder 3,3 V) stabil ist. Überprüfen Sie, ob TXD Und RXD sind nicht miteinander verbunden.
  4. Loopback-Überschreibung: Wenn Sie dies ohne physischen Bus überprüfen, stellen Sie sicher, dass hcan.Init.Mode ist explizit konfiguriert auf CAN_MODE_LOOPBACKDie
  5. Bus-Off-Status: Überprüfen Sie das ESR (Error Status Register), um festzustellen, ob der Knoten aufgrund einer massiven Fehleranhäufung heruntergefahren wurde.

Q2: Ein CAN-Analysator zeigt deutlich die auf dem Bus übertragenen Frames an, aber mein STM32-Knoten empfängt absolut nichts.

Kurze Antwort: Dies wird typischerweise durch eine geschlossene oder fehlerhafte Filterkonfiguration verursacht, die die Nachrichten blockiert, oder durch nicht aktivierte Interrupts.

• Checkliste:
  1. Filtermaskenkonfiguration: Ist Ihr Filter zu streng? Vergewissern Sie sich, dass Sie eine Filtermaske mit der Aufschrift „Alle akzeptieren“ konfiguriert haben (FilterId Und FilterMaskId eingestellt auf 0) während der ersten Fehlersuche.
  2. Interrupt-Aktivierung: Prüfen Sie, ob HAL_CAN_ActivateNotification wurde angerufen mit CAN_IT_RX_FIFO0_MSG_PENDINGDie
  3. NVIC-Konfiguration: Prüfen Sie, ob CAN-Global-Interrupts im NVIC-Controller Ihres Mikrocontrollers aktiviert sind.
  4. FIFO-Fehlanpassung: Stellen Sie sicher, dass Ihre Initialisierung mit Ihrem Callback übereinstimmt. Wenn Sie konfigurieren CAN_RX_FIFO0 in Ihren Filtern, aber implementieren HAL_CAN_RxFifo1MsgPendingCallback (FIFO1), der Interrupt wird ausgelöst, ohne dass Ihr Code ausgeführt wird.

Frage 3: Warum zeigt mein Bus beim Senden ständig „ACK-Fehler“ an?

Kurze Antwort: ACK-Fehler treten auf, wenn kein anderer aktiver Knoten online ist, um Ihren Frame zu bestätigen, oder wenn eine Diskrepanz zwischen physikalischem Bus und Baudrate besteht.

• Checkliste:
  1. Gibt es weitere Knoten? CAN ist ein kollaborativer Bus. Wenn kein anderer Knoten online ist, der Ihre Nachricht lesen und den Bus während des ACK-Slots von rezessiv nach dominant umschalten kann, meldet der sendende Knoten einen ACK-Fehler.
  2. Baudraten-Fehlanpassung: Wenn der empfangende Knoten mit einer anderen Baudrate konfiguriert ist, kann er den Frame nicht lesen und keine Bestätigung (ACK) abgeben.
  3. Abschlusswiderstände: Fehlende Abschlusswiderstände (120 Ω an beiden Enden) verursachen extreme Signalreflexionen und Flankenverzerrungen, was eine korrekte ACK-Abtastung verhindert.

Frage 4: Warum wechselt mein STM32-Knoten sofort in den Zustand “Bus-Off”, wenn er an das Netzwerk angeschlossen wird?

Kurze Antwort: Instant Bus-Off wird durch eine massive Anhäufung von Fehlerframes verursacht, üblicherweise aufgrund falscher Baudraten oder physikalischer Kurzschlüsse.

• Checkliste:
  1. Baudratenabweichung: Eine gravierende Baudratenabweichung verursacht einen kontinuierlichen Strom von Fehlerframes, die den Schwellenwert des Sendefehlerzählers (TEC) von 255 sofort überschreiten.
  2. Physische Kurzfilme: Verwenden Sie ein Multimeter, um zu überprüfen, ob kein physischer Kurzschluss zwischen CAN_H Und CAN_L oder zu Boden.
  3. Sende-/Empfangsspannung: Eine unzureichende Stromversorgung des Transceivers kann zu schwachen Differenzialtreiberpegeln führen und dadurch schwerwiegende lokale Hardwarewarnungen auslösen.

13. Abschließende Checkliste & Nächste Schritte

Die Beherrschung der STM32 CAN-Kommunikation erfordert ein synchronisiertes Verständnis sowohl der Hardware- als auch der Software-Zustandsautomaten:

1. Genaue Uhrenstrukturen festlegen und berechnen Sie Phasensegmente für stabile Baudraten-Timings.
2. Entsperren Sie Ihre Filter um die Wege für Systemdiagnosetests freizumachen.
3. Implementieren Sie saubere, schlanke, interruptgesteuerte Empfangsroutinen. um auf komplexe Netzwerke skalieren zu können.

In unserem nächsten Artikel werden wir uns dem Thema zuwenden. Erweiterte CAN-Bus-Fehlerbehebung und technische DiagnoseWie man Wellenformverzerrungen mit einem Oszilloskop analysiert, rauschbedingte Fehlerframes isoliert und robuste Bus-Off-Auto-Recovery-Routinen in extremen Industrieumgebungen implementiert. Bleiben Sie dran!