FDCAN应用说明

已于 2025-03-26 21:15:02 修改
阅读量722 收藏 27
点赞数 8
文章标签： 嵌入式硬件 c语言 单片机
于 2025-03-26 21:11:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wenbo13579/article/details/146541123
版权

FDCAN应用说明

概述

最近用到了FDCAN，下面对FDCAN的一些使用注意事项进行分析。

一些FDCAN的基本概念可以看这些文章。一文搞懂CAN FD总线协议帧格式 - 知乎、STM32H743使用FDCAN+TJA1042T配合CubeMX及HAL库实现仲裁段1M速率，数据段5M速率的FDCAN总线传输记录_stm32h743 can cubemx-CSDN博客

假设作为软件工程师，不想关注具体里面的东西，可以简单理解为每个CAN交互报文都是如下格式。ID和CRC是协议必须带的，Data0-Datan是实际要发送的内容。

1742992170894

对于FDCAN和CAN的差异，从软件侧来看，主要包括如下。由于ID和CRC要占不少东西，而且还有抢占的问题，所以一般软件能用FDCAN就用FDCAN。

CANFDCAN
Data最大长度（Bytes）864
Data段最大速度1Mbps5Mbps（其他段最大还是1Mbps）
PHY芯片普通的TJA1050就行如果要大于1Mbps，用TJA1042

ST芯片时钟配置

在STM32H5上面使用时，里面有2个FDCAN控制器，可独立使用。

但是FDCAN2的时钟配置好像必须一样，不然行为就很奇怪。其他配置没细的尝试，应该主要和红框有关，其他影响不大。

1742990990123

某种情况下，IO有限，只能使用FDCAN2时，分频系数必须配置为DIV1。

1742991169787

ST芯片FDCAN重置

FDCAN有个比较麻烦的地方，就是其是有ACK机制的，也就是发送的数据包如果没ACK（或者没接PHY转换芯片，其会监控TX和RX信号），数据包会一直在队列中。

但是应用某些情况下需要把FIFO中的数据包都清空。可以先调用HAL_FDCAN_Stop接口，再调用HAL_FDCAN_Start接口，即可重置。


void FDCAN_DeConfig(FDCAN_HandleTypeDef *hfdcan)
{
  if (HAL_FDCAN_Stop(hfdcan) != HAL_OK)
  {
    while(1);
  }
}
 
void FDCAN_Config(FDCAN_HandleTypeDef *hfdcan)
{
  ...
  
  /* Start the FDCAN module */
  if (HAL_FDCAN_Start(hfdcan) != HAL_OK)
  {
    while(1);
  }
}

void fdcan_control_restart(FDCAN_HandleTypeDef *hfdcan)
{
  FDCAN_DeConfig(hfdcan);
  FDCAN_Config(hfdcan);
}

FDCAN的TX和RX

需要注意，当有PHY芯片时，如果用逻辑分析仪看MCU的TX和RX信号，会发现TX发送任何数据，RX就会收到与之对应的数据。

这也是为什么MCU可以做到冲突规避的原理。

注意，可以把总线所有设备都拿掉，直接看TX，RX的信号。

1742991856440

FDCAN的ID唯一性

注意，注意，注意，这里每个设备最好都用一个唯一的ID来总线上交互，不然会丢包。

由于总线上每个设备都可以随时发起数据包请求，当然应用协议上做好限制，交互是响应式（Request+Response）的请求模式的话， 允许所有设备用一个ID进行交互。

因为当设备的ID相同时，假设同时发起来FDCAN请求，那FDCAN的硬件仲裁机制将无法正常工作，这时总线上很可能有多个设备同时工作，有些设备的数据包可能没发送出去，但是硬件却认为数据包已经发送成功了。这个在大规模数据压力测试时出现会恶心死。

FDCAN的拓扑结构

标准的CAN网络要求有一个总线，所有设备都接入到总线中，总线的起点和终点需要放置120欧的电阻。

1742992961448

但是实际项目中基本都不是这种情况，一般都是星形网络，支持节点的热插拔。

在这种网络中，并没有像汽车那种一根长长的总线。总线可能就是一个PCB板，留了很多接入点，设备可以用线缆连入，这个情况下，总线长度可能不到10cm，支线的长度却有2-5m的长度，这个情况下，因为不确定什么时候有设备加入，也无法决定哪个子节点需要加120欧电阻。

那这个情况下，就直接所有子节点都不加120欧电阻。通过示波器查看电压，可以看看各个节点的压降都还不错。

此外，既然已经非标了，就别使用太高速的CAN频率，使用250kbps或者500kbps即可。

1742993262907

FDCAN测试设备

协议分析怎么能少了仪器，虽然示波器已经能看很多东西了，但是业务问题还是有这种抓包仪器会好分析一些。200-300就可以抓包看了。多通道USB转CAN分析仪调试器CAN盒CANFD总线CANopen J1939OBD ZLG-淘宝网。

个人买了一个2通道的就足够用了。

1742994231445

安装上位机软件可以抓到交互的数据包。

96f18474b3f7c3b96234c4415905684

FDCAN总线示波器波形

可以看看大佬写的文章，写得很好了。用示波器排查CAN的各种错误帧（1） - 知乎

最好在每个终端节点旁边都测测其看到的差分电平压降，只要不衰减太厉害，所设计的电路和can网络拓扑就没什么问题。下面借鉴大佬的一个图，上面的相对干净了。

确保上升沿和下降沿迅速切换，别有斜坡（别用太大的电容）。

img

一个简易FDCAN控制器代码

#include <stdint.h>
#include <string.h>






FDCAN_HandleTypeDef hfdcan1;
FDCAN_HandleTypeDef hfdcan2;


/**
  * @brief This function handles FDCAN1 interrupt 0.
  */
 void FDCAN1_IT0_IRQHandler(void)
 {
   /* USER CODE BEGIN FDCAN1_IT0_IRQn 0 */
 
   /* USER CODE END FDCAN1_IT0_IRQn 0 */
   HAL_FDCAN_IRQHandler(&hfdcan1);
   /* USER CODE BEGIN FDCAN1_IT0_IRQn 1 */
 
   /* USER CODE END FDCAN1_IT0_IRQn 1 */
 }
 
/**
  * @brief This function handles FDCAN2 interrupt 0.
  */
void FDCAN2_IT0_IRQHandler(void)
{
  /* USER CODE BEGIN FDCAN2_IT0_IRQn 0 */

  /* USER CODE END FDCAN2_IT0_IRQn 0 */
  HAL_FDCAN_IRQHandler(&hfdcan2);
  /* USER CODE BEGIN FDCAN2_IT0_IRQn 1 */

  /* USER CODE END FDCAN2_IT0_IRQn 1 */
}
 
/**
  * @brief FDCAN1 Initialization Function
  * @param None
  * @retval None
  */
 static void MX_FDCAN1_Init(void)
 {
 
   /* USER CODE BEGIN FDCAN1_Init 0 */
 
   /* USER CODE END FDCAN1_Init 0 */
 
   /* USER CODE BEGIN FDCAN1_Init 1 */
 
   /* USER CODE END FDCAN1_Init 1 */
   hfdcan1.Instance = FDCAN1;
   hfdcan1.Init.ClockDivider = FDCAN_CLOCK_DIV2;
   hfdcan1.Init.FrameFormat = FDCAN_FRAME_FD_NO_BRS;
   hfdcan1.Init.Mode = FDCAN_MODE_NORMAL;
   hfdcan1.Init.AutoRetransmission = ENABLE;
   hfdcan1.Init.TransmitPause = DISABLE;
   hfdcan1.Init.ProtocolException = DISABLE;
   hfdcan1.Init.NominalPrescaler = 1;
   hfdcan1.Init.NominalSyncJumpWidth = 62;
   hfdcan1.Init.NominalTimeSeg1 = 187;
   hfdcan1.Init.NominalTimeSeg2 = 62;
   hfdcan1.Init.DataPrescaler = 2;
   hfdcan1.Init.DataSyncJumpWidth = 5;
   hfdcan1.Init.DataTimeSeg1 = 19;
   hfdcan1.Init.DataTimeSeg2 = 5;
   hfdcan1.Init.StdFiltersNbr = 1;
   hfdcan1.Init.ExtFiltersNbr = 0;
   hfdcan1.Init.TxFifoQueueMode = FDCAN_TX_FIFO_OPERATION;
   if (HAL_FDCAN_Init(&hfdcan1) != HAL_OK)
   {
    while(1);
   }
   /* USER CODE BEGIN FDCAN1_Init 2 */
 
   /* USER CODE END FDCAN1_Init 2 */
 
 }

/**
  * @brief FDCAN2 Initialization Function
  * @param None
  * @retval None
  */
 static void MX_FDCAN2_Init(void)
 {
 
   /* USER CODE BEGIN FDCAN2_Init 0 */
 
   /* USER CODE END FDCAN2_Init 0 */
 
   /* USER CODE BEGIN FDCAN2_Init 1 */
 
   /* USER CODE END FDCAN2_Init 1 */
   hfdcan2.Instance = FDCAN2;
   hfdcan2.Init.ClockDivider = FDCAN_CLOCK_DIV2;
   hfdcan2.Init.FrameFormat = FDCAN_FRAME_FD_NO_BRS;
   hfdcan2.Init.Mode = FDCAN_MODE_NORMAL;
   hfdcan2.Init.AutoRetransmission = ENABLE;
   hfdcan2.Init.TransmitPause = DISABLE;
   hfdcan2.Init.ProtocolException = DISABLE;
   hfdcan2.Init.NominalPrescaler = 1;
   hfdcan2.Init.NominalSyncJumpWidth = 62;
   hfdcan2.Init.NominalTimeSeg1 = 187;
   hfdcan2.Init.NominalTimeSeg2 = 62;
   hfdcan2.Init.DataPrescaler = 2;
   hfdcan2.Init.DataSyncJumpWidth = 5;
   hfdcan2.Init.DataTimeSeg1 = 19;
   hfdcan2.Init.DataTimeSeg2 = 5;
   hfdcan2.Init.StdFiltersNbr = 1;
   hfdcan2.Init.ExtFiltersNbr = 0;
   hfdcan2.Init.TxFifoQueueMode = FDCAN_TX_FIFO_OPERATION;
   if (HAL_FDCAN_Init(&hfdcan2) != HAL_OK)
   {
     while(1);
   }
   /* USER CODE BEGIN FDCAN2_Init 2 */
 
   /* USER CODE END FDCAN2_Init 2 */
 
 }
 
 
void FDCAN_DeConfig(FDCAN_HandleTypeDef *hfdcan)
{
  if (HAL_FDCAN_Stop(hfdcan) != HAL_OK)
  {
    while(1);
  }
}
 
void FDCAN_Config(FDCAN_HandleTypeDef *hfdcan)
{
  FDCAN_FilterTypeDef sFilterConfig;
  /* Configure Rx filter */
  sFilterConfig.IdType = FDCAN_STANDARD_ID;
  sFilterConfig.FilterIndex = 0;
  sFilterConfig.FilterType = FDCAN_FILTER_RANGE;
  if(hfdcan->Instance == FDCAN1)
  {
    sFilterConfig.FilterConfig = FDCAN_FILTER_TO_RXFIFO0;
    // sFilterConfig.FilterConfig = FDCAN_FILTER_TO_RXFIFO1;
  }
  else if(hfdcan->Instance == FDCAN2)
  {
    sFilterConfig.FilterConfig = FDCAN_FILTER_TO_RXFIFO1;
  }
  sFilterConfig.FilterID1 = 0x00000000;
  sFilterConfig.FilterID2 = 0x000007FF;
  if (HAL_FDCAN_ConfigFilter(hfdcan, &sFilterConfig) != HAL_OK)
  {
    while(1);
  }

  /* Configure global filter:
     Filter all remote frames with STD and EXT ID
     Reject non matching frames with STD ID and EXT ID */
  if (HAL_FDCAN_ConfigGlobalFilter(hfdcan, FDCAN_REJECT, FDCAN_REJECT, FDCAN_FILTER_REMOTE, FDCAN_FILTER_REMOTE) != HAL_OK)
  {
    while(1);
  }

  /* Activate Rx FIFO 0 new message notification on both FDCAN instances */
  // if (HAL_FDCAN_ActivateNotification(&hfdcan1, FDCAN_IT_RX_FIFO0_NEW_MESSAGE |
  //   FDCAN_IT_RAM_ACCESS_FAILURE | FDCAN_IT_ERROR_LOGGING_OVERFLOW | FDCAN_IT_RAM_WATCHDOG | FDCAN_IT_ARB_PROTOCOL_ERROR | FDCAN_IT_DATA_PROTOCOL_ERROR | FDCAN_IT_RESERVED_ADDRESS_ACCESS 
  //   | FDCAN_IT_ERROR_PASSIVE | FDCAN_IT_ERROR_WARNING | FDCAN_IT_BUS_OFF
  //   , 0) != HAL_OK)
  // {
  //   while(1);
  // }
  if(hfdcan->Instance == FDCAN1)
  {
    if (HAL_FDCAN_ActivateNotification(hfdcan, FDCAN_IT_RX_FIFO0_NEW_MESSAGE | FDCAN_IT_RX_FIFO0_MESSAGE_LOST | FDCAN_IT_RX_FIFO0_FULL, 0) != HAL_OK)
    {
      while(1);
    }
  }
  else
  {
    if (HAL_FDCAN_ActivateNotification(hfdcan, FDCAN_IT_RX_FIFO1_NEW_MESSAGE | FDCAN_IT_RX_FIFO1_MESSAGE_LOST | FDCAN_IT_RX_FIFO1_FULL, 0) != HAL_OK)
    {
      while(1);
    }
  }

  // if (HAL_FDCAN_ActivateNotification(hfdcan, FDCAN_IT_BUS_OFF, 0) != HAL_OK)
  // {
  //   while(1);
  // }

  /* Configure and enable Tx Delay Compensation, required for BRS mode.
        TdcOffset default recommended value: DataTimeSeg1 * DataPrescaler
        TdcFilter default recommended value: 0 */
  HAL_FDCAN_ConfigTxDelayCompensation(hfdcan, hfdcan->Init.DataPrescaler * hfdcan->Init.DataTimeSeg1, 0);
  HAL_FDCAN_EnableTxDelayCompensation(hfdcan);
  
  /* Start the FDCAN module */
  if (HAL_FDCAN_Start(hfdcan) != HAL_OK)
  {
    while(1);
  }
}

// void HAL_FDCAN_ErrorCallback(FDCAN_HandleTypeDef *hfdcan)
// {
//   printf("HAL_FDCAN_ErrorCallback, Error Code = 0x%x, State = 0x%x\r\n", hfdcan->ErrorCode, hfdcan->State);
// }

// void HAL_FDCAN_ErrorStatusCallback(FDCAN_HandleTypeDef *hfdcan, uint32_t ErrorStatusITs)
// {
//   printf("HAL_FDCAN_ErrorStatusCallback, Error Code = 0x%x, State = 0x%x, ErrorStatusITs = 0x%x\r\n", hfdcan->ErrorCode, hfdcan->State, ErrorStatusITs);
// }


int fdcan_control_get_tx_len_by_real_len(uint32_t real_len)
{
  if(real_len <= 0)
  {
    return FDCAN_DLC_BYTES_0;
  }
  else if(real_len <= 1)
  {
    return FDCAN_DLC_BYTES_1;
  }
  else if(real_len <= 2)
  {
    return FDCAN_DLC_BYTES_2;
  }
  else if(real_len <= 3)
  {
    return FDCAN_DLC_BYTES_3;
  }
  else if(real_len <= 4)
  {
    return FDCAN_DLC_BYTES_4;
  }
  else if(real_len <= 5)
  {
    return FDCAN_DLC_BYTES_5;
  }
  else if(real_len <= 6)
  {
    return FDCAN_DLC_BYTES_6;
  }
  else if(real_len <= 7)
  {
    return FDCAN_DLC_BYTES_7;
  }
  else if(real_len <= 8)
  {
    return FDCAN_DLC_BYTES_8;
  }
  else if(real_len <= 12)
  {
    return FDCAN_DLC_BYTES_12;
  }
  else if(real_len <= 16)
  {
    return FDCAN_DLC_BYTES_16;
  }
  else if(real_len <= 20)
  {
    return FDCAN_DLC_BYTES_20;
  }
  else if(real_len <= 24)
  {
    return FDCAN_DLC_BYTES_24;
  }
  else if(real_len <= 32)
  {
    return FDCAN_DLC_BYTES_32;
  }
  else if(real_len <= 48)
  {
    return FDCAN_DLC_BYTES_48;
  }
  
  return FDCAN_DLC_BYTES_64;
}

void fdcan_control_restart(FDCAN_HandleTypeDef *hfdcan)
{
  int index = hfdcan->Instance == FDCAN1 ? 0 : 1;
  EASY_LOG_ERR("fdcan_control_restart, index: %d\r\n", index);

  // reconfig fdcan
  FDCAN_DeConfig(hfdcan);
  FDCAN_Config(hfdcan);
}

int fdcan_control_tx_packet(FDCAN_HandleTypeDef *hfdcan, uint16_t id, const uint8_t *data, uint32_t len)
{
  uint8_t data_buf[64] = {0};
  int index = hfdcan->Instance == FDCAN1 ? 0 : 1;
  if(len > 64)
  {
    len = 64;
  }
  memcpy(data_buf, data, len);

  FDCAN_TxHeaderTypeDef TxHeader;
  TxHeader.Identifier = id;                 // CAN ID
  TxHeader.IdType = FDCAN_STANDARD_ID;         // 标准ID
  TxHeader.TxFrameType = FDCAN_DATA_FRAME;
  TxHeader.DataLength = fdcan_control_get_tx_len_by_real_len(len);          // 发送长度：64byte
  TxHeader.ErrorStateIndicator = FDCAN_ESI_ACTIVE;
  TxHeader.BitRateSwitch = FDCAN_BRS_OFF;
  TxHeader.FDFormat = FDCAN_FD_CAN;            // CANFD
  TxHeader.TxEventFifoControl = FDCAN_NO_TX_EVENTS;  
  TxHeader.MessageMarker = 0;


  int ret = 0;
  ret = HAL_FDCAN_AddMessageToTxFifoQ(hfdcan, &TxHeader, data_buf);
  if(ret != HAL_OK)
  {
    return 0;
  }
  else
  {
  }

  return len;
}

void HAL_FDCAN_TxBufferCompleteCallback(FDCAN_HandleTypeDef *hfdcan, uint32_t BufferIndexes)
{
    EASY_LOG_DBG("Tx complete\r\n");
}

__EASY_WEAK__ void fdcan1_control_rx_packet(uint32_t can_id, uint8_t *data, uint32_t len)
{

}

__EASY_WEAK__ void fdcan2_control_rx_packet(uint32_t can_id, uint8_t *data, uint32_t len)
{

}

static const uint8_t DLCtoBytes[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 12, 16, 20, 24, 32, 48, 64};
void HAL_FDCAN_RxFifo0Callback(FDCAN_HandleTypeDef *hfdcan, uint32_t RxFifo0ITs)
{
  FDCAN_RxHeaderTypeDef RxHeader;
  uint8_t data_buf[64] = {0};
  uint16_t data_len = 0;

  if((RxFifo0ITs & FDCAN_IT_RX_FIFO0_NEW_MESSAGE) != RESET)
  {
    // int work_cnt = 0;
    /* Retrieve Rx messages from RX FIFO0 */
    /* Check if FIFO 0 receive at least one message */
    while (HAL_FDCAN_GetRxFifoFillLevel(hfdcan, FDCAN_RX_FIFO0))
    {
      // work_cnt ++;
      // if(work_cnt > 1)
      // {
      //   printf("!!!!!!!work_cnt = %d\r\n", work_cnt);
      // }
      if (HAL_FDCAN_GetRxMessage(hfdcan, FDCAN_RX_FIFO0, &RxHeader, data_buf) != HAL_OK)
      {
        while(1);
      }

      data_len = DLCtoBytes[RxHeader.DataLength];
  
      // printf("Identifier = 0x%x\r\n", RxHeader.Identifier);
      // printf("DataLength = %d(0x%x)\r\n", data_len, RxHeader.DataLength);
      // printf("FDFormat = 0x%x\r\n", RxHeader.FDFormat);
      // printf("BitRateSwitch = %d\r\n", RxHeader.BitRateSwitch);
      // printf("ErrorStateIndicator = 0x%x\r\n", RxHeader.ErrorStateIndicator);
      // for(int i = 0; i < data_len; i++)
      // {
      //   printf("Data[%d] = 0x%x\r\n", i, can1_rxbuf[i]);
      // }

      if(hfdcan->Instance == FDCAN1)
      {
        fdcan1_control_rx_packet(RxHeader.Identifier, data_buf, data_len);
      }
      else if(hfdcan->Instance == FDCAN2)
      {
        fdcan2_control_rx_packet(RxHeader.Identifier, data_buf, data_len);
      }
    }

    /* Retrieve Rx messages from RX FIFO0 */
    // status = HAL_FDCAN_GetRxMessage(&hfdcan, FDCAN_RX_FIFO0, &RxHeader, RxData);
    // if (HAL_FDCAN_GetRxMessage(hfdcan, FDCAN_RX_FIFO0, &RxHeader, data_buf) != HAL_OK)
    // {
    //   while(1);
    // }

    
  }
  
  if((RxFifo0ITs & FDCAN_IT_RX_FIFO0_MESSAGE_LOST) != RESET)
  {
   EASY_LOG_DBG("Rx FIFO0 message lost\r\n");
  }
  
  if((RxFifo0ITs & FDCAN_IT_RX_FIFO0_FULL) != RESET)
  {
   EASY_LOG_DBG("Rx FIFO0 message full\r\n");
  }
}



void HAL_FDCAN_RxFifo1Callback(FDCAN_HandleTypeDef *hfdcan, uint32_t RxFifo1ITs)
{
  FDCAN_RxHeaderTypeDef RxHeader;
  uint8_t data_buf[64] = {0};
  uint16_t data_len = 0;

  if((RxFifo1ITs & FDCAN_IT_RX_FIFO1_NEW_MESSAGE) != RESET)
  {
    // int work_cnt = 0;
    /* Retrieve Rx messages from RX FIFO1 */
    /* Check if FIFO 0 receive at least one message */
    while (HAL_FDCAN_GetRxFifoFillLevel(hfdcan, FDCAN_RX_FIFO1))
    {
      // work_cnt ++;
      // if(work_cnt > 1)
      // {
      //   printf("!!!!!!!work_cnt = %d\r\n", work_cnt);
      // }
      if (HAL_FDCAN_GetRxMessage(hfdcan, FDCAN_RX_FIFO1, &RxHeader, data_buf) != HAL_OK)
      {
        while(1);
      }

      data_len = DLCtoBytes[RxHeader.DataLength];
  
      // printf("Identifier = 0x%x\r\n", RxHeader.Identifier);
      // printf("DataLength = %d(0x%x)\r\n", data_len, RxHeader.DataLength);
      // printf("FDFormat = 0x%x\r\n", RxHeader.FDFormat);
      // printf("BitRateSwitch = %d\r\n", RxHeader.BitRateSwitch);
      // printf("ErrorStateIndicator = 0x%x\r\n", RxHeader.ErrorStateIndicator);
      // for(int i = 0; i < data_len; i++)
      // {
      //   printf("Data[%d] = 0x%x\r\n", i, can1_rxbuf[i]);
      // }

      if(hfdcan->Instance == FDCAN1)
      {
        fdcan1_control_rx_packet(RxHeader.Identifier, data_buf, data_len);
      }
      else if(hfdcan->Instance == FDCAN2)
      {
        fdcan2_control_rx_packet(RxHeader.Identifier, data_buf, data_len);
      }
    }

    /* Retrieve Rx messages from RX FIFO1 */
    // status = HAL_FDCAN_GetRxMessage(&hfdcan, FDCAN_RX_FIFO1, &RxHeader, RxData);
    // if (HAL_FDCAN_GetRxMessage(hfdcan, FDCAN_RX_FIFO1, &RxHeader, data_buf) != HAL_OK)
    // {
    //   while(1);
    // }

    
  }
  
  if((RxFifo1ITs & FDCAN_IT_RX_FIFO1_MESSAGE_LOST) != RESET)
  {
   EASY_LOG_DBG("Rx FIFO1 message lost\r\n");
  }
  
  if((RxFifo1ITs & FDCAN_IT_RX_FIFO1_FULL) != RESET)
  {
   EASY_LOG_DBG("Rx FIFO1 message full\r\n");
  }
}



int fdcan_control_init(void)
{
    EASY_LOG_DBG("fdcan_control_init\n");

    MX_FDCAN1_Init();
    MX_FDCAN2_Init();

    return 0;
}
来可电子车载CANFD数据记录仪使用教程
weixin_66730120的博客
11-02 576
LKMaster，新建一个项目文件之后，点击“设备管理”查找设备-查找WiFi设备，点击选择设备，如果有弹出设备校时提醒，点击YES，需要长时间记录钱，最好打开软件进行一次校时。可以选择报文文件格式ASC/BLF/BIN，ASC格式中，如果记录的全部是CAN报文，建议选择ASC7.0，如果记录的报文中有CANFD数据，选择ASC11.0。点击查看记录文件，即可查看文件列表，文件名即为开始记录的时间戳，比如此文件为2023年10月31日 开始的三分钟的数据文件（前面设置的记录时间）
STM32H743使用FDCAN+TJA1042T配合CubeMX及HAL库实现仲裁段1M速率，数据段5M速率的FDCAN总线传输记录
weixin_43642862的博客
02-04 2584
STM32H743自带CAN控制器，外部需要加一个CAN收发器，即可实现CAN总线通信本次使用TJA1042T作为CAN收发器，进行FDCAN通信，其中仲裁的波特率为1M，数据段波特兰为5M下面直接上配置及代码。
STM32H723串口接收全为0 & CAN错误中断问题
weixin_38743772的博客
11-03 3000
STM32H723串口接收全为0 和 叠加的导致CAN错误问题
STM32CubeMX与HAL库学习--简单的CAN回环测试
weixin_45209978的博客
08-22 3570
STM32CubeMX与HAL库学习--简单的CAN回环测试前言STM32CubeMX生成初始化代码在MDK-ARM里编辑代码其他 前言 本人小白，最近看了CAN协议与STM32的bxCAN外设的一些资料，简单地做个CAN回环测试练习一下。这只是一个初学者的简单练习记录，学习的话还是要看对应的教程啦。 使用到的工具及版本： STM32CubeMX版本：6.3.0 HAL库:STM32CubeF4 Firmware Package V1.26.1 MDK-ARM：V5.32.0.0 开发板：野火的霸天虎开发板
STM32 CAN/CANFD软件快速配置（HAL库版本）
ShenZhen_zixian的博客
09-09 9868
控制器局域网总线（CAN，Controller Area Network）是一种用于实时应用的串行通讯协议总线，它可以使用双绞线来传输信号，是世界上应用最广泛的现场总线之一。CAN协议用于汽车中各种不同元件之间的通信，以此取代昂贵而笨重的配电线束。该协议的健壮性使其用途延伸到其他自动化和工业应用。CAN协议的特性包括完整性的串行数据通讯、提供实时支持、传输速率高达1Mb/s、同时具有11位的寻址以及检错能力。
STM32 FDCAN调试
圆桌骑士的博客
12-20 6559
工具： KEIL5.23 cubemx 6.0.1 广成科技USBCAN卡 步骤1：cubemx生成基础工程 1 时钟配置比较简单，不做介绍，CAN时钟配置成80Mhz，根据“Prescaler”“Seg1”“Seg2”计算可得到波特率位500kbps（Nominal和Data可以设置为不同波特率，这里为了方便，均设置为500K）。 2 Can发送配置。一定要把“Tx Fifo Queue Elmts Nbr”“Tx Fifo Queue Mode”“Tx Elmt Size”设置如下所示.
STM32H7实现FDCAN通信系统的设计与应用
不过，基于文件名称“基于STM32H7的FDCAN通信系统设计与实现.pdf”，我们可以推测文档内容应该涵盖了上述提及的知识点，并且会以更详细的技术说明、配置步骤、编程示例以及测试结果的形式展现。文档可能会对STM32H7...
FDcan中断
03-08
这段C语言脚本说明了怎样从指定缓冲区读取有效载荷以及传递至更高层次的应用处理器进行后续分析[^3]。 #### 错误恢复策略 考虑到通信过程中可能出现的各种错误状况（如位填充错乱、CRC校验失败等），建议开发者仔细...
fdcan通讯
最新发布
03-21
错误排查部分需要详细说明常见的错误类型，比如位错误、CRC错误等，以及如何通过工具如示波器或专用分析仪来诊断问题，特别是引用[3]中的例子，错误出现在数据段的特定位置，可以举例说明如何处理位错误。...
stm32_can_fdcan源码.zip
09-29
7. **文档**：虽然标签没有提及，但源码包中可能附带了关于CAN和FDCAN接口的使用说明或教程，这对于初学者理解和使用这些功能非常有帮助。 总之，通过分析和理解"stm32_can_fdcan源码.zip"中的源代码，开发者可以...
stm32fdcan
01-08
特别是针对不同系列MCU的具体实现细节给予了充分说明，这对于理解如何高效利用FDCAN接口尤为关键。 #### 配置工具的支持 除了阅读理论性的指导材料之外，实际操作中的配置同样重要。通过STM32CubeMX图形化界面可以...
理解CAN-FD发送模式讲解
ABC15570925784的博客
08-02 5478
TXQUEUE 的发送方式为专用发送队列，最大支持 32 个深度的发送队列，将需要放的发送的数据放入发送队列之后，硬件会根据报文的帧 ID 不同，按照帧 ID 数值越小的先发送，例如压了2帧数据，帧 ID 分别是 0x101 和 0X102，先压入 0x102 在压入 0x101 ，那么先发出去的消息是 0x101 的报文。TXFIFO 的发送方式为先入先出，最大支持 32 个深度的发送 FIFO，将需要放的发送的数据放入发送 FIFO 之后，硬件会根据报文的放入的顺序，依次发送。
STM32H750 更好用的CANFD 用例详解
热门推荐
weifengdq的专栏
02-23 1万+
目录前言Message RAM分配STM32工程搭建串口配置100us定时器FDCAN配置Bus-Off处理新消息接收处理发送处理使用Xavier配合测试一下完整工程下载关于用作Classic CAN微信公众号 前言 参考前几篇: Jetson Xavier/XavierNX/TX2 CANFD 配置使用 STM32 CANFD 基础知识 STM32G474 CANFD 用例详解 STM32H7系列的FDCAN目前最大也支持3路, 如STM32H730/723/725/733/735等, Message
STM32G474 CANFD 用例详解
weifengdq的专栏
02-22 1万+
目录前景提要STM32工程搭建串口配置100us定时器FDCAN配置Bus-Off处理新消息接收处理发送处理使用Xavier配合测试一下完整工程下载关于用作Classic CAN微信公众号 前景提要 CANFD基础知识可参考前篇: Jetson Xavier/XavierNX/TX2 CANFD 配置使用 STM32 CANFD 基础知识 本篇用起来, 连接关系如下: CAN收发器均选用支持2M及以上CANFD的收费器, LPUART到PC用STLINK连接. STM32工程搭建 STM32CubeM
【保持更新】记录单片机调试过程中遇到的坑
Rysin的博客
10-20 2642
记录STM32调试过程中遇到的一些坑假装这是一个目录？零、 CubeMX1.发现新大陆一、串口与DMA1.配置与使用2.串口中断与DMA3.串口中断异常二、PWM三、FDCAN1.CAN波特率=APB频率/BRP分频器/ （1+tBS1+tBS2）2.CAN配置为发送的时候，数据长度的是在第16位开始设置！！3.CAN配置为接收的时候，HAL_FDCAN_ConfigGlobalFilter（函数的第二和第三个参数要正确配置，网上的教程会让整Reject，结果是一直进不了中断）4.CAN接收时候会回调 HA
【CAN开发】STM32 FDCAN(CAN-FD) Controller（FDCAN控制器）外设开发
m0_74209072的博客
10-29 4526
介绍STM32 FDCAN外设：这里主要是讲FDCAN与CAN的区别STM32H7 FDCAN兼容普通CAN使用 基于CubeMX配置_stm32cubeide h7配置fdcan作为普通can-CSDN博客STM32 CAN使用记录：FDCAN基础通讯_stm32 canfd-CSDN博客CAN基础概念_can时钟40mhz-CSDN博客STM32H7系列FDCAN配置成经典CAN的经验教程和注意事项_stm32h7 can-CSDN博客。
CAN通信(二)
金凯*博客
09-24 1822
FDCAN,CAN,HAL库程序
基于HAL库的CAN通信二：通信调试（基于STM32CUBE FW_F1 V1.8.5）
sdhj21的博客
06-12 1223
注意： 部分STM32芯片有2路CAN控制器，使用CAN2时也需要打开CAN时钟。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

CoderBob

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值