How to Use CAN Protocol in STM32 – CAN Bus Communication with Transceivers & Filters

Learn how the CAN (Controller Area Network) protocol works in STM32 microcontrollers using CubeMX and HAL. In this STM32 tutorial, we’ll set up CAN bus communication between two STM32 boards using MCP2551 transceivers. You’ll understand how to configure CAN filters, interrupts, and data frames—ideal for anyone building with microcontrollers that support CAN transceivers.

This tutorial will cover the Basic Can protocol in STM32. Here we will see how to communicate between two STM32 MCUs using the CAN protocol. Of course we would need 2 can transceivers (at least) to do that, and that’s why I am using MCP2551 can transceivers.

Introducing the CAN Peripheral in STM32

The CAN (Controller Area Network) peripheral in STM32 microcontrollers is a powerful communication interface designed for robust, real-time data exchange between multiple devices over a single bus. Originally developed for automotive applications, CAN is widely used in industrial automation, robotics, and other embedded systems where reliability and fault tolerance are critical.

In STM32, the CAN peripheral handles the low-level protocol mechanics, including message framing, filtering, error handling, and arbitration. It supports both standard (11-bit) and extended (29-bit) identifiers and can operate in normal, loopback, or silent modes, making it suitable for both development and deployment.

STM32 devices often include one or more FDCAN (Flexible Data-rate CAN) peripherals in newer series like STM32G4, H7, and L5, offering higher data throughput and improved flexibility over classic CAN.

Here are some important features of STM32 CAN:

1. Standard and Extended Frame Support
   Supports both 11-bit (standard) and 29-bit (extended) identifiers, making it compatible with a wide range of CAN-based systems.
2. Hardware Message Filtering
   Built-in filter banks allow selective message reception, reducing CPU overhead and improving efficiency.
3. Error Detection and Automatic Retransmission
   Includes robust error handling with automatic retransmission, fault confinement, and error counters for reliable communication.
4. Interrupt and DMA Support
   Offers both interrupt-driven and DMA-based data handling, enabling fast and efficient message processing.

What Is the CAN Bus Protocol and How Does It Work?

The CAN (Controller Area Network) bus is a robust communication protocol designed to allow multiple microcontrollers or devices—called nodes—to exchange data efficiently without needing a central host. Originally developed by Bosch for automotive systems, it’s now widely used in industrial automation, embedded systems, and medical devices due to its reliability, fault tolerance, and noise immunity.

Key Characteristics:

• Two-wire differential communication: CAN uses CANH and CANL lines for differential signaling, which improves noise resistance and allows reliable communication over long distances.
• Decentralized architecture: There’s no master-slave setup. Any node can initiate communication when the bus is idle.
• Message priority via arbitration: Messages use identifiers, and lower values represent higher priority. If two nodes transmit simultaneously, the higher-priority message continues while others back off.
• Built-in error handling: CAN includes CRC checks, acknowledgment bits, and automatic retransmission to ensure high data integrity.

A microcontroller with CAN support needs an external transceiver (like the MCP2551) to convert logic-level signals into the differential voltages used on the bus. The transceiver also handles bus interfacing and ensures proper signal levels for transmission and reception.

The CAN protocol offers a reliable, efficient, and real-time method of communication between devices, making it ideal for complex systems where performance and stability are critical.

SOME INFO ABOUT THE CAN PROTOCOL

I am not going to explain every small detail here, instead we will just focus on some important things. For more details about the Protocol, you can google it.

CAN (Controlled Area Network) Protocol is a way of communication between different devices, but under certain rules. These rules must be followed when a message is transmitted over the CAN bus. Here we are going to see these rules.

Below is the image showing the Standard CAN Frame.

• Here, Identifier is the ID of the transmitting Device. It can be either 11 bits (Standard ID) or 29 bits (Extended ID).
• RTR (Remote Transmission Request) Specifies if the data is Remote frame or Data frame.
• IDE specifies if we are using Standard ID or Extended ID.
• r is the Reserved bit.
• DLC specifies the data length in Bytes.
• Data Field is where we send the actual data bytes. It can be upto 8 bytes in size.
• CRC is the checksum data byte.
• ACK is the acknowledgment bit.

In this Tutorial, we will see up to the Data Field only. The CRC and ACK will be handled by the HAL Library.

CONNECTION AND CONFIGURATION

CAN Configuration

The CubeMX Configuration for the CAN Peripheral is shown below.

I am using CAN1 for this tutorial.

• Here the BAUD RATE is set to 500000 bps. You can try different different combinations for Prescaler and Time Quanta to achieve this.
• The Operating Mode is NORMAL Mode.
• Pins PA11 and PA12 are configured as CAN_RX and CAN_TX.

We also need to enable the pull up for the RX pin as shown below.

Using a Microcontroller with CAN Transceiver (e.g. STM32 + MCP2551)

The Connection between F446 and F103 is shown below.

• Here the CAN_Tx and CAN_Rx from the Transceivers are connected to PA12 and PA11 of the Respective controllers
• CANH and CANL are connected to each other
• Also there is a 120 ohms Resistance at the node. This is very important, or else you will not get the data.

MODIFY THE CAN DATA FRAME

To do this, we will define some variables, where we can store the header and the data information.

CAN_TxHeaderTypeDef   TxHeader;
uint8_t               TxData[8];
uint32_t              TxMailbox;

CAN_TxHeaderTypeDef   TxHeader;
uint8_t               TxData[8];
uint32_t              TxMailbox;

• Here TxHeader will be used to store the header information, like RTR, DLC, etc. This is the type CAN_TxHeaderTypeDef.
• TxData is used to store the data that we are going to transmit over the CAN bus.
• TxMailbox is the mailbox, which will be sent to the CAN bus.

Now we will store the required values in the TxHeader, and in the TxData.

TxHeader.IDE = CAN_ID_STD;
TxHeader.StdId = 0x446;
TxHeader.RTR = CAN_RTR_DATA;
TxHeader.DLC = 2;

TxData[0] = 50;  
TxData[1] = 0xAA;

TxHeader.IDE = CAN_ID_STD;
TxHeader.StdId = 0x446;
TxHeader.RTR = CAN_RTR_DATA;
TxHeader.DLC = 2;

TxData[0] = 50;  
TxData[1] = 0xAA;

• Here CAN_ID_STD means that we are using the Standard ID (not extended)
• 0x446 is the Identifier. This is the ID of the Transmitter, and it should be maximum 11 bit wide for the Standard ID.
• CAN_RTR_DATA indicates that we are sending a data frame
• DLC is the Length of data bytes, and here we are sending 2 data Bytes
• Now we will store the 2 data bytes in the TxData array

We have the information ready to be transmitted, and now we will finally transmit it on the CAN bus

if (HAL_CAN_AddTxMessage(&hcan1, &TxHeader, TxData, &TxMailbox) != HAL_OK)
{
   Error_Handler ();
}

if (HAL_CAN_AddTxMessage(&hcan1, &TxHeader, TxData, &TxMailbox) != HAL_OK)
{
   Error_Handler ();
}

This can be done by using the function HAL_CAN_AddTxMessage. It have the following parameters

• hcan1 is the instance of the CAN, that we are using.
• TxHeader is the Header of the message.
• TxData is the Data field.
• TxMailbox is the mailbox, which will carry the header and data message.

You can see above the data on the TX Line.

• Identifier is 0x446, the STD ID of the transmitter
• Control Field is 0x2, it contains DLC, RTR, IDE
• 2 Bytes of data Field
• And at last there is CRC Value, which was added by the HAL

This message is sent to the CAN bus, and now all the CAN devices on this bus will sort of receive this message. I said sort of, because whether to receive the message or not, depends on the Filter Configuration for each device.

If the message satisfies the conditions as per the FILTER, only then it will be allowed to pass.

FILTER CONFIGURATION

In order to reduce CPU Load to filter out messages, the STM32 have the Filters built inside the CAN peripheral. Let’s Check them out

  CAN_FilterTypeDef canfilterconfig;

  canfilterconfig.FilterActivation = CAN_FILTER_ENABLE;
  canfilterconfig.FilterBank = 18;  // which filter bank to use from the assigned ones
  canfilterconfig.FilterFIFOAssignment = CAN_FILTER_FIFO0;
  canfilterconfig.FilterIdHigh = 0x446<<5;
  canfilterconfig.FilterIdLow = 0;
  canfilterconfig.FilterMaskIdHigh = 0x446<<5;
  canfilterconfig.FilterMaskIdLow = 0x0000;
  canfilterconfig.FilterMode = CAN_FILTERMODE_IDMASK;
  canfilterconfig.FilterScale = CAN_FILTERSCALE_32BIT;
  canfilterconfig.SlaveStartFilterBank = 20;  // how many filters to assign to the CAN1 (master can)

  HAL_CAN_ConfigFilter(&hcan1, &canfilterconfig);

  CAN_FilterTypeDef canfilterconfig;

  canfilterconfig.FilterActivation = CAN_FILTER_ENABLE;
  canfilterconfig.FilterBank = 18;  // which filter bank to use from the assigned ones
  canfilterconfig.FilterFIFOAssignment = CAN_FILTER_FIFO0;
  canfilterconfig.FilterIdHigh = 0x446<<5;
  canfilterconfig.FilterIdLow = 0;
  canfilterconfig.FilterMaskIdHigh = 0x446<<5;
  canfilterconfig.FilterMaskIdLow = 0x0000;
  canfilterconfig.FilterMode = CAN_FILTERMODE_IDMASK;
  canfilterconfig.FilterScale = CAN_FILTERSCALE_32BIT;
  canfilterconfig.SlaveStartFilterBank = 20;  // how many filters to assign to the CAN1 (master can)

  HAL_CAN_ConfigFilter(&hcan1, &canfilterconfig);

The Last 2 points might be hard to understand, so I would suggest that you watch the video below. It could be better explained with the working example, and that’s shown in the VIDEO.

RECEIVING DATA

We will use the interrupt for the RX FIFO, so whenever a message is passed through the Filter an interrupt will be triggered.

First of all We will enable the CAN1 RX0 interrupt in the CubeMX

Now Inside the main Function, we will Activate the Notification for the Received message.

  if (HAL_CAN_ActivateNotification(&hcan1, CAN_IT_RX_FIFO0_MSG_PENDING) != HAL_OK)
  {
	  Error_Handler();
  }

  if (HAL_CAN_ActivateNotification(&hcan1, CAN_IT_RX_FIFO0_MSG_PENDING) != HAL_OK)
  {
	  Error_Handler();
  }

Here we will choose CAN_IT_RX_FIFO0_MSG_PENDING. This would trigger the interrupt whenever there is some pending message in the RX_FIFO 0. Once the interrupt is triggered, a callback function will be called. In this case, it will be HAL_CAN_RxFifo0MsgPendingCallback

CAN_RxHeaderTypeDef   RxHeader;
uint8_t               RxData[8];

void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan)
{
  if (HAL_CAN_GetRxMessage(hcan, CAN_RX_FIFO0, &RxHeader, RxData) != HAL_OK)
  {
    Error_Handler();
  }
  if ((RxHeader.StdId == 0x103))
  {
	  datacheck = 1;
  }
}

CAN_RxHeaderTypeDef   RxHeader;
uint8_t               RxData[8];

void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan)
{
  if (HAL_CAN_GetRxMessage(hcan, CAN_RX_FIFO0, &RxHeader, RxData) != HAL_OK)
  {
    Error_Handler();
  }
  if ((RxHeader.StdId == 0x103))
  {
	  datacheck = 1;
  }
}

• Here we will Receive the message from RX_FIFO 0.
• The message Header will be stored in the RxHeader, and the data will be stored in RxData.
• We can do further checks, like if the message was received from the ID 0x103, then the datacheck flag will be set.
• Later in the while loop we can perform some actions based on this flag

if (datacheck)
{
 HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_SET);
}

if (datacheck)
{
 HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_SET);
}

For example, If the Flag is set, The LED will turn ON.

VIDEO TUTORIAL

You can check the video to see the complete explanation and working of this project.

In this project, we learned how to build a CAN communication system using two STM32 microcontrollers and MCP2551 CAN transceivers. This tutorial showed how to send and receive messages, set up filters, and use interrupts with HAL. You can apply the same logic to other STM32 families or any microcontroller with CAN support.

PROJECT DOWNLOAD

STM32 CAN Protocol Project FAQs

You might also like

STM32 FDCAN Normal Mode Tutorial – Filters, RAM, and HAL Examples

STM32 HAL

2022-09-15 • 15 min read

STM32 FDCAN in Loopback Mode

STM32 HAL

2022-08-19 • 12 min read

STM32 UART #10 || Lin Protocol PART 3

STM32 UART Series

2024-03-23 • 11 min read

FreeRTOS TUTORIAL #4 -> Using Counting Semaphore

STM32 RTOS

2020-02-18 • 9 min read

STM32 ETHERNET #4. TCP SERVER

STM32 HAL

2021-08-29 • 10 min read

Control Continuous Servo RPM with Potentiometer & STM32

STM32 HAL

2024-07-26 • 12 min read