cdl_tool/MOTINOVA_CDL_App/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 "uart_process.h"
#include "gpio.h"

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

const uint16_t ID_Index[CAN_ID_NUM] = 
{
   ID_MC_BC              ,//0x710
   ID_MC_TO_BMS          ,//0x712	
   ID_MC_TO_PBU          ,//0x713	
   ID_MC_TO_HMI          ,//0x714	
   ID_MC_TO_CDL          ,//0x715	

   ID_MC_TE_TO_CDL       ,//0x615
	 
   ID_BMS_BC             ,//0x720
   ID_BMS_TO_MC          ,//0x721	
   ID_BMS_TO_PBU         ,//0x723	
   ID_BMS_TO_HMI         ,//0x724	
   ID_BMS_TO_CDL         ,//0x725
	 
   ID_PBU_BC             ,//0x730
   ID_PBU_TO_MC          ,//0x731	
   ID_PBU_TO_BMS         ,//0x732	
   ID_PBU_TO_HMI         ,//0x734	
   ID_PBU_TO_CDL         ,//0x735

   ID_PBU_TE_TO_CDL      ,//0x635
	 
   ID_HMI_BC             ,//0x740
   ID_HMI_TO_MC          ,//0x741	
   ID_HMI_TO_BMS         ,//0x742	
   ID_HMI_TO_PBU         ,//0x743	
   ID_HMI_TO_CDL          //0x745	
};

uint8_t CAN_RxBuf[CAN_ID_NUM][CAN_BUFF_SIZE];
CAN_Buf_TypeDef CAN_RxBuf_Struct[CAN_ID_NUM];

/* USER CODE END 0 */

CAN_HandleTypeDef hcan;

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

  hcan.Instance = CAN1;
  //hcan.Init.Prescaler = (HAL_GPIO_ReadPin(BautrateSwitch_GPIO_Port, BautrateSwitch_Pin) == GPIO_PIN_SET) ? 24 : 48;
	hcan.Init.Prescaler = (CAN_Baudrate == 125) ? 48 : 24;
  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    
    PA11     ------> CAN_RX
    PA12     ------> CAN_TX 
    */
    GPIO_InitStruct.Pin = GPIO_PIN_11;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = GPIO_PIN_12;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    /* CAN1 interrupt Init */
    HAL_NVIC_SetPriority(USB_LP_CAN1_RX0_IRQn, 0, 0);
    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    
    PA11     ------> CAN_RX
    PA12     ------> CAN_TX 
    */
    HAL_GPIO_DeInit(GPIOA, GPIO_PIN_11|GPIO_PIN_12);

    /* 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 */
void CAN_RxBuf_Init(void)
{
  uint8_t i;
	
	for(i=0; i<CAN_ID_NUM; i++)
	{
	  CAN_RxBuf_Struct[i].ucBufID = 0;
		CAN_RxBuf_Struct[i].ucBufSize = CAN_BUFF_SIZE;
		CAN_RxBuf_Struct[i].ucBufWrInde = 0;
		CAN_RxBuf_Struct[i].ucBufRdInde = 0;
		CAN_RxBuf_Struct[i].ucBufCnt = 0;
		CAN_RxBuf_Struct[i].ucBufOvf = 0;
		CAN_RxBuf_Struct[i].pcBufAddr = CAN_RxBuf[i];
		CAN_RxBuf_Struct[i].DelayTimeCnt = 0;
		CAN_RxBuf_Struct[i].IsWaitRX_Flag = FALSE;
	}
}

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;
	}  

	//根据ID索引数组下标
	uint16_t Index;
	for(Index=0 ;Index<CAN_ID_NUM; Index++)
	{
	  if(CanHandle->pRxMsg->StdId == ID_Index[Index])
		{
			//数据转移到队列
			CAN_RxBuf_Struct[Index].ucBufID = CanHandle->pRxMsg->StdId;
			CAN_Rx_ISR(&CAN_RxBuf_Struct[Index], CanHandle->pRxMsg->DLC);
			
			T_RecvCANMsg = HAL_GetTick();
		  break;
		}
	}
	
	#if 0
	switch(CanHandle->pRxMsg->StdId)
	{
	  //MC广播的数据
		case ID_MC_BC:
		{
		  CAN_RxBuf_Struct_MC_BC.ucBufID = CanHandle->pRxMsg->StdId;
			CAN_Rx_ISR(&CAN_RxBuf_Struct_MC_BC,CanHandle->pRxMsg->DLC);
			break;
		}
		//MC发送给CDL的数据
		case ID_MC_TO_CDL:
		{
		  CAN_RxBuf_Struct_MC_TO_CDL.ucBufID = CanHandle->pRxMsg->StdId;
			CAN_Rx_ISR(&CAN_RxBuf_Struct_MC_TO_CDL,CanHandle->pRxMsg->DLC);
			break;
		}
		//MC_TE发送给CDL的数据
		case ID_MC_TE_TO_CDL:
		{
		  CAN_RxBuf_Struct_MC_TE_TO_CDL.ucBufID = CanHandle->pRxMsg->StdId;
			CAN_Rx_ISR(&CAN_RxBuf_Struct_MC_TE_TO_CDL,CanHandle->pRxMsg->DLC);
			break;
		}
		
		//PBU广播的数据
		case ID_PBU_BC:
		{
		  CAN_RxBuf_Struct_PBU_BC.ucBufID = CanHandle->pRxMsg->StdId;
			CAN_Rx_ISR(&CAN_RxBuf_Struct_PBU_BC,CanHandle->pRxMsg->DLC);
			break;
		}
		//PBU发送给CDL的数据
		case ID_PBU_TO_CDL:
		{
		  CAN_RxBuf_Struct_PBU_TO_CDL.ucBufID = CanHandle->pRxMsg->StdId;
			CAN_Rx_ISR(&CAN_RxBuf_Struct_PBU_TO_CDL,CanHandle->pRxMsg->DLC);
			break;
		}
		//PBU_TE发送给CDL的数据
		case ID_PBU_TE_TO_CDL:
		{
		  CAN_RxBuf_Struct_PBU_TE_TO_CDL.ucBufID = CanHandle->pRxMsg->StdId;
			CAN_Rx_ISR(&CAN_RxBuf_Struct_PBU_TE_TO_CDL,CanHandle->pRxMsg->DLC);
			break;
		}
		
		//BMS广播的数据
		case ID_BMS_BC:
		{
		  CAN_RxBuf_Struct_BMS_BC.ucBufID = CanHandle->pRxMsg->StdId;
			CAN_Rx_ISR(&CAN_RxBuf_Struct_BMS_BC,CanHandle->pRxMsg->DLC);
			break;
		}
		//BMS发送给CDL的数据
		case ID_BMS_TO_CDL:
		{
		  CAN_RxBuf_Struct_BMS_TO_CDL.ucBufID = CanHandle->pRxMsg->StdId;
			CAN_Rx_ISR(&CAN_RxBuf_Struct_BMS_TO_CDL,CanHandle->pRxMsg->DLC);
			break;
		}
		//HMI广播的数据
		case ID_HMI_BC:
		{
		  CAN_RxBuf_Struct_HMI_BC.ucBufID = CanHandle->pRxMsg->StdId;
			CAN_Rx_ISR(&CAN_RxBuf_Struct_HMI_BC,CanHandle->pRxMsg->DLC);
			break;
		}
		//HMI发送给CDL的数据
		case ID_HMI_TO_CDL:
		{
		  CAN_RxBuf_Struct_HMI_TO_CDL.ucBufID = CanHandle->pRxMsg->StdId;
			CAN_Rx_ISR(&CAN_RxBuf_Struct_HMI_TO_CDL,CanHandle->pRxMsg->DLC);
			break;
		}
		default:break;
	}
	#endif
	
	__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(Transmit_UARTOrCAN == 2)
	{
			return;
	}
	
	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_OK)
		  {
		    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_OK)
		{
				//MX_CAN_Init();
				if(0 == Transmit_UARTOrCAN)
				{
						Transmit_UARTOrCAN = 2;
						HAL_Delay(100);
						HAL_GPIO_WritePin(CommSwitch_GPIO_Port, CommSwitch_Pin1, GPIO_PIN_SET);
						HAL_GPIO_WritePin(CommSwitch_GPIO_Port, CommSwitch_Pin2, GPIO_PIN_SET);
				}
		}
		else
		{
				Transmit_UARTOrCAN = 1;
		}
	}
}

//过滤器设置
void CANFilterConfig_Scale32_IdMask_StandardIdOnly(void)
{
  CAN_FilterConfTypeDef  sFilterConfig;  
  
	//设置过滤器组0，指定接收发送给CDL的数据
  sFilterConfig.FilterNumber = 0;             
  sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK;   
  sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT; 
	
	//设置过滤寄存器
  sFilterConfig.FilterIdHigh = (uint16_t)((((uint32_t)ID_FILTER << 21) & 0xFFFF0000) >> 16);   
  sFilterConfig.FilterIdLow = (uint16_t)(((uint32_t)ID_FILTER << 21) | CAN_ID_STD | CAN_RTR_DATA) & 0xFFFF;  
    
	//设置屏蔽寄存器
  sFilterConfig.FilterMaskIdHigh = (uint16_t)((((uint32_t)ID_MASK << 21) & 0xFFFF0000) >> 16);;  
  sFilterConfig.FilterMaskIdLow = 0xFFFF;       
    
  sFilterConfig.FilterFIFOAssignment = 0;    
  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; 
	
	//设置过滤寄存器
  sFilterConfig.FilterIdHigh = (uint16_t)((((uint32_t)ID_FILTER << 21) & 0xFFFF0000) >> 16);   
  sFilterConfig.FilterIdLow = (uint16_t)(((uint32_t)ID_FILTER << 21) | CAN_ID_STD | CAN_RTR_DATA) & 0xFFFF;  
    
	//设置屏蔽寄存器
  sFilterConfig.FilterMaskIdHigh = (uint16_t)((((uint32_t)ID_MASK << 21) & 0xFFFF0000) >> 16);;  
  sFilterConfig.FilterMaskIdLow = 0xFFFF;       
    
  sFilterConfig.FilterFIFOAssignment = 0;    
  sFilterConfig.FilterActivation = ENABLE;   
    
  if(HAL_CAN_ConfigFilter(&hcan, &sFilterConfig) != HAL_OK)  
  {  
    Error_Handler();  
  }
}
/* USER CODE END 1 */

/**
  * @}
  */

/**
  * @}
  */

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