STM32H723ZGT6 CAN1 CAN2 发送和接受

zq4132
已于 2023-06-20 08:59:35 修改
阅读量1.4k
点赞数
文章标签： stm32 嵌入式硬件单片机
于 2023-05-22 13:51:01 首次发布
本文链接：https://blog.csdn.net/zq4132/article/details/130805438
版权
注意：相互探讨，如有参考请不要用于盈利。
1.接上文档，本文档只关注CAN
2.Stm32CubeMX配置
2.代码
注意：相互探讨，如有参考请不要用于盈利。
/* Includes ------------------------------------------------------------------*/
#include "fdcan.h"

/* USER CODE BEGIN 0 */
#include<stdio.h>
#include<string.h>
FDCAN_TxHeaderTypeDef fdcan_TxHeader;
/* USER CODE END 0 */

FDCAN_HandleTypeDef hfdcan1;
FDCAN_HandleTypeDef hfdcan2;

/* FDCAN1 init function */
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.FrameFormat = FDCAN_FRAME_CLASSIC;
  hfdcan1.Init.Mode = FDCAN_MODE_NORMAL;
  hfdcan1.Init.AutoRetransmission = DISABLE;
  hfdcan1.Init.TransmitPause = DISABLE;
  hfdcan1.Init.ProtocolException = DISABLE;
  hfdcan1.Init.NominalPrescaler = 1;
  hfdcan1.Init.NominalSyncJumpWidth = 1;
  hfdcan1.Init.NominalTimeSeg1 = 15;
  hfdcan1.Init.NominalTimeSeg2 = 4;
  hfdcan1.Init.DataPrescaler = 1;
  hfdcan1.Init.DataSyncJumpWidth = 1;
  hfdcan1.Init.DataTimeSeg1 = 0xF;
  hfdcan1.Init.DataTimeSeg2 = 0x4;
  hfdcan1.Init.MessageRAMOffset = 0;
  hfdcan1.Init.StdFiltersNbr = 1;
  hfdcan1.Init.ExtFiltersNbr = 0;
  hfdcan1.Init.RxFifo0ElmtsNbr = 32;
  hfdcan1.Init.RxFifo0ElmtSize = FDCAN_DATA_BYTES_8;
  hfdcan1.Init.RxFifo1ElmtsNbr = 0;
  hfdcan1.Init.RxFifo1ElmtSize = FDCAN_DATA_BYTES_8;
  hfdcan1.Init.RxBuffersNbr = 0;
  hfdcan1.Init.RxBufferSize = FDCAN_DATA_BYTES_8;
  hfdcan1.Init.TxEventsNbr = 0;
  hfdcan1.Init.TxBuffersNbr = 0;
  hfdcan1.Init.TxFifoQueueElmtsNbr = 6;
  hfdcan1.Init.TxFifoQueueMode = FDCAN_TX_FIFO_OPERATION;
  hfdcan1.Init.TxElmtSize = FDCAN_DATA_BYTES_8;
  if (HAL_FDCAN_Init(&hfdcan1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN FDCAN1_Init 2 */
	printf("%lx\r\n",SRAMCAN_BASE);
	printf("%x\r\n",hfdcan1.msgRam.EndAddress);
	FDCAN1_RX_Filter_Init();
	HAL_FDCAN_Start(&hfdcan1); 
	
  /* USER CODE END FDCAN1_Init 2 */

}
/* FDCAN2 init function */
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.FrameFormat = FDCAN_FRAME_CLASSIC;
  hfdcan2.Init.Mode = FDCAN_MODE_NORMAL;
  hfdcan2.Init.AutoRetransmission = DISABLE;
  hfdcan2.Init.TransmitPause = DISABLE;
  hfdcan2.Init.ProtocolException = DISABLE;
  hfdcan2.Init.NominalPrescaler = 1;
  hfdcan2.Init.NominalSyncJumpWidth = 1;
  hfdcan2.Init.NominalTimeSeg1 = 15;
  hfdcan2.Init.NominalTimeSeg2 = 4;
  hfdcan2.Init.DataPrescaler = 1;
  hfdcan2.Init.DataSyncJumpWidth = 1;
  hfdcan2.Init.DataTimeSeg1 = 15;
  hfdcan2.Init.DataTimeSeg2 = 4;
  hfdcan2.Init.MessageRAMOffset = 0x406;
  hfdcan2.Init.StdFiltersNbr = 1;
  hfdcan2.Init.ExtFiltersNbr = 0;
  hfdcan2.Init.RxFifo0ElmtsNbr = 0;
  hfdcan2.Init.RxFifo0ElmtSize = FDCAN_DATA_BYTES_8;
  hfdcan2.Init.RxFifo1ElmtsNbr = 32;
  hfdcan2.Init.RxFifo1ElmtSize = FDCAN_DATA_BYTES_8;
  hfdcan2.Init.RxBuffersNbr = 0;
  hfdcan2.Init.RxBufferSize = FDCAN_DATA_BYTES_8;
  hfdcan2.Init.TxEventsNbr = 0;
  hfdcan2.Init.TxBuffersNbr = 0;
  hfdcan2.Init.TxFifoQueueElmtsNbr = 6;
  hfdcan2.Init.TxFifoQueueMode = FDCAN_TX_FIFO_OPERATION;
  hfdcan2.Init.TxElmtSize = FDCAN_DATA_BYTES_8;
  if (HAL_FDCAN_Init(&hfdcan2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN FDCAN2_Init 2 */
	FDCAN2_RX_Filter_Init();
	HAL_FDCAN_Start(&hfdcan2);
	
  /* USER CODE END FDCAN2_Init 2 */

}

static uint32_t HAL_RCC_FDCAN_CLK_ENABLED=0;

void HAL_FDCAN_MspInit(FDCAN_HandleTypeDef* fdcanHandle)
{

  GPIO_InitTypeDef GPIO_InitStruct = {0};
  if(fdcanHandle->Instance==FDCAN1)
  {
  /* USER CODE BEGIN FDCAN1_MspInit 0 */

  /* USER CODE END FDCAN1_MspInit 0 */
    /* FDCAN1 clock enable */
    HAL_RCC_FDCAN_CLK_ENABLED++;
    if(HAL_RCC_FDCAN_CLK_ENABLED==1){
      __HAL_RCC_FDCAN_CLK_ENABLE();
    }

    __HAL_RCC_GPIOA_CLK_ENABLE();
    /**FDCAN1 GPIO Configuration
    PA11     ------> FDCAN1_RX
    PA12     ------> FDCAN1_TX
    */
    GPIO_InitStruct.Pin = GPIO_PIN_11|GPIO_PIN_12;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF9_FDCAN1;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    /* FDCAN1 interrupt Init */
    HAL_NVIC_SetPriority(FDCAN1_IT0_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(FDCAN1_IT0_IRQn);
  /* USER CODE BEGIN FDCAN1_MspInit 1 */

  /* USER CODE END FDCAN1_MspInit 1 */
  }
  else if(fdcanHandle->Instance==FDCAN2)
  {
  /* USER CODE BEGIN FDCAN2_MspInit 0 */

  /* USER CODE END FDCAN2_MspInit 0 */
    /* FDCAN2 clock enable */
    HAL_RCC_FDCAN_CLK_ENABLED++;
    if(HAL_RCC_FDCAN_CLK_ENABLED==1){
      __HAL_RCC_FDCAN_CLK_ENABLE();
    }

    __HAL_RCC_GPIOB_CLK_ENABLE();
    /**FDCAN2 GPIO Configuration
    PB12     ------> FDCAN2_RX
    PB6     ------> FDCAN2_TX
    */
    GPIO_InitStruct.Pin = GPIO_PIN_12;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    GPIO_InitStruct.Alternate = GPIO_AF9_FDCAN2;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = GPIO_PIN_6;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF9_FDCAN2;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    /* FDCAN2 interrupt Init */
    HAL_NVIC_SetPriority(FDCAN2_IT0_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(FDCAN2_IT0_IRQn);
  /* USER CODE BEGIN FDCAN2_MspInit 1 */

  /* USER CODE END FDCAN2_MspInit 1 */
  }
}

void HAL_FDCAN_MspDeInit(FDCAN_HandleTypeDef* fdcanHandle)
{

  if(fdcanHandle->Instance==FDCAN1)
  {
  /* USER CODE BEGIN FDCAN1_MspDeInit 0 */

  /* USER CODE END FDCAN1_MspDeInit 0 */
    /* Peripheral clock disable */
    HAL_RCC_FDCAN_CLK_ENABLED--;
    if(HAL_RCC_FDCAN_CLK_ENABLED==0){
      __HAL_RCC_FDCAN_CLK_DISABLE();
    }

    /**FDCAN1 GPIO Configuration
    PA11     ------> FDCAN1_RX
    PA12     ------> FDCAN1_TX
    */
    HAL_GPIO_DeInit(GPIOA, GPIO_PIN_11|GPIO_PIN_12);

    /* FDCAN1 interrupt Deinit */
    HAL_NVIC_DisableIRQ(FDCAN1_IT0_IRQn);
  /* USER CODE BEGIN FDCAN1_MspDeInit 1 */

  /* USER CODE END FDCAN1_MspDeInit 1 */
  }
  else if(fdcanHandle->Instance==FDCAN2)
  {
  /* USER CODE BEGIN FDCAN2_MspDeInit 0 */

  /* USER CODE END FDCAN2_MspDeInit 0 */
    /* Peripheral clock disable */
    HAL_RCC_FDCAN_CLK_ENABLED--;
    if(HAL_RCC_FDCAN_CLK_ENABLED==0){
      __HAL_RCC_FDCAN_CLK_DISABLE();
    }

    /**FDCAN2 GPIO Configuration
    PB12     ------> FDCAN2_RX
    PB6     ------> FDCAN2_TX
    */
    HAL_GPIO_DeInit(GPIOB, GPIO_PIN_12|GPIO_PIN_6);

    /* FDCAN2 interrupt Deinit */
    HAL_NVIC_DisableIRQ(FDCAN2_IT0_IRQn);
  /* USER CODE BEGIN FDCAN2_MspDeInit 1 */

  /* USER CODE END FDCAN2_MspDeInit 1 */
  }
}

/* USER CODE BEGIN 1 */

/**
  * 函数功能: 设置并初始化滤波器0,供FDCAN1使用
  * 输入参数: void     
  * 返回值：  void
  */
void FDCAN1_RX_Filter_Init(void)
{
	 FDCAN_FilterTypeDef hfdcan1_RX_Filter;   /* FDCAN1滤波器0对象句柄 */
   
	 hfdcan1_RX_Filter.IdType = FDCAN_STANDARD_ID;              /* 只接收标准帧ID */
   hfdcan1_RX_Filter.FilterIndex = 0;                         /* 滤波器索引0 */
   hfdcan1_RX_Filter.FilterType = FDCAN_FILTER_MASK;          /* 滤波器类型 */
   hfdcan1_RX_Filter.FilterConfig = FDCAN_FILTER_TO_RXFIFO0;  /* 滤波器关联到RXFIFO0 */
   hfdcan1_RX_Filter.FilterID1 = 0x111;                       /* 滤波ID1: 0x00 */
   hfdcan1_RX_Filter.FilterID2 = 0x7FF; /* 滤波ID2: 0x00 */
   HAL_FDCAN_ConfigFilter(&hfdcan1,&hfdcan1_RX_Filter);       /* 看看滤波器有没有创建成功 */
   /* HAL_FDCAN_ConfigGlobalFilter()
    * 参数2：设置标准帧ID，接收的报文ID没有匹配上滤波器时，选择拒绝接收(没有匹配上时,可以选择放入FIFO0或者FIFO1)。
    * 参数3：设置拓展帧ID，接收的报文ID没有匹配上滤波器时，选择拒绝接收。
    * 参数4：设置是否拒绝远程标准帧，ENABLE代表拒绝接收。
    * 参数5：设置是否拒绝远程拓展帧，ENABLE代表拒绝接收。
    */
   HAL_FDCAN_ConfigGlobalFilter(&hfdcan1,FDCAN_REJECT,FDCAN_REJECT,DISABLE,ENABLE); /* 设置FDCAN1滤波器0全局配置  */
	 HAL_FDCAN_ActivateNotification(&hfdcan1,FDCAN_IT_RX_FIFO0_NEW_MESSAGE,0);
}

/**
  * 函数功能: 设置并初始化滤波器1,供FDCAN2使用
  * 输入参数: void         
  * 返回值：  void
  */
void FDCAN2_RX_Filter_Init(void)
{
	 FDCAN_FilterTypeDef hfdcan2_RX_Filter;   /* FDCAN2滤波器0对象句柄 */
   
	 hfdcan2_RX_Filter.IdType = FDCAN_STANDARD_ID;              /* 只接收标准帧ID */
   hfdcan2_RX_Filter.FilterIndex = 0;                         /* 滤波器索引0 */
   hfdcan2_RX_Filter.FilterType = FDCAN_FILTER_MASK;          /* 滤波器类型(允许接收报文的ID范围是FilterID1至FilterID2 */
   hfdcan2_RX_Filter.FilterConfig = FDCAN_FILTER_TO_RXFIFO1;  /* 滤波器关联到RXFIFO1 */
   hfdcan2_RX_Filter.FilterID1 = 0x111;                       /* 滤波ID1: 0x00 */
   hfdcan2_RX_Filter.FilterID2 = 0x7FF;                      /* 滤波ID2:   0x00 */
   HAL_FDCAN_ConfigFilter(&hfdcan2,&hfdcan2_RX_Filter);       /* 看看滤波器有没有创建成功 */

   /* HAL_FDCAN_ConfigGlobalFilter()
    * 参数2：设置标准帧ID，接收的报文ID没有匹配上滤波器时，选择拒绝接收(没有匹配上时,可以选择放入FIFO0或者FIFO1)。
    * 参数3：设置拓展帧ID，接收的报文ID没有匹配上滤波器时，选择拒绝接收。
    * 参数4：设置是否拒绝远程标准帧，ENABLE代表拒绝接收。
    * 参数5：设置是否拒绝远程拓展帧，ENABLE代表拒绝接收。
    */
   HAL_FDCAN_ConfigGlobalFilter(&hfdcan2,FDCAN_REJECT,FDCAN_REJECT,DISABLE,ENABLE); /* 设置FDCAN1滤波器1全局配置  */
	 HAL_FDCAN_ActivateNotification(&hfdcan2,FDCAN_IT_RX_FIFO1_NEW_MESSAGE,0);
}

/**
  * 函数功能: FDCAN2启动
  * 输入参数: uint8_t  canordernumber  CAN1 为1 CAN2为2   
  * 输入参数: uint8_t  sendcanid  发送数据的canid 
	* 输入参数: uint8_t* msg  发送数据的数组
	* 输入参数: uint32_t len  发送数据的长度
  * 返回值：  uint8_t  成功返回数据1 失败返回数据0
  * 说明:     
  */
uint8_t FDCAN_Send_Msg(uint8_t canordernumber,uint32_t sendcanid,uint8_t* msg,uint32_t len)
{	
	  static uint8_t msgdata[10]={0};
		memcpy(msgdata,msg,len);
    fdcan_TxHeader.Identifier=sendcanid;                      //32位ID
    fdcan_TxHeader.IdType=FDCAN_STANDARD_ID;                  //标准ID
    fdcan_TxHeader.TxFrameType=FDCAN_DATA_FRAME;              //数据帧
    fdcan_TxHeader.DataLength=FDCAN_DLC_BYTES_8;              //数据长度
    fdcan_TxHeader.ErrorStateIndicator=FDCAN_ESI_ACTIVE;            
    fdcan_TxHeader.BitRateSwitch=FDCAN_BRS_OFF;               //关闭速率切换
    fdcan_TxHeader.FDFormat=FDCAN_CLASSIC_CAN;                //传统的CAN模式
    fdcan_TxHeader.TxEventFifoControl=FDCAN_NO_TX_EVENTS;     //无发送事件
    fdcan_TxHeader.MessageMarker=0;                           
    
		if(canordernumber==1)
		{
				if(HAL_FDCAN_AddMessageToTxFifoQ(&hfdcan1,&fdcan_TxHeader,msgdata)!=HAL_OK) return 1;//发送
		}
		else if(canordernumber==2)
		{
				if(HAL_FDCAN_AddMessageToTxFifoQ(&hfdcan2,&fdcan_TxHeader,msgdata)!=HAL_OK) return 1;//发送
		}
    return 0;	
}

/**
  * 函数功能: FIFO0的接收中断回调函数
  * 输入参数: RxFifo0ITs：返回标志位
  * 返回值：  void
  * 说明:
  *      1.FDCAN1使用RXFIFO0
  */
void HAL_FDCAN_RxFifo0Callback(FDCAN_HandleTypeDef *hfdcan, uint32_t RxFifo0ITs)
{
		uint8_t i=0;
    uint8_t rxdata[8];
	  FDCAN_RxHeaderTypeDef FDCAN1_RxHeader;
    if((RxFifo0ITs&FDCAN_IT_RX_FIFO0_NEW_MESSAGE)!=RESET)   //FIFO0新数据中断
    {
        //提取FIFO0中接收到的数据
        HAL_FDCAN_GetRxMessage(hfdcan,FDCAN_RX_FIFO0,&FDCAN1_RxHeader,rxdata);
        printf("id:%#x\r\n",FDCAN1_RxHeader.Identifier);
        printf("len:%d\r\n",FDCAN1_RxHeader.DataLength>>16);
        for(i=0;i<8;i++)
        printf("rxdata[%d]:%d\r\n",i,rxdata[i]);
			
				FDCAN_Send_Msg(1,FDCAN1_RxHeader.Identifier,rxdata,8);
    }
}


/**
  * 函数功能: FIFO1的接收中断回调函数
  * 输入参数: RxFifo0ITs：返回标志位
  * 返回值：  void
  * 说明:
  *     1、FDCAN2使用RXFIFO1
  */
void HAL_FDCAN_RxFifo1Callback(FDCAN_HandleTypeDef *hfdcan, uint32_t RxFifo1ITs)
{
	  uint8_t i=0;
    uint8_t rxdata[8];
	  FDCAN_RxHeaderTypeDef FDCAN2_RxHeader;
    if((RxFifo1ITs&FDCAN_IT_RX_FIFO1_NEW_MESSAGE)!=RESET)   //FIFO1新数据中断
    {
        //提取FIFO0中接收到的数据
        HAL_FDCAN_GetRxMessage(hfdcan,FDCAN_RX_FIFO1,&FDCAN2_RxHeader,rxdata);
        printf("id:%#x\r\n",FDCAN2_RxHeader.Identifier);
        printf("len:%d\r\n",FDCAN2_RxHeader.DataLength>>16);
        for(i=0;i<8;i++)
        printf("rxdata[%d]:%d\r\n",i,rxdata[i]);
			  FDCAN_Send_Msg(2,FDCAN2_RxHeader.Identifier,rxdata,8);
    }
}



/* USER CODE END 1 */