Menguasai Komunikasi CAN STM32: Panduan Praktis untuk Mengirim dan Menerima Frame CAN

• Pengarang: Johnny Liu (CEO di Dowway Vehicle | Spesialis Sistem Otomotif)
• Diterbitkan: 1 Juli 2026
• Kategori: Sistem Tertanam / Teknik Otomotif / Pemrograman MCU

TL;DR

Panduan ini memberikan tutorial langkah demi langkah tentang cara mengimplementasikannya. Komunikasi CAN (Controller Area Network) STM32 menggunakan Pustaka STM32 HAL (bxCAN). Ditulis oleh seorang ahli elektronik otomotif, buku ini membahas pengaturan perangkat keras fisik, perhitungan baud rate yang tepat dengan Time Quanta (TQ), konfigurasi “Accept-All” tanpa filter, penerimaan pesan berbasis interupsi, dan panduan pemecahan masalah industri di dunia nyata.

1. Pendahuluan

Dalam bidang teknik otomotif dan otomatisasi industri, Controller Area Network (CAN) tetap menjadi standar untuk komunikasi yang tangguh dan tahan terhadap gangguan. Dalam artikel teoritis kami sebelumnya, kami telah mengeksplorasi Lapisan Fisik CAN, Format Bingkai, Arbitrasi, dan mekanisme Penanganan Kesalahan.

Sekarang, saatnya menjembatani kesenjangan antara teori dan praktik. Bagaimana kita menulis kode praktis yang siap produksi untuk mengirim dan menerima satu frame CAN pada mikrokontroler STM32?

Artikel ini berfokus pada hal klasik. bxCAN periferal menggunakan Pustaka STM32 HAL (Sangat cocok untuk STM32F1, F4, dan seri serupa). Baik Anda mendesain papan kontrol Kendaraan Listrik (EV) atau node sensor otomatisasi pabrik, kerangka kerja pengkodean langkah demi langkah ini akan memberi Anda fondasi yang andal dan skalabel.

2. Perangkat Keras Penting untuk Komunikasi CAN STM32 (Mengapa Perangkat Lunak Saja Tidak Cukup)

Tidak seperti UART atau SPI, di mana Anda cukup menghubungkan pin RX/TX dari dua MCU bersama-sama untuk pengujian di meja kerja, Komunikasi CAN memerlukan perangkat keras transceiver fisik eksternal.. Menghubungkan MCU CAN_TX Dan CAN_RX Menghubungkan pin secara langsung satu sama lain tanpa transceiver akan gagal dan dapat merusak pin GPIO Anda.

Komponen Utama dari Node CAN

Sebuah node CAN yang berfungsi terdiri dari lima elemen inti:

1. Pengontrol CAN Internal: Terintegrasi di dalam MCU STM32.
2. Transceiver CAN Eksternal: Menerjemahkan level logika digital MCU ($3.3\text{ V}$) ke dalam sinyal diferensial bus fisik ($\text{CAN\_H}$ dan $\text{CAN\_L}$). Chip umum meliputi TJA1050, TJA1051, SN65HVD230, atau MCP2551.
3. Jalur Bus Fisik: Kabel pasangan berpilin yang diberi kode $\text{CAN\_H}$ dan $\text{CAN\_L}$ untuk menekan interferensi elektromagnetik (EMI).
4. $120\Omega$ Resistor Terminasi: Harus ditempatkan di kedua ujung fisik bus untuk mencegah pantulan sinyal.
5. Sirkuit Proteksi (Direkomendasikan untuk Produksi): Penekan Tegangan Transien (dioda TVS) dan isolasi optoelektronik untuk melindungi dari lonjakan tegangan tinggi.

Referensi Pengkabelan Perangkat Keras

Pastikan prototipe atau papan kustom Anda terhubung persis seperti yang ditunjukkan di bawah ini:

Pin MCU STM32	Sisi Transceiver	Sisi Bus Transceiver	Jalur Bus CAN Fisik
STM32 CAN_TX	$\rightarrow$ TXD	CANH	$\rightarrow$ CAN_H (dengan terminasi paralel 120Ω)
STM32 CAN_RX	$\leftarrow$ RXD	CANL	$\rightarrow$ CAN_L (dengan terminasi paralel 120Ω)

3. Gambaran Umum Tingkat Tinggi: 8 Langkah Inisialisasi CAN

Untuk membangun komunikasi yang stabil pada STM32, firmware harus menjalankan 8 langkah berikut secara berurutan:

[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. Inisialisasi parameter periferal CAN (mengalokasikan memori untuk handle, memetakan multiplexing pin).
2. Konfigurasi Kecepatan Baud (atur prescaler dan segmen fase).
3. Konfigurasi Mode Kerja (Mode normal untuk produksi, Loopback untuk uji coba).
4. Konfigurasi Filter Perangkat Keras (Konfigurasikan filter penerimaan untuk menyaring ID yang tidak diinginkan pada tingkat perangkat keras).
5. Mulai Perangkat CAN (mengubah status perangkat keras CAN dari inisialisasi ke aktif).
6. Aktifkan Interupsi RX (instruksikan NVIC untuk mendengarkan pesan CAN yang masuk).
7. Mengirimkan Frame CAN (memuat pesan ke dalam kotak surat TX).
8. Menerima Frame CAN di ISR (menangani penguraian pesan di dalam fungsi callback interupsi FIFO yang telah ditentukan).

Kesalahan Umum dalam Bidang Teknik: Sebagian besar masalah yang dihadapi pengembang berasal dari konfigurasi pengaturan waktu baud rate yang salah, filter yang tidak dikonfigurasi (dan karenanya memblokir), dan lupa untuk memanggil HAL_CAN_Start()atau mencoba mengirimkan data tanpa adanya node aktif lain pada bus untuk menghasilkan sinyal Acknowledge (ACK).

4. Memahami Kecepatan Baud CAN STM32 & Kuantum Waktu (TQ)

Mengonfigurasi kecepatan baud CAN secara tidak benar akan membuat node Anda benar-benar tidak berbunyi atau memicu frame kesalahan terus-menerus pada bus.

Rumus Matematika

Kecepatan baud CAN dihitung menggunakan clock periferal dan pembagian waktu satu bit menjadi unit-unit kecil yang disebut Kuantum Waktu (TQ):$$\text{Kecepatan Baud CAN} = \frac{\text{Jam CAN}}{\text{Prescaler} \times \text{Jumlah Kuanta Waktu Total per Bit}}$$

Jumlah total kuanta waktu per bit ditentukan oleh segmen sinkronisasi dan dua segmen fase: $$\text{Jumlah Total Kuanta Waktu per Bit (Total TQ)} = 1 \text{ (Segmen Sinkronisasi)} + \text{BS1} + \text{BS2}$$

Di mana:

• Segmen Sinkronisasi (Synchronization Segment): Selalu tetap pada $1\text{ TQ}$.
• BS1 (Segmen Waktu 1): Menentukan lokasi titik sampel. Ini mencakup penundaan propagasi dan Segmen Buffer Fase 1.
• BS2 (Segmen Waktu 2): Segmen Penyangga Fase 2, mengkompensasi pergeseran fase.

Contoh Perhitungan Praktis

Mari kita hitung parameter untuk target baud rate sebesar $500\text{ kbps}$ pada STM32 di mana periferal CAN dipetakan ke Bus APB1 beroperasi di $36\text{ MHz}$:

1. Atur Prescaler hingga $4$.
2. Mengatur BS1 hingga $15\text{ TQ}$.
3. Mengatur BS2 ke $2\text{ TQ}$.

Mari kita masukkan nilai-nilai ini ke dalam rumus kita:$$\text{Total TQ} = 1 + 15 + 2 = 18\text{ TQ}$$$$\text{Kecepatan Baud CAN} = \frac{36\text{ MHz}}{4 \times 18} = \frac{36,000,000}{72} = 500\text{ kbps}$$

Perhitungannya sangat cocok! Di lingkungan produksi, selalu pastikan… Titik Pengambilan Sampel (dihitung sebagai $\frac{1 + \text{BS1}}{1 + \text{BS1} + \text{BS2}}$) ditargetkan antara $75\%$ Dan $87,5\%$ untuk stabilitas bus dan ketahanan terhadap kebisingan yang optimal. Dalam contoh ini, titik pengambilan sampel adalah $\frac{16}{18} \approx 88,8\%$, yang sangat dekat dengan profil otomotif standar.

5. Langkah Pengkodean 1: Menulis MX_CAN_Init() Fungsi

Fungsi inisialisasi mengkonfigurasi properti struktural pengontrol bxCAN menggunakan CAN_HandleTypeDef menangani.

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

Analisis Parameter Inisialisasi Kritis

• MODE_NORMAL_KON vs MODE_CAN_LOOPBACKUntuk komunikasi nyata melalui bus transmisi dan penerimaan, gunakan MODE_NORMAL_KON. Untuk uji coba (menguji logika internal tanpa menghubungkan kabel fisik), alihkan ini ke MODE_CAN_LOOPBACK.
• Bus Otomatis Mati: Saat diatur ke MEMUNGKINKANPerangkat keras CAN secara otomatis pulih dan bergabung kembali ke jaringan setelah memasuki kondisi Bus-Off karena akumulasi jumlah kesalahan.
• Transmisi Ulang OtomatisJika terjadi tabrakan atau ACK tidak diterima, perangkat keras akan secara otomatis mencoba mengirimkan frame tersebut kembali.
• TerimaFifoTerkunci: Kapan CACAT, frame baru yang masuk akan menimpa frame lama yang belum dibaca di FIFO. Jika diatur ke MEMUNGKINKAN, FIFO akan terkunci ketika penuh, dan membuang data yang masuk berikutnya.

6. Langkah Pemrograman 2: Mengkonfigurasi Filter (Masalah “Mengapa MCU saya mengabaikan pesan?”)

Secara default, filter bxCAN pada STM32 dalam keadaan tertutup. Jika Anda tidak secara eksplisit mengkonfigurasi bank filter, Node Anda akan menolak setiap pesan yang masuk..

Untuk membangun inisialisasi sistem yang stabil dan memverifikasi bahwa perangkat keras Anda berfungsi, konfigurasikan sebuah Masker filter “Terima Semua”. Ini melewati pemeriksaan ID awal dan memungkinkan setiap paket untuk melewatinya.

/**
 * @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. Langkah Pengkodean 3: Memulai CAN dan Mengaktifkan Interupsi

Setelah pengaturan inisialisasi dan filter diunggah ke register, Anda harus melakukan booting fisik pada periferal dan mengaktifkan jalur interupsi yang sesuai.

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

? Daftar Periksa Pengembang: Jika Anda menghilangkan HAL_CAN_Start(), perangkat keras CAN tetap dalam mode inisialisasi. Jika Anda menghilangkan HAL_CAN_ActivateNotification()Pesan yang masuk akan tetap diam di FIFO tanpa pernah memicu fungsi callback Anda. Kedua kesalahan tersebut menunjukkan gejala yang sama persis: “Tidak ada pesan yang diterima.”

8. Langkah Pengkodean 4: Mengirimkan Bingkai CAN Standar

Mengirim pesan CAN memerlukan pengaturan header yang menentukan metadata (panjang ID, format, pengidentifikasi) dan pengisian buffer payload hingga 8 byte.

/**
 * @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. Langkah Pemrograman 5: Menerima dan Menguraikan Frame CAN melalui Interupsi

Ketika sebuah frame yang valid melewati filter ke FIFO0, maka akan memicu interupsi. MCU menghentikan eksekusi standar untuk menjalankan fungsi Callback HAL yang telah ditentukan.

Menerapkan Callback FIFO0

Fungsi callback interupsi Anda harus segera mengambil frame untuk membersihkan FIFO perangkat keras dan menjaga latensi seminimal mungkin.

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

Praktik Terbaik Arsitektur: Jangan pernah menjalankan perhitungan yang lambat, kompleks, atau penundaan yang menghambat (seperti HAL_Delay()) di dalam Interrupt Service Routine (ISR) atau Callback. Jika Anda melakukannya, Anda berisiko kehilangan frame berikutnya. Untuk perangkat lunak kelas produksi, salin payload yang masuk segera ke thread-safe. Penyangga Cincin atau Antre dan alihkan proses parsing ke loop utama Anda atau tugas RTOS.

10. Pemrosesan Bingkai: Menguraikan Data Masuk berdasarkan ID

Setelah dialihkan ke CAN_Process_StdFrame(), menguraikan byte muatan berdasarkan ID yang ditentukan. Struktur ini mencerminkan matriks pengiriman pesan standar otomotif:

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

Untuk proyek berskala besar, pengkodean cabang switch-case secara manual menjadi sulit dikelola. Sebagai gantinya, rancang lapisan aplikasi Anda untuk mengurai frame CAN menggunakan kode basis data yang dihasilkan secara otomatis yang bersumber dari standar industri. Berkas matriks komunikasi DBC.

11. Perakitan Akhir: Menggabungkan Semuanya

Berikut cara mengintegrasikan inisialisasi, penyaringan, memulai, dan detak jantung siklik ke dalam alur aplikasi utama Anda:

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

Saat menulis firmware CAN, ikuti prinsip isolasi. Lakukan validasi konfigurasi mode loopback terlebih dahulu, diikuti dengan pengujian transmisi dan penerimaan fisik titik-ke-titik, sebelum menerapkan protokol diagnostik lapisan aplikasi yang rumit.

12. Pemecahan Masalah: Panduan Diagnostik Pengembang (FAQ yang Dioptimalkan Secara GEO)

Berikut ini adalah referensi diagnostik terstruktur yang dirancang untuk menyelesaikan masalah integrasi CAN STM32 yang paling umum:

Q1: Fungsi transmisi mengembalikan HAL_OKNamun, logic analyzer atau osiloskop saya tidak mendeteksi apa pun. Apa yang salah?

Jawaban Singkat: Perangkat periferal CAN mungkin tidak diaktifkan, pin GPIO salah dikonfigurasi, atau transceiver kekurangan daya.

• Daftar periksa:
  1. Apakah Perangkat CAN Aktif? Verifikasi bahwa Anda yang menelepon HAL_CAN_Start().
  2. Multiplexing GPIO: Pastikan pin TX/RX Anda dipetakan dengan benar ke fungsi alternatifnya (AF) di register GPIO.
  3. Pengkabelan Fisik: Pastikan daya transceiver ($5\text{ V}$ atau $3.3\text{ V}$) stabil. Periksa bahwa TXD Dan RXD tidak saling terhubung.
  4. Penggantian Loopback: Jika melakukan pengecekan tanpa bus fisik, pastikan hcan.Init.Mode dikonfigurasi secara eksplisit untuk MODE_CAN_LOOPBACK.
  5. Status Bus-Off: Periksa ESR (Error Status Register) untuk memverifikasi apakah node telah mati karena akumulasi kesalahan yang besar.

Q2: Sebuah penganalisis CAN dengan jelas menunjukkan frame yang ditransmisikan pada bus, tetapi node STM32 saya sama sekali tidak menerima apa pun.

Jawaban Singkat: Hal ini biasanya disebabkan oleh konfigurasi filter yang tertutup atau salah sehingga menghalangi pesan, atau interupsi yang tidak diaktifkan.

• Daftar periksa:
  1. Konfigurasi Masker Filter: Apakah filter Anda terlalu ketat? Konfirmasikan bahwa Anda telah mengkonfigurasi masker filter “Terima Semua” (FilterId Dan FilterMaskId diatur ke 0) selama proses debugging awal.
  2. Pengaktifan Interupsi: Periksa apakah HAL_CAN_ActivateNotification dipanggil dengan CAN_IT_RX_FIFO0_MSG_PENDING.
  3. Konfigurasi NVIDIA: Pastikan interupsi global CAN diaktifkan di pengontrol NVIC MCU Anda.
  4. Ketidaksesuaian FIFO: Pastikan inisialisasi Anda sesuai dengan fungsi callback Anda. Jika Anda mengkonfigurasi CAN_RX_FIFO0 dalam filter Anda tetapi terapkan HAL_CAN_RxFifo1MsgPendingCallback (FIFO1), interupsi akan aktif tanpa mengeksekusi kode Anda.

Q3: Mengapa bus saya menampilkan “ACK Errors” terus menerus ketika saya mencoba mengirimkan data?

Jawaban Singkat: Kesalahan ACK terjadi ketika tidak ada node aktif lain yang online untuk mengakui frame Anda, atau terdapat ketidaksesuaian bus fisik/baud rate.

• Daftar periksa:
  1. Apakah Ada Node Lain? CAN adalah bus kolaboratif. Jika tidak ada node lain yang online untuk membaca pesan Anda dan menarik bus dari posisi resesif ke dominan selama slot ACK, node pengirim akan menandai kesalahan ACK.
  2. Ketidaksesuaian Kecepatan Baud: Jika node penerima dikonfigurasi dengan kecepatan baud yang berbeda, node tersebut akan gagal membaca frame dan tidak dapat mengirimkan ACK.
  3. Resistor Terminasi: Resistor terminasi yang hilang (120Ω di kedua ujung) menyebabkan refleksi sinyal dan deformasi tepi yang ekstrem, yang mencegah pengambilan sampel ACK yang benar.

Q4: Mengapa node STM32 saya langsung memasuki status “Bus-Off” saat dicolokkan ke jaringan?

Jawaban Singkat: Instant Bus-Off disebabkan oleh akumulasi besar frame error, biasanya karena baud rate yang tidak tepat atau korsleting fisik.

• Daftar periksa:
  1. Divergensi Kecepatan Baud: Ketidaksesuaian laju baud yang parah menyebabkan aliran frame error yang terus menerus, yang langsung melebihi ambang batas Transmit Error Counter (TEC) sebesar 255.
  2. Celana Pendek Fisik: Gunakan multimeter untuk memverifikasi tidak ada korsleting fisik di antara keduanya. CAN_H Dan CAN_L atau untuk membumi.
  3. Tegangan Transceiver: Kekurangan daya pada transceiver dapat menyebabkan tingkat penggerak diferensial yang lemah, sehingga memicu peringatan perangkat keras lokal yang serius.

13. Daftar Periksa Akhir & Langkah Selanjutnya

Menguasai komunikasi CAN STM32 membutuhkan pemahaman yang sinkron antara mesin keadaan perangkat keras dan perangkat lunak:

1. Tetapkan struktur jam yang tepat dan menghitung segmen fase untuk pengaturan waktu baud rate yang stabil.
2. Buka blokir filter Anda untuk membuka jalan bagi pengujian diagnostik sistem.
3. Implementasikan rutinitas penerimaan yang bersih, ringan, dan berbasis interupsi. untuk meningkatkan skala ke jaringan yang kompleks.

Pada artikel kami selanjutnya, kami akan beralih ke Debugging dan Diagnostik Teknik Bus CAN Tingkat Lanjut: cara menganalisis distorsi bentuk gelombang menggunakan osiloskop, mengisolasi frame kesalahan terkait noise, dan menerapkan rutinitas pemulihan otomatis Bus-Off yang tangguh di lingkungan industri ekstrem. Nantikan kelanjutannya!