【物联网】深入理解CAN通信：原理、应用和实现（超详细，万字警告）

小鱼儿 2024-03-22 21:19 24阅读 0赞

> CAN（Controller Area Network）是一种广泛应用于汽车和工业领域的多节点通信协议。它具有高可靠性、高实时性和抗干扰能力强等特点，能够满足复杂系统中节点之间的数据传输需求。本文将全面介绍CAN通信的原理、应用和实现，并提供实际开发中常用的方法和技巧，帮助读者更好地理解和应用CAN通信技术。

#### 文章目录 ####

*   *  1. 什么是CAN通信？
     *  2. CAN通信原理
     *  3. CAN通信的应用领域
     *  4. CAN帧格式与标识符
     *  5. CAN通信管理和控制
     *   *  5.1 CAN总线位定时（Bit Timing）
         *  5.2 CAN通信模式
         *  5.3 CAN错误处理与故障状态
     *  6. 使用HAL库实现CAN通信
     *   *  6.1 STM32 CAN通信配置:
         *  6.2 步骤的代码实现
         *  6.3 实现的整体代码
     *  7. 使用标准库实现CAN通信
     *   *  7.1 实现步骤
         *  7.2 步骤的代码实现
         *  7.3 实现的整体代码
     *  8. CAN通信实际案例分析

### 1. 什么是CAN通信？ ###

CAN通信是一种多节点通信协议，最早由Bosch公司开发并在1986年首次推出。它被广泛应用于汽车电子控制系统、工业自动化领域以及其他需求多节点通信的应用场景中。

CAN通信的特点之一是支持多节点之间的高速数据传输，适用于需要高实时性和高可靠性的系统。CAN总线由`两根线`组成，分别是`CAN_H（CAN High）和CAN_L（CAN Low）`。CAN总线使用不同的电压电平来表示0和1，并通过差分信号传输来抗干扰。

### 2. CAN通信原理 ###

CAN通信采用`CSMA/CD`（Carrier Sense Multiple Access with Collision Detection）的工作原理。简单来说，这意味着每个节点都可以在总线上发送消息，但在发送之前需要先监听总线上的通信情况。

当一个节点要发送消息时，首先会监听总线，如果没有其他节点正在发送消息，它就可以开始发送。如果同时有多个节点尝试发送消息，就会发生冲突。在CAN总线上使用的是非毁坏性冲突检测机制，冲突的节点会立即停止发送，并在发送完自己的消息后再次来检测冲突。

CAN通信中还使用了位定时传输方式，即总线上的每个位都有固定的时间段。发送节点将每个位的电平保持一段时间，接收节点则在相应的时间段内检测位的电平。这种位定时传输方式确保了数据的同步和准确性。

此外，CAN通信还通过帧的`优先级`来管理消息的传输。较低优先级的帧会在总线上等待较高优先级的帧发送完毕后再发送，确保重要消息的及时传输。

### 3. CAN通信的应用领域 ###

CAN通信被广泛应用于各种领域，特别是在汽车和工业控制系统中。

在汽车领域，CAN通信用于连接汽车的各个控制单元，如发动机控制单元（ECU）、刹车系统、仪表盘等。CAN总线提供了高速、实时的数据传输，使得这些控制单元能够相互通信和协调工作，实现车辆的高效控制和监测。

在工业控制系统中，CAN通信被用于连接各种设备和传感器，例如机器人、PLC（可编程逻辑控制器）、传感器网络等。通过CAN总线，这些设备可以实现实时数据交换和远程控制，从而提高生产效率和系统的可靠性。

除了汽车和工业控制，CAN通信还应用于其他领域，包括航空航天、医疗设备、能源管理等。CAN通信的高可靠性和抗干扰能力使其成为处理实时数据和多节点通信的理想选择。

### 4. CAN帧格式与标识符 ###

CAN通信使用帧格式来传输数据。CAN帧分为`标准帧`和`扩展帧`两种格式。

标准帧由`11位标识符、数据域、控制域和CRC`（循环冗余校验）组成。标识符用于标识消息的优先级和内容，数据域用于传输实际的数据，控制域包含帧的控制信息，而CRC用于发送节点计算校验和，接收节点用于验证数据的完整性。

扩展帧使用29位标识符，其他组成部分与标准帧相同。扩展帧的使用使得CAN网络能够处理更多的节点和更大的数据量。

标识符的选择对于CAN通信至关重要。帧使用的标识符决定了其在总线上的优先级，较低的标识符意味着较高的优先级。在设计和配置CAN网络时，需要合理设置标识符以确保系统的正确运行。

### 5. CAN通信管理和控制 ###

CAN通信的管理和控制涉及多个方面，包括位定时、通信模式、错误处理和故障状态等。

#### 5.1 CAN总线位定时（Bit Timing） ####

在CAN通信中，位定时是指将每个CAN总线的位划分为不同的时间段，并将位的电平保持一段时间。位定时可以通过设置同步段(Sync Segment)、传播段(Propagation Segment)和相位段(Phase Segment)来实现。

同步段用于确保总线上的节点能够在每个位开始时达到同步。传播段定义了信号在总线上传播的时间，而相位段用于确定位值的边界。

位定时的设置很关键，它直接影响到通信的可靠性和性能。在系统设计中，需要根据总线的特性和系统要求合理地设置位定时参数，以确保数据的正确传输。

#### 5.2 CAN通信模式 ####

CAN通信有几种不同的模式，可以通过配置CAN控制器的寄存器来选择适合应用需求的模式。

常见的CAN通信模式包括：

*  **正常模式（Normal Mode）**：用于实际通信，节点能够发送和接收数据。  
    \-\*\* 监听模式（Listen-Only Mode）\*\*：节点只能监听总线上的通信，但不能发送消息。
 *  **回环模式（Loopback Mode）**：发送的帧会回环到本地接收，用于自测和调试。
 *  **静默模式（Silent Mode）**：节点只能监听总线上的通信，不能发送消息，并向其他节点传递错误状态。

#### 5.3 CAN错误处理与故障状态 ####

在CAN通信中，可能会出现一些错误情况，例如位错误、格式错误、CRC错误、接收溢出等。CAN控制器会检测这些错误，并根据具体的错误类型生成相应的错误码。

在错误处理中，可以通过读取错误状态寄存器来获取错误码和错误类型。常见的错误处理方法包括：

*  **重传机制**：如果发送的帧在总线上出现错误，发送节点可以重传帧以确保数据的正确传输。
 *  **错误状态清除**：将错误计数器重置为0，清除错误状态以使节点恢复正常通信。
 *  **错误管理器（Error Management）**：通过协议定义的错误管理器对错误进行处理和控制，例如决定是否启用自动重传。
 *  **错误标志位（Error Flag）**：通过检查错误标志位确定是否有错误发生，并根据需要采取相应的处理措施。

### 6. 使用HAL库实现CAN通信 ###

对于使用HAL（Hardware Abstraction Layer）库进行STM32开发的用户，HAL库提供了高级的抽象接口和简洁的函数调用，方便编写和管理CAN通信。

#### 6.1 STM32 CAN通信配置: ####

a. **使能CAN外设**：在初始化阶段，需要使能所选择的CAN外设，并配置相应的时钟。

b. **配置CAN控制器**：通过设置CAN控制器的特殊寄存器，配置CAN通信的参数，包括波特率、工作模式、过滤器等。

c. **配置GPIO引脚**：将相关的GPIO引脚配置为CAN模式，以实现CAN数据的收发。

d. **初始化CAN通信**：通过初始化CAN控制器的寄存器，准备CAN通信的环境，包括清除任何悬空状态和错误标志。

e. **开始CAN通信**：使能CAN控制器的接收和发送功能，使其处于工作状态。

#### 6.2 步骤的代码实现 ####

1.  包含所需的头文件：
    
        #include "stm32f4xx_hal.h"
        #include "stm32f4xx_hal_can.h"
2.  定义CAN\_HandleTypeDef结构体和CAN消息结构体：
    
        CAN_HandleTypeDef hcan;
        CAN_TxHeaderTypeDef TxHeader;
        CAN_RxHeaderTypeDef RxHeader;
        uint8_t TxData[8];
        uint8_t RxData[8];
3.  配置CAN模式和参数：
    
        hcan.Instance = CAN1;
        hcan.Init.Mode = CAN_MODE_NORMAL;
        hcan.Init.AutoBusOff = ENABLE;
        hcan.Init.AutoRetransmission = ENABLE;
        hcan.Init.AutoWakeUp = DISABLE;
        hcan.Init.ReceiveFifoLocked = DISABLE;
        hcan.Init.TimeTriggeredMode = DISABLE;
        hcan.Init.TransmitFifoPriority = DISABLE;
        hcan.Init.Prescaler = 10;
        hcan.Init.SyncJumpWidth = CAN_SJW_1TQ;
        hcan.Init.TimeSeg1 = CAN_BS1_8TQ;
        hcan.Init.TimeSeg2 = CAN_BS2_7TQ;
        
        if (HAL_CAN_Init(&hcan) != HAL_OK) {
              
            // 错误处理
        }
4.  配置CAN过滤器：
    
        CAN_FilterTypeDef sFilterConfig;
        sFilterConfig.FilterBank = 0;
        sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK;
        sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT;
        sFilterConfig.FilterIdHigh = 0x0000;
        sFilterConfig.FilterIdLow = 0x0000;
        sFilterConfig.FilterMaskIdHigh = 0x0000;
        sFilterConfig.FilterMaskIdLow = 0x0000;
        sFilterConfig.FilterFIFOAssignment = CAN_RX_FIFO0;
        sFilterConfig.FilterActivation = ENABLE;
        sFilterConfig.SlaveStartFilterBank = 0;
        
        if (HAL_CAN_ConfigFilter(&hcan, &sFilterConfig) != HAL_OK) {
              
            // 错误处理
        }
5.  启动CAN：
    
        if (HAL_CAN_Start(&hcan) != HAL_OK) {
              
            // 错误处理
        }
6.  发送和接收数据：
    
        if (HAL_CAN_AddTxMessage(&hcan, &TxHeader, TxData, &TxMailbox) != HAL_OK) {
              
            // 错误处理
        }
        
        if (HAL_CAN_GetRxMessage(&hcan, CAN_RX_FIFO0, &RxHeader, RxData) != HAL_OK) {
              
            // 错误处理
        }

#### 6.3 实现的整体代码 ####

// 包含所需的头文件
    #include "stm32f4xx_hal.h"
    
    // CAN消息结构体
    CAN_TxHeaderTypeDef TxHeader;
    CAN_RxHeaderTypeDef RxHeader;
    uint8_t TxData[8];
    uint8_t RxData[8];
    
    void CAN_Configuration(void)
    {
        
      // 初始化CAN控制器
      hcan.Instance = CAN1;
      hcan.Init.Prescaler = 10;
      hcan.Init.Mode = CAN_MODE_NORMAL;
      hcan.Init.SyncJumpWidth = CAN_SJW_1TQ;
      hcan.Init.TimeSeg1 = CAN_BS1_8TQ;
      hcan.Init.TimeSeg2 = CAN_BS2_7TQ;
      hcan.Init.TimeTriggeredMode = DISABLE;
      hcan.Init.AutoBusOff = ENABLE;
      hcan.Init.AutoWakeUp = DISABLE;
      hcan.Init.AutoRetransmission = ENABLE;
      hcan.Init.ReceiveFifoLocked = DISABLE;
      HAL_CAN_Init(&hcan);
    
      // 配置CAN过滤器
      CAN_FilterTypeDef sFilterConfig;
      sFilterConfig.FilterBank = 0;
      sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK;
      sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT;
      sFilterConfig.FilterIdHigh = 0x0000;
      sFilterConfig.FilterIdLow = 0x0000;
      sFilterConfig.FilterMaskIdHigh = 0x0000;
      sFilterConfig.FilterMaskIdLow = 0x0000;
      sFilterConfig.Filter
    继续
    MaskIdHigh = 0x0000;
    sFilterConfig.FilterMaskIdLow = 0x0000;
    sFilterConfig.FilterFIFOAssignment = CAN_FILTER_FIFO0;
    sFilterConfig.FilterActivation = ENABLE;
    sFilterConfig.SlaveStartFilterBank = 14;
    HAL_CAN_ConfigFilter(&hcan, &sFilterConfig);
    
    // 启动CAN通信
    HAL_CAN_Start(&hcan);
    
    // 配置CAN消息头
    TxHeader.StdId = 0x123;
    TxHeader.ExtId = 0x00;
    TxHeader.RTR = CAN_RTR_DATA;
    TxHeader.IDE = CAN_ID_STD;
    TxHeader.DLC = 8;
    TxHeader.TransmitGlobalTime = DISABLE;
    }
    
    void CAN_SendData(uint8_t* data, uint32_t length)
    {
        
    // 填充发送消息的数据
    for (uint8_t i = 0; i < length; i++) {
        
    TxData[i] = data[i];
    }
    
    // 发送消息
    if (HAL_CAN_AddTxMessage(&hcan, &TxHeader, TxData, &TxMailbox) == HAL_OK) {
        
    HAL_CAN_Transmit(&hcan, 100);
    }
    }
    
    void CAN_ReceiveData(void)
    {
        
    // 接收消息
    if (HAL_CAN_GetRxFifoFillLevel(&hcan, CAN_RX_FIFO0) > 0) {
        
    if (HAL_CAN_GetRxMessage(&hcan, CAN_RX_FIFO0, &RxHeader, RxData) == HAL_OK) {
        
    // 处理接收到的数据
    // …
    }
    }
    }
    
    int main(void)
    {
        
    // 初始化HAL库和其他外设
    
    // 配置CAN通信
    CAN_Configuration();
    
    while (1) {
        
    // 发送数据
    uint8_t sendData[] = {
        0x01, 0x02, 0x03};
    CAN_SendData(sendData, sizeof(sendData));
    
    // 接收数据
    CAN_ReceiveData();
    }
    }

以上示例代码演示了一个简单的CAN发送和接收流程。首先，在`CAN_Configuration`函数中，配置CAN控制器和过滤器。然后，在主函数中，使用`CAN_SendData`函数发送数据，使用`CAN_ReceiveData`函数接收数据。

此外，为了调试和监测CAN通信，HAL库提供了一些有用的函数和工具。例如，可以使用`HAL_CAN_GetState()`函数获取CAN控制器的当前状态，包括初始化、准备就绪、发送中、传输完成等。还可以使用`HAL_CAN_GetErrorCounter()`函数获取错误计数器的值，以及使用`HAL_CAN_GetRxMessage()`函数获取接收到的CAN帧的相关信息。

### 7. 使用标准库实现CAN通信 ###

除了HAL库，还可以使用标准库进行CAN通信的实现。标准库相对较底层，需要直接操作寄存器和位操作来配置和控制CAN控制器。

与HAL库类似，使用标准库进行CAN通信需要进行CAN总线的初始化、过滤器的配置、数据的发送和接收等操作。不同之处在于，需要直接操作寄存器来完成这些任务。

#### 7.1 实现步骤 ####

*  配置GPIO端口和引脚，用于连接CAN总线。
 *  配置CAN控制器的工作模式、波特率、位定时参数等。
 *  配置CAN过滤器，设置过滤器的标识符、执行类型等。
 *  使用CAN发送函数将数据发送到总线上。
 *  使用CAN接收函数接收来自其他节点的数据。

#### 7.2 步骤的代码实现 ####

当使用标准库实现STM32的CAN通信时，需要按照以下步骤进行配置和操作：

1.  配置CAN1时钟：
    
        RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
2.  初始化CAN1：
    
        CAN_InitTypeDef CAN_InitStructure;
        CAN_InitStructure.CAN_TTCM = DISABLE;
        CAN_InitStructure.CAN_ABOM = DISABLE;
        CAN_InitStructure.CAN_AWUM = DISABLE;
        CAN_InitStructure.CAN_NART = DISABLE;
        CAN_InitStructure.CAN_RFLM = DISABLE;
        CAN_InitStructure.CAN_TXFP = DISABLE;
        CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;
        CAN_InitStructure.CAN_SJW = CAN_SJW_1tq;
        CAN_InitStructure.CAN_BS1 = CAN_BS1_8tq;
        CAN_InitStructure.CAN_BS2 = CAN_BS2_7tq;
        CAN_InitStructure.CAN_Prescaler = 10;
        CAN_Init(CAN1, &CAN_InitStructure);
3.  配置CAN过滤器：
    
        CAN_FilterInitTypeDef CAN_FilterInitStructure;
        CAN_FilterInitStructure.CAN_FilterNumber = 0;
        CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdMask;
        CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit;
        CAN_FilterInitStructure.CAN_FilterIdHigh = 0x0000;
        CAN_FilterInitStructure.CAN_FilterIdLow = 0x0000;
        CAN_FilterInitStructure.CAN_FilterMaskIdHigh = 0x0000;
        CAN_FilterInitStructure.CAN_FilterMaskIdLow = 0x0000;
        CAN_FilterInitStructure.CAN_FilterFIFOAssignment = CAN_FIFO0;
        CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;
        CAN_FilterInit(&CAN_FilterInitStructure);
4.  使能CAN1接收中断：
    
        NVIC_InitTypeDef NVIC_InitStructure;
        NVIC_InitStructure.NVIC_IRQChannel = CAN1_RX0_IRQn;
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
        NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
        NVIC_Init(&NVIC_InitStructure);
        CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE);
5.  实现CAN1接收中断处理函数：
    
        void CAN1_RX0_IRQHandler(void) {
              
          if (CAN_GetITStatus(CAN1, CAN_IT_FMP0) != RESET) {
              
            CAN_Receive(CAN1, CAN_FIFO0, &RxMessage);
            // 处理接收到的消息
          }
        }
6.  编写CAN发送函数：
    
        void CAN_SendData(uint8_t* data, uint8_t length) {
              
          // 填充发送消息的数据
          for (uint8_t i = 0; i < length; i++) {
              
            TxMessage.Data[i] = data[i];
          }
        
          // 设置发送消息的参数
          TxMessage.StdId = 0x123;
          TxMessage.ExtId = 0x00;
          TxMessage.IDE = CAN_Id_Standard;
          TxMessage.RTR = CAN_RTR_DATA;
          TxMessage.DLC = length;
        
          // 发送消息
          uint8_t mailbox;
          CAN_Transmit(CAN1, &TxMessage);
        }
7.  在主函数中调用相关函数：
    
        int main(void) {
              
          // 初始化CAN配置
          CAN_Configuration();
        
          while ((CAN1->MSR & CAN_MSR_INAK) == CAN_MSR_INAK) {
              
            // 等待CAN1退出初始化模式
          }
        
          while (1) {
              
            // 发送数据
            uint8_t sendData[] = {
              0x01, 0x02, 0x03};
            CAN_SendData(sendData, sizeof(sendData));
        
            // 延时一段时间
            for (volatile uint32_t i = 0; i < 1000000; i++) {
              }
          }
        }

#### 7.3 实现的整体代码 ####

#include "stm32f4xx.h"
    
    // CAN消息结构体
    CanTxMsgTypeDef TxMessage;
    CanRxMsgTypeDef RxMessage;
    
    void CAN_Configuration(void) {
        
      // 使能CAN1时钟
      RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
    
      // CAN1初始化
      CAN_InitTypeDef CAN_InitStructure;
      CAN_InitStructure.CAN_TTCM = DISABLE;
      CAN_InitStructure.CAN_ABOM = DISABLE;
      CAN_InitStructure.CAN_AWUM = DISABLE;
      CAN_InitStructure.CAN_NART = DISABLE;
      CAN_InitStructure.CAN_RFLM = DISABLE;
      CAN_InitStructure.CAN_TXFP = DISABLE;
      CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;
      CAN_InitStructure.CAN_SJW = CAN_SJW_1tq;
      CAN_InitStructure.CAN_BS1 = CAN_BS1_8tq;
      CAN_InitStructure.CAN_BS2 = CAN_BS2_7tq;
      CAN_InitStructure.CAN_Prescaler = 10;
      CAN_Init(CAN1, &CAN_InitStructure);
    
      // CAN过滤器配置
      CAN_FilterInitTypeDef CAN_FilterInitStructure;
      CAN_FilterInitStructure.CAN_FilterNumber = 0;
      CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdMask;
      CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit;
      CAN_FilterInitStructure.CAN_FilterIdHigh = 0x0000;
      CAN_FilterInitStructure.CAN_FilterIdLow = 0x0000;
      CAN_FilterInitStructure.CAN_FilterMaskIdHigh = 0x0000;
      CAN_FilterInitStructure.CAN_FilterMaskIdLow = 0x0000;
      CAN_FilterInitStructure.CAN_FilterFIFOAssignment = CAN_FIFO0;
      CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;
      CAN_FilterInit(&CAN_FilterInitStructure);
    
      // CAN接收中断使能
      CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE);
    
      // 使能CAN1
      CAN_Cmd(CAN1, ENABLE);
    
      // NVIC中断配置
      NVIC_InitTypeDef NVIC_InitStructure;
      NVIC_InitStructure.NVIC_IRQChannel = CAN1_RX0_IRQn;
      NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
      NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
      NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
      NVIC_Init(&NVIC_InitStructure);
    }
    
    void CAN_SendData(uint8_t* data, uint8_t length) {
        
      // 填充发送消息的数据
      for (uint8_t i = 0; i < length; i++) {
        
        TxMessage.Data[i] = data[i];
      }
    
      // 设置发送消息的参数
      TxMessage.StdId = 0x123;
      TxMessage.ExtId = 0x00;
      TxMessage.IDE = CAN_Id_Standard;
      TxMessage.RTR = CAN_RTR_DATA;
      TxMessage.DLC = length;
    
      // 发送消息
      uint8_t transmissionMailbox = 0;
      CAN_Transmit(CAN1, &TxMessage);
    }
    
    void CAN1_RX0_IRQHandler(void) {
        
      if (CAN_GetITStatus(CAN1, CAN_IT_FMP0) != RESET) {
        
        // 接收到消息
        CAN_Receive(CAN1, CAN_FIFO0, &RxMessage);
    
        // 处理接收到的消息
        // ...
      }
    }
    
    int main(void) {
        
      // 初始化CAN配置
      CAN_Configuration();
    
      while ((CAN1->MSR & CAN_MSR_INAK) == CAN_MSR_INAK) {
        
        // 等待CAN1退出初始化模式
      }
    
      while (1) {
        
        // 发送数据
        uint8_t sendData[] = {
        0x01, 0x02, 0x03};
        CAN_SendData(sendData, sizeof(sendData));
    
        // 延时一段时间
        for (volatile uint32_t i = 0; i < 1000000; i++) {
        }
      }
    }

### 8. CAN通信实际案例分析 ###

在汽车电控系统中，CAN通信被广泛应用于各个控制单元之间的数据传输。例如，在引擎控制单元（ECU）中，通过CAN总线与刹车系统的控制单元、仪表盘的控制单元进行通信。引擎控制单元可以向刹车系统发送刹车指令，同时获取仪表盘上的车速和引擎转速等信息。

在工业控制系统中，CAN通信常用于连接不同的设备和传感器，以实现实时数据交换和协调工作。例如，在机器人系统中，通过CAN总线连接各个关节控制器和传感器，实现机器人的协调运动和数据传输。