libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity
rt-thread-official/bsp/acm32f4xx-nucleo/libraries/HAL_Driver/Src/HAL_CAN.c

732 lines
30 KiB
C
Raw Normal View History

ACM32F4XX bsp add
2021-09-22 17:14:47 +08:00
/*
******************************************************************************
* @file HAL_Can.c
* @version V1.0.0
* @date 2020
* @brief CAN HAL module driver.
* This file provides firmware functions to manage the following
* functionalities of the Universal Asynchronous Receiver Transmitter Peripheral (CAN).
* @ Initialization and de-initialization functions
* @ IO operation functions
* @ Peripheral Control functions
******************************************************************************
*/
#include "ACM32Fxx_HAL.h"
/*********************************************************************************
* Function : HAL_CAN_OperatingModeRequest
* Description : Select the CAN Operation mode.
* Input : hcan : pointer to a CAN_HandleTypeDef structure that contains
* the configuration information for CAN module
* Input : CAN_OperatingMode:CAN Operating Mode. This parameter can be one of @ref CAN_OperatingMode enumeration.
* Output : HAL status
* Author : CWT Data : 2020
**********************************************************************************/
HAL_StatusTypeDef HAL_CAN_OperatingModeRequest(CAN_HandleTypeDef *hcan, uint8_t CAN_OperatingMode)
{
uint8_t status = HAL_ERROR;
/* Check the parameters */
if(!IS_CAN_ALL_PERIPH(hcan->Instance)) return HAL_ERROR;
if(!IS_CAN_OPERATING_MODE(CAN_OperatingMode)) return HAL_ERROR;
if (CAN_OperatingMode == CAN_OperatingMode_Initialization)
{
hcan->Instance->MOD |= CAN_OperatingMode_Initialization; // enter Initialization
if ((hcan->Instance->MOD & CAN_MOD_RM) != CAN_OperatingMode_Initialization)
{
status = HAL_ERROR;
}
else
{
status = HAL_OK;
}
}
else if(CAN_OperatingMode == CAN_OperatingMode_Normal)
{
hcan->Instance->MOD &=~ CAN_OperatingMode_Initialization; //1-->0 enter Normal
if ((hcan->Instance->MOD & CAN_MOD_RM) != CAN_OperatingMode_Normal)
{
status = HAL_ERROR;
}
else
{
status = HAL_OK;
}
}
else if (CAN_OperatingMode == CAN_OperatingMode_Sleep)
{
hcan->Instance->MOD |= CAN_OperatingMode_Sleep; // enter Normal
if ((hcan->Instance->MOD & CAN_MOD_SM) != CAN_OperatingMode_Sleep)
{
status = HAL_ERROR;
}
else
{
status = HAL_OK;
}
}
else if(CAN_OperatingMode == CAN_OperatingMode_Listen)
{
hcan->Instance->MOD |= CAN_OperatingMode_Listen; // enter Normal
if((hcan->Instance->MOD & CAN_MOD_LOM) != CAN_OperatingMode_Listen)
{
status = HAL_ERROR;
}
else
{
status = HAL_OK;
}
}
else
{
status = HAL_ERROR;
}
return (uint8_t) status;
}
/*********************************************************************************
* Function : HAL_CAN_MspInit
* Description : Initialize the CAN MSP.
* Input : hcan : pointer to a CAN_HandleTypeDef structure that contains
* the configuration information for CAN module
* Output :
* Author : CWT Data : 2020
**********************************************************************************/
__weak void HAL_CAN_MspInit(CAN_HandleTypeDef *hcan)
{
/* NOTE : This function should not be modified, when the callback is needed,
the HAL_UART_MspInit can be implemented in the user file
*/
/* For Example */
GPIO_InitTypeDef GPIO_InitStruct;
if(hcan->Instance==CAN1)
{
/* Enable CAN clock */
System_Module_Enable(EN_CAN1);
GPIO_InitTypeDef GPIO_InitStructure;
/* Initialization GPIO */
/* PA11:Rx */ /* PA12:Tx */
GPIO_InitStructure.Pin = GPIO_PIN_11|GPIO_PIN_12;
GPIO_InitStructure.Alternate=GPIO_FUNCTION_5;
GPIO_InitStructure.Pull=GPIO_PULLUP;
GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;
HAL_GPIO_Init(GPIOA, &GPIO_InitStructure);
}
else if(hcan->Instance==CAN2)
{
/* Enable CAN clock */
System_Module_Enable(EN_CAN2);
GPIO_InitTypeDef GPIO_InitStructure;
/* Initialization GPIO */
/* PB5:Rx */ /* PB6:Tx */
GPIO_InitStructure.Pin = GPIO_PIN_5|GPIO_PIN_6;
GPIO_InitStructure.Alternate=GPIO_FUNCTION_5;
GPIO_InitStructure.Pull=GPIO_PULLUP;
GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;
HAL_GPIO_Init(GPIOB, &GPIO_InitStructure);
/* Enable the CAN Receive interrupt */
hcan->Instance->IER |= CAN_IER_RIE;
NVIC_ClearPendingIRQ(CAN2_IRQn);
NVIC_SetPriority(CAN2_IRQn, 5);
NVIC_EnableIRQ(CAN2_IRQn);
}
}
/*********************************************************************************
* Function : HAL_CAN_MspDeInit
* Description : CAN MSP De-Initialization
* This function frees the hardware resources used in this example:
* - Disable the Peripheral's clock
* - Revert GPIO configuration to their default state
* Input : hcan : pointer to a CAN_HandleTypeDef structure that contains
* the configuration information for CAN module
* Output :
* Author : CWT Data : 2020
**********************************************************************************/
void HAL_CAN_MspDeInit(CAN_HandleTypeDef *hcan)
{
if(hcan->Instance==CAN1)
{
/* Reset CAN clock */
System_Module_Disable(EN_CAN1);
GPIO_InitTypeDef GPIO_InitStructure;
/* Initialization GPIO */
/* PA11:Rx */ /* PA12:Tx */
HAL_GPIO_DeInit(GPIOA, GPIO_PIN_11);
HAL_GPIO_DeInit(GPIOA, GPIO_PIN_12);
}
else if(hcan->Instance==CAN2)
{
/* Reset CAN clock */
System_Module_Disable(EN_CAN2);
GPIO_InitTypeDef GPIO_InitStructure;
/* Initialization GPIO */
/* PB5:Rx */ /* PB6:Tx */
HAL_GPIO_DeInit(GPIOB, GPIO_PIN_5);
HAL_GPIO_DeInit(GPIOB, GPIO_PIN_6);
}
}
/*********************************************************************************
* Function : HAL_CAN_Init
* Description : Initializes the CAN peripheral according to the specified parameters in the CAN_HandleTypeDef..
* Input : hcan : pointer to a CAN_HandleTypeDef structure that contains
* the configuration information for CAN module
* Output : HAL status
* Author : CWT Data : 2020
**********************************************************************************/
HAL_StatusTypeDef HAL_CAN_Init(CAN_HandleTypeDef *hcan)
{
uint8_t InitStatus = HAL_ERROR;
/* Check the parameters */
if(!IS_CAN_ALL_PERIPH(hcan->Instance)) return HAL_ERROR;
if(!IS_CAN_MODE(hcan->Init.CAN_Mode)) return HAL_ERROR;
if(!IS_CAN_SJW(hcan->Init.CAN_SJW)) return HAL_ERROR;
if(!IS_CAN_TSEG1(hcan->Init.CAN_TSEG1)) return HAL_ERROR;
if(!IS_CAN_TSEG2(hcan->Init.CAN_TSEG2)) return HAL_ERROR;
if(!IS_CAN_BRP(hcan->Init.CAN_BRP)) return HAL_ERROR;
if(!IS_CAN_SAM(hcan->Init.CAN_SAM)) return HAL_ERROR;
/* Reset the CANx */
if(hcan->Instance==CAN1)
{
System_Module_Reset(RST_CAN1);
}
else
{
System_Module_Reset(RST_CAN2);
}
HAL_CAN_MspInit(hcan);
HAL_CAN_OperatingModeRequest(hcan,CAN_OperatingMode_Initialization);//enter CAN_OperatingMode_Initialization
hcan->Instance->BTR0=0xff;
hcan->Instance->BTR0=(hcan->Init.CAN_SJW<<6)|(hcan->Init.CAN_BRP);
hcan->Instance->BTR1=(hcan->Init.CAN_SAM<<7)|(hcan->Init.CAN_TSEG2<<4)|(hcan->Init.CAN_TSEG1);
HAL_CAN_OperatingModeRequest(hcan,CAN_OperatingMode_Normal);//enter CAN_OperatingMode_Normal
return HAL_OK;
}
/*********************************************************************************
* Function : HAL_CAN_DeInit
* Description : Deinitializes the CAN peripheral registers to their default
* reset values.
* Input : hcan : pointer to a CAN_HandleTypeDef structure that contains
* the configuration information for CAN module
* Output : HAL status
* Author : CWT Data : 2020
**********************************************************************************/
HAL_StatusTypeDef HAL_CAN_DeInit(CAN_HandleTypeDef *hcan)
{
/* Check CAN handle */
if(!IS_CAN_ALL_PERIPH(hcan->Instance)) return HAL_ERROR;
HAL_CAN_MspDeInit(hcan);
/* Reset the CAN peripheral */
SET_BIT(hcan->Instance->MOD, CAN_MOD_RM);
/* Return function status */
return HAL_OK;
}
/*********************************************************************************
* Function : HAL_CAN_Transmit
* Description : Initiates the transmission of a message.
* Input : hcan : pointer to a CAN_HandleTypeDef structure that contains
* the configuration information for CAN module
* Input : TxMessage : ppointer to a structure which contains CAN Id, CAN
* DLC and CAN data.
* Output :
* Author : CWT Data : 2020
**********************************************************************************/
HAL_StatusTypeDef HAL_CAN_Transmit(CAN_HandleTypeDef *hcan, CanTxRxMsg* TxMessage)
{
uint8_t i = 0;
uint8_t can_id[4];
uint32_t frame_header;
/* Check the parameters */
if(!IS_CAN_ALL_PERIPH(hcan->Instance)) return HAL_ERROR ;
if(!IS_CAN_IDTYPE(TxMessage->IDE)) return HAL_ERROR;
if(!IS_CAN_RTR(TxMessage->RTR)) return HAL_ERROR;
if(!IS_CAN_DLC(TxMessage->DLC)) return HAL_ERROR;
/* Set up the DLC */
frame_header =TxMessage->DLC & 0x0F; // standard data frame
/* Set up the Id */
if(TxMessage->IDE==CAN_Id_Standard)//Standard ID
{
can_id[0] = TxMessage->StdId >>3;
can_id[1] = (TxMessage->StdId&0x07)<<5;
for(i=0;i<2;i++)
{
hcan->Instance->DF.DATABUF[1+i] = can_id[i];
}
}
else//Id_Extended
{
can_id[0] = TxMessage->ExtId>>21;
can_id[1] = (TxMessage->ExtId&0x1FE000)>>13;
can_id[2] = (TxMessage->ExtId&0x1FE0)>>5;
can_id[3] = (TxMessage->ExtId&0x1F)<<3;
frame_header |= (CAN_Id_Extended<<7); // extended data frame
for(i=0;i<4;i++)
{
hcan->Instance->DF.DATABUF[1+i] = can_id[i];
}
}
if(TxMessage->RTR==CAN_RTR_Data)//CAN_RTR_Data
{
frame_header&=~(CAN_RTR_Remote<<6);
for(i=0; i<TxMessage->DLC; i++)
{
hcan->Instance->DF.DATABUF[3+(TxMessage->IDE*2)+i] = TxMessage->Data[i];
}
}
else//CAN_RTR_Remote
{
frame_header|=(CAN_RTR_Remote<<6);
}
hcan->Instance->DF.DATABUF[0]=frame_header;
hcan->Instance->CMR = CAN_CMR_TR; // transfer request
while((hcan->Instance->SR & CAN_SR_TCS)==0x00); //wait for send ok
return HAL_OK;
}
/*********************************************************************************
* Function : HAL_CAN_CancelTransmit
* Description : Cancels a transmit request.
* Input : hcan : pointer to a CAN_HandleTypeDef structure that contains
* the configuration information for CAN module
* Output :
* Author : CWT Data : 2020
**********************************************************************************/
void HAL_CAN_CancelTransmit(CAN_HandleTypeDef *hcan)
{
/* Check the parameters */
if(!IS_CAN_ALL_PERIPH(hcan->Instance)) return ;
/* abort transmission */
hcan->Instance->CMR |= CAN_CMR_AT; //Abort Transmission
}
/*********************************************************************************
* Function : HAL_CAN_Receive
* Description : Receives a message.
* Input : hcan : pointer to a CAN_HandleTypeDef structure that contains
* the configuration information for CAN module
* Input : RxMessage : pointer to a structure receive message which contains
* CAN Id, CAN DLC, CAN datas .
* Output :
* Author : CWT Data : 2020
**********************************************************************************/
HAL_StatusTypeDef HAL_CAN_Receive_IT(CAN_HandleTypeDef *hcan, CanTxRxMsg* RxMessage)
{
/* Check the parameters */
if(!IS_CAN_ALL_PERIPH(hcan->Instance)) return HAL_ERROR ;
hcan->RxMessage=RxMessage;
/* Enable the CAN Receive interrupt */
hcan->Instance->IER |= CAN_IER_RIE;
NVIC_ClearPendingIRQ(CAN1_IRQn);
NVIC_SetPriority(CAN1_IRQn, 5);
NVIC_EnableIRQ(CAN1_IRQn);
return HAL_OK;
}
/*********************************************************************************
* Function : HAL_CAN_Receive
* Description : Receives a message.
* Input : hcan : pointer to a CAN_HandleTypeDef structure that contains
* the configuration information for CAN module
* Input : RxMessage : pointer to a structure receive message which contains
* CAN Id, CAN DLC, CAN datas .
* Output :
* Author : CWT Data : 2020
**********************************************************************************/
HAL_StatusTypeDef HAL_CAN_Receive(CAN_HandleTypeDef *hcan, CanTxRxMsg* RxMessage)
{
/* Check the parameters */
if(!IS_CAN_ALL_PERIPH(hcan->Instance)) return HAL_ERROR ;
while(!(hcan->Instance->SR & CAN_SR_RBS));
HAL_CAN_GetRxMessage(hcan, RxMessage);
return HAL_OK;
}
void HAL_CAN_GetRxMessage(CAN_HandleTypeDef *hcan, CanTxRxMsg* RxMessage)
{
uint8_t i=0;
/* Check the parameters */
if(!IS_CAN_ALL_PERIPH(hcan->Instance)) return ;
if(0 == (hcan->Instance->SR & CAN_SR_RBS) ) return; // receive fifo not empty
/* Get the IDE */
RxMessage->IDE = (uint8_t)(0x80 & hcan->Instance->DF.DATABUF[0])>>7;
/* Get the RTR */
RxMessage->RTR = (uint8_t)(0x40 & hcan->Instance->DF.DATABUF[0])>>6;
/* Get the DLC */
RxMessage->DLC = (uint8_t)0x0F & hcan->Instance->DF.DATABUF[0];
if (RxMessage->IDE == CAN_Id_Standard)
{
RxMessage->StdId = (uint32_t)(( hcan->Instance->DF.DATABUF[1]<<8) | hcan->Instance->DF.DATABUF[2])>>5;;
for(i=0; i<RxMessage->DLC; i++)
{
RxMessage->Data[i] = hcan->Instance->DF.DATABUF[3+i];
}
}
else
{
RxMessage->ExtId = (uint32_t)(( hcan->Instance->DF.DATABUF[1]<<24) | ( hcan->Instance->DF.DATABUF[2]<<16) | ( hcan->Instance->DF.DATABUF[3]<<8) | (hcan->Instance->DF.DATABUF[4] ))>>3;;
for(i=0; i<RxMessage->DLC; i++)
{
RxMessage->Data[i] = hcan->Instance->DF.DATABUF[5+i];
}
}
/* Release the FIFO */
hcan->Instance->CMR |= CAN_CMR_RRB; //Release Receive Buffer
}
/**
* @brief Initializes the CAN peripheral according to the specified
* parameters in the CAN_FilterInitStruct.
* @param CANx: where x can be 1 or 2 to to select the CAN peripheral.
CAN_FilterInitStruct: pointer to a CAN_FilterInitTypeDef
* structure that contains the configuration
* information.
* @retval None.
*/
/*********************************************************************************
* Function : HAL_CAN_ConfigFilter
* Description : Initializes the CAN peripheral according to the specified parameters in the CAN_FilterInitStruct.
* Input : hcan : pointer to a CAN_HandleTypeDef structure that contains
* the configuration information for CAN module
* Input : CAN_FilterInitStruct : pointer to a CAN_FilterInitTypeDef structure that contains the configuration
* information.
* Output :
* Author : CWT Data : 2020
**********************************************************************************/
void HAL_CAN_ConfigFilter(CAN_HandleTypeDef *hcan,CAN_FilterInitTypeDef* CAN_FilterInitStruct)
{
HAL_CAN_OperatingModeRequest(hcan,CAN_OperatingMode_Initialization);//enter CAN_OperatingMode_Initialization
/* Filter Mode */
if (CAN_FilterInitStruct->CAN_FilterMode ==CAN_FilterMode_Dual) /*Dual mode*/
{
hcan->Instance->MOD &= ~CAN_MOD_AFM;
/*Dual mode ACR set*/
hcan->Instance->DF.FILTER.ACR[0] = (CAN_FilterInitStruct->CAN_FilterId1&0x1FE00000)>>21; /*Dual mode ACR0=ID28...ID21 of ID1*/
hcan->Instance->DF.FILTER.ACR[1] = (CAN_FilterInitStruct->CAN_FilterId1&0x1FE000)>>13; /*Dual mode ACR0=ID20...ID13 of ID1*/
hcan->Instance->DF.FILTER.ACR[2] = (CAN_FilterInitStruct->CAN_FilterId2&0x1FE00000)>>21; /*Dual mode ACR0=ID28...ID21 of ID2*/
hcan->Instance->DF.FILTER.ACR[3] = (CAN_FilterInitStruct->CAN_FilterId2&0x1FE000)>>13; /*Dual mode ACR0=ID20...ID13 of ID2*/
/*Dual mode AMR set*/
hcan->Instance->DF.FILTER.AMR[0] = (CAN_FilterInitStruct->CAN_FilterMaskId1)>>24;
hcan->Instance->DF.FILTER.AMR[1] = (CAN_FilterInitStruct->CAN_FilterMaskId1&0xFF0000)>>16;
hcan->Instance->DF.FILTER.AMR[2] = (CAN_FilterInitStruct->CAN_FilterMaskId2)>>24;
hcan->Instance->DF.FILTER.AMR[3] = (CAN_FilterInitStruct->CAN_FilterMaskId2&0xFF0000)>>16;
}
else /*Single mode*/
{
hcan->Instance->MOD |= CAN_MOD_AFM;
/*Single mode ACR set*/
hcan->Instance->DF.FILTER.ACR[0] = (CAN_FilterInitStruct->CAN_FilterId1&0x1FE00000)>>21; /*Single mode ACR0=ID28...ID21*/
hcan->Instance->DF.FILTER.ACR[1] = (CAN_FilterInitStruct->CAN_FilterId1&0x1FE000)>>13; /*Single mode ACR1=ID20...ID13*/
hcan->Instance->DF.FILTER.ACR[2] = (CAN_FilterInitStruct->CAN_FilterId1&0x1FE0)>>5; /*Single mode ACR2=ID12...ID5*/
hcan->Instance->DF.FILTER.ACR[3] = (CAN_FilterInitStruct->CAN_FilterId1&0x1F)<<3; /*Single mode ACR3=ID4...ID0*/
/*Single mode AMR set*/
hcan->Instance->DF.FILTER.AMR[0] = (CAN_FilterInitStruct->CAN_FilterMaskId1)>>24;
hcan->Instance->DF.FILTER.AMR[1] = (CAN_FilterInitStruct->CAN_FilterMaskId1&0xFF0000)>>16;
hcan->Instance->DF.FILTER.AMR[2] = (CAN_FilterInitStruct->CAN_FilterMaskId1&0xFF00)>>8;
hcan->Instance->DF.FILTER.AMR[3] = (CAN_FilterInitStruct->CAN_FilterMaskId1&0xFF);
}
HAL_CAN_OperatingModeRequest(hcan,CAN_OperatingMode_Normal);//enter CAN_OperatingMode_Initialization
}
/*********************************************************************************
* Function : HAL_CAN_Sleep
* Description : Enters the sleep mode.
* Input : hcan : pointer to a CAN_HandleTypeDef structure that contains
* the configuration information for CAN module
* Output :
* Author : CWT Data : 2020
**********************************************************************************/
HAL_StatusTypeDef HAL_CAN_Sleep(CAN_HandleTypeDef *hcan)
{
HAL_StatusTypeDef status;
/* Check the parameters */
if(!IS_CAN_ALL_PERIPH(hcan->Instance)) return HAL_ERROR;
/* Request Sleep mode */
hcan->Instance->MOD |= CAN_MOD_SM; //Enter Sleep Mode
/* Sleep mode status */
if ((hcan->Instance->MOD & CAN_MOD_SM) == CAN_MOD_SM)
{
/* Sleep mode entered */
status= HAL_OK;
}else
{
status=HAL_ERROR;
}
/* return sleep mode status */
return status;
}
/*********************************************************************************
* Function : HAL_CAN_WakeUp
* Description : Wakes the CAN up.
* Input : hcan : pointer to a CAN_HandleTypeDef structure that contains
* the configuration information for CAN module
* Output :
* Author : CWT Data : 2020
**********************************************************************************/
HAL_StatusTypeDef HAL_CAN_WakeUp(CAN_HandleTypeDef *hcan)
{
HAL_StatusTypeDef status;
/* Check the parameters */
if(!IS_CAN_ALL_PERIPH(hcan->Instance)) return HAL_ERROR;
/* sleep wake mode */
hcan->Instance->MOD &=~ CAN_MOD_SM; //Enter Sleep Mode
/* sleep wake status */
if ((hcan->Instance->MOD & CAN_MOD_SM)== CAN_MOD_SM)
{
/* sleep wake not entered */
status= HAL_ERROR;
}else
{
status=HAL_OK;
}
/* return sleep mode status */
return status;
}
/*********************************************************************************
* Function : HAL_CAN_GetTransmitErrorCounter
* Description : Returns the CANx Transmit Error Counter(TXERR).
* Input : hcan : pointer to a CAN_HandleTypeDef structure that contains
* the configuration information for CAN module
* Output :
* Author : CWT Data : 2020
**********************************************************************************/
int8_t HAL_CAN_GetTransmitErrorCounter(CAN_HandleTypeDef *hcan)
{
uint8_t counter=0;
/* Check the parameters */
if(!IS_CAN_ALL_PERIPH(hcan->Instance)) return -1;
/* Get the CANx Transmit Error Counter(TXERR) */
counter = (uint8_t)(hcan->Instance->TXERR);
/* Return the CANx Transmit Error Counter(TXERR) */
return counter;
}
/*********************************************************************************
* Function : HAL_CAN_GetReceiveErrorCounter
* Description : Returns the CANx Receive Error Counter(RXERR).
* Input : hcan : pointer to a CAN_HandleTypeDef structure that contains
* the configuration information for CAN module
* Output :
* Author : CWT Data : 2020
**********************************************************************************/
int8_t HAL_CAN_GetReceiveErrorCounter(CAN_HandleTypeDef *hcan)
{
uint8_t counter=0;
/* Check the parameters */
if(!IS_CAN_ALL_PERIPH(hcan->Instance)) return -1;
/* Get the CANx Receive Error Counter(RXERR) */
counter = (uint8_t)(hcan->Instance->RXERR);
/* Return the CANx Receive Error Counter(RXERR) */
return counter;
}
/*********************************************************************************
* Function : HAL_CAN_GetErrorCode
* Description : Returns the CANx's error code (ECC).
* Input : hcan : pointer to a CAN_HandleTypeDef structure that contains
* the configuration information for CAN module
* Input : Error_Type:This parameter can be one of the following flags:
* CAN_ErrorType_SegCode
* CAN_ErrorType_Direction
* CAN_ErrorType_ErrCode
* Output :
* Author : CWT Data : 2020
**********************************************************************************/
int8_t HAL_CAN_GetErrorCode(CAN_HandleTypeDef *hcan,uint32_t Error_Type)
{
uint8_t ErrorCode=0;
if(!IS_CAN_ALL_PERIPH(hcan->Instance)) return -1;
if(!IS_CAN_ErrorType(Error_Type)) return -1;
/* Get the CANx Error SegCode */
if(Error_Type==CAN_ErrorType_SegCode)
{
ErrorCode= (uint8_t)(hcan->Instance->ECC & CAN_ErrorType_SegCode);
}
/* Get the CANx Error Direction */
else if(Error_Type==CAN_ErrorType_Direction)
{
ErrorCode= (uint8_t)((hcan->Instance->ECC & CAN_ErrorType_Direction)>>5);
}
/* Get the CANx Error ErrCode */
else
{
ErrorCode= (uint8_t)((hcan->Instance->ECC & CAN_ErrorType_ErrCode)>>6);
}
return ErrorCode;
}
/*********************************************************************************
* Function : HAL_CAN_GetErrorAlarmCounter
* Description : Returns the CANx Error Alarm Counter(EWLR).
* Input : hcan : pointer to a CAN_HandleTypeDef structure that contains
* the configuration information for CAN module
* Output :
* Author : CWT Data : 2020
**********************************************************************************/
int8_t HAL_CAN_GetErrorAlarmCounter(CAN_HandleTypeDef *hcan)
{
uint8_t counter=0;
/* Check the parameters */
if(!IS_CAN_ALL_PERIPH(hcan->Instance)) return -1;
/* Get the CANx Error Alarm Counter(EWLR) */
counter = (uint8_t)(hcan->Instance->EWLR);
/* Return the CANx Error Alarm Counter(EWLR) */
return counter;
}
/*********************************************************************************
* Function : HAL_CAN_GetArbitrationErrorPosition
* Description : Returns the CANx Arbitration Error Position(ALC).
* Input : hcan : pointer to a CAN_HandleTypeDef structure that contains
* the configuration information for CAN module
* Output :
* Author : CWT Data : 2020
**********************************************************************************/
int8_t HAL_CAN_GetArbitrationErrorPosition(CAN_HandleTypeDef *hcan)
{
uint8_t position=0;
/* Check the parameters */
if(!IS_CAN_ALL_PERIPH(hcan->Instance)) return -1;
/* Get the CANx Arbitration Error Counter(ALC) */
position = (uint8_t)((hcan->Instance->ALC)+1);
/* Return the CANx Arbitration Error Counter(ALC) */
return position;
}
/*********************************************************************************
* Function : HAL_CAN_GetReceiveFiFoCounter
* Description : Returns the CANx Receive FiFo Counter(RMC).
* Input : hcan : pointer to a CAN_HandleTypeDef structure that contains
* the configuration information for CAN module
* Output :
* Author : CWT Data : 2020
**********************************************************************************/
int8_t HAL_CAN_GetReceiveFiFoCounter(CAN_HandleTypeDef *hcan)
{
uint8_t counter=0;
/* Check the parameters */
if(!IS_CAN_ALL_PERIPH(hcan->Instance)) return -1;
/* Get the CANx Receive FiFo Counter(RMC) */
counter = (uint8_t)(hcan->Instance->RMC);
/* Return the CANx Receive FiFo Counter(RMC) */
return counter;
}
/*********************************************************************************
* Function : HAL_CAN_GetReceiveFiFoAddr
* Description : Returns the CANx Receive FiFo start address(RBSA).
* Input : hcan : pointer to a CAN_HandleTypeDef structure that contains
* the configuration information for CAN module
* Output :
* Author : CWT Data : 2020
**********************************************************************************/
int8_t HAL_CAN_GetReceiveFiFoAddr(CAN_HandleTypeDef *hcan)
{
uint8_t addr=0;
/* Check the parameters */
if(!IS_CAN_ALL_PERIPH(hcan->Instance)) return -1;
/* Get the CANx Receive FiFo start address(RBSA) */
addr = (uint8_t)(hcan->Instance->RBSA);
/* Return the CANx Receive FiFo start address(RBSA) */
return addr;
}
/*********************************************************************************
* Function : HAL_CAN_ReleaseReceiveFIFO
* Description : Releases the Receive FIFO.
* Input : hcan : pointer to a CAN_HandleTypeDef structure that contains
* the configuration information for CAN module
* Output :
* Author : CWT Data : 2020
**********************************************************************************/
void HAL_CAN_ReleaseReceiveFIFO(CAN_HandleTypeDef *hcan)
{
/* Check the parameters */
if(!IS_CAN_ALL_PERIPH(hcan->Instance)) return;
/* Releases the Receive FIFO. */
hcan->Instance->CMR|=CAN_CMR_RRB;
}
/*********************************************************************************
* Function : HAL_CAN_ClearOverload
* Description : Clear Overload
* Input : hcan : pointer to a CAN_HandleTypeDef structure that contains
* the configuration information for CAN module
* Output :
* Author : CWT Data : 2020
**********************************************************************************/
void HAL_CAN_ClearOverload(CAN_HandleTypeDef *hcan)
{
/* Check the parameters */
if(!IS_CAN_ALL_PERIPH(hcan->Instance)) return;
/* Clear Overload. */
hcan->Instance->CMR|=CAN_CMR_CDO;
}
/*********************************************************************************
* Function : HAL_CAN_SlefReceive
* Description : Slef Receive
* Input : hcan : pointer to a CAN_HandleTypeDef structure that contains
* the configuration information for CAN module
* Output :
* Author : CWT Data : 2020
**********************************************************************************/
void HAL_CAN_SelfReceive(CAN_HandleTypeDef *hcan)
{
/* Check the parameters */
if(!IS_CAN_ALL_PERIPH(hcan->Instance)) return;
/* Slef Receive. */
hcan->Instance->CMR|=CAN_CMR_SRR;
while((hcan->Instance->SR & CAN_SR_TCS)==0x00); //wait for send ok
}
/*********************************************************************************
* Function : HAL_CAN_IRQHandler
* Description : This function handles CAN interrupt request.
* Input : hdma : pointer to a CAN_HandleTypeDef structure that contains
* the configuration information for CAN module
* Outpu :
* Author : Chris_Kyle Data : 2020
**********************************************************************************/
void HAL_CAN_IRQHandler(CAN_HandleTypeDef *hcan)
{
volatile uint32_t lu32_IR;
lu32_IR = hcan->Instance->IR;//read clear
if(lu32_IR & CAN_IR_RI) //RI
{
/* CAN ReceiveIT complete callback */
HAL_CAN_GetRxMessage(hcan, hcan->RxMessage);
hcan->CAN_ReceiveIT_Callback(hcan);
}
if(lu32_IR & CAN_IR_TI) //TI
{
/* CAN TransmitIT complete callback */
hcan->CAN_TransmitIT_Callback(hcan);
}
}