motor_ctl-3/Core/Src/can.c

/**
  ******************************************************************************
  * File Name          : CAN.c
  * Description        : This file provides code for the configuration
  *                      of the CAN instances.
  ******************************************************************************
  ** This notice applies to any and all portions of this file
  * that are not between comment pairs USER CODE BEGIN and
  * USER CODE END. Other portions of this file, whether 
  * inserted by the user or by software development tools
  * are owned by their respective copyright owners.
  *
  * COPYRIGHT(c) 2019 STMicroelectronics
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
  *   1. Redistributions of source code must retain the above copyright notice,
  *      this list of conditions and the following disclaimer.
  *   2. Redistributions in binary form must reproduce the above copyright notice,
  *      this list of conditions and the following disclaimer in the documentation
  *      and/or other materials provided with the distribution.
  *   3. Neither the name of STMicroelectronics nor the names of its contributors
  *      may be used to endorse or promote products derived from this software
  *      without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  ******************************************************************************
  */

/* Includes ------------------------------------------------------------------*/
#include "can.h"

#include "gpio.h"

/* USER CODE BEGIN 0 */
CanTxMsgTypeDef CAN_TxMessaage;
CanRxMsgTypeDef CAN_RxMessaage;

uint8_t CAN_RxBuf_PBU[255];
CAN_Buf_TypeDef CAN_RxBuf_Struct_PBU = {0,255,0,0,0,0,CAN_RxBuf_PBU,0,FALSE};
uint8_t CAN_RxBuf_BMS[255];
CAN_Buf_TypeDef CAN_RxBuf_Struct_BMS = {0,255,0,0,0,0,CAN_RxBuf_BMS,0,FALSE};
uint8_t CAN_RxBuf_HMI[255];
CAN_Buf_TypeDef CAN_RxBuf_Struct_HMI = {0,255,0,0,0,0,CAN_RxBuf_HMI,0,FALSE};
uint8_t CAN_RxBuf_CDL[255];
CAN_Buf_TypeDef CAN_RxBuf_Struct_CDL = {0,255,0,0,0,0,CAN_RxBuf_CDL,0,FALSE};

/* USER CODE END 0 */

CAN_HandleTypeDef hcan;

/* CAN init function */
void MX_CAN_Init(void)
{

  hcan.Instance = CAN1;
  hcan.Init.Prescaler = 48;
  hcan.Init.Mode = CAN_MODE_NORMAL;
  hcan.Init.SJW = CAN_SJW_1TQ;
  hcan.Init.BS1 = CAN_BS1_4TQ;
  hcan.Init.BS2 = CAN_BS2_1TQ;
  hcan.Init.TTCM = DISABLE;
  hcan.Init.ABOM = ENABLE;
  hcan.Init.AWUM = DISABLE;
  hcan.Init.NART = DISABLE;
  hcan.Init.RFLM = DISABLE;
  hcan.Init.TXFP = DISABLE;
  if (HAL_CAN_Init(&hcan) != HAL_OK)
  {
    _Error_Handler(__FILE__, __LINE__);
  }
}

void HAL_CAN_MspInit(CAN_HandleTypeDef* canHandle)
{

  GPIO_InitTypeDef GPIO_InitStruct;
  if(canHandle->Instance==CAN1)
  {
  /* USER CODE BEGIN CAN1_MspInit 0 */

  /* USER CODE END CAN1_MspInit 0 */
    /* CAN1 clock enable */
    __HAL_RCC_CAN1_CLK_ENABLE();
  
    /**CAN GPIO Configuration    
    PB8     ------> CAN_RX
    PB9     ------> CAN_TX 
    */
    GPIO_InitStruct.Pin = GPIO_PIN_8;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = GPIO_PIN_9;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    __HAL_AFIO_REMAP_CAN1_2();

    /* CAN1 interrupt Init */
    HAL_NVIC_SetPriority(USB_LP_CAN1_RX0_IRQn, 1, 1);
    HAL_NVIC_EnableIRQ(USB_LP_CAN1_RX0_IRQn);
  /* USER CODE BEGIN CAN1_MspInit 1 */
    canHandle->pTxMsg = &CAN_TxMessaage;
		canHandle->pRxMsg = &CAN_RxMessaage;
		CANFilterConfig_Scale32_IdMask_StandardIdOnly();
		__HAL_CAN_ENABLE_IT(&hcan, CAN_IT_FMP0);		
  /* USER CODE END CAN1_MspInit 1 */
  }
}

void HAL_CAN_MspDeInit(CAN_HandleTypeDef* canHandle)
{

  if(canHandle->Instance==CAN1)
  {
  /* USER CODE BEGIN CAN1_MspDeInit 0 */

  /* USER CODE END CAN1_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_CAN1_CLK_DISABLE();
  
    /**CAN GPIO Configuration    
    PB8     ------> CAN_RX
    PB9     ------> CAN_TX 
    */
    HAL_GPIO_DeInit(GPIOB, GPIO_PIN_8|GPIO_PIN_9);

    /* CAN1 interrupt Deinit */
    HAL_NVIC_DisableIRQ(USB_LP_CAN1_RX0_IRQn);
  /* USER CODE BEGIN CAN1_MspDeInit 1 */

  /* USER CODE END CAN1_MspDeInit 1 */
  }
} 

/* USER CODE BEGIN 1 */
//CAN接收数据处理
void CAN_Rx_ISR(CAN_Buf_TypeDef*ptCANRx,uint8_t ucLength)
{
	for(uint8_t i=0;i<ucLength;i++)
	{
		*((* ptCANRx).pcBufAddr + (* ptCANRx).ucBufWrInde) = hcan.pRxMsg->Data[i];         
		if(++(* ptCANRx).ucBufWrInde >= (* ptCANRx).ucBufSize)
		{
			(* ptCANRx).ucBufWrInde = 0; 
		}	
		if(++(* ptCANRx).ucBufCnt > (* ptCANRx).ucBufSize)  
		{
			(* ptCANRx).ucBufCnt = (* ptCANRx).ucBufSize;  
			(* ptCANRx).ucBufOvf = 1;
		}
	}		   	
}

void HAL_CAN_RxCpltCallback(CAN_HandleTypeDef *CanHandle)
{
	if((CanHandle->pRxMsg->IDE != CAN_ID_STD)||(CanHandle->pRxMsg->DLC == 0))
  {
		__HAL_CAN_ENABLE_IT(&hcan, CAN_IT_FMP0);//开接收中断
		return;
	}  
	switch(CanHandle->pRxMsg->StdId)
	{
	  case ID_PBU_BC: case ID_PBU_TO_MC://接收PBU数据
		{
		  CAN_RxBuf_Struct_PBU.ucBufID = CanHandle->pRxMsg->StdId;
			CAN_Rx_ISR(&CAN_RxBuf_Struct_PBU,CanHandle->pRxMsg->DLC);
			break;
		}
		case ID_BMS_BC: case ID_BMS_TO_MC://接收BMS数据
		{
		  CAN_RxBuf_Struct_BMS.ucBufID = CanHandle->pRxMsg->StdId;
			CAN_Rx_ISR(&CAN_RxBuf_Struct_BMS,CanHandle->pRxMsg->DLC);
			break;
		}
		case ID_HMI_BC: case ID_HMI_TO_MC://接收HMI数据
		{
		  CAN_RxBuf_Struct_HMI.ucBufID = CanHandle->pRxMsg->StdId;
			CAN_Rx_ISR(&CAN_RxBuf_Struct_HMI,CanHandle->pRxMsg->DLC);
			break;
		}
		case ID_CDL_BC: case ID_CDL_TO_MC:case ID_CDL_TO_MC_TE://接收CDL数据
		{
		  CAN_RxBuf_Struct_CDL.ucBufID = CanHandle->pRxMsg->StdId;
			CAN_Rx_ISR(&CAN_RxBuf_Struct_CDL,CanHandle->pRxMsg->DLC);
			break;
		}
		default:break;
	}
	__HAL_CAN_ENABLE_IT(&hcan, CAN_IT_FMP0);//开接收中断
}

//CAN发送数据
void CAN_SendData(uint16_t ID, uint8_t *Data, uint16_t Length)
{
  uint16_t LastPacketLen, PacketNum;
	uint16_t i,j;
	
	if(Length > 0)
	{
	  //计算分包个数
		LastPacketLen = Length % 8;//最后一个数据包长度
		if(LastPacketLen == 0)
		{
		  LastPacketLen = 8;
			PacketNum = Length / 8;
		}
		else
		{
	  	PacketNum = Length / 8 + 1;
		}
		//开始发送数据
		hcan.pTxMsg->StdId = ID;
	  hcan.pTxMsg->RTR = CAN_RTR_DATA;
	  hcan.pTxMsg->IDE = CAN_ID_STD;
		//发送前（PacketNum - 1）个数据包
		for(i = 0;i < (PacketNum - 1); i++)
		{
		  hcan.pTxMsg->DLC = 8;
			for(j = 0;j < 8;j++)
			{
			  hcan.pTxMsg->Data[j] = Data[8 * i + j];
			}
			if(HAL_CAN_Transmit(&hcan, 10) == HAL_ERROR)
		  {
		    MX_CAN_Init();
		  }
		}
		//发送最后一个数据包
		hcan.pTxMsg->DLC = LastPacketLen;
		for(j = 0;j < LastPacketLen;j++)
		{
			hcan.pTxMsg->Data[j] = Data[8 * i + j];
		}
		if(HAL_CAN_Transmit(&hcan, 10) == HAL_ERROR)
		{
		  MX_CAN_Init();
		}
	}
}

//过滤器设置
void CANFilterConfig_Scale32_IdMask_StandardIdOnly(void)
{
  CAN_FilterConfTypeDef  sFilterConfig;  
  
	//设置过滤器组0，指定接收发送给PBU的数据
  sFilterConfig.FilterNumber = 0;//使用过滤器0             
  sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK;//配置为掩码模式   
  sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT;//设置为32位宽 
	
  //过滤寄存器判断接收的报文ID,符合过滤寄存器的则接收
  //屏蔽寄存器判断接收的报文ID,符合屏蔽寄存器的则丢弃
  //当屏蔽寄存器的某位为0时,过滤寄存器的相应位不起作用,即信息标识符相应位无论是0还是1都会被接收
  //当屏蔽寄存器的某位为1时,信息标识符相应位与过滤器的相应位必须一致才能接收
	//设置过滤寄存器
  //(0x701 & 0x605)=601
  //0X601<<21 0110 0000 0001 <<21 --> 1100 0000 0010 0000 0000 0000 0000 0000 -->C0200000
  //0XC0200000&0XFFFF0000=0XC0200000
  //0XC0200000>>16=0XC020
  //0xC0200000|0x00000000U|0x00000000U=0XC0200000=0X0000
  sFilterConfig.FilterIdHigh = (uint16_t)((((uint32_t)ID_TO_MC_FILTER << 21) & 0xFFFF0000) >> 16); //0XC020  
  sFilterConfig.FilterIdLow = (uint16_t)(((uint32_t)ID_TO_MC_FILTER << 21) | CAN_ID_STD | CAN_RTR_DATA) & 0xFFFF;//0X0000  
  
  //(0x70F & 0x60F)=60F  
  //60F<<21 0110 0000 1111<<21 -->1100 0001 1110 0000 0000 0000 0000 0000 -->0XC1E0 0000
	//设置屏蔽寄存器
  sFilterConfig.FilterMaskIdHigh = (uint16_t)((((uint32_t)ID_TO_MC_MASK << 21) & 0xFFFF0000) >> 16);//0XC1E0  
  sFilterConfig.FilterMaskIdLow = 0xFFFF;       
  //以上定义的含义为:1100 0000 0010 0000 0000 0000 0000 0000
  //                 1100 0001 1110 0000 1111 1111 1111 1111
  //                   
  sFilterConfig.FilterFIFOAssignment = 0; //设置通过的数据帧进入到FIFO中   
  sFilterConfig.FilterActivation = ENABLE;   
    
  if(HAL_CAN_ConfigFilter(&hcan, &sFilterConfig) != HAL_OK)  
  {  
    Error_Handler();  
  }
	
	//设置过滤器组1，指定接收广播数据
  sFilterConfig.FilterNumber = 1;             
  sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK;//配置为掩码模式    
  sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT;//设置为32位宽  
	
	//设置过滤寄存器
  sFilterConfig.FilterIdHigh = (uint16_t)((((uint32_t)ID_BC_FILTER << 21) & 0xFFFF0000) >> 16);   
  sFilterConfig.FilterIdLow = (uint16_t)(((uint32_t)ID_BC_FILTER << 21) | CAN_ID_STD | CAN_RTR_DATA) & 0xFFFF;  
    
	//设置屏蔽寄存器
  sFilterConfig.FilterMaskIdHigh = (uint16_t)((((uint32_t)ID_BC_MASK << 21) & 0xFFFF0000) >> 16);;  
  sFilterConfig.FilterMaskIdLow = 0xFFFF;       
    
  sFilterConfig.FilterFIFOAssignment = 0;    
  sFilterConfig.FilterActivation = ENABLE;   
    
  if(HAL_CAN_ConfigFilter(&hcan, &sFilterConfig) != HAL_OK)  
  {  
    Error_Handler();  
  }
}

void HAL_CAN_ErrorCallback(CAN_HandleTypeDef *hcan)
{
	__HAL_CAN_ENABLE_IT(hcan, CAN_IT_FMP0);
}

/* USER CODE END 1 */

/**
  * @}
  */

/**
  * @}
  */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/