Pedro Correia / mbed-dev

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Fork of mbed-dev by mbed official

targets/TARGET_STM/TARGET_STM32F4/device/stm32f4xx_hal_can.c@187:fa51feb62426, 2018-10-09 (annotated)

Committer:
pmcorreia
Date:
Tue Oct 09 14:42:37 2018 +0000
Revision:
187:fa51feb62426
Parent:
182:a56a73fd2a6f 
Updated version to work with F446RE

Who changed what in which revision?

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