motor_ctl-2/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"
#include "can_process.h"
#include "bms_magene.h"

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

#if defined BARD_250K
const uint32_t Baudrate __attribute__((at(0x08018000))) = 0xAA55AA12; //低8位表示波特率分频系数，Bootloader取用
#elif defined BARD_125K
const uint32_t Baudrate __attribute__((at(0x08018000))) = 0xAA55AA24; //低8位表示波特率分频系数，Bootloader取用
#else
Error();
#endif

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};
uint8_t CAN_RxBuf_To_BMS[255];
CAN_Buf_TypeDef CAN_RxBuf_Struct_To_BMS = {0,255,0,0,0,0,CAN_RxBuf_To_BMS,0,FALSE};

/* USER CODE END 0 */

CAN_HandleTypeDef hcan;

/* CAN init function */
void MX_CAN_Init(void)
{
  hcan.Instance = CAN1;
	hcan.Init.Prescaler = (Baudrate & 0x000000FF);
  hcan.Init.Mode = CAN_MODE_NORMAL;
  hcan.Init.SJW = CAN_SJW_1TQ;
  hcan.Init.BS1 = CAN_BS1_6TQ;
  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);
    HAL_NVIC_SetPriority(CAN1_RX1_IRQn, 1, 1);
    HAL_NVIC_EnableIRQ(CAN1_RX1_IRQn);
    /* USER CODE BEGIN CAN1_MspInit 1 */
    canHandle->pTxMsg = &CAN_TxMessaage;
		canHandle->pRxMsg = &CAN_RxMessaage;
    canHandle->pRx1Msg = &CAN_RxMessaage1;
		CANFilterConfig_Scale32_IdMask_StandardIdOnly();
		__HAL_CAN_ENABLE_IT(&hcan, CAN_IT_FMP0);
    __HAL_CAN_ENABLE_IT(&hcan, CAN_IT_FMP1);
  /* 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);
    HAL_NVIC_DisableIRQ(CAN1_RX1_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;
		}
		case ID_PBU_TO_BMS: case ID_CDL_TO_BMS://接收仪表和CDL发送BMS的数据
		{
		  CAN_RxBuf_Struct_To_BMS.ucBufID = CanHandle->pRxMsg->StdId;
			CAN_Rx_ISR(&CAN_RxBuf_Struct_To_BMS,CanHandle->pRxMsg->DLC);
			break;
		}
		default:break;
	}
	__HAL_CAN_ENABLE_IT(&hcan, CAN_IT_FMP0);//开接收中断
}

void HAL_CAN_Rx1CpltCallback(CAN_HandleTypeDef *CanHandle)
{
	if((CanHandle->pRx1Msg->IDE != CAN_ID_STD)||(CanHandle->pRxMsg->DLC == 0))
	{
		__HAL_CAN_ENABLE_IT(&hcan, CAN_IT_FMP1);//开接收中断
		return;
	}
	switch(CanHandle->pRx1Msg->StdId)
	{
		case BMS_MAGENE_BASE_RPDO + BMS_MAGENE_ADDRESS_MAIN: case BMS_MAGENE_BASE_RPDO + BMS_MAGENE_ADDRESS_BACK:
		{
			if(CanHandle->pRx1Msg->DLC == 8)//由于没有帧头帧尾和CRC,故保证数据的准确性必须为8字节才解析
			{
				BMS_Magene_CanData.RefreshFlag = 1;
        BMS_Magene_CanData.ID = CanHandle->pRx1Msg->StdId;
				memcpy((uint8_t*)BMS_Magene_CanData.Data, (uint8_t*)CanHandle->pRx1Msg->Data, 8);
			}
			break;
		}
		default:break;
	}
	__HAL_CAN_ENABLE_IT(&hcan, CAN_IT_FMP1);//开接收中断
}

//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和CDL的数据
  sFilterConfig.FilterNumber = 0;//使用过滤器0             
  sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK;//配置为掩码模式   
  sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT;//设置为32位宽 
	
  //设置过滤寄存器
  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  
  
	//设置屏蔽寄存器
  sFilterConfig.FilterMaskIdHigh = (uint16_t)((((uint32_t)ID_TO_MC_MASK << 21) & 0xFFFF0000) >> 16);//0XC1E0  
  sFilterConfig.FilterMaskIdLow = 0xFFFF;       

  //FIFO0                  
  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;       

  //FIFO0  
  sFilterConfig.FilterFIFOAssignment = 0;    
  sFilterConfig.FilterActivation = ENABLE;   
    
  if(HAL_CAN_ConfigFilter(&hcan, &sFilterConfig) != HAL_OK)  
  {  
    Error_Handler();  
  }

  //设置过滤器组2，指定接收enviolo的报文
  sFilterConfig.FilterNumber = 2;             
  sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK;//配置为掩码模式    
  sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT;//设置为32位宽  
	
	//设置过滤寄存器
  sFilterConfig.FilterIdHigh = (uint16_t)((((uint32_t)ID_BMS_MAGENE_FILTER << 21) & 0xFFFF0000) >> 16);
  sFilterConfig.FilterIdLow = (uint16_t)(((uint32_t)ID_BMS_MAGENE_FILTER << 21) | CAN_ID_STD | CAN_RTR_DATA) & 0xFFFF;  
    
	//设置屏蔽寄存器
  sFilterConfig.FilterMaskIdHigh = (uint16_t)((((uint32_t)ID_BMS_MAGENE_MASK << 21) & 0xFFFF0000) >> 16);
  sFilterConfig.FilterMaskIdLow = 0xFFFF;       

  //FIFO1  
  sFilterConfig.FilterFIFOAssignment = 1;    
  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);
  __HAL_CAN_ENABLE_IT(hcan, CAN_IT_FMP1);
}

/* USER CODE END 1 */

/**
  * @}
  */

/**
  * @}
  */

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