WebSVN – AFRtranscoder – Blame – /trunk/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_can.c

Rev	Author	Line No.	Line
2	mjames	1	/**
		2	******************************************************************************
		3	* @file stm32f1xx_hal_can.c
		4	* @author MCD Application Team
		5	* @brief CAN HAL module driver.
		6	* This file provides firmware functions to manage the following
		7	* functionalities of the Controller Area Network (CAN) peripheral:
		8	* + Initialization and de-initialization functions
		9	* + Configuration functions
		10	* + Control functions
		11	* + Interrupts management
		12	* + Callbacks functions
		13	* + Peripheral State and Error functions
		14	*
		15	******************************************************************************
		16	* @attention
		17	*
		18	* Copyright (c) 2016 STMicroelectronics.
		19	* All rights reserved.
		20	*
		21	* This software is licensed under terms that can be found in the LICENSE file
		22	* in the root directory of this software component.
		23	* If no LICENSE file comes with this software, it is provided AS-IS.
		24	*
		25	******************************************************************************
		26	@verbatim
		27	==============================================================================
		28	##### How to use this driver #####
		29	==============================================================================
		30	[..]
		31	(#) Initialize the CAN low level resources by implementing the
		32	HAL_CAN_MspInit():
		33	(++) Enable the CAN interface clock using __HAL_RCC_CANx_CLK_ENABLE()
		34	(++) Configure CAN pins
		35	(+++) Enable the clock for the CAN GPIOs
		36	(+++) Configure CAN pins as alternate function open-drain
		37	(++) In case of using interrupts (e.g. HAL_CAN_ActivateNotification())
		38	(+++) Configure the CAN interrupt priority using
		39	HAL_NVIC_SetPriority()
		40	(+++) Enable the CAN IRQ handler using HAL_NVIC_EnableIRQ()
		41	(+++) In CAN IRQ handler, call HAL_CAN_IRQHandler()
		42
		43	(#) Initialize the CAN peripheral using HAL_CAN_Init() function. This
		44	function resorts to HAL_CAN_MspInit() for low-level initialization.
		45
		46	(#) Configure the reception filters using the following configuration
		47	functions:
		48	(++) HAL_CAN_ConfigFilter()
		49
		50	(#) Start the CAN module using HAL_CAN_Start() function. At this level
		51	the node is active on the bus: it receive messages, and can send
		52	messages.
		53
		54	(#) To manage messages transmission, the following Tx control functions
		55	can be used:
		56	(++) HAL_CAN_AddTxMessage() to request transmission of a new
		57	message.
		58	(++) HAL_CAN_AbortTxRequest() to abort transmission of a pending
		59	message.
		60	(++) HAL_CAN_GetTxMailboxesFreeLevel() to get the number of free Tx
		61	mailboxes.
		62	(++) HAL_CAN_IsTxMessagePending() to check if a message is pending
		63	in a Tx mailbox.
		64	(++) HAL_CAN_GetTxTimestamp() to get the timestamp of Tx message
		65	sent, if time triggered communication mode is enabled.
		66
		67	(#) When a message is received into the CAN Rx FIFOs, it can be retrieved
		68	using the HAL_CAN_GetRxMessage() function. The function
		69	HAL_CAN_GetRxFifoFillLevel() allows to know how many Rx message are
		70	stored in the Rx Fifo.
		71
		72	(#) Calling the HAL_CAN_Stop() function stops the CAN module.
		73
		74	(#) The deinitialization is achieved with HAL_CAN_DeInit() function.
		75
		76
		77	* Polling mode operation *
		78	==============================
		79	[..]
		80	(#) Reception:
		81	(++) Monitor reception of message using HAL_CAN_GetRxFifoFillLevel()
		82	until at least one message is received.
		83	(++) Then get the message using HAL_CAN_GetRxMessage().
		84
		85	(#) Transmission:
		86	(++) Monitor the Tx mailboxes availability until at least one Tx
		87	mailbox is free, using HAL_CAN_GetTxMailboxesFreeLevel().
		88	(++) Then request transmission of a message using
		89	HAL_CAN_AddTxMessage().
		90
		91
		92	* Interrupt mode operation *
		93	================================
		94	[..]
		95	(#) Notifications are activated using HAL_CAN_ActivateNotification()
		96	function. Then, the process can be controlled through the
		97	available user callbacks: HAL_CAN_xxxCallback(), using same APIs
		98	HAL_CAN_GetRxMessage() and HAL_CAN_AddTxMessage().
		99
		100	(#) Notifications can be deactivated using
		101	HAL_CAN_DeactivateNotification() function.
		102
		103	(#) Special care should be taken for CAN_IT_RX_FIFO0_MSG_PENDING and
		104	CAN_IT_RX_FIFO1_MSG_PENDING notifications. These notifications trig
		105	the callbacks HAL_CAN_RxFIFO0MsgPendingCallback() and
		106	HAL_CAN_RxFIFO1MsgPendingCallback(). User has two possible options
		107	here.
		108	(++) Directly get the Rx message in the callback, using
		109	HAL_CAN_GetRxMessage().
		110	(++) Or deactivate the notification in the callback without
		111	getting the Rx message. The Rx message can then be got later
		112	using HAL_CAN_GetRxMessage(). Once the Rx message have been
		113	read, the notification can be activated again.
		114
		115
		116	* Sleep mode *
		117	==================
		118	[..]
		119	(#) The CAN peripheral can be put in sleep mode (low power), using
		120	HAL_CAN_RequestSleep(). The sleep mode will be entered as soon as the
		121	current CAN activity (transmission or reception of a CAN frame) will
		122	be completed.
		123
		124	(#) A notification can be activated to be informed when the sleep mode
		125	will be entered.
		126
		127	(#) It can be checked if the sleep mode is entered using
		128	HAL_CAN_IsSleepActive().
		129	Note that the CAN state (accessible from the API HAL_CAN_GetState())
		130	is HAL_CAN_STATE_SLEEP_PENDING as soon as the sleep mode request is
		131	submitted (the sleep mode is not yet entered), and become
		132	HAL_CAN_STATE_SLEEP_ACTIVE when the sleep mode is effective.
		133
		134	(#) The wake-up from sleep mode can be triggered by two ways:
		135	(++) Using HAL_CAN_WakeUp(). When returning from this function,
		136	the sleep mode is exited (if return status is HAL_OK).
		137	(++) When a start of Rx CAN frame is detected by the CAN peripheral,
		138	if automatic wake up mode is enabled.
		139
		140	* Callback registration *
		141	=============================================
		142
		143	The compilation define USE_HAL_CAN_REGISTER_CALLBACKS when set to 1
		144	allows the user to configure dynamically the driver callbacks.
		145	Use Function HAL_CAN_RegisterCallback() to register an interrupt callback.
		146
		147	Function HAL_CAN_RegisterCallback() allows to register following callbacks:
		148	(+) TxMailbox0CompleteCallback : Tx Mailbox 0 Complete Callback.
		149	(+) TxMailbox1CompleteCallback : Tx Mailbox 1 Complete Callback.
		150	(+) TxMailbox2CompleteCallback : Tx Mailbox 2 Complete Callback.
		151	(+) TxMailbox0AbortCallback : Tx Mailbox 0 Abort Callback.
		152	(+) TxMailbox1AbortCallback : Tx Mailbox 1 Abort Callback.
		153	(+) TxMailbox2AbortCallback : Tx Mailbox 2 Abort Callback.
		154	(+) RxFifo0MsgPendingCallback : Rx Fifo 0 Message Pending Callback.
		155	(+) RxFifo0FullCallback : Rx Fifo 0 Full Callback.
		156	(+) RxFifo1MsgPendingCallback : Rx Fifo 1 Message Pending Callback.
		157	(+) RxFifo1FullCallback : Rx Fifo 1 Full Callback.
		158	(+) SleepCallback : Sleep Callback.
		159	(+) WakeUpFromRxMsgCallback : Wake Up From Rx Message Callback.
		160	(+) ErrorCallback : Error Callback.
		161	(+) MspInitCallback : CAN MspInit.
		162	(+) MspDeInitCallback : CAN MspDeInit.
		163	This function takes as parameters the HAL peripheral handle, the Callback ID
		164	and a pointer to the user callback function.
		165
		166	Use function HAL_CAN_UnRegisterCallback() to reset a callback to the default
		167	weak function.
		168	HAL_CAN_UnRegisterCallback takes as parameters the HAL peripheral handle,
		169	and the Callback ID.
		170	This function allows to reset following callbacks:
		171	(+) TxMailbox0CompleteCallback : Tx Mailbox 0 Complete Callback.
		172	(+) TxMailbox1CompleteCallback : Tx Mailbox 1 Complete Callback.
		173	(+) TxMailbox2CompleteCallback : Tx Mailbox 2 Complete Callback.
		174	(+) TxMailbox0AbortCallback : Tx Mailbox 0 Abort Callback.
		175	(+) TxMailbox1AbortCallback : Tx Mailbox 1 Abort Callback.
		176	(+) TxMailbox2AbortCallback : Tx Mailbox 2 Abort Callback.
		177	(+) RxFifo0MsgPendingCallback : Rx Fifo 0 Message Pending Callback.
		178	(+) RxFifo0FullCallback : Rx Fifo 0 Full Callback.
		179	(+) RxFifo1MsgPendingCallback : Rx Fifo 1 Message Pending Callback.
		180	(+) RxFifo1FullCallback : Rx Fifo 1 Full Callback.
		181	(+) SleepCallback : Sleep Callback.
		182	(+) WakeUpFromRxMsgCallback : Wake Up From Rx Message Callback.
		183	(+) ErrorCallback : Error Callback.
		184	(+) MspInitCallback : CAN MspInit.
		185	(+) MspDeInitCallback : CAN MspDeInit.
		186
		187	By default, after the HAL_CAN_Init() and when the state is HAL_CAN_STATE_RESET,
		188	all callbacks are set to the corresponding weak functions:
		189	example HAL_CAN_ErrorCallback().
		190	Exception done for MspInit and MspDeInit functions that are
		191	reset to the legacy weak function in the HAL_CAN_Init()/ HAL_CAN_DeInit() only when
		192	these callbacks are null (not registered beforehand).
		193	if not, MspInit or MspDeInit are not null, the HAL_CAN_Init()/ HAL_CAN_DeInit()
		194	keep and use the user MspInit/MspDeInit callbacks (registered beforehand)
		195
		196	Callbacks can be registered/unregistered in HAL_CAN_STATE_READY state only.
		197	Exception done MspInit/MspDeInit that can be registered/unregistered
		198	in HAL_CAN_STATE_READY or HAL_CAN_STATE_RESET state,
		199	thus registered (user) MspInit/DeInit callbacks can be used during the Init/DeInit.
		200	In that case first register the MspInit/MspDeInit user callbacks
		201	using HAL_CAN_RegisterCallback() before calling HAL_CAN_DeInit()
		202	or HAL_CAN_Init() function.
		203
		204	When The compilation define USE_HAL_CAN_REGISTER_CALLBACKS is set to 0 or
		205	not defined, the callback registration feature is not available and all callbacks
		206	are set to the corresponding weak functions.
		207
		208	@endverbatim
		209	******************************************************************************
		210	*/
		211
		212	/* Includes ------------------------------------------------------------------*/
		213	#include "stm32f1xx_hal.h"
		214
		215	/** @addtogroup STM32F1xx_HAL_Driver
		216	* @{
		217	*/
		218
		219	#if defined(CAN1)
		220
		221	/** @defgroup CAN CAN
		222	* @brief CAN driver modules
		223	* @{
		224	*/
		225
		226	#ifdef HAL_CAN_MODULE_ENABLED
		227
		228	#ifdef HAL_CAN_LEGACY_MODULE_ENABLED
		229	#error "The CAN driver cannot be used with its legacy, Please enable only one CAN module at once"
		230	#endif /* HAL_CAN_LEGACY_MODULE_ENABLED */
		231
		232	/* Private typedef -----------------------------------------------------------*/
		233	/* Private define ------------------------------------------------------------*/
		234	/** @defgroup CAN_Private_Constants CAN Private Constants
		235	* @{
		236	*/
		237	#define CAN_TIMEOUT_VALUE 10U
		238	/**
		239	* @}
		240	*/
		241	/* Private macro -------------------------------------------------------------*/
		242	/* Private variables ---------------------------------------------------------*/
		243	/* Private function prototypes -----------------------------------------------*/
		244	/* Exported functions --------------------------------------------------------*/
		245
		246	/** @defgroup CAN_Exported_Functions CAN Exported Functions
		247	* @{
		248	*/
		249
		250	/** @defgroup CAN_Exported_Functions_Group1 Initialization and de-initialization functions
		251	* @brief Initialization and Configuration functions
		252	*
		253	@verbatim
		254	==============================================================================
		255	##### Initialization and de-initialization functions #####
		256	==============================================================================
		257	[..] This section provides functions allowing to:
		258	(+) HAL_CAN_Init : Initialize and configure the CAN.
		259	(+) HAL_CAN_DeInit : De-initialize the CAN.
		260	(+) HAL_CAN_MspInit : Initialize the CAN MSP.
		261	(+) HAL_CAN_MspDeInit : DeInitialize the CAN MSP.
		262
		263	@endverbatim
		264	* @{
		265	*/
		266
		267	/**
		268	* @brief Initializes the CAN peripheral according to the specified
		269	* parameters in the CAN_InitStruct.
		270	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		271	* the configuration information for the specified CAN.
		272	* @retval HAL status
		273	*/
		274	HAL_StatusTypeDef HAL_CAN_Init(CAN_HandleTypeDef *hcan)
		275	{
		276	uint32_t tickstart;
		277
		278	/* Check CAN handle */
		279	if (hcan == NULL)
		280	{
		281	return HAL_ERROR;
		282	}
		283
		284	/* Check the parameters */
		285	assert_param(IS_CAN_ALL_INSTANCE(hcan->Instance));
		286	assert_param(IS_FUNCTIONAL_STATE(hcan->Init.TimeTriggeredMode));
		287	assert_param(IS_FUNCTIONAL_STATE(hcan->Init.AutoBusOff));
		288	assert_param(IS_FUNCTIONAL_STATE(hcan->Init.AutoWakeUp));
		289	assert_param(IS_FUNCTIONAL_STATE(hcan->Init.AutoRetransmission));
		290	assert_param(IS_FUNCTIONAL_STATE(hcan->Init.ReceiveFifoLocked));
		291	assert_param(IS_FUNCTIONAL_STATE(hcan->Init.TransmitFifoPriority));
		292	assert_param(IS_CAN_MODE(hcan->Init.Mode));
		293	assert_param(IS_CAN_SJW(hcan->Init.SyncJumpWidth));
		294	assert_param(IS_CAN_BS1(hcan->Init.TimeSeg1));
		295	assert_param(IS_CAN_BS2(hcan->Init.TimeSeg2));
		296	assert_param(IS_CAN_PRESCALER(hcan->Init.Prescaler));
		297
		298	#if USE_HAL_CAN_REGISTER_CALLBACKS == 1
		299	if (hcan->State == HAL_CAN_STATE_RESET)
		300	{
		301	/* Reset callbacks to legacy functions */
		302	hcan->RxFifo0MsgPendingCallback = HAL_CAN_RxFifo0MsgPendingCallback; /* Legacy weak RxFifo0MsgPendingCallback */
		303	hcan->RxFifo0FullCallback = HAL_CAN_RxFifo0FullCallback; /* Legacy weak RxFifo0FullCallback */
		304	hcan->RxFifo1MsgPendingCallback = HAL_CAN_RxFifo1MsgPendingCallback; /* Legacy weak RxFifo1MsgPendingCallback */
		305	hcan->RxFifo1FullCallback = HAL_CAN_RxFifo1FullCallback; /* Legacy weak RxFifo1FullCallback */
		306	hcan->TxMailbox0CompleteCallback = HAL_CAN_TxMailbox0CompleteCallback; /* Legacy weak TxMailbox0CompleteCallback */
		307	hcan->TxMailbox1CompleteCallback = HAL_CAN_TxMailbox1CompleteCallback; /* Legacy weak TxMailbox1CompleteCallback */
		308	hcan->TxMailbox2CompleteCallback = HAL_CAN_TxMailbox2CompleteCallback; /* Legacy weak TxMailbox2CompleteCallback */
		309	hcan->TxMailbox0AbortCallback = HAL_CAN_TxMailbox0AbortCallback; /* Legacy weak TxMailbox0AbortCallback */
		310	hcan->TxMailbox1AbortCallback = HAL_CAN_TxMailbox1AbortCallback; /* Legacy weak TxMailbox1AbortCallback */
		311	hcan->TxMailbox2AbortCallback = HAL_CAN_TxMailbox2AbortCallback; /* Legacy weak TxMailbox2AbortCallback */
		312	hcan->SleepCallback = HAL_CAN_SleepCallback; /* Legacy weak SleepCallback */
		313	hcan->WakeUpFromRxMsgCallback = HAL_CAN_WakeUpFromRxMsgCallback; /* Legacy weak WakeUpFromRxMsgCallback */
		314	hcan->ErrorCallback = HAL_CAN_ErrorCallback; /* Legacy weak ErrorCallback */
		315
		316	if (hcan->MspInitCallback == NULL)
		317	{
		318	hcan->MspInitCallback = HAL_CAN_MspInit; /* Legacy weak MspInit */
		319	}
		320
		321	/* Init the low level hardware: CLOCK, NVIC */
		322	hcan->MspInitCallback(hcan);
		323	}
		324
		325	#else
		326	if (hcan->State == HAL_CAN_STATE_RESET)
		327	{
		328	/* Init the low level hardware: CLOCK, NVIC */
		329	HAL_CAN_MspInit(hcan);
		330	}
		331	#endif /* (USE_HAL_CAN_REGISTER_CALLBACKS) */
		332
		333	/* Request initialisation */
		334	SET_BIT(hcan->Instance->MCR, CAN_MCR_INRQ);
		335
		336	/* Get tick */
		337	tickstart = HAL_GetTick();
		338
		339	/* Wait initialisation acknowledge */
		340	while ((hcan->Instance->MSR & CAN_MSR_INAK) == 0U)
		341	{
		342	if ((HAL_GetTick() - tickstart) > CAN_TIMEOUT_VALUE)
		343	{
		344	/* Update error code */
		345	hcan->ErrorCode \|= HAL_CAN_ERROR_TIMEOUT;
		346
		347	/* Change CAN state */
		348	hcan->State = HAL_CAN_STATE_ERROR;
		349
		350	return HAL_ERROR;
		351	}
		352	}
		353
		354	/* Exit from sleep mode */
		355	CLEAR_BIT(hcan->Instance->MCR, CAN_MCR_SLEEP);
		356
		357	/* Get tick */
		358	tickstart = HAL_GetTick();
		359
		360	/* Check Sleep mode leave acknowledge */
		361	while ((hcan->Instance->MSR & CAN_MSR_SLAK) != 0U)
		362	{
		363	if ((HAL_GetTick() - tickstart) > CAN_TIMEOUT_VALUE)
		364	{
		365	/* Update error code */
		366	hcan->ErrorCode \|= HAL_CAN_ERROR_TIMEOUT;
		367
		368	/* Change CAN state */
		369	hcan->State = HAL_CAN_STATE_ERROR;
		370
		371	return HAL_ERROR;
		372	}
		373	}
		374
		375	/* Set the time triggered communication mode */
		376	if (hcan->Init.TimeTriggeredMode == ENABLE)
		377	{
		378	SET_BIT(hcan->Instance->MCR, CAN_MCR_TTCM);
		379	}
		380	else
		381	{
		382	CLEAR_BIT(hcan->Instance->MCR, CAN_MCR_TTCM);
		383	}
		384
		385	/* Set the automatic bus-off management */
		386	if (hcan->Init.AutoBusOff == ENABLE)
		387	{
		388	SET_BIT(hcan->Instance->MCR, CAN_MCR_ABOM);
		389	}
		390	else
		391	{
		392	CLEAR_BIT(hcan->Instance->MCR, CAN_MCR_ABOM);
		393	}
		394
		395	/* Set the automatic wake-up mode */
		396	if (hcan->Init.AutoWakeUp == ENABLE)
		397	{
		398	SET_BIT(hcan->Instance->MCR, CAN_MCR_AWUM);
		399	}
		400	else
		401	{
		402	CLEAR_BIT(hcan->Instance->MCR, CAN_MCR_AWUM);
		403	}
		404
		405	/* Set the automatic retransmission */
		406	if (hcan->Init.AutoRetransmission == ENABLE)
		407	{
		408	CLEAR_BIT(hcan->Instance->MCR, CAN_MCR_NART);
		409	}
		410	else
		411	{
		412	SET_BIT(hcan->Instance->MCR, CAN_MCR_NART);
		413	}
		414
		415	/* Set the receive FIFO locked mode */
		416	if (hcan->Init.ReceiveFifoLocked == ENABLE)
		417	{
		418	SET_BIT(hcan->Instance->MCR, CAN_MCR_RFLM);
		419	}
		420	else
		421	{
		422	CLEAR_BIT(hcan->Instance->MCR, CAN_MCR_RFLM);
		423	}
		424
		425	/* Set the transmit FIFO priority */
		426	if (hcan->Init.TransmitFifoPriority == ENABLE)
		427	{
		428	SET_BIT(hcan->Instance->MCR, CAN_MCR_TXFP);
		429	}
		430	else
		431	{
		432	CLEAR_BIT(hcan->Instance->MCR, CAN_MCR_TXFP);
		433	}
		434
		435	/* Set the bit timing register */
		436	WRITE_REG(hcan->Instance->BTR, (uint32_t)(hcan->Init.Mode \|
		437	hcan->Init.SyncJumpWidth \|
		438	hcan->Init.TimeSeg1 \|
		439	hcan->Init.TimeSeg2 \|
		440	(hcan->Init.Prescaler - 1U)));
		441
		442	/* Initialize the error code */
		443	hcan->ErrorCode = HAL_CAN_ERROR_NONE;
		444
		445	/* Initialize the CAN state */
		446	hcan->State = HAL_CAN_STATE_READY;
		447
		448	/* Return function status */
		449	return HAL_OK;
		450	}
		451
		452	/**
		453	* @brief Deinitializes the CAN peripheral registers to their default
		454	* reset values.
		455	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		456	* the configuration information for the specified CAN.
		457	* @retval HAL status
		458	*/
		459	HAL_StatusTypeDef HAL_CAN_DeInit(CAN_HandleTypeDef *hcan)
		460	{
		461	/* Check CAN handle */
		462	if (hcan == NULL)
		463	{
		464	return HAL_ERROR;
		465	}
		466
		467	/* Check the parameters */
		468	assert_param(IS_CAN_ALL_INSTANCE(hcan->Instance));
		469
		470	/* Stop the CAN module */
		471	(void)HAL_CAN_Stop(hcan);
		472
		473	#if USE_HAL_CAN_REGISTER_CALLBACKS == 1
		474	if (hcan->MspDeInitCallback == NULL)
		475	{
		476	hcan->MspDeInitCallback = HAL_CAN_MspDeInit; /* Legacy weak MspDeInit */
		477	}
		478
		479	/* DeInit the low level hardware: CLOCK, NVIC */
		480	hcan->MspDeInitCallback(hcan);
		481
		482	#else
		483	/* DeInit the low level hardware: CLOCK, NVIC */
		484	HAL_CAN_MspDeInit(hcan);
		485	#endif /* (USE_HAL_CAN_REGISTER_CALLBACKS) */
		486
		487	/* Reset the CAN peripheral */
		488	SET_BIT(hcan->Instance->MCR, CAN_MCR_RESET);
		489
		490	/* Reset the CAN ErrorCode */
		491	hcan->ErrorCode = HAL_CAN_ERROR_NONE;
		492
		493	/* Change CAN state */
		494	hcan->State = HAL_CAN_STATE_RESET;
		495
		496	/* Return function status */
		497	return HAL_OK;
		498	}
		499
		500	/**
		501	* @brief Initializes the CAN MSP.
		502	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		503	* the configuration information for the specified CAN.
		504	* @retval None
		505	*/
		506	__weak void HAL_CAN_MspInit(CAN_HandleTypeDef *hcan)
		507	{
		508	/* Prevent unused argument(s) compilation warning */
		509	UNUSED(hcan);
		510
		511	/* NOTE : This function Should not be modified, when the callback is needed,
		512	the HAL_CAN_MspInit could be implemented in the user file
		513	*/
		514	}
		515
		516	/**
		517	* @brief DeInitializes the CAN MSP.
		518	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		519	* the configuration information for the specified CAN.
		520	* @retval None
		521	*/
		522	__weak void HAL_CAN_MspDeInit(CAN_HandleTypeDef *hcan)
		523	{
		524	/* Prevent unused argument(s) compilation warning */
		525	UNUSED(hcan);
		526
		527	/* NOTE : This function Should not be modified, when the callback is needed,
		528	the HAL_CAN_MspDeInit could be implemented in the user file
		529	*/
		530	}
		531
		532	#if USE_HAL_CAN_REGISTER_CALLBACKS == 1
		533	/**
		534	* @brief Register a CAN CallBack.
		535	* To be used instead of the weak predefined callback
		536	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		537	* the configuration information for CAN module
		538	* @param CallbackID ID of the callback to be registered
		539	* This parameter can be one of the following values:
		540	* @arg @ref HAL_CAN_TX_MAILBOX0_COMPLETE_CB_ID Tx Mailbox 0 Complete callback ID
		541	* @arg @ref HAL_CAN_TX_MAILBOX1_COMPLETE_CB_ID Tx Mailbox 1 Complete callback ID
		542	* @arg @ref HAL_CAN_TX_MAILBOX2_COMPLETE_CB_ID Tx Mailbox 2 Complete callback ID
		543	* @arg @ref HAL_CAN_TX_MAILBOX0_ABORT_CB_ID Tx Mailbox 0 Abort callback ID
		544	* @arg @ref HAL_CAN_TX_MAILBOX1_ABORT_CB_ID Tx Mailbox 1 Abort callback ID
		545	* @arg @ref HAL_CAN_TX_MAILBOX2_ABORT_CB_ID Tx Mailbox 2 Abort callback ID
		546	* @arg @ref HAL_CAN_RX_FIFO0_MSG_PENDING_CB_ID Rx Fifo 0 message pending callback ID
		547	* @arg @ref HAL_CAN_RX_FIFO0_FULL_CB_ID Rx Fifo 0 full callback ID
		548	* @arg @ref HAL_CAN_RX_FIFO1_MSG_PENDING_CB_ID Rx Fifo 1 message pending callback ID
		549	* @arg @ref HAL_CAN_RX_FIFO1_FULL_CB_ID Rx Fifo 1 full callback ID
		550	* @arg @ref HAL_CAN_SLEEP_CB_ID Sleep callback ID
		551	* @arg @ref HAL_CAN_WAKEUP_FROM_RX_MSG_CB_ID Wake Up from Rx message callback ID
		552	* @arg @ref HAL_CAN_ERROR_CB_ID Error callback ID
		553	* @arg @ref HAL_CAN_MSPINIT_CB_ID MspInit callback ID
		554	* @arg @ref HAL_CAN_MSPDEINIT_CB_ID MspDeInit callback ID
		555	* @param pCallback pointer to the Callback function
		556	* @retval HAL status
		557	*/
		558	HAL_StatusTypeDef HAL_CAN_RegisterCallback(CAN_HandleTypeDef *hcan, HAL_CAN_CallbackIDTypeDef CallbackID,
		559	void (* pCallback)(CAN_HandleTypeDef *_hcan))
		560	{
		561	HAL_StatusTypeDef status = HAL_OK;
		562
		563	if (pCallback == NULL)
		564	{
		565	/* Update the error code */
		566	hcan->ErrorCode \|= HAL_CAN_ERROR_INVALID_CALLBACK;
		567
		568	return HAL_ERROR;
		569	}
		570
		571	if (hcan->State == HAL_CAN_STATE_READY)
		572	{
		573	switch (CallbackID)
		574	{
		575	case HAL_CAN_TX_MAILBOX0_COMPLETE_CB_ID :
		576	hcan->TxMailbox0CompleteCallback = pCallback;
		577	break;
		578
		579	case HAL_CAN_TX_MAILBOX1_COMPLETE_CB_ID :
		580	hcan->TxMailbox1CompleteCallback = pCallback;
		581	break;
		582
		583	case HAL_CAN_TX_MAILBOX2_COMPLETE_CB_ID :
		584	hcan->TxMailbox2CompleteCallback = pCallback;
		585	break;
		586
		587	case HAL_CAN_TX_MAILBOX0_ABORT_CB_ID :
		588	hcan->TxMailbox0AbortCallback = pCallback;
		589	break;
		590
		591	case HAL_CAN_TX_MAILBOX1_ABORT_CB_ID :
		592	hcan->TxMailbox1AbortCallback = pCallback;
		593	break;
		594
		595	case HAL_CAN_TX_MAILBOX2_ABORT_CB_ID :
		596	hcan->TxMailbox2AbortCallback = pCallback;
		597	break;
		598
		599	case HAL_CAN_RX_FIFO0_MSG_PENDING_CB_ID :
		600	hcan->RxFifo0MsgPendingCallback = pCallback;
		601	break;
		602
		603	case HAL_CAN_RX_FIFO0_FULL_CB_ID :
		604	hcan->RxFifo0FullCallback = pCallback;
		605	break;
		606
		607	case HAL_CAN_RX_FIFO1_MSG_PENDING_CB_ID :
		608	hcan->RxFifo1MsgPendingCallback = pCallback;
		609	break;
		610
		611	case HAL_CAN_RX_FIFO1_FULL_CB_ID :
		612	hcan->RxFifo1FullCallback = pCallback;
		613	break;
		614
		615	case HAL_CAN_SLEEP_CB_ID :
		616	hcan->SleepCallback = pCallback;
		617	break;
		618
		619	case HAL_CAN_WAKEUP_FROM_RX_MSG_CB_ID :
		620	hcan->WakeUpFromRxMsgCallback = pCallback;
		621	break;
		622
		623	case HAL_CAN_ERROR_CB_ID :
		624	hcan->ErrorCallback = pCallback;
		625	break;
		626
		627	case HAL_CAN_MSPINIT_CB_ID :
		628	hcan->MspInitCallback = pCallback;
		629	break;
		630
		631	case HAL_CAN_MSPDEINIT_CB_ID :
		632	hcan->MspDeInitCallback = pCallback;
		633	break;
		634
		635	default :
		636	/* Update the error code */
		637	hcan->ErrorCode \|= HAL_CAN_ERROR_INVALID_CALLBACK;
		638
		639	/* Return error status */
		640	status = HAL_ERROR;
		641	break;
		642	}
		643	}
		644	else if (hcan->State == HAL_CAN_STATE_RESET)
		645	{
		646	switch (CallbackID)
		647	{
		648	case HAL_CAN_MSPINIT_CB_ID :
		649	hcan->MspInitCallback = pCallback;
		650	break;
		651
		652	case HAL_CAN_MSPDEINIT_CB_ID :
		653	hcan->MspDeInitCallback = pCallback;
		654	break;
		655
		656	default :
		657	/* Update the error code */
		658	hcan->ErrorCode \|= HAL_CAN_ERROR_INVALID_CALLBACK;
		659
		660	/* Return error status */
		661	status = HAL_ERROR;
		662	break;
		663	}
		664	}
		665	else
		666	{
		667	/* Update the error code */
		668	hcan->ErrorCode \|= HAL_CAN_ERROR_INVALID_CALLBACK;
		669
		670	/* Return error status */
		671	status = HAL_ERROR;
		672	}
		673
		674	return status;
		675	}
		676
		677	/**
		678	* @brief Unregister a CAN CallBack.
		679	* CAN callback is redirected to the weak predefined callback
		680	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		681	* the configuration information for CAN module
		682	* @param CallbackID ID of the callback to be unregistered
		683	* This parameter can be one of the following values:
		684	* @arg @ref HAL_CAN_TX_MAILBOX0_COMPLETE_CB_ID Tx Mailbox 0 Complete callback ID
		685	* @arg @ref HAL_CAN_TX_MAILBOX1_COMPLETE_CB_ID Tx Mailbox 1 Complete callback ID
		686	* @arg @ref HAL_CAN_TX_MAILBOX2_COMPLETE_CB_ID Tx Mailbox 2 Complete callback ID
		687	* @arg @ref HAL_CAN_TX_MAILBOX0_ABORT_CB_ID Tx Mailbox 0 Abort callback ID
		688	* @arg @ref HAL_CAN_TX_MAILBOX1_ABORT_CB_ID Tx Mailbox 1 Abort callback ID
		689	* @arg @ref HAL_CAN_TX_MAILBOX2_ABORT_CB_ID Tx Mailbox 2 Abort callback ID
		690	* @arg @ref HAL_CAN_RX_FIFO0_MSG_PENDING_CB_ID Rx Fifo 0 message pending callback ID
		691	* @arg @ref HAL_CAN_RX_FIFO0_FULL_CB_ID Rx Fifo 0 full callback ID
		692	* @arg @ref HAL_CAN_RX_FIFO1_MSG_PENDING_CB_ID Rx Fifo 1 message pending callback ID
		693	* @arg @ref HAL_CAN_RX_FIFO1_FULL_CB_ID Rx Fifo 1 full callback ID
		694	* @arg @ref HAL_CAN_SLEEP_CB_ID Sleep callback ID
		695	* @arg @ref HAL_CAN_WAKEUP_FROM_RX_MSG_CB_ID Wake Up from Rx message callback ID
		696	* @arg @ref HAL_CAN_ERROR_CB_ID Error callback ID
		697	* @arg @ref HAL_CAN_MSPINIT_CB_ID MspInit callback ID
		698	* @arg @ref HAL_CAN_MSPDEINIT_CB_ID MspDeInit callback ID
		699	* @retval HAL status
		700	*/
		701	HAL_StatusTypeDef HAL_CAN_UnRegisterCallback(CAN_HandleTypeDef *hcan, HAL_CAN_CallbackIDTypeDef CallbackID)
		702	{
		703	HAL_StatusTypeDef status = HAL_OK;
		704
		705	if (hcan->State == HAL_CAN_STATE_READY)
		706	{
		707	switch (CallbackID)
		708	{
		709	case HAL_CAN_TX_MAILBOX0_COMPLETE_CB_ID :
		710	hcan->TxMailbox0CompleteCallback = HAL_CAN_TxMailbox0CompleteCallback;
		711	break;
		712
		713	case HAL_CAN_TX_MAILBOX1_COMPLETE_CB_ID :
		714	hcan->TxMailbox1CompleteCallback = HAL_CAN_TxMailbox1CompleteCallback;
		715	break;
		716
		717	case HAL_CAN_TX_MAILBOX2_COMPLETE_CB_ID :
		718	hcan->TxMailbox2CompleteCallback = HAL_CAN_TxMailbox2CompleteCallback;
		719	break;
		720
		721	case HAL_CAN_TX_MAILBOX0_ABORT_CB_ID :
		722	hcan->TxMailbox0AbortCallback = HAL_CAN_TxMailbox0AbortCallback;
		723	break;
		724
		725	case HAL_CAN_TX_MAILBOX1_ABORT_CB_ID :
		726	hcan->TxMailbox1AbortCallback = HAL_CAN_TxMailbox1AbortCallback;
		727	break;
		728
		729	case HAL_CAN_TX_MAILBOX2_ABORT_CB_ID :
		730	hcan->TxMailbox2AbortCallback = HAL_CAN_TxMailbox2AbortCallback;
		731	break;
		732
		733	case HAL_CAN_RX_FIFO0_MSG_PENDING_CB_ID :
		734	hcan->RxFifo0MsgPendingCallback = HAL_CAN_RxFifo0MsgPendingCallback;
		735	break;
		736
		737	case HAL_CAN_RX_FIFO0_FULL_CB_ID :
		738	hcan->RxFifo0FullCallback = HAL_CAN_RxFifo0FullCallback;
		739	break;
		740
		741	case HAL_CAN_RX_FIFO1_MSG_PENDING_CB_ID :
		742	hcan->RxFifo1MsgPendingCallback = HAL_CAN_RxFifo1MsgPendingCallback;
		743	break;
		744
		745	case HAL_CAN_RX_FIFO1_FULL_CB_ID :
		746	hcan->RxFifo1FullCallback = HAL_CAN_RxFifo1FullCallback;
		747	break;
		748
		749	case HAL_CAN_SLEEP_CB_ID :
		750	hcan->SleepCallback = HAL_CAN_SleepCallback;
		751	break;
		752
		753	case HAL_CAN_WAKEUP_FROM_RX_MSG_CB_ID :
		754	hcan->WakeUpFromRxMsgCallback = HAL_CAN_WakeUpFromRxMsgCallback;
		755	break;
		756
		757	case HAL_CAN_ERROR_CB_ID :
		758	hcan->ErrorCallback = HAL_CAN_ErrorCallback;
		759	break;
		760
		761	case HAL_CAN_MSPINIT_CB_ID :
		762	hcan->MspInitCallback = HAL_CAN_MspInit;
		763	break;
		764
		765	case HAL_CAN_MSPDEINIT_CB_ID :
		766	hcan->MspDeInitCallback = HAL_CAN_MspDeInit;
		767	break;
		768
		769	default :
		770	/* Update the error code */
		771	hcan->ErrorCode \|= HAL_CAN_ERROR_INVALID_CALLBACK;
		772
		773	/* Return error status */
		774	status = HAL_ERROR;
		775	break;
		776	}
		777	}
		778	else if (hcan->State == HAL_CAN_STATE_RESET)
		779	{
		780	switch (CallbackID)
		781	{
		782	case HAL_CAN_MSPINIT_CB_ID :
		783	hcan->MspInitCallback = HAL_CAN_MspInit;
		784	break;
		785
		786	case HAL_CAN_MSPDEINIT_CB_ID :
		787	hcan->MspDeInitCallback = HAL_CAN_MspDeInit;
		788	break;
		789
		790	default :
		791	/* Update the error code */
		792	hcan->ErrorCode \|= HAL_CAN_ERROR_INVALID_CALLBACK;
		793
		794	/* Return error status */
		795	status = HAL_ERROR;
		796	break;
		797	}
		798	}
		799	else
		800	{
		801	/* Update the error code */
		802	hcan->ErrorCode \|= HAL_CAN_ERROR_INVALID_CALLBACK;
		803
		804	/* Return error status */
		805	status = HAL_ERROR;
		806	}
		807
		808	return status;
		809	}
		810	#endif /* USE_HAL_CAN_REGISTER_CALLBACKS */
		811
		812	/**
		813	* @}
		814	*/
		815
		816	/** @defgroup CAN_Exported_Functions_Group2 Configuration functions
		817	* @brief Configuration functions.
		818	*
		819	@verbatim
		820	==============================================================================
		821	##### Configuration functions #####
		822	==============================================================================
		823	[..] This section provides functions allowing to:
		824	(+) HAL_CAN_ConfigFilter : Configure the CAN reception filters
		825
		826	@endverbatim
		827	* @{
		828	*/
		829
		830	/**
		831	* @brief Configures the CAN reception filter according to the specified
		832	* parameters in the CAN_FilterInitStruct.
		833	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		834	* the configuration information for the specified CAN.
		835	* @param sFilterConfig pointer to a CAN_FilterTypeDef structure that
		836	* contains the filter configuration information.
		837	* @retval None
		838	*/
		839	HAL_StatusTypeDef HAL_CAN_ConfigFilter(CAN_HandleTypeDef hcan, const CAN_FilterTypeDef sFilterConfig)
		840	{
		841	uint32_t filternbrbitpos;
		842	CAN_TypeDef *can_ip = hcan->Instance;
		843	HAL_CAN_StateTypeDef state = hcan->State;
		844
		845	if ((state == HAL_CAN_STATE_READY) \|\|
		846	(state == HAL_CAN_STATE_LISTENING))
		847	{
		848	/* Check the parameters */
		849	assert_param(IS_CAN_FILTER_ID_HALFWORD(sFilterConfig->FilterIdHigh));
		850	assert_param(IS_CAN_FILTER_ID_HALFWORD(sFilterConfig->FilterIdLow));
		851	assert_param(IS_CAN_FILTER_ID_HALFWORD(sFilterConfig->FilterMaskIdHigh));
		852	assert_param(IS_CAN_FILTER_ID_HALFWORD(sFilterConfig->FilterMaskIdLow));
		853	assert_param(IS_CAN_FILTER_MODE(sFilterConfig->FilterMode));
		854	assert_param(IS_CAN_FILTER_SCALE(sFilterConfig->FilterScale));
		855	assert_param(IS_CAN_FILTER_FIFO(sFilterConfig->FilterFIFOAssignment));
		856	assert_param(IS_CAN_FILTER_ACTIVATION(sFilterConfig->FilterActivation));
		857
		858	#if defined(CAN2)
		859	/* CAN1 and CAN2 are dual instances with 28 common filters banks */
		860	/* Select master instance to access the filter banks */
		861	can_ip = CAN1;
		862
		863	/* Check the parameters */
		864	assert_param(IS_CAN_FILTER_BANK_DUAL(sFilterConfig->FilterBank));
		865	assert_param(IS_CAN_FILTER_BANK_DUAL(sFilterConfig->SlaveStartFilterBank));
		866	#else
		867	/* CAN1 is single instance with 14 dedicated filters banks */
		868
		869	/* Check the parameters */
		870	assert_param(IS_CAN_FILTER_BANK_SINGLE(sFilterConfig->FilterBank));
		871	#endif
		872
		873	/* Initialisation mode for the filter */
		874	SET_BIT(can_ip->FMR, CAN_FMR_FINIT);
		875
		876	#if defined(CAN2)
		877	/* Select the start filter number of CAN2 slave instance */
		878	CLEAR_BIT(can_ip->FMR, CAN_FMR_CAN2SB);
		879	SET_BIT(can_ip->FMR, sFilterConfig->SlaveStartFilterBank << CAN_FMR_CAN2SB_Pos);
		880
		881	#endif
		882	/* Convert filter number into bit position */
		883	filternbrbitpos = (uint32_t)1 << (sFilterConfig->FilterBank & 0x1FU);
		884
		885	/* Filter Deactivation */
		886	CLEAR_BIT(can_ip->FA1R, filternbrbitpos);
		887
		888	/* Filter Scale */
		889	if (sFilterConfig->FilterScale == CAN_FILTERSCALE_16BIT)
		890	{
		891	/* 16-bit scale for the filter */
		892	CLEAR_BIT(can_ip->FS1R, filternbrbitpos);
		893
		894	/* First 16-bit identifier and First 16-bit mask */
		895	/* Or First 16-bit identifier and Second 16-bit identifier */
		896	can_ip->sFilterRegister[sFilterConfig->FilterBank].FR1 =
		897	((0x0000FFFFU & (uint32_t)sFilterConfig->FilterMaskIdLow) << 16U) \|
		898	(0x0000FFFFU & (uint32_t)sFilterConfig->FilterIdLow);
		899
		900	/* Second 16-bit identifier and Second 16-bit mask */
		901	/* Or Third 16-bit identifier and Fourth 16-bit identifier */
		902	can_ip->sFilterRegister[sFilterConfig->FilterBank].FR2 =
		903	((0x0000FFFFU & (uint32_t)sFilterConfig->FilterMaskIdHigh) << 16U) \|
		904	(0x0000FFFFU & (uint32_t)sFilterConfig->FilterIdHigh);
		905	}
		906
		907	if (sFilterConfig->FilterScale == CAN_FILTERSCALE_32BIT)
		908	{
		909	/* 32-bit scale for the filter */
		910	SET_BIT(can_ip->FS1R, filternbrbitpos);
		911
		912	/* 32-bit identifier or First 32-bit identifier */
		913	can_ip->sFilterRegister[sFilterConfig->FilterBank].FR1 =
		914	((0x0000FFFFU & (uint32_t)sFilterConfig->FilterIdHigh) << 16U) \|
		915	(0x0000FFFFU & (uint32_t)sFilterConfig->FilterIdLow);
		916
		917	/* 32-bit mask or Second 32-bit identifier */
		918	can_ip->sFilterRegister[sFilterConfig->FilterBank].FR2 =
		919	((0x0000FFFFU & (uint32_t)sFilterConfig->FilterMaskIdHigh) << 16U) \|
		920	(0x0000FFFFU & (uint32_t)sFilterConfig->FilterMaskIdLow);
		921	}
		922
		923	/* Filter Mode */
		924	if (sFilterConfig->FilterMode == CAN_FILTERMODE_IDMASK)
		925	{
		926	/* Id/Mask mode for the filter*/
		927	CLEAR_BIT(can_ip->FM1R, filternbrbitpos);
		928	}
		929	else /* CAN_FilterInitStruct->CAN_FilterMode == CAN_FilterMode_IdList */
		930	{
		931	/* Identifier list mode for the filter*/
		932	SET_BIT(can_ip->FM1R, filternbrbitpos);
		933	}
		934
		935	/* Filter FIFO assignment */
		936	if (sFilterConfig->FilterFIFOAssignment == CAN_FILTER_FIFO0)
		937	{
		938	/* FIFO 0 assignation for the filter */
		939	CLEAR_BIT(can_ip->FFA1R, filternbrbitpos);
		940	}
		941	else
		942	{
		943	/* FIFO 1 assignation for the filter */
		944	SET_BIT(can_ip->FFA1R, filternbrbitpos);
		945	}
		946
		947	/* Filter activation */
		948	if (sFilterConfig->FilterActivation == CAN_FILTER_ENABLE)
		949	{
		950	SET_BIT(can_ip->FA1R, filternbrbitpos);
		951	}
		952
		953	/* Leave the initialisation mode for the filter */
		954	CLEAR_BIT(can_ip->FMR, CAN_FMR_FINIT);
		955
		956	/* Return function status */
		957	return HAL_OK;
		958	}
		959	else
		960	{
		961	/* Update error code */
		962	hcan->ErrorCode \|= HAL_CAN_ERROR_NOT_INITIALIZED;
		963
		964	return HAL_ERROR;
		965	}
		966	}
		967
		968	/**
		969	* @}
		970	*/
		971
		972	/** @defgroup CAN_Exported_Functions_Group3 Control functions
		973	* @brief Control functions
		974	*
		975	@verbatim
		976	==============================================================================
		977	##### Control functions #####
		978	==============================================================================
		979	[..] This section provides functions allowing to:
		980	(+) HAL_CAN_Start : Start the CAN module
		981	(+) HAL_CAN_Stop : Stop the CAN module
		982	(+) HAL_CAN_RequestSleep : Request sleep mode entry.
		983	(+) HAL_CAN_WakeUp : Wake up from sleep mode.
		984	(+) HAL_CAN_IsSleepActive : Check is sleep mode is active.
		985	(+) HAL_CAN_AddTxMessage : Add a message to the Tx mailboxes
		986	and activate the corresponding
		987	transmission request
		988	(+) HAL_CAN_AbortTxRequest : Abort transmission request
		989	(+) HAL_CAN_GetTxMailboxesFreeLevel : Return Tx mailboxes free level
		990	(+) HAL_CAN_IsTxMessagePending : Check if a transmission request is
		991	pending on the selected Tx mailbox
		992	(+) HAL_CAN_GetRxMessage : Get a CAN frame from the Rx FIFO
		993	(+) HAL_CAN_GetRxFifoFillLevel : Return Rx FIFO fill level
		994
		995	@endverbatim
		996	* @{
		997	*/
		998
		999	/**
		1000	* @brief Start the CAN module.
		1001	* @param hcan pointer to an CAN_HandleTypeDef structure that contains
		1002	* the configuration information for the specified CAN.
		1003	* @retval HAL status
		1004	*/
		1005	HAL_StatusTypeDef HAL_CAN_Start(CAN_HandleTypeDef *hcan)
		1006	{
		1007	uint32_t tickstart;
		1008
		1009	if (hcan->State == HAL_CAN_STATE_READY)
		1010	{
		1011	/* Change CAN peripheral state */
		1012	hcan->State = HAL_CAN_STATE_LISTENING;
		1013
		1014	/* Request leave initialisation */
		1015	CLEAR_BIT(hcan->Instance->MCR, CAN_MCR_INRQ);
		1016
		1017	/* Get tick */
		1018	tickstart = HAL_GetTick();
		1019
		1020	/* Wait the acknowledge */
		1021	while ((hcan->Instance->MSR & CAN_MSR_INAK) != 0U)
		1022	{
		1023	/* Check for the Timeout */
		1024	if ((HAL_GetTick() - tickstart) > CAN_TIMEOUT_VALUE)
		1025	{
		1026	/* Update error code */
		1027	hcan->ErrorCode \|= HAL_CAN_ERROR_TIMEOUT;
		1028
		1029	/* Change CAN state */
		1030	hcan->State = HAL_CAN_STATE_ERROR;
		1031
		1032	return HAL_ERROR;
		1033	}
		1034	}
		1035
		1036	/* Reset the CAN ErrorCode */
		1037	hcan->ErrorCode = HAL_CAN_ERROR_NONE;
		1038
		1039	/* Return function status */
		1040	return HAL_OK;
		1041	}
		1042	else
		1043	{
		1044	/* Update error code */
		1045	hcan->ErrorCode \|= HAL_CAN_ERROR_NOT_READY;
		1046
		1047	return HAL_ERROR;
		1048	}
		1049	}
		1050
		1051	/**
		1052	* @brief Stop the CAN module and enable access to configuration registers.
		1053	* @param hcan pointer to an CAN_HandleTypeDef structure that contains
		1054	* the configuration information for the specified CAN.
		1055	* @retval HAL status
		1056	*/
		1057	HAL_StatusTypeDef HAL_CAN_Stop(CAN_HandleTypeDef *hcan)
		1058	{
		1059	uint32_t tickstart;
		1060
		1061	if (hcan->State == HAL_CAN_STATE_LISTENING)
		1062	{
		1063	/* Request initialisation */
		1064	SET_BIT(hcan->Instance->MCR, CAN_MCR_INRQ);
		1065
		1066	/* Get tick */
		1067	tickstart = HAL_GetTick();
		1068
		1069	/* Wait the acknowledge */
		1070	while ((hcan->Instance->MSR & CAN_MSR_INAK) == 0U)
		1071	{
		1072	/* Check for the Timeout */
		1073	if ((HAL_GetTick() - tickstart) > CAN_TIMEOUT_VALUE)
		1074	{
		1075	/* Update error code */
		1076	hcan->ErrorCode \|= HAL_CAN_ERROR_TIMEOUT;
		1077
		1078	/* Change CAN state */
		1079	hcan->State = HAL_CAN_STATE_ERROR;
		1080
		1081	return HAL_ERROR;
		1082	}
		1083	}
		1084
		1085	/* Exit from sleep mode */
		1086	CLEAR_BIT(hcan->Instance->MCR, CAN_MCR_SLEEP);
		1087
		1088	/* Change CAN peripheral state */
		1089	hcan->State = HAL_CAN_STATE_READY;
		1090
		1091	/* Return function status */
		1092	return HAL_OK;
		1093	}
		1094	else
		1095	{
		1096	/* Update error code */
		1097	hcan->ErrorCode \|= HAL_CAN_ERROR_NOT_STARTED;
		1098
		1099	return HAL_ERROR;
		1100	}
		1101	}
		1102
		1103	/**
		1104	* @brief Request the sleep mode (low power) entry.
		1105	* When returning from this function, Sleep mode will be entered
		1106	* as soon as the current CAN activity (transmission or reception
		1107	* of a CAN frame) has been completed.
		1108	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		1109	* the configuration information for the specified CAN.
		1110	* @retval HAL status.
		1111	*/
		1112	HAL_StatusTypeDef HAL_CAN_RequestSleep(CAN_HandleTypeDef *hcan)
		1113	{
		1114	HAL_CAN_StateTypeDef state = hcan->State;
		1115
		1116	if ((state == HAL_CAN_STATE_READY) \|\|
		1117	(state == HAL_CAN_STATE_LISTENING))
		1118	{
		1119	/* Request Sleep mode */
		1120	SET_BIT(hcan->Instance->MCR, CAN_MCR_SLEEP);
		1121
		1122	/* Return function status */
		1123	return HAL_OK;
		1124	}
		1125	else
		1126	{
		1127	/* Update error code */
		1128	hcan->ErrorCode \|= HAL_CAN_ERROR_NOT_INITIALIZED;
		1129
		1130	/* Return function status */
		1131	return HAL_ERROR;
		1132	}
		1133	}
		1134
		1135	/**
		1136	* @brief Wake up from sleep mode.
		1137	* When returning with HAL_OK status from this function, Sleep mode
		1138	* is exited.
		1139	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		1140	* the configuration information for the specified CAN.
		1141	* @retval HAL status.
		1142	*/
		1143	HAL_StatusTypeDef HAL_CAN_WakeUp(CAN_HandleTypeDef *hcan)
		1144	{
		1145	__IO uint32_t count = 0;
		1146	uint32_t timeout = 1000000U;
		1147	HAL_CAN_StateTypeDef state = hcan->State;
		1148
		1149	if ((state == HAL_CAN_STATE_READY) \|\|
		1150	(state == HAL_CAN_STATE_LISTENING))
		1151	{
		1152	/* Wake up request */
		1153	CLEAR_BIT(hcan->Instance->MCR, CAN_MCR_SLEEP);
		1154
		1155	/* Wait sleep mode is exited */
		1156	do
		1157	{
		1158	/* Increment counter */
		1159	count++;
		1160
		1161	/* Check if timeout is reached */
		1162	if (count > timeout)
		1163	{
		1164	/* Update error code */
		1165	hcan->ErrorCode \|= HAL_CAN_ERROR_TIMEOUT;
		1166
		1167	return HAL_ERROR;
		1168	}
		1169	}
		1170	while ((hcan->Instance->MSR & CAN_MSR_SLAK) != 0U);
		1171
		1172	/* Return function status */
		1173	return HAL_OK;
		1174	}
		1175	else
		1176	{
		1177	/* Update error code */
		1178	hcan->ErrorCode \|= HAL_CAN_ERROR_NOT_INITIALIZED;
		1179
		1180	return HAL_ERROR;
		1181	}
		1182	}
		1183
		1184	/**
		1185	* @brief Check is sleep mode is active.
		1186	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		1187	* the configuration information for the specified CAN.
		1188	* @retval Status
		1189	* - 0 : Sleep mode is not active.
		1190	* - 1 : Sleep mode is active.
		1191	*/
		1192	uint32_t HAL_CAN_IsSleepActive(const CAN_HandleTypeDef *hcan)
		1193	{
		1194	uint32_t status = 0U;
		1195	HAL_CAN_StateTypeDef state = hcan->State;
		1196
		1197	if ((state == HAL_CAN_STATE_READY) \|\|
		1198	(state == HAL_CAN_STATE_LISTENING))
		1199	{
		1200	/* Check Sleep mode */
		1201	if ((hcan->Instance->MSR & CAN_MSR_SLAK) != 0U)
		1202	{
		1203	status = 1U;
		1204	}
		1205	}
		1206
		1207	/* Return function status */
		1208	return status;
		1209	}
		1210
		1211	/**
		1212	* @brief Add a message to the first free Tx mailbox and activate the
		1213	* corresponding transmission request.
		1214	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		1215	* the configuration information for the specified CAN.
		1216	* @param pHeader pointer to a CAN_TxHeaderTypeDef structure.
		1217	* @param aData array containing the payload of the Tx frame.
		1218	* @param pTxMailbox pointer to a variable where the function will return
		1219	* the TxMailbox used to store the Tx message.
		1220	* This parameter can be a value of @arg CAN_Tx_Mailboxes.
		1221	* @retval HAL status
		1222	*/
		1223	HAL_StatusTypeDef HAL_CAN_AddTxMessage(CAN_HandleTypeDef hcan, const CAN_TxHeaderTypeDef pHeader,
		1224	const uint8_t aData[], uint32_t *pTxMailbox)
		1225	{
		1226	uint32_t transmitmailbox;
		1227	HAL_CAN_StateTypeDef state = hcan->State;
		1228	uint32_t tsr = READ_REG(hcan->Instance->TSR);
		1229
		1230	/* Check the parameters */
		1231	assert_param(IS_CAN_IDTYPE(pHeader->IDE));
		1232	assert_param(IS_CAN_RTR(pHeader->RTR));
		1233	assert_param(IS_CAN_DLC(pHeader->DLC));
		1234	if (pHeader->IDE == CAN_ID_STD)
		1235	{
		1236	assert_param(IS_CAN_STDID(pHeader->StdId));
		1237	}
		1238	else
		1239	{
		1240	assert_param(IS_CAN_EXTID(pHeader->ExtId));
		1241	}
		1242	assert_param(IS_FUNCTIONAL_STATE(pHeader->TransmitGlobalTime));
		1243
		1244	if ((state == HAL_CAN_STATE_READY) \|\|
		1245	(state == HAL_CAN_STATE_LISTENING))
		1246	{
		1247	/* Check that all the Tx mailboxes are not full */
		1248	if (((tsr & CAN_TSR_TME0) != 0U) \|\|
		1249	((tsr & CAN_TSR_TME1) != 0U) \|\|
		1250	((tsr & CAN_TSR_TME2) != 0U))
		1251	{
		1252	/* Select an empty transmit mailbox */
		1253	transmitmailbox = (tsr & CAN_TSR_CODE) >> CAN_TSR_CODE_Pos;
		1254
		1255	/* Store the Tx mailbox */
		1256	*pTxMailbox = (uint32_t)1 << transmitmailbox;
		1257
		1258	/* Set up the Id */
		1259	if (pHeader->IDE == CAN_ID_STD)
		1260	{
		1261	hcan->Instance->sTxMailBox[transmitmailbox].TIR = ((pHeader->StdId << CAN_TI0R_STID_Pos) \|
		1262	pHeader->RTR);
		1263	}
		1264	else
		1265	{
		1266	hcan->Instance->sTxMailBox[transmitmailbox].TIR = ((pHeader->ExtId << CAN_TI0R_EXID_Pos) \|
		1267	pHeader->IDE \|
		1268	pHeader->RTR);
		1269	}
		1270
		1271	/* Set up the DLC */
		1272	hcan->Instance->sTxMailBox[transmitmailbox].TDTR = (pHeader->DLC);
		1273
		1274	/* Set up the Transmit Global Time mode */
		1275	if (pHeader->TransmitGlobalTime == ENABLE)
		1276	{
		1277	SET_BIT(hcan->Instance->sTxMailBox[transmitmailbox].TDTR, CAN_TDT0R_TGT);
		1278	}
		1279
		1280	/* Set up the data field */
		1281	WRITE_REG(hcan->Instance->sTxMailBox[transmitmailbox].TDHR,
		1282	((uint32_t)aData[7] << CAN_TDH0R_DATA7_Pos) \|
		1283	((uint32_t)aData[6] << CAN_TDH0R_DATA6_Pos) \|
		1284	((uint32_t)aData[5] << CAN_TDH0R_DATA5_Pos) \|
		1285	((uint32_t)aData[4] << CAN_TDH0R_DATA4_Pos));
		1286	WRITE_REG(hcan->Instance->sTxMailBox[transmitmailbox].TDLR,
		1287	((uint32_t)aData[3] << CAN_TDL0R_DATA3_Pos) \|
		1288	((uint32_t)aData[2] << CAN_TDL0R_DATA2_Pos) \|
		1289	((uint32_t)aData[1] << CAN_TDL0R_DATA1_Pos) \|
		1290	((uint32_t)aData[0] << CAN_TDL0R_DATA0_Pos));
		1291
		1292	/* Request transmission */
		1293	SET_BIT(hcan->Instance->sTxMailBox[transmitmailbox].TIR, CAN_TI0R_TXRQ);
		1294
		1295	/* Return function status */
		1296	return HAL_OK;
		1297	}
		1298	else
		1299	{
		1300	/* Update error code */
		1301	hcan->ErrorCode \|= HAL_CAN_ERROR_PARAM;
		1302
		1303	return HAL_ERROR;
		1304	}
		1305	}
		1306	else
		1307	{
		1308	/* Update error code */
		1309	hcan->ErrorCode \|= HAL_CAN_ERROR_NOT_INITIALIZED;
		1310
		1311	return HAL_ERROR;
		1312	}
		1313	}
		1314
		1315	/**
		1316	* @brief Abort transmission requests
		1317	* @param hcan pointer to an CAN_HandleTypeDef structure that contains
		1318	* the configuration information for the specified CAN.
		1319	* @param TxMailboxes List of the Tx Mailboxes to abort.
		1320	* This parameter can be any combination of @arg CAN_Tx_Mailboxes.
		1321	* @retval HAL status
		1322	*/
		1323	HAL_StatusTypeDef HAL_CAN_AbortTxRequest(CAN_HandleTypeDef *hcan, uint32_t TxMailboxes)
		1324	{
		1325	HAL_CAN_StateTypeDef state = hcan->State;
		1326
		1327	/* Check function parameters */
		1328	assert_param(IS_CAN_TX_MAILBOX_LIST(TxMailboxes));
		1329
		1330	if ((state == HAL_CAN_STATE_READY) \|\|
		1331	(state == HAL_CAN_STATE_LISTENING))
		1332	{
		1333	/* Check Tx Mailbox 0 */
		1334	if ((TxMailboxes & CAN_TX_MAILBOX0) != 0U)
		1335	{
		1336	/* Add cancellation request for Tx Mailbox 0 */
		1337	SET_BIT(hcan->Instance->TSR, CAN_TSR_ABRQ0);
		1338	}
		1339
		1340	/* Check Tx Mailbox 1 */
		1341	if ((TxMailboxes & CAN_TX_MAILBOX1) != 0U)
		1342	{
		1343	/* Add cancellation request for Tx Mailbox 1 */
		1344	SET_BIT(hcan->Instance->TSR, CAN_TSR_ABRQ1);
		1345	}
		1346
		1347	/* Check Tx Mailbox 2 */
		1348	if ((TxMailboxes & CAN_TX_MAILBOX2) != 0U)
		1349	{
		1350	/* Add cancellation request for Tx Mailbox 2 */
		1351	SET_BIT(hcan->Instance->TSR, CAN_TSR_ABRQ2);
		1352	}
		1353
		1354	/* Return function status */
		1355	return HAL_OK;
		1356	}
		1357	else
		1358	{
		1359	/* Update error code */
		1360	hcan->ErrorCode \|= HAL_CAN_ERROR_NOT_INITIALIZED;
		1361
		1362	return HAL_ERROR;
		1363	}
		1364	}
		1365
		1366	/**
		1367	* @brief Return Tx Mailboxes free level: number of free Tx Mailboxes.
		1368	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		1369	* the configuration information for the specified CAN.
		1370	* @retval Number of free Tx Mailboxes.
		1371	*/
		1372	uint32_t HAL_CAN_GetTxMailboxesFreeLevel(const CAN_HandleTypeDef *hcan)
		1373	{
		1374	uint32_t freelevel = 0U;
		1375	HAL_CAN_StateTypeDef state = hcan->State;
		1376
		1377	if ((state == HAL_CAN_STATE_READY) \|\|
		1378	(state == HAL_CAN_STATE_LISTENING))
		1379	{
		1380	/* Check Tx Mailbox 0 status */
		1381	if ((hcan->Instance->TSR & CAN_TSR_TME0) != 0U)
		1382	{
		1383	freelevel++;
		1384	}
		1385
		1386	/* Check Tx Mailbox 1 status */
		1387	if ((hcan->Instance->TSR & CAN_TSR_TME1) != 0U)
		1388	{
		1389	freelevel++;
		1390	}
		1391
		1392	/* Check Tx Mailbox 2 status */
		1393	if ((hcan->Instance->TSR & CAN_TSR_TME2) != 0U)
		1394	{
		1395	freelevel++;
		1396	}
		1397	}
		1398
		1399	/* Return Tx Mailboxes free level */
		1400	return freelevel;
		1401	}
		1402
		1403	/**
		1404	* @brief Check if a transmission request is pending on the selected Tx
		1405	* Mailboxes.
		1406	* @param hcan pointer to an CAN_HandleTypeDef structure that contains
		1407	* the configuration information for the specified CAN.
		1408	* @param TxMailboxes List of Tx Mailboxes to check.
		1409	* This parameter can be any combination of @arg CAN_Tx_Mailboxes.
		1410	* @retval Status
		1411	* - 0 : No pending transmission request on any selected Tx Mailboxes.
		1412	* - 1 : Pending transmission request on at least one of the selected
		1413	* Tx Mailbox.
		1414	*/
		1415	uint32_t HAL_CAN_IsTxMessagePending(const CAN_HandleTypeDef *hcan, uint32_t TxMailboxes)
		1416	{
		1417	uint32_t status = 0U;
		1418	HAL_CAN_StateTypeDef state = hcan->State;
		1419
		1420	/* Check function parameters */
		1421	assert_param(IS_CAN_TX_MAILBOX_LIST(TxMailboxes));
		1422
		1423	if ((state == HAL_CAN_STATE_READY) \|\|
		1424	(state == HAL_CAN_STATE_LISTENING))
		1425	{
		1426	/* Check pending transmission request on the selected Tx Mailboxes */
		1427	if ((hcan->Instance->TSR & (TxMailboxes << CAN_TSR_TME0_Pos)) != (TxMailboxes << CAN_TSR_TME0_Pos))
		1428	{
		1429	status = 1U;
		1430	}
		1431	}
		1432
		1433	/* Return status */
		1434	return status;
		1435	}
		1436
		1437	/**
		1438	* @brief Return timestamp of Tx message sent, if time triggered communication
		1439	mode is enabled.
		1440	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		1441	* the configuration information for the specified CAN.
		1442	* @param TxMailbox Tx Mailbox where the timestamp of message sent will be
		1443	* read.
		1444	* This parameter can be one value of @arg CAN_Tx_Mailboxes.
		1445	* @retval Timestamp of message sent from Tx Mailbox.
		1446	*/
		1447	uint32_t HAL_CAN_GetTxTimestamp(const CAN_HandleTypeDef *hcan, uint32_t TxMailbox)
		1448	{
		1449	uint32_t timestamp = 0U;
		1450	uint32_t transmitmailbox;
		1451	HAL_CAN_StateTypeDef state = hcan->State;
		1452
		1453	/* Check function parameters */
		1454	assert_param(IS_CAN_TX_MAILBOX(TxMailbox));
		1455
		1456	if ((state == HAL_CAN_STATE_READY) \|\|
		1457	(state == HAL_CAN_STATE_LISTENING))
		1458	{
		1459	/* Select the Tx mailbox */
		1460	transmitmailbox = POSITION_VAL(TxMailbox);
		1461
		1462	/* Get timestamp */
		1463	timestamp = (hcan->Instance->sTxMailBox[transmitmailbox].TDTR & CAN_TDT0R_TIME) >> CAN_TDT0R_TIME_Pos;
		1464	}
		1465
		1466	/* Return the timestamp */
		1467	return timestamp;
		1468	}
		1469
		1470	/**
		1471	* @brief Get an CAN frame from the Rx FIFO zone into the message RAM.
		1472	* @param hcan pointer to an CAN_HandleTypeDef structure that contains
		1473	* the configuration information for the specified CAN.
		1474	* @param RxFifo Fifo number of the received message to be read.
		1475	* This parameter can be a value of @arg CAN_receive_FIFO_number.
		1476	* @param pHeader pointer to a CAN_RxHeaderTypeDef structure where the header
		1477	* of the Rx frame will be stored.
		1478	* @param aData array where the payload of the Rx frame will be stored.
		1479	* @retval HAL status
		1480	*/
		1481	HAL_StatusTypeDef HAL_CAN_GetRxMessage(CAN_HandleTypeDef *hcan, uint32_t RxFifo,
		1482	CAN_RxHeaderTypeDef *pHeader, uint8_t aData[])
		1483	{
		1484	HAL_CAN_StateTypeDef state = hcan->State;
		1485
		1486	assert_param(IS_CAN_RX_FIFO(RxFifo));
		1487
		1488	if ((state == HAL_CAN_STATE_READY) \|\|
		1489	(state == HAL_CAN_STATE_LISTENING))
		1490	{
		1491	/* Check the Rx FIFO */
		1492	if (RxFifo == CAN_RX_FIFO0) /* Rx element is assigned to Rx FIFO 0 */
		1493	{
		1494	/* Check that the Rx FIFO 0 is not empty */
		1495	if ((hcan->Instance->RF0R & CAN_RF0R_FMP0) == 0U)
		1496	{
		1497	/* Update error code */
		1498	hcan->ErrorCode \|= HAL_CAN_ERROR_PARAM;
		1499
		1500	return HAL_ERROR;
		1501	}
		1502	}
		1503	else /* Rx element is assigned to Rx FIFO 1 */
		1504	{
		1505	/* Check that the Rx FIFO 1 is not empty */
		1506	if ((hcan->Instance->RF1R & CAN_RF1R_FMP1) == 0U)
		1507	{
		1508	/* Update error code */
		1509	hcan->ErrorCode \|= HAL_CAN_ERROR_PARAM;
		1510
		1511	return HAL_ERROR;
		1512	}
		1513	}
		1514
		1515	/* Get the header */
		1516	pHeader->IDE = CAN_RI0R_IDE & hcan->Instance->sFIFOMailBox[RxFifo].RIR;
		1517	if (pHeader->IDE == CAN_ID_STD)
		1518	{
		1519	pHeader->StdId = (CAN_RI0R_STID & hcan->Instance->sFIFOMailBox[RxFifo].RIR) >> CAN_TI0R_STID_Pos;
		1520	}
		1521	else
		1522	{
		1523	pHeader->ExtId = ((CAN_RI0R_EXID \| CAN_RI0R_STID) &
		1524	hcan->Instance->sFIFOMailBox[RxFifo].RIR) >> CAN_RI0R_EXID_Pos;
		1525	}
		1526	pHeader->RTR = (CAN_RI0R_RTR & hcan->Instance->sFIFOMailBox[RxFifo].RIR);
		1527	if (((CAN_RDT0R_DLC & hcan->Instance->sFIFOMailBox[RxFifo].RDTR) >> CAN_RDT0R_DLC_Pos) >= 8U)
		1528	{
		1529	/* Truncate DLC to 8 if received field is over range */
		1530	pHeader->DLC = 8U;
		1531	}
		1532	else
		1533	{
		1534	pHeader->DLC = (CAN_RDT0R_DLC & hcan->Instance->sFIFOMailBox[RxFifo].RDTR) >> CAN_RDT0R_DLC_Pos;
		1535	}
		1536	pHeader->FilterMatchIndex = (CAN_RDT0R_FMI & hcan->Instance->sFIFOMailBox[RxFifo].RDTR) >> CAN_RDT0R_FMI_Pos;
		1537	pHeader->Timestamp = (CAN_RDT0R_TIME & hcan->Instance->sFIFOMailBox[RxFifo].RDTR) >> CAN_RDT0R_TIME_Pos;
		1538
		1539	/* Get the data */
		1540	aData[0] = (uint8_t)((CAN_RDL0R_DATA0 & hcan->Instance->sFIFOMailBox[RxFifo].RDLR) >> CAN_RDL0R_DATA0_Pos);
		1541	aData[1] = (uint8_t)((CAN_RDL0R_DATA1 & hcan->Instance->sFIFOMailBox[RxFifo].RDLR) >> CAN_RDL0R_DATA1_Pos);
		1542	aData[2] = (uint8_t)((CAN_RDL0R_DATA2 & hcan->Instance->sFIFOMailBox[RxFifo].RDLR) >> CAN_RDL0R_DATA2_Pos);
		1543	aData[3] = (uint8_t)((CAN_RDL0R_DATA3 & hcan->Instance->sFIFOMailBox[RxFifo].RDLR) >> CAN_RDL0R_DATA3_Pos);
		1544	aData[4] = (uint8_t)((CAN_RDH0R_DATA4 & hcan->Instance->sFIFOMailBox[RxFifo].RDHR) >> CAN_RDH0R_DATA4_Pos);
		1545	aData[5] = (uint8_t)((CAN_RDH0R_DATA5 & hcan->Instance->sFIFOMailBox[RxFifo].RDHR) >> CAN_RDH0R_DATA5_Pos);
		1546	aData[6] = (uint8_t)((CAN_RDH0R_DATA6 & hcan->Instance->sFIFOMailBox[RxFifo].RDHR) >> CAN_RDH0R_DATA6_Pos);
		1547	aData[7] = (uint8_t)((CAN_RDH0R_DATA7 & hcan->Instance->sFIFOMailBox[RxFifo].RDHR) >> CAN_RDH0R_DATA7_Pos);
		1548
		1549	/* Release the FIFO */
		1550	if (RxFifo == CAN_RX_FIFO0) /* Rx element is assigned to Rx FIFO 0 */
		1551	{
		1552	/* Release RX FIFO 0 */
		1553	SET_BIT(hcan->Instance->RF0R, CAN_RF0R_RFOM0);
		1554	}
		1555	else /* Rx element is assigned to Rx FIFO 1 */
		1556	{
		1557	/* Release RX FIFO 1 */
		1558	SET_BIT(hcan->Instance->RF1R, CAN_RF1R_RFOM1);
		1559	}
		1560
		1561	/* Return function status */
		1562	return HAL_OK;
		1563	}
		1564	else
		1565	{
		1566	/* Update error code */
		1567	hcan->ErrorCode \|= HAL_CAN_ERROR_NOT_INITIALIZED;
		1568
		1569	return HAL_ERROR;
		1570	}
		1571	}
		1572
		1573	/**
		1574	* @brief Return Rx FIFO fill level.
		1575	* @param hcan pointer to an CAN_HandleTypeDef structure that contains
		1576	* the configuration information for the specified CAN.
		1577	* @param RxFifo Rx FIFO.
		1578	* This parameter can be a value of @arg CAN_receive_FIFO_number.
		1579	* @retval Number of messages available in Rx FIFO.
		1580	*/
		1581	uint32_t HAL_CAN_GetRxFifoFillLevel(const CAN_HandleTypeDef *hcan, uint32_t RxFifo)
		1582	{
		1583	uint32_t filllevel = 0U;
		1584	HAL_CAN_StateTypeDef state = hcan->State;
		1585
		1586	/* Check function parameters */
		1587	assert_param(IS_CAN_RX_FIFO(RxFifo));
		1588
		1589	if ((state == HAL_CAN_STATE_READY) \|\|
		1590	(state == HAL_CAN_STATE_LISTENING))
		1591	{
		1592	if (RxFifo == CAN_RX_FIFO0)
		1593	{
		1594	filllevel = hcan->Instance->RF0R & CAN_RF0R_FMP0;
		1595	}
		1596	else /* RxFifo == CAN_RX_FIFO1 */
		1597	{
		1598	filllevel = hcan->Instance->RF1R & CAN_RF1R_FMP1;
		1599	}
		1600	}
		1601
		1602	/* Return Rx FIFO fill level */
		1603	return filllevel;
		1604	}
		1605
		1606	/**
		1607	* @}
		1608	*/
		1609
		1610	/** @defgroup CAN_Exported_Functions_Group4 Interrupts management
		1611	* @brief Interrupts management
		1612	*
		1613	@verbatim
		1614	==============================================================================
		1615	##### Interrupts management #####
		1616	==============================================================================
		1617	[..] This section provides functions allowing to:
		1618	(+) HAL_CAN_ActivateNotification : Enable interrupts
		1619	(+) HAL_CAN_DeactivateNotification : Disable interrupts
		1620	(+) HAL_CAN_IRQHandler : Handles CAN interrupt request
		1621
		1622	@endverbatim
		1623	* @{
		1624	*/
		1625
		1626	/**
		1627	* @brief Enable interrupts.
		1628	* @param hcan pointer to an CAN_HandleTypeDef structure that contains
		1629	* the configuration information for the specified CAN.
		1630	* @param ActiveITs indicates which interrupts will be enabled.
		1631	* This parameter can be any combination of @arg CAN_Interrupts.
		1632	* @retval HAL status
		1633	*/
		1634	HAL_StatusTypeDef HAL_CAN_ActivateNotification(CAN_HandleTypeDef *hcan, uint32_t ActiveITs)
		1635	{
		1636	HAL_CAN_StateTypeDef state = hcan->State;
		1637
		1638	/* Check function parameters */
		1639	assert_param(IS_CAN_IT(ActiveITs));
		1640
		1641	if ((state == HAL_CAN_STATE_READY) \|\|
		1642	(state == HAL_CAN_STATE_LISTENING))
		1643	{
		1644	/* Enable the selected interrupts */
		1645	__HAL_CAN_ENABLE_IT(hcan, ActiveITs);
		1646
		1647	/* Return function status */
		1648	return HAL_OK;
		1649	}
		1650	else
		1651	{
		1652	/* Update error code */
		1653	hcan->ErrorCode \|= HAL_CAN_ERROR_NOT_INITIALIZED;
		1654
		1655	return HAL_ERROR;
		1656	}
		1657	}
		1658
		1659	/**
		1660	* @brief Disable interrupts.
		1661	* @param hcan pointer to an CAN_HandleTypeDef structure that contains
		1662	* the configuration information for the specified CAN.
		1663	* @param InactiveITs indicates which interrupts will be disabled.
		1664	* This parameter can be any combination of @arg CAN_Interrupts.
		1665	* @retval HAL status
		1666	*/
		1667	HAL_StatusTypeDef HAL_CAN_DeactivateNotification(CAN_HandleTypeDef *hcan, uint32_t InactiveITs)
		1668	{
		1669	HAL_CAN_StateTypeDef state = hcan->State;
		1670
		1671	/* Check function parameters */
		1672	assert_param(IS_CAN_IT(InactiveITs));
		1673
		1674	if ((state == HAL_CAN_STATE_READY) \|\|
		1675	(state == HAL_CAN_STATE_LISTENING))
		1676	{
		1677	/* Disable the selected interrupts */
		1678	__HAL_CAN_DISABLE_IT(hcan, InactiveITs);
		1679
		1680	/* Return function status */
		1681	return HAL_OK;
		1682	}
		1683	else
		1684	{
		1685	/* Update error code */
		1686	hcan->ErrorCode \|= HAL_CAN_ERROR_NOT_INITIALIZED;
		1687
		1688	return HAL_ERROR;
		1689	}
		1690	}
		1691
		1692	/**
		1693	* @brief Handles CAN interrupt request
		1694	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		1695	* the configuration information for the specified CAN.
		1696	* @retval None
		1697	*/
		1698	void HAL_CAN_IRQHandler(CAN_HandleTypeDef *hcan)
		1699	{
		1700	uint32_t errorcode = HAL_CAN_ERROR_NONE;
		1701	uint32_t interrupts = READ_REG(hcan->Instance->IER);
		1702	uint32_t msrflags = READ_REG(hcan->Instance->MSR);
		1703	uint32_t tsrflags = READ_REG(hcan->Instance->TSR);
		1704	uint32_t rf0rflags = READ_REG(hcan->Instance->RF0R);
		1705	uint32_t rf1rflags = READ_REG(hcan->Instance->RF1R);
		1706	uint32_t esrflags = READ_REG(hcan->Instance->ESR);
		1707
		1708	/* Transmit Mailbox empty interrupt management *****************************/
		1709	if ((interrupts & CAN_IT_TX_MAILBOX_EMPTY) != 0U)
		1710	{
		1711	/* Transmit Mailbox 0 management *****************************************/
		1712	if ((tsrflags & CAN_TSR_RQCP0) != 0U)
		1713	{
		1714	/* Clear the Transmission Complete flag (and TXOK0,ALST0,TERR0 bits) */
		1715	__HAL_CAN_CLEAR_FLAG(hcan, CAN_FLAG_RQCP0);
		1716
		1717	if ((tsrflags & CAN_TSR_TXOK0) != 0U)
		1718	{
		1719	/* Transmission Mailbox 0 complete callback */
		1720	#if USE_HAL_CAN_REGISTER_CALLBACKS == 1
		1721	/* Call registered callback*/
		1722	hcan->TxMailbox0CompleteCallback(hcan);
		1723	#else
		1724	/* Call weak (surcharged) callback */
		1725	HAL_CAN_TxMailbox0CompleteCallback(hcan);
		1726	#endif /* USE_HAL_CAN_REGISTER_CALLBACKS */
		1727	}
		1728	else
		1729	{
		1730	if ((tsrflags & CAN_TSR_ALST0) != 0U)
		1731	{
		1732	/* Update error code */
		1733	errorcode \|= HAL_CAN_ERROR_TX_ALST0;
		1734	}
		1735	else if ((tsrflags & CAN_TSR_TERR0) != 0U)
		1736	{
		1737	/* Update error code */
		1738	errorcode \|= HAL_CAN_ERROR_TX_TERR0;
		1739	}
		1740	else
		1741	{
		1742	/* Transmission Mailbox 0 abort callback */
		1743	#if USE_HAL_CAN_REGISTER_CALLBACKS == 1
		1744	/* Call registered callback*/
		1745	hcan->TxMailbox0AbortCallback(hcan);
		1746	#else
		1747	/* Call weak (surcharged) callback */
		1748	HAL_CAN_TxMailbox0AbortCallback(hcan);
		1749	#endif /* USE_HAL_CAN_REGISTER_CALLBACKS */
		1750	}
		1751	}
		1752	}
		1753
		1754	/* Transmit Mailbox 1 management *****************************************/
		1755	if ((tsrflags & CAN_TSR_RQCP1) != 0U)
		1756	{
		1757	/* Clear the Transmission Complete flag (and TXOK1,ALST1,TERR1 bits) */
		1758	__HAL_CAN_CLEAR_FLAG(hcan, CAN_FLAG_RQCP1);
		1759
		1760	if ((tsrflags & CAN_TSR_TXOK1) != 0U)
		1761	{
		1762	/* Transmission Mailbox 1 complete callback */
		1763	#if USE_HAL_CAN_REGISTER_CALLBACKS == 1
		1764	/* Call registered callback*/
		1765	hcan->TxMailbox1CompleteCallback(hcan);
		1766	#else
		1767	/* Call weak (surcharged) callback */
		1768	HAL_CAN_TxMailbox1CompleteCallback(hcan);
		1769	#endif /* USE_HAL_CAN_REGISTER_CALLBACKS */
		1770	}
		1771	else
		1772	{
		1773	if ((tsrflags & CAN_TSR_ALST1) != 0U)
		1774	{
		1775	/* Update error code */
		1776	errorcode \|= HAL_CAN_ERROR_TX_ALST1;
		1777	}
		1778	else if ((tsrflags & CAN_TSR_TERR1) != 0U)
		1779	{
		1780	/* Update error code */
		1781	errorcode \|= HAL_CAN_ERROR_TX_TERR1;
		1782	}
		1783	else
		1784	{
		1785	/* Transmission Mailbox 1 abort callback */
		1786	#if USE_HAL_CAN_REGISTER_CALLBACKS == 1
		1787	/* Call registered callback*/
		1788	hcan->TxMailbox1AbortCallback(hcan);
		1789	#else
		1790	/* Call weak (surcharged) callback */
		1791	HAL_CAN_TxMailbox1AbortCallback(hcan);
		1792	#endif /* USE_HAL_CAN_REGISTER_CALLBACKS */
		1793	}
		1794	}
		1795	}
		1796
		1797	/* Transmit Mailbox 2 management *****************************************/
		1798	if ((tsrflags & CAN_TSR_RQCP2) != 0U)
		1799	{
		1800	/* Clear the Transmission Complete flag (and TXOK2,ALST2,TERR2 bits) */
		1801	__HAL_CAN_CLEAR_FLAG(hcan, CAN_FLAG_RQCP2);
		1802
		1803	if ((tsrflags & CAN_TSR_TXOK2) != 0U)
		1804	{
		1805	/* Transmission Mailbox 2 complete callback */
		1806	#if USE_HAL_CAN_REGISTER_CALLBACKS == 1
		1807	/* Call registered callback*/
		1808	hcan->TxMailbox2CompleteCallback(hcan);
		1809	#else
		1810	/* Call weak (surcharged) callback */
		1811	HAL_CAN_TxMailbox2CompleteCallback(hcan);
		1812	#endif /* USE_HAL_CAN_REGISTER_CALLBACKS */
		1813	}
		1814	else
		1815	{
		1816	if ((tsrflags & CAN_TSR_ALST2) != 0U)
		1817	{
		1818	/* Update error code */
		1819	errorcode \|= HAL_CAN_ERROR_TX_ALST2;
		1820	}
		1821	else if ((tsrflags & CAN_TSR_TERR2) != 0U)
		1822	{
		1823	/* Update error code */
		1824	errorcode \|= HAL_CAN_ERROR_TX_TERR2;
		1825	}
		1826	else
		1827	{
		1828	/* Transmission Mailbox 2 abort callback */
		1829	#if USE_HAL_CAN_REGISTER_CALLBACKS == 1
		1830	/* Call registered callback*/
		1831	hcan->TxMailbox2AbortCallback(hcan);
		1832	#else
		1833	/* Call weak (surcharged) callback */
		1834	HAL_CAN_TxMailbox2AbortCallback(hcan);
		1835	#endif /* USE_HAL_CAN_REGISTER_CALLBACKS */
		1836	}
		1837	}
		1838	}
		1839	}
		1840
		1841	/* Receive FIFO 0 overrun interrupt management *****************************/
		1842	if ((interrupts & CAN_IT_RX_FIFO0_OVERRUN) != 0U)
		1843	{
		1844	if ((rf0rflags & CAN_RF0R_FOVR0) != 0U)
		1845	{
		1846	/* Set CAN error code to Rx Fifo 0 overrun error */
		1847	errorcode \|= HAL_CAN_ERROR_RX_FOV0;
		1848
		1849	/* Clear FIFO0 Overrun Flag */
		1850	__HAL_CAN_CLEAR_FLAG(hcan, CAN_FLAG_FOV0);
		1851	}
		1852	}
		1853
		1854	/* Receive FIFO 0 full interrupt management ********************************/
		1855	if ((interrupts & CAN_IT_RX_FIFO0_FULL) != 0U)
		1856	{
		1857	if ((rf0rflags & CAN_RF0R_FULL0) != 0U)
		1858	{
		1859	/* Clear FIFO 0 full Flag */
		1860	__HAL_CAN_CLEAR_FLAG(hcan, CAN_FLAG_FF0);
		1861
		1862	/* Receive FIFO 0 full Callback */
		1863	#if USE_HAL_CAN_REGISTER_CALLBACKS == 1
		1864	/* Call registered callback*/
		1865	hcan->RxFifo0FullCallback(hcan);
		1866	#else
		1867	/* Call weak (surcharged) callback */
		1868	HAL_CAN_RxFifo0FullCallback(hcan);
		1869	#endif /* USE_HAL_CAN_REGISTER_CALLBACKS */
		1870	}
		1871	}
		1872
		1873	/* Receive FIFO 0 message pending interrupt management *********************/
		1874	if ((interrupts & CAN_IT_RX_FIFO0_MSG_PENDING) != 0U)
		1875	{
		1876	/* Check if message is still pending */
		1877	if ((hcan->Instance->RF0R & CAN_RF0R_FMP0) != 0U)
		1878	{
		1879	/* Receive FIFO 0 message pending Callback */
		1880	#if USE_HAL_CAN_REGISTER_CALLBACKS == 1
		1881	/* Call registered callback*/
		1882	hcan->RxFifo0MsgPendingCallback(hcan);
		1883	#else
		1884	/* Call weak (surcharged) callback */
		1885	HAL_CAN_RxFifo0MsgPendingCallback(hcan);
		1886	#endif /* USE_HAL_CAN_REGISTER_CALLBACKS */
		1887	}
		1888	}
		1889
		1890	/* Receive FIFO 1 overrun interrupt management *****************************/
		1891	if ((interrupts & CAN_IT_RX_FIFO1_OVERRUN) != 0U)
		1892	{
		1893	if ((rf1rflags & CAN_RF1R_FOVR1) != 0U)
		1894	{
		1895	/* Set CAN error code to Rx Fifo 1 overrun error */
		1896	errorcode \|= HAL_CAN_ERROR_RX_FOV1;
		1897
		1898	/* Clear FIFO1 Overrun Flag */
		1899	__HAL_CAN_CLEAR_FLAG(hcan, CAN_FLAG_FOV1);
		1900	}
		1901	}
		1902
		1903	/* Receive FIFO 1 full interrupt management ********************************/
		1904	if ((interrupts & CAN_IT_RX_FIFO1_FULL) != 0U)
		1905	{
		1906	if ((rf1rflags & CAN_RF1R_FULL1) != 0U)
		1907	{
		1908	/* Clear FIFO 1 full Flag */
		1909	__HAL_CAN_CLEAR_FLAG(hcan, CAN_FLAG_FF1);
		1910
		1911	/* Receive FIFO 1 full Callback */
		1912	#if USE_HAL_CAN_REGISTER_CALLBACKS == 1
		1913	/* Call registered callback*/
		1914	hcan->RxFifo1FullCallback(hcan);
		1915	#else
		1916	/* Call weak (surcharged) callback */
		1917	HAL_CAN_RxFifo1FullCallback(hcan);
		1918	#endif /* USE_HAL_CAN_REGISTER_CALLBACKS */
		1919	}
		1920	}
		1921
		1922	/* Receive FIFO 1 message pending interrupt management *********************/
		1923	if ((interrupts & CAN_IT_RX_FIFO1_MSG_PENDING) != 0U)
		1924	{
		1925	/* Check if message is still pending */
		1926	if ((hcan->Instance->RF1R & CAN_RF1R_FMP1) != 0U)
		1927	{
		1928	/* Receive FIFO 1 message pending Callback */
		1929	#if USE_HAL_CAN_REGISTER_CALLBACKS == 1
		1930	/* Call registered callback*/
		1931	hcan->RxFifo1MsgPendingCallback(hcan);
		1932	#else
		1933	/* Call weak (surcharged) callback */
		1934	HAL_CAN_RxFifo1MsgPendingCallback(hcan);
		1935	#endif /* USE_HAL_CAN_REGISTER_CALLBACKS */
		1936	}
		1937	}
		1938
		1939	/* Sleep interrupt management *********************************************/
		1940	if ((interrupts & CAN_IT_SLEEP_ACK) != 0U)
		1941	{
		1942	if ((msrflags & CAN_MSR_SLAKI) != 0U)
		1943	{
		1944	/* Clear Sleep interrupt Flag */
		1945	__HAL_CAN_CLEAR_FLAG(hcan, CAN_FLAG_SLAKI);
		1946
		1947	/* Sleep Callback */
		1948	#if USE_HAL_CAN_REGISTER_CALLBACKS == 1
		1949	/* Call registered callback*/
		1950	hcan->SleepCallback(hcan);
		1951	#else
		1952	/* Call weak (surcharged) callback */
		1953	HAL_CAN_SleepCallback(hcan);
		1954	#endif /* USE_HAL_CAN_REGISTER_CALLBACKS */
		1955	}
		1956	}
		1957
		1958	/* WakeUp interrupt management *********************************************/
		1959	if ((interrupts & CAN_IT_WAKEUP) != 0U)
		1960	{
		1961	if ((msrflags & CAN_MSR_WKUI) != 0U)
		1962	{
		1963	/* Clear WakeUp Flag */
		1964	__HAL_CAN_CLEAR_FLAG(hcan, CAN_FLAG_WKU);
		1965
		1966	/* WakeUp Callback */
		1967	#if USE_HAL_CAN_REGISTER_CALLBACKS == 1
		1968	/* Call registered callback*/
		1969	hcan->WakeUpFromRxMsgCallback(hcan);
		1970	#else
		1971	/* Call weak (surcharged) callback */
		1972	HAL_CAN_WakeUpFromRxMsgCallback(hcan);
		1973	#endif /* USE_HAL_CAN_REGISTER_CALLBACKS */
		1974	}
		1975	}
		1976
		1977	/* Error interrupts management *********************************************/
		1978	if ((interrupts & CAN_IT_ERROR) != 0U)
		1979	{
		1980	if ((msrflags & CAN_MSR_ERRI) != 0U)
		1981	{
		1982	/* Check Error Warning Flag */
		1983	if (((interrupts & CAN_IT_ERROR_WARNING) != 0U) &&
		1984	((esrflags & CAN_ESR_EWGF) != 0U))
		1985	{
		1986	/* Set CAN error code to Error Warning */
		1987	errorcode \|= HAL_CAN_ERROR_EWG;
		1988
		1989	/* No need for clear of Error Warning Flag as read-only */
		1990	}
		1991
		1992	/* Check Error Passive Flag */
		1993	if (((interrupts & CAN_IT_ERROR_PASSIVE) != 0U) &&
		1994	((esrflags & CAN_ESR_EPVF) != 0U))
		1995	{
		1996	/* Set CAN error code to Error Passive */
		1997	errorcode \|= HAL_CAN_ERROR_EPV;
		1998
		1999	/* No need for clear of Error Passive Flag as read-only */
		2000	}
		2001
		2002	/* Check Bus-off Flag */
		2003	if (((interrupts & CAN_IT_BUSOFF) != 0U) &&
		2004	((esrflags & CAN_ESR_BOFF) != 0U))
		2005	{
		2006	/* Set CAN error code to Bus-Off */
		2007	errorcode \|= HAL_CAN_ERROR_BOF;
		2008
		2009	/* No need for clear of Error Bus-Off as read-only */
		2010	}
		2011
		2012	/* Check Last Error Code Flag */
		2013	if (((interrupts & CAN_IT_LAST_ERROR_CODE) != 0U) &&
		2014	((esrflags & CAN_ESR_LEC) != 0U))
		2015	{
		2016	switch (esrflags & CAN_ESR_LEC)
		2017	{
		2018	case (CAN_ESR_LEC_0):
		2019	/* Set CAN error code to Stuff error */
		2020	errorcode \|= HAL_CAN_ERROR_STF;
		2021	break;
		2022	case (CAN_ESR_LEC_1):
		2023	/* Set CAN error code to Form error */
		2024	errorcode \|= HAL_CAN_ERROR_FOR;
		2025	break;
		2026	case (CAN_ESR_LEC_1 \| CAN_ESR_LEC_0):
		2027	/* Set CAN error code to Acknowledgement error */
		2028	errorcode \|= HAL_CAN_ERROR_ACK;
		2029	break;
		2030	case (CAN_ESR_LEC_2):
		2031	/* Set CAN error code to Bit recessive error */
		2032	errorcode \|= HAL_CAN_ERROR_BR;
		2033	break;
		2034	case (CAN_ESR_LEC_2 \| CAN_ESR_LEC_0):
		2035	/* Set CAN error code to Bit Dominant error */
		2036	errorcode \|= HAL_CAN_ERROR_BD;
		2037	break;
		2038	case (CAN_ESR_LEC_2 \| CAN_ESR_LEC_1):
		2039	/* Set CAN error code to CRC error */
		2040	errorcode \|= HAL_CAN_ERROR_CRC;
		2041	break;
		2042	default:
		2043	break;
		2044	}
		2045
		2046	/* Clear Last error code Flag */
		2047	CLEAR_BIT(hcan->Instance->ESR, CAN_ESR_LEC);
		2048	}
		2049	}
		2050
		2051	/* Clear ERRI Flag */
		2052	__HAL_CAN_CLEAR_FLAG(hcan, CAN_FLAG_ERRI);
		2053	}
		2054
		2055	/* Call the Error call Back in case of Errors */
		2056	if (errorcode != HAL_CAN_ERROR_NONE)
		2057	{
		2058	/* Update error code in handle */
		2059	hcan->ErrorCode \|= errorcode;
		2060
		2061	/* Call Error callback function */
		2062	#if USE_HAL_CAN_REGISTER_CALLBACKS == 1
		2063	/* Call registered callback*/
		2064	hcan->ErrorCallback(hcan);
		2065	#else
		2066	/* Call weak (surcharged) callback */
		2067	HAL_CAN_ErrorCallback(hcan);
		2068	#endif /* USE_HAL_CAN_REGISTER_CALLBACKS */
		2069	}
		2070	}
		2071
		2072	/**
		2073	* @}
		2074	*/
		2075
		2076	/** @defgroup CAN_Exported_Functions_Group5 Callback functions
		2077	* @brief CAN Callback functions
		2078	*
		2079	@verbatim
		2080	==============================================================================
		2081	##### Callback functions #####
		2082	==============================================================================
		2083	[..]
		2084	This subsection provides the following callback functions:
		2085	(+) HAL_CAN_TxMailbox0CompleteCallback
		2086	(+) HAL_CAN_TxMailbox1CompleteCallback
		2087	(+) HAL_CAN_TxMailbox2CompleteCallback
		2088	(+) HAL_CAN_TxMailbox0AbortCallback
		2089	(+) HAL_CAN_TxMailbox1AbortCallback
		2090	(+) HAL_CAN_TxMailbox2AbortCallback
		2091	(+) HAL_CAN_RxFifo0MsgPendingCallback
		2092	(+) HAL_CAN_RxFifo0FullCallback
		2093	(+) HAL_CAN_RxFifo1MsgPendingCallback
		2094	(+) HAL_CAN_RxFifo1FullCallback
		2095	(+) HAL_CAN_SleepCallback
		2096	(+) HAL_CAN_WakeUpFromRxMsgCallback
		2097	(+) HAL_CAN_ErrorCallback
		2098
		2099	@endverbatim
		2100	* @{
		2101	*/
		2102
		2103	/**
		2104	* @brief Transmission Mailbox 0 complete callback.
		2105	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		2106	* the configuration information for the specified CAN.
		2107	* @retval None
		2108	*/
		2109	__weak void HAL_CAN_TxMailbox0CompleteCallback(CAN_HandleTypeDef *hcan)
		2110	{
		2111	/* Prevent unused argument(s) compilation warning */
		2112	UNUSED(hcan);
		2113
		2114	/* NOTE : This function Should not be modified, when the callback is needed,
		2115	the HAL_CAN_TxMailbox0CompleteCallback could be implemented in the
		2116	user file
		2117	*/
		2118	}
		2119
		2120	/**
		2121	* @brief Transmission Mailbox 1 complete callback.
		2122	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		2123	* the configuration information for the specified CAN.
		2124	* @retval None
		2125	*/
		2126	__weak void HAL_CAN_TxMailbox1CompleteCallback(CAN_HandleTypeDef *hcan)
		2127	{
		2128	/* Prevent unused argument(s) compilation warning */
		2129	UNUSED(hcan);
		2130
		2131	/* NOTE : This function Should not be modified, when the callback is needed,
		2132	the HAL_CAN_TxMailbox1CompleteCallback could be implemented in the
		2133	user file
		2134	*/
		2135	}
		2136
		2137	/**
		2138	* @brief Transmission Mailbox 2 complete callback.
		2139	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		2140	* the configuration information for the specified CAN.
		2141	* @retval None
		2142	*/
		2143	__weak void HAL_CAN_TxMailbox2CompleteCallback(CAN_HandleTypeDef *hcan)
		2144	{
		2145	/* Prevent unused argument(s) compilation warning */
		2146	UNUSED(hcan);
		2147
		2148	/* NOTE : This function Should not be modified, when the callback is needed,
		2149	the HAL_CAN_TxMailbox2CompleteCallback could be implemented in the
		2150	user file
		2151	*/
		2152	}
		2153
		2154	/**
		2155	* @brief Transmission Mailbox 0 Cancellation callback.
		2156	* @param hcan pointer to an CAN_HandleTypeDef structure that contains
		2157	* the configuration information for the specified CAN.
		2158	* @retval None
		2159	*/
		2160	__weak void HAL_CAN_TxMailbox0AbortCallback(CAN_HandleTypeDef *hcan)
		2161	{
		2162	/* Prevent unused argument(s) compilation warning */
		2163	UNUSED(hcan);
		2164
		2165	/* NOTE : This function Should not be modified, when the callback is needed,
		2166	the HAL_CAN_TxMailbox0AbortCallback could be implemented in the
		2167	user file
		2168	*/
		2169	}
		2170
		2171	/**
		2172	* @brief Transmission Mailbox 1 Cancellation callback.
		2173	* @param hcan pointer to an CAN_HandleTypeDef structure that contains
		2174	* the configuration information for the specified CAN.
		2175	* @retval None
		2176	*/
		2177	__weak void HAL_CAN_TxMailbox1AbortCallback(CAN_HandleTypeDef *hcan)
		2178	{
		2179	/* Prevent unused argument(s) compilation warning */
		2180	UNUSED(hcan);
		2181
		2182	/* NOTE : This function Should not be modified, when the callback is needed,
		2183	the HAL_CAN_TxMailbox1AbortCallback could be implemented in the
		2184	user file
		2185	*/
		2186	}
		2187
		2188	/**
		2189	* @brief Transmission Mailbox 2 Cancellation callback.
		2190	* @param hcan pointer to an CAN_HandleTypeDef structure that contains
		2191	* the configuration information for the specified CAN.
		2192	* @retval None
		2193	*/
		2194	__weak void HAL_CAN_TxMailbox2AbortCallback(CAN_HandleTypeDef *hcan)
		2195	{
		2196	/* Prevent unused argument(s) compilation warning */
		2197	UNUSED(hcan);
		2198
		2199	/* NOTE : This function Should not be modified, when the callback is needed,
		2200	the HAL_CAN_TxMailbox2AbortCallback could be implemented in the
		2201	user file
		2202	*/
		2203	}
		2204
		2205	/**
		2206	* @brief Rx FIFO 0 message pending callback.
		2207	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		2208	* the configuration information for the specified CAN.
		2209	* @retval None
		2210	*/
		2211	__weak void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan)
		2212	{
		2213	/* Prevent unused argument(s) compilation warning */
		2214	UNUSED(hcan);
		2215
		2216	/* NOTE : This function Should not be modified, when the callback is needed,
		2217	the HAL_CAN_RxFifo0MsgPendingCallback could be implemented in the
		2218	user file
		2219	*/
		2220	}
		2221
		2222	/**
		2223	* @brief Rx FIFO 0 full callback.
		2224	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		2225	* the configuration information for the specified CAN.
		2226	* @retval None
		2227	*/
		2228	__weak void HAL_CAN_RxFifo0FullCallback(CAN_HandleTypeDef *hcan)
		2229	{
		2230	/* Prevent unused argument(s) compilation warning */
		2231	UNUSED(hcan);
		2232
		2233	/* NOTE : This function Should not be modified, when the callback is needed,
		2234	the HAL_CAN_RxFifo0FullCallback could be implemented in the user
		2235	file
		2236	*/
		2237	}
		2238
		2239	/**
		2240	* @brief Rx FIFO 1 message pending callback.
		2241	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		2242	* the configuration information for the specified CAN.
		2243	* @retval None
		2244	*/
		2245	__weak void HAL_CAN_RxFifo1MsgPendingCallback(CAN_HandleTypeDef *hcan)
		2246	{
		2247	/* Prevent unused argument(s) compilation warning */
		2248	UNUSED(hcan);
		2249
		2250	/* NOTE : This function Should not be modified, when the callback is needed,
		2251	the HAL_CAN_RxFifo1MsgPendingCallback could be implemented in the
		2252	user file
		2253	*/
		2254	}
		2255
		2256	/**
		2257	* @brief Rx FIFO 1 full callback.
		2258	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		2259	* the configuration information for the specified CAN.
		2260	* @retval None
		2261	*/
		2262	__weak void HAL_CAN_RxFifo1FullCallback(CAN_HandleTypeDef *hcan)
		2263	{
		2264	/* Prevent unused argument(s) compilation warning */
		2265	UNUSED(hcan);
		2266
		2267	/* NOTE : This function Should not be modified, when the callback is needed,
		2268	the HAL_CAN_RxFifo1FullCallback could be implemented in the user
		2269	file
		2270	*/
		2271	}
		2272
		2273	/**
		2274	* @brief Sleep callback.
		2275	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		2276	* the configuration information for the specified CAN.
		2277	* @retval None
		2278	*/
		2279	__weak void HAL_CAN_SleepCallback(CAN_HandleTypeDef *hcan)
		2280	{
		2281	/* Prevent unused argument(s) compilation warning */
		2282	UNUSED(hcan);
		2283
		2284	/* NOTE : This function Should not be modified, when the callback is needed,
		2285	the HAL_CAN_SleepCallback could be implemented in the user file
		2286	*/
		2287	}
		2288
		2289	/**
		2290	* @brief WakeUp from Rx message callback.
		2291	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		2292	* the configuration information for the specified CAN.
		2293	* @retval None
		2294	*/
		2295	__weak void HAL_CAN_WakeUpFromRxMsgCallback(CAN_HandleTypeDef *hcan)
		2296	{
		2297	/* Prevent unused argument(s) compilation warning */
		2298	UNUSED(hcan);
		2299
		2300	/* NOTE : This function Should not be modified, when the callback is needed,
		2301	the HAL_CAN_WakeUpFromRxMsgCallback could be implemented in the
		2302	user file
		2303	*/
		2304	}
		2305
		2306	/**
		2307	* @brief Error CAN callback.
		2308	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		2309	* the configuration information for the specified CAN.
		2310	* @retval None
		2311	*/
		2312	__weak void HAL_CAN_ErrorCallback(CAN_HandleTypeDef *hcan)
		2313	{
		2314	/* Prevent unused argument(s) compilation warning */
		2315	UNUSED(hcan);
		2316
		2317	/* NOTE : This function Should not be modified, when the callback is needed,
		2318	the HAL_CAN_ErrorCallback could be implemented in the user file
		2319	*/
		2320	}
		2321
		2322	/**
		2323	* @}
		2324	*/
		2325
		2326	/** @defgroup CAN_Exported_Functions_Group6 Peripheral State and Error functions
		2327	* @brief CAN Peripheral State functions
		2328	*
		2329	@verbatim
		2330	==============================================================================
		2331	##### Peripheral State and Error functions #####
		2332	==============================================================================
		2333	[..]
		2334	This subsection provides functions allowing to :
		2335	(+) HAL_CAN_GetState() : Return the CAN state.
		2336	(+) HAL_CAN_GetError() : Return the CAN error codes if any.
		2337	(+) HAL_CAN_ResetError(): Reset the CAN error codes if any.
		2338
		2339	@endverbatim
		2340	* @{
		2341	*/
		2342
		2343	/**
		2344	* @brief Return the CAN state.
		2345	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		2346	* the configuration information for the specified CAN.
		2347	* @retval HAL state
		2348	*/
		2349	HAL_CAN_StateTypeDef HAL_CAN_GetState(const CAN_HandleTypeDef *hcan)
		2350	{
		2351	HAL_CAN_StateTypeDef state = hcan->State;
		2352
		2353	if ((state == HAL_CAN_STATE_READY) \|\|
		2354	(state == HAL_CAN_STATE_LISTENING))
		2355	{
		2356	/* Check sleep mode acknowledge flag */
		2357	if ((hcan->Instance->MSR & CAN_MSR_SLAK) != 0U)
		2358	{
		2359	/* Sleep mode is active */
		2360	state = HAL_CAN_STATE_SLEEP_ACTIVE;
		2361	}
		2362	/* Check sleep mode request flag */
		2363	else if ((hcan->Instance->MCR & CAN_MCR_SLEEP) != 0U)
		2364	{
		2365	/* Sleep mode request is pending */
		2366	state = HAL_CAN_STATE_SLEEP_PENDING;
		2367	}
		2368	else
		2369	{
		2370	/* Neither sleep mode request nor sleep mode acknowledge */
		2371	}
		2372	}
		2373
		2374	/* Return CAN state */
		2375	return state;
		2376	}
		2377
		2378	/**
		2379	* @brief Return the CAN error code.
		2380	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		2381	* the configuration information for the specified CAN.
		2382	* @retval CAN Error Code
		2383	*/
		2384	uint32_t HAL_CAN_GetError(const CAN_HandleTypeDef *hcan)
		2385	{
		2386	/* Return CAN error code */
		2387	return hcan->ErrorCode;
		2388	}
		2389
		2390	/**
		2391	* @brief Reset the CAN error code.
		2392	* @param hcan pointer to a CAN_HandleTypeDef structure that contains
		2393	* the configuration information for the specified CAN.
		2394	* @retval HAL status
		2395	*/
		2396	HAL_StatusTypeDef HAL_CAN_ResetError(CAN_HandleTypeDef *hcan)
		2397	{
		2398	HAL_StatusTypeDef status = HAL_OK;
		2399	HAL_CAN_StateTypeDef state = hcan->State;
		2400
		2401	if ((state == HAL_CAN_STATE_READY) \|\|
		2402	(state == HAL_CAN_STATE_LISTENING))
		2403	{
		2404	/* Reset CAN error code */
		2405	hcan->ErrorCode = 0U;
		2406	}
		2407	else
		2408	{
		2409	/* Update error code */
		2410	hcan->ErrorCode \|= HAL_CAN_ERROR_NOT_INITIALIZED;
		2411
		2412	status = HAL_ERROR;
		2413	}
		2414
		2415	/* Return the status */
		2416	return status;
		2417	}
		2418
		2419	/**
		2420	* @}
		2421	*/
		2422
		2423	/**
		2424	* @}
		2425	*/
		2426
		2427	#endif /* HAL_CAN_MODULE_ENABLED */
		2428
		2429	/**
		2430	* @}
		2431	*/
		2432
		2433	#endif /* CAN1 */
		2434
		2435	/**
		2436	* @}
		2437	*/

Subversion Repositories AFRtranscoder

(root)/trunk/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_can.c – Rev 2