TUKS MCU Introductory course / TUKS-COURSE-TIMER

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.

HAL_L476/stm32l4xx_hal_can.c@1:d0dfbce63a89, 2017-02-24 (annotated)

Committer:
elmot
Date:
Fri Feb 24 21:13:56 2017 +0000
Revision:
1:d0dfbce63a89
Ready-to-copy

Who changed what in which revision?

UserRevisionLine numberNew contents of line
elmot 1:d0dfbce63a89 1 /**
elmot 1:d0dfbce63a89 2 ******************************************************************************
elmot 1:d0dfbce63a89 3 * @file stm32l4xx_hal_can.c
elmot 1:d0dfbce63a89 4 * @author MCD Application Team
elmot 1:d0dfbce63a89 5 * @version V1.5.1
elmot 1:d0dfbce63a89 6 * @date 31-May-2016
elmot 1:d0dfbce63a89 7 * @brief CAN HAL module driver.
elmot 1:d0dfbce63a89 8 * This file provides firmware functions to manage the following
elmot 1:d0dfbce63a89 9 * functionalities of the Controller Area Network (CAN) peripheral:
elmot 1:d0dfbce63a89 10 * + Initialization and de-initialization functions
elmot 1:d0dfbce63a89 11 * + IO operation functions
elmot 1:d0dfbce63a89 12 * + Peripheral Control functions
elmot 1:d0dfbce63a89 13 * + Peripheral State and Error functions
elmot 1:d0dfbce63a89 14 *
elmot 1:d0dfbce63a89 15 @verbatim
elmot 1:d0dfbce63a89 16 ==============================================================================
elmot 1:d0dfbce63a89 17 ##### How to use this driver #####
elmot 1:d0dfbce63a89 18 ==============================================================================
elmot 1:d0dfbce63a89 19 [..]
elmot 1:d0dfbce63a89 20 (#) Enable the CAN controller interface clock using
elmot 1:d0dfbce63a89 21 __HAL_RCC_CAN1_CLK_ENABLE() for CAN1.
elmot 1:d0dfbce63a89 22
elmot 1:d0dfbce63a89 23 (#) CAN pins configuration
elmot 1:d0dfbce63a89 24 (++) Enable the clock for the CAN GPIOs using the following function:
elmot 1:d0dfbce63a89 25 __HAL_RCC_GPIOx_CLK_ENABLE();
elmot 1:d0dfbce63a89 26 (++) Connect and configure the involved CAN pins using the
elmot 1:d0dfbce63a89 27 following function HAL_GPIO_Init();
elmot 1:d0dfbce63a89 28
elmot 1:d0dfbce63a89 29 (#) Initialize and configure the CAN using HAL_CAN_Init() function.
elmot 1:d0dfbce63a89 30
elmot 1:d0dfbce63a89 31 (#) Transmit the desired CAN frame using HAL_CAN_Transmit() or
elmot 1:d0dfbce63a89 32 HAL_CAN_Transmit_IT() function.
elmot 1:d0dfbce63a89 33
elmot 1:d0dfbce63a89 34 (#) Receive a CAN frame using HAL_CAN_Receive() or HAL_CAN_Receive_IT() function.
elmot 1:d0dfbce63a89 35
elmot 1:d0dfbce63a89 36 *** Polling mode IO operation ***
elmot 1:d0dfbce63a89 37 =================================
elmot 1:d0dfbce63a89 38 [..]
elmot 1:d0dfbce63a89 39 (+) Start the CAN peripheral transmission and wait the end of this operation
elmot 1:d0dfbce63a89 40 using HAL_CAN_Transmit(), at this stage user can specify the value of timeout
elmot 1:d0dfbce63a89 41 according to his end application
elmot 1:d0dfbce63a89 42 (+) Start the CAN peripheral reception and wait the end of this operation
elmot 1:d0dfbce63a89 43 using HAL_CAN_Receive(), at this stage user can specify the value of timeout
elmot 1:d0dfbce63a89 44 according to his end application
elmot 1:d0dfbce63a89 45
elmot 1:d0dfbce63a89 46 *** Interrupt mode IO operation ***
elmot 1:d0dfbce63a89 47 ===================================
elmot 1:d0dfbce63a89 48 [..]
elmot 1:d0dfbce63a89 49 (+) Start the CAN peripheral transmission using HAL_CAN_Transmit_IT()
elmot 1:d0dfbce63a89 50 (+) Start the CAN peripheral reception using HAL_CAN_Receive_IT()
elmot 1:d0dfbce63a89 51 (+) Use HAL_CAN_IRQHandler() called under the used CAN Interrupt subroutine
elmot 1:d0dfbce63a89 52 (+) At CAN end of transmission HAL_CAN_TxCpltCallback() function is executed and user can
elmot 1:d0dfbce63a89 53 add his own code by customization of function pointer HAL_CAN_TxCpltCallback
elmot 1:d0dfbce63a89 54 (+) In case of CAN Error, HAL_CAN_ErrorCallback() function is executed and user can
elmot 1:d0dfbce63a89 55 add his own code by customization of function pointer HAL_CAN_ErrorCallback
elmot 1:d0dfbce63a89 56
elmot 1:d0dfbce63a89 57 *** CAN HAL driver macros list ***
elmot 1:d0dfbce63a89 58 =============================================
elmot 1:d0dfbce63a89 59 [..]
elmot 1:d0dfbce63a89 60 Below the list of most used macros in CAN HAL driver.
elmot 1:d0dfbce63a89 61
elmot 1:d0dfbce63a89 62 (+) __HAL_CAN_ENABLE_IT: Enable the specified CAN interrupts
elmot 1:d0dfbce63a89 63 (+) __HAL_CAN_DISABLE_IT: Disable the specified CAN interrupts
elmot 1:d0dfbce63a89 64 (+) __HAL_CAN_GET_IT_SOURCE: Check if the specified CAN interrupt source is enabled or disabled
elmot 1:d0dfbce63a89 65 (+) __HAL_CAN_CLEAR_FLAG: Clear the CAN's pending flags
elmot 1:d0dfbce63a89 66 (+) __HAL_CAN_GET_FLAG: Get the selected CAN's flag status
elmot 1:d0dfbce63a89 67
elmot 1:d0dfbce63a89 68 [..]
elmot 1:d0dfbce63a89 69 (@) You can refer to the CAN HAL driver header file for more useful macros
elmot 1:d0dfbce63a89 70
elmot 1:d0dfbce63a89 71 @endverbatim
elmot 1:d0dfbce63a89 72
elmot 1:d0dfbce63a89 73 ******************************************************************************
elmot 1:d0dfbce63a89 74 * @attention
elmot 1:d0dfbce63a89 75 *
elmot 1:d0dfbce63a89 76 * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
elmot 1:d0dfbce63a89 77 *
elmot 1:d0dfbce63a89 78 * Redistribution and use in source and binary forms, with or without modification,
elmot 1:d0dfbce63a89 79 * are permitted provided that the following conditions are met:
elmot 1:d0dfbce63a89 80 * 1. Redistributions of source code must retain the above copyright notice,
elmot 1:d0dfbce63a89 81 * this list of conditions and the following disclaimer.
elmot 1:d0dfbce63a89 82 * 2. Redistributions in binary form must reproduce the above copyright notice,
elmot 1:d0dfbce63a89 83 * this list of conditions and the following disclaimer in the documentation
elmot 1:d0dfbce63a89 84 * and/or other materials provided with the distribution.
elmot 1:d0dfbce63a89 85 * 3. Neither the name of STMicroelectronics nor the names of its contributors
elmot 1:d0dfbce63a89 86 * may be used to endorse or promote products derived from this software
elmot 1:d0dfbce63a89 87 * without specific prior written permission.
elmot 1:d0dfbce63a89 88 *
elmot 1:d0dfbce63a89 89 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
elmot 1:d0dfbce63a89 90 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
elmot 1:d0dfbce63a89 91 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
elmot 1:d0dfbce63a89 92 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
elmot 1:d0dfbce63a89 93 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
elmot 1:d0dfbce63a89 94 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
elmot 1:d0dfbce63a89 95 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
elmot 1:d0dfbce63a89 96 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
elmot 1:d0dfbce63a89 97 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
elmot 1:d0dfbce63a89 98 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
elmot 1:d0dfbce63a89 99 *
elmot 1:d0dfbce63a89 100 ******************************************************************************
elmot 1:d0dfbce63a89 101 */
elmot 1:d0dfbce63a89 102
elmot 1:d0dfbce63a89 103 /* Includes ------------------------------------------------------------------*/
elmot 1:d0dfbce63a89 104 #include "stm32l4xx_hal.h"
elmot 1:d0dfbce63a89 105
elmot 1:d0dfbce63a89 106 /** @addtogroup STM32L4xx_HAL_Driver
elmot 1:d0dfbce63a89 107 * @{
elmot 1:d0dfbce63a89 108 */
elmot 1:d0dfbce63a89 109
elmot 1:d0dfbce63a89 110 /** @defgroup CAN CAN
elmot 1:d0dfbce63a89 111 * @brief CAN driver modules
elmot 1:d0dfbce63a89 112 * @{
elmot 1:d0dfbce63a89 113 */
elmot 1:d0dfbce63a89 114
elmot 1:d0dfbce63a89 115 #ifdef HAL_CAN_MODULE_ENABLED
elmot 1:d0dfbce63a89 116
elmot 1:d0dfbce63a89 117 /* Private typedef -----------------------------------------------------------*/
elmot 1:d0dfbce63a89 118 /* Private define ------------------------------------------------------------*/
elmot 1:d0dfbce63a89 119 /** @defgroup CAN_Private_Constants CAN Private Constants
elmot 1:d0dfbce63a89 120 * @{
elmot 1:d0dfbce63a89 121 */
elmot 1:d0dfbce63a89 122 #define CAN_TIMEOUT_VALUE 10
elmot 1:d0dfbce63a89 123 /**
elmot 1:d0dfbce63a89 124 * @}
elmot 1:d0dfbce63a89 125 */
elmot 1:d0dfbce63a89 126 /* Private macro -------------------------------------------------------------*/
elmot 1:d0dfbce63a89 127 /* Private variables ---------------------------------------------------------*/
elmot 1:d0dfbce63a89 128 /* Private function prototypes -----------------------------------------------*/
elmot 1:d0dfbce63a89 129 /** @defgroup CAN_Private_Functions CAN Private Functions
elmot 1:d0dfbce63a89 130 * @{
elmot 1:d0dfbce63a89 131 */
elmot 1:d0dfbce63a89 132 static HAL_StatusTypeDef CAN_Receive_IT(CAN_HandleTypeDef* hcan, uint8_t FIFONumber);
elmot 1:d0dfbce63a89 133 static HAL_StatusTypeDef CAN_Transmit_IT(CAN_HandleTypeDef* hcan);
elmot 1:d0dfbce63a89 134 /**
elmot 1:d0dfbce63a89 135 * @}
elmot 1:d0dfbce63a89 136 */
elmot 1:d0dfbce63a89 137
elmot 1:d0dfbce63a89 138 /* Exported functions --------------------------------------------------------*/
elmot 1:d0dfbce63a89 139
elmot 1:d0dfbce63a89 140 /** @defgroup CAN_Exported_Functions CAN Exported Functions
elmot 1:d0dfbce63a89 141 * @{
elmot 1:d0dfbce63a89 142 */
elmot 1:d0dfbce63a89 143
elmot 1:d0dfbce63a89 144 /** @defgroup CAN_Exported_Functions_Group1 Initialization and de-initialization functions
elmot 1:d0dfbce63a89 145 * @brief Initialization and Configuration functions
elmot 1:d0dfbce63a89 146 *
elmot 1:d0dfbce63a89 147 @verbatim
elmot 1:d0dfbce63a89 148 ==============================================================================
elmot 1:d0dfbce63a89 149 ##### Initialization and de-initialization functions #####
elmot 1:d0dfbce63a89 150 ==============================================================================
elmot 1:d0dfbce63a89 151 [..] This section provides functions allowing to:
elmot 1:d0dfbce63a89 152 (+) Initialize and configure the CAN.
elmot 1:d0dfbce63a89 153 (+) De-initialize the CAN.
elmot 1:d0dfbce63a89 154
elmot 1:d0dfbce63a89 155 @endverbatim
elmot 1:d0dfbce63a89 156 * @{
elmot 1:d0dfbce63a89 157 */
elmot 1:d0dfbce63a89 158
elmot 1:d0dfbce63a89 159 /**
elmot 1:d0dfbce63a89 160 * @brief Initialize the CAN peripheral according to the specified parameters
elmot 1:d0dfbce63a89 161 * in the CAN_InitStruct structure and initialize the associated handle.
elmot 1:d0dfbce63a89 162 * @param hcan: pointer to a CAN_HandleTypeDef structure that contains
elmot 1:d0dfbce63a89 163 * the configuration information for the specified CAN.
elmot 1:d0dfbce63a89 164 * @retval HAL status
elmot 1:d0dfbce63a89 165 */
elmot 1:d0dfbce63a89 166 HAL_StatusTypeDef HAL_CAN_Init(CAN_HandleTypeDef* hcan)
elmot 1:d0dfbce63a89 167 {
elmot 1:d0dfbce63a89 168 uint32_t status = CAN_INITSTATUS_FAILED; /* Default init status */
elmot 1:d0dfbce63a89 169 uint32_t tickstart = 0;
elmot 1:d0dfbce63a89 170
elmot 1:d0dfbce63a89 171 /* Check CAN handle */
elmot 1:d0dfbce63a89 172 if(hcan == NULL)
elmot 1:d0dfbce63a89 173 {
elmot 1:d0dfbce63a89 174 return HAL_ERROR;
elmot 1:d0dfbce63a89 175 }
elmot 1:d0dfbce63a89 176
elmot 1:d0dfbce63a89 177 /* Check the parameters */
elmot 1:d0dfbce63a89 178 assert_param(IS_CAN_ALL_INSTANCE(hcan->Instance));
elmot 1:d0dfbce63a89 179 assert_param(IS_FUNCTIONAL_STATE(hcan->Init.TTCM));
elmot 1:d0dfbce63a89 180 assert_param(IS_FUNCTIONAL_STATE(hcan->Init.ABOM));
elmot 1:d0dfbce63a89 181 assert_param(IS_FUNCTIONAL_STATE(hcan->Init.AWUM));
elmot 1:d0dfbce63a89 182 assert_param(IS_FUNCTIONAL_STATE(hcan->Init.NART));
elmot 1:d0dfbce63a89 183 assert_param(IS_FUNCTIONAL_STATE(hcan->Init.RFLM));
elmot 1:d0dfbce63a89 184 assert_param(IS_FUNCTIONAL_STATE(hcan->Init.TXFP));
elmot 1:d0dfbce63a89 185 assert_param(IS_CAN_MODE(hcan->Init.Mode));
elmot 1:d0dfbce63a89 186 assert_param(IS_CAN_SJW(hcan->Init.SJW));
elmot 1:d0dfbce63a89 187 assert_param(IS_CAN_BS1(hcan->Init.BS1));
elmot 1:d0dfbce63a89 188 assert_param(IS_CAN_BS2(hcan->Init.BS2));
elmot 1:d0dfbce63a89 189 assert_param(IS_CAN_PRESCALER(hcan->Init.Prescaler));
elmot 1:d0dfbce63a89 190
elmot 1:d0dfbce63a89 191 if(hcan->State == HAL_CAN_STATE_RESET)
elmot 1:d0dfbce63a89 192 {
elmot 1:d0dfbce63a89 193 /* Allocate lock resource and initialize it */
elmot 1:d0dfbce63a89 194 hcan->Lock = HAL_UNLOCKED;
elmot 1:d0dfbce63a89 195
elmot 1:d0dfbce63a89 196 /* Init the low level hardware */
elmot 1:d0dfbce63a89 197 HAL_CAN_MspInit(hcan);
elmot 1:d0dfbce63a89 198 }
elmot 1:d0dfbce63a89 199
elmot 1:d0dfbce63a89 200 /* Initialize the CAN state*/
elmot 1:d0dfbce63a89 201 hcan->State = HAL_CAN_STATE_BUSY;
elmot 1:d0dfbce63a89 202
elmot 1:d0dfbce63a89 203 /* Exit from sleep mode */
elmot 1:d0dfbce63a89 204 hcan->Instance->MCR &= (~(uint32_t)CAN_MCR_SLEEP);
elmot 1:d0dfbce63a89 205
elmot 1:d0dfbce63a89 206 /* Request initialisation */
elmot 1:d0dfbce63a89 207 hcan->Instance->MCR |= CAN_MCR_INRQ ;
elmot 1:d0dfbce63a89 208
elmot 1:d0dfbce63a89 209 /* Get tick */
elmot 1:d0dfbce63a89 210 tickstart = HAL_GetTick();
elmot 1:d0dfbce63a89 211
elmot 1:d0dfbce63a89 212 /* Wait the acknowledge */
elmot 1:d0dfbce63a89 213 while((hcan->Instance->MSR & CAN_MSR_INAK) != CAN_MSR_INAK)
elmot 1:d0dfbce63a89 214 {
elmot 1:d0dfbce63a89 215 if((HAL_GetTick()-tickstart) > CAN_TIMEOUT_VALUE)
elmot 1:d0dfbce63a89 216 {
elmot 1:d0dfbce63a89 217 hcan->State= HAL_CAN_STATE_TIMEOUT;
elmot 1:d0dfbce63a89 218 /* Process unlocked */
elmot 1:d0dfbce63a89 219 __HAL_UNLOCK(hcan);
elmot 1:d0dfbce63a89 220 return HAL_TIMEOUT;
elmot 1:d0dfbce63a89 221 }
elmot 1:d0dfbce63a89 222 }
elmot 1:d0dfbce63a89 223
elmot 1:d0dfbce63a89 224 /* Check acknowledge */
elmot 1:d0dfbce63a89 225 if ((hcan->Instance->MSR & CAN_MSR_INAK) == CAN_MSR_INAK)
elmot 1:d0dfbce63a89 226 {
elmot 1:d0dfbce63a89 227 /* Set the time triggered communication mode */
elmot 1:d0dfbce63a89 228 if (hcan->Init.TTCM == ENABLE)
elmot 1:d0dfbce63a89 229 {
elmot 1:d0dfbce63a89 230 hcan->Instance->MCR |= CAN_MCR_TTCM;
elmot 1:d0dfbce63a89 231 }
elmot 1:d0dfbce63a89 232 else
elmot 1:d0dfbce63a89 233 {
elmot 1:d0dfbce63a89 234 hcan->Instance->MCR &= ~(uint32_t)CAN_MCR_TTCM;
elmot 1:d0dfbce63a89 235 }
elmot 1:d0dfbce63a89 236
elmot 1:d0dfbce63a89 237 /* Set the automatic bus-off management */
elmot 1:d0dfbce63a89 238 if (hcan->Init.ABOM == ENABLE)
elmot 1:d0dfbce63a89 239 {
elmot 1:d0dfbce63a89 240 hcan->Instance->MCR |= CAN_MCR_ABOM;
elmot 1:d0dfbce63a89 241 }
elmot 1:d0dfbce63a89 242 else
elmot 1:d0dfbce63a89 243 {
elmot 1:d0dfbce63a89 244 hcan->Instance->MCR &= ~(uint32_t)CAN_MCR_ABOM;
elmot 1:d0dfbce63a89 245 }
elmot 1:d0dfbce63a89 246
elmot 1:d0dfbce63a89 247 /* Set the automatic wake-up mode */
elmot 1:d0dfbce63a89 248 if (hcan->Init.AWUM == ENABLE)
elmot 1:d0dfbce63a89 249 {
elmot 1:d0dfbce63a89 250 hcan->Instance->MCR |= CAN_MCR_AWUM;
elmot 1:d0dfbce63a89 251 }
elmot 1:d0dfbce63a89 252 else
elmot 1:d0dfbce63a89 253 {
elmot 1:d0dfbce63a89 254 hcan->Instance->MCR &= ~(uint32_t)CAN_MCR_AWUM;
elmot 1:d0dfbce63a89 255 }
elmot 1:d0dfbce63a89 256
elmot 1:d0dfbce63a89 257 /* Set the no automatic retransmission */
elmot 1:d0dfbce63a89 258 if (hcan->Init.NART == ENABLE)
elmot 1:d0dfbce63a89 259 {
elmot 1:d0dfbce63a89 260 hcan->Instance->MCR |= CAN_MCR_NART;
elmot 1:d0dfbce63a89 261 }
elmot 1:d0dfbce63a89 262 else
elmot 1:d0dfbce63a89 263 {
elmot 1:d0dfbce63a89 264 hcan->Instance->MCR &= ~(uint32_t)CAN_MCR_NART;
elmot 1:d0dfbce63a89 265 }
elmot 1:d0dfbce63a89 266
elmot 1:d0dfbce63a89 267 /* Set the receive FIFO locked mode */
elmot 1:d0dfbce63a89 268 if (hcan->Init.RFLM == ENABLE)
elmot 1:d0dfbce63a89 269 {
elmot 1:d0dfbce63a89 270 hcan->Instance->MCR |= CAN_MCR_RFLM;
elmot 1:d0dfbce63a89 271 }
elmot 1:d0dfbce63a89 272 else
elmot 1:d0dfbce63a89 273 {
elmot 1:d0dfbce63a89 274 hcan->Instance->MCR &= ~(uint32_t)CAN_MCR_RFLM;
elmot 1:d0dfbce63a89 275 }
elmot 1:d0dfbce63a89 276
elmot 1:d0dfbce63a89 277 /* Set the transmit FIFO priority */
elmot 1:d0dfbce63a89 278 if (hcan->Init.TXFP == ENABLE)
elmot 1:d0dfbce63a89 279 {
elmot 1:d0dfbce63a89 280 hcan->Instance->MCR |= CAN_MCR_TXFP;
elmot 1:d0dfbce63a89 281 }
elmot 1:d0dfbce63a89 282 else
elmot 1:d0dfbce63a89 283 {
elmot 1:d0dfbce63a89 284 hcan->Instance->MCR &= ~(uint32_t)CAN_MCR_TXFP;
elmot 1:d0dfbce63a89 285 }
elmot 1:d0dfbce63a89 286
elmot 1:d0dfbce63a89 287 /* Set the bit timing register */
elmot 1:d0dfbce63a89 288 hcan->Instance->BTR = (uint32_t)((uint32_t)hcan->Init.Mode) | \
elmot 1:d0dfbce63a89 289 ((uint32_t)hcan->Init.SJW) | \
elmot 1:d0dfbce63a89 290 ((uint32_t)hcan->Init.BS1) | \
elmot 1:d0dfbce63a89 291 ((uint32_t)hcan->Init.BS2) | \
elmot 1:d0dfbce63a89 292 ((uint32_t)hcan->Init.Prescaler - 1);
elmot 1:d0dfbce63a89 293
elmot 1:d0dfbce63a89 294 /* Request leave initialisation */
elmot 1:d0dfbce63a89 295 hcan->Instance->MCR &= ~(uint32_t)CAN_MCR_INRQ;
elmot 1:d0dfbce63a89 296
elmot 1:d0dfbce63a89 297 /* Get tick */
elmot 1:d0dfbce63a89 298 tickstart = HAL_GetTick();
elmot 1:d0dfbce63a89 299
elmot 1:d0dfbce63a89 300 /* Wait the acknowledge */
elmot 1:d0dfbce63a89 301 while((hcan->Instance->MSR & CAN_MSR_INAK) == CAN_MSR_INAK)
elmot 1:d0dfbce63a89 302 {
elmot 1:d0dfbce63a89 303 if((HAL_GetTick()-tickstart) > CAN_TIMEOUT_VALUE)
elmot 1:d0dfbce63a89 304 {
elmot 1:d0dfbce63a89 305 hcan->State= HAL_CAN_STATE_TIMEOUT;
elmot 1:d0dfbce63a89 306 /* Process unlocked */
elmot 1:d0dfbce63a89 307 __HAL_UNLOCK(hcan);
elmot 1:d0dfbce63a89 308 return HAL_TIMEOUT;
elmot 1:d0dfbce63a89 309 }
elmot 1:d0dfbce63a89 310 }
elmot 1:d0dfbce63a89 311
elmot 1:d0dfbce63a89 312 /* Check acknowledged */
elmot 1:d0dfbce63a89 313 if ((hcan->Instance->MSR & CAN_MSR_INAK) != CAN_MSR_INAK)
elmot 1:d0dfbce63a89 314 {
elmot 1:d0dfbce63a89 315 status = CAN_INITSTATUS_SUCCESS;
elmot 1:d0dfbce63a89 316 }
elmot 1:d0dfbce63a89 317 }
elmot 1:d0dfbce63a89 318
elmot 1:d0dfbce63a89 319 if(status == CAN_INITSTATUS_SUCCESS)
elmot 1:d0dfbce63a89 320 {
elmot 1:d0dfbce63a89 321 /* Set CAN error code to none */
elmot 1:d0dfbce63a89 322 hcan->ErrorCode = HAL_CAN_ERROR_NONE;
elmot 1:d0dfbce63a89 323
elmot 1:d0dfbce63a89 324 /* Initialize the CAN state */
elmot 1:d0dfbce63a89 325 hcan->State = HAL_CAN_STATE_READY;
elmot 1:d0dfbce63a89 326
elmot 1:d0dfbce63a89 327 /* Return function status */
elmot 1:d0dfbce63a89 328 return HAL_OK;
elmot 1:d0dfbce63a89 329 }
elmot 1:d0dfbce63a89 330 else
elmot 1:d0dfbce63a89 331 {
elmot 1:d0dfbce63a89 332 /* Initialize the CAN state */
elmot 1:d0dfbce63a89 333 hcan->State = HAL_CAN_STATE_ERROR;
elmot 1:d0dfbce63a89 334
elmot 1:d0dfbce63a89 335 /* Return function status */
elmot 1:d0dfbce63a89 336 return HAL_ERROR;
elmot 1:d0dfbce63a89 337 }
elmot 1:d0dfbce63a89 338 }
elmot 1:d0dfbce63a89 339
elmot 1:d0dfbce63a89 340 /**
elmot 1:d0dfbce63a89 341 * @brief Configure the CAN reception filter according to the specified
elmot 1:d0dfbce63a89 342 * parameters in the CAN_FilterInitStruct.
elmot 1:d0dfbce63a89 343 * @param hcan: pointer to a CAN_HandleTypeDef structure that contains
elmot 1:d0dfbce63a89 344 * the configuration information for the specified CAN.
elmot 1:d0dfbce63a89 345 * @param sFilterConfig: pointer to a CAN_FilterConfTypeDef structure that
elmot 1:d0dfbce63a89 346 * contains the filter configuration information.
elmot 1:d0dfbce63a89 347 * @retval None
elmot 1:d0dfbce63a89 348 */
elmot 1:d0dfbce63a89 349 HAL_StatusTypeDef HAL_CAN_ConfigFilter(CAN_HandleTypeDef* hcan, CAN_FilterConfTypeDef* sFilterConfig)
elmot 1:d0dfbce63a89 350 {
elmot 1:d0dfbce63a89 351 uint32_t filternbrbitpos = 0;
elmot 1:d0dfbce63a89 352
elmot 1:d0dfbce63a89 353 /* Prevent unused argument(s) compilation warning */
elmot 1:d0dfbce63a89 354 UNUSED(hcan);
elmot 1:d0dfbce63a89 355
elmot 1:d0dfbce63a89 356 /* Check the parameters */
elmot 1:d0dfbce63a89 357 assert_param(IS_CAN_FILTER_NUMBER(sFilterConfig->FilterNumber));
elmot 1:d0dfbce63a89 358 assert_param(IS_CAN_FILTER_MODE(sFilterConfig->FilterMode));
elmot 1:d0dfbce63a89 359 assert_param(IS_CAN_FILTER_SCALE(sFilterConfig->FilterScale));
elmot 1:d0dfbce63a89 360 assert_param(IS_CAN_FILTER_FIFO(sFilterConfig->FilterFIFOAssignment));
elmot 1:d0dfbce63a89 361 assert_param(IS_FUNCTIONAL_STATE(sFilterConfig->FilterActivation));
elmot 1:d0dfbce63a89 362 assert_param(IS_CAN_BANKNUMBER(sFilterConfig->BankNumber));
elmot 1:d0dfbce63a89 363
elmot 1:d0dfbce63a89 364 filternbrbitpos = ((uint32_t)1) << sFilterConfig->FilterNumber;
elmot 1:d0dfbce63a89 365
elmot 1:d0dfbce63a89 366 /* Initialisation mode for the filter */
elmot 1:d0dfbce63a89 367 CAN1->FMR |= (uint32_t)CAN_FMR_FINIT;
elmot 1:d0dfbce63a89 368
elmot 1:d0dfbce63a89 369 /* Filter Deactivation */
elmot 1:d0dfbce63a89 370 CAN1->FA1R &= ~(uint32_t)filternbrbitpos;
elmot 1:d0dfbce63a89 371
elmot 1:d0dfbce63a89 372 /* Filter Scale */
elmot 1:d0dfbce63a89 373 if (sFilterConfig->FilterScale == CAN_FILTERSCALE_16BIT)
elmot 1:d0dfbce63a89 374 {
elmot 1:d0dfbce63a89 375 /* 16-bit scale for the filter */
elmot 1:d0dfbce63a89 376 CAN1->FS1R &= ~(uint32_t)filternbrbitpos;
elmot 1:d0dfbce63a89 377
elmot 1:d0dfbce63a89 378 /* First 16-bit identifier and First 16-bit mask */
elmot 1:d0dfbce63a89 379 /* Or First 16-bit identifier and Second 16-bit identifier */
elmot 1:d0dfbce63a89 380 CAN1->sFilterRegister[sFilterConfig->FilterNumber].FR1 =
elmot 1:d0dfbce63a89 381 ((0x0000FFFF & (uint32_t)sFilterConfig->FilterMaskIdLow) << 16) |
elmot 1:d0dfbce63a89 382 (0x0000FFFF & (uint32_t)sFilterConfig->FilterIdLow);
elmot 1:d0dfbce63a89 383
elmot 1:d0dfbce63a89 384 /* Second 16-bit identifier and Second 16-bit mask */
elmot 1:d0dfbce63a89 385 /* Or Third 16-bit identifier and Fourth 16-bit identifier */
elmot 1:d0dfbce63a89 386 CAN1->sFilterRegister[sFilterConfig->FilterNumber].FR2 =
elmot 1:d0dfbce63a89 387 ((0x0000FFFF & (uint32_t)sFilterConfig->FilterMaskIdHigh) << 16) |
elmot 1:d0dfbce63a89 388 (0x0000FFFF & (uint32_t)sFilterConfig->FilterIdHigh);
elmot 1:d0dfbce63a89 389 }
elmot 1:d0dfbce63a89 390
elmot 1:d0dfbce63a89 391 if (sFilterConfig->FilterScale == CAN_FILTERSCALE_32BIT)
elmot 1:d0dfbce63a89 392 {
elmot 1:d0dfbce63a89 393 /* 32-bit scale for the filter */
elmot 1:d0dfbce63a89 394 CAN1->FS1R |= filternbrbitpos;
elmot 1:d0dfbce63a89 395 /* 32-bit identifier or First 32-bit identifier */
elmot 1:d0dfbce63a89 396 CAN1->sFilterRegister[sFilterConfig->FilterNumber].FR1 =
elmot 1:d0dfbce63a89 397 ((0x0000FFFF & (uint32_t)sFilterConfig->FilterIdHigh) << 16) |
elmot 1:d0dfbce63a89 398 (0x0000FFFF & (uint32_t)sFilterConfig->FilterIdLow);
elmot 1:d0dfbce63a89 399 /* 32-bit mask or Second 32-bit identifier */
elmot 1:d0dfbce63a89 400 CAN1->sFilterRegister[sFilterConfig->FilterNumber].FR2 =
elmot 1:d0dfbce63a89 401 ((0x0000FFFF & (uint32_t)sFilterConfig->FilterMaskIdHigh) << 16) |
elmot 1:d0dfbce63a89 402 (0x0000FFFF & (uint32_t)sFilterConfig->FilterMaskIdLow);
elmot 1:d0dfbce63a89 403 }
elmot 1:d0dfbce63a89 404
elmot 1:d0dfbce63a89 405 /* Filter Mode */
elmot 1:d0dfbce63a89 406 if (sFilterConfig->FilterMode == CAN_FILTERMODE_IDMASK)
elmot 1:d0dfbce63a89 407 {
elmot 1:d0dfbce63a89 408 /*Id/Mask mode for the filter*/
elmot 1:d0dfbce63a89 409 CAN1->FM1R &= ~(uint32_t)filternbrbitpos;
elmot 1:d0dfbce63a89 410 }
elmot 1:d0dfbce63a89 411 else /* CAN_FilterInitStruct->CAN_FilterMode == CAN_FilterMode_IdList */
elmot 1:d0dfbce63a89 412 {
elmot 1:d0dfbce63a89 413 /*Identifier list mode for the filter*/
elmot 1:d0dfbce63a89 414 CAN1->FM1R |= (uint32_t)filternbrbitpos;
elmot 1:d0dfbce63a89 415 }
elmot 1:d0dfbce63a89 416
elmot 1:d0dfbce63a89 417 /* Filter FIFO assignment */
elmot 1:d0dfbce63a89 418 if (sFilterConfig->FilterFIFOAssignment == CAN_FILTER_FIFO0)
elmot 1:d0dfbce63a89 419 {
elmot 1:d0dfbce63a89 420 /* FIFO 0 assignation for the filter */
elmot 1:d0dfbce63a89 421 CAN1->FFA1R &= ~(uint32_t)filternbrbitpos;
elmot 1:d0dfbce63a89 422 }
elmot 1:d0dfbce63a89 423
elmot 1:d0dfbce63a89 424 if (sFilterConfig->FilterFIFOAssignment == CAN_FILTER_FIFO1)
elmot 1:d0dfbce63a89 425 {
elmot 1:d0dfbce63a89 426 /* FIFO 1 assignation for the filter */
elmot 1:d0dfbce63a89 427 CAN1->FFA1R |= (uint32_t)filternbrbitpos;
elmot 1:d0dfbce63a89 428 }
elmot 1:d0dfbce63a89 429
elmot 1:d0dfbce63a89 430 /* Filter activation */
elmot 1:d0dfbce63a89 431 if (sFilterConfig->FilterActivation == ENABLE)
elmot 1:d0dfbce63a89 432 {
elmot 1:d0dfbce63a89 433 CAN1->FA1R |= filternbrbitpos;
elmot 1:d0dfbce63a89 434 }
elmot 1:d0dfbce63a89 435
elmot 1:d0dfbce63a89 436 /* Leave the initialisation mode for the filter */
elmot 1:d0dfbce63a89 437 CAN1->FMR &= ~((uint32_t)CAN_FMR_FINIT);
elmot 1:d0dfbce63a89 438
elmot 1:d0dfbce63a89 439 /* Return function status */
elmot 1:d0dfbce63a89 440 return HAL_OK;
elmot 1:d0dfbce63a89 441 }
elmot 1:d0dfbce63a89 442
elmot 1:d0dfbce63a89 443 /**
elmot 1:d0dfbce63a89 444 * @brief DeInitialize the CAN peripheral registers to their default reset values.
elmot 1:d0dfbce63a89 445 * @param hcan: pointer to a CAN_HandleTypeDef structure that contains
elmot 1:d0dfbce63a89 446 * the configuration information for the specified CAN.
elmot 1:d0dfbce63a89 447 * @retval HAL status
elmot 1:d0dfbce63a89 448 */
elmot 1:d0dfbce63a89 449 HAL_StatusTypeDef HAL_CAN_DeInit(CAN_HandleTypeDef* hcan)
elmot 1:d0dfbce63a89 450 {
elmot 1:d0dfbce63a89 451 /* Check CAN handle */
elmot 1:d0dfbce63a89 452 if(hcan == NULL)
elmot 1:d0dfbce63a89 453 {
elmot 1:d0dfbce63a89 454 return HAL_ERROR;
elmot 1:d0dfbce63a89 455 }
elmot 1:d0dfbce63a89 456
elmot 1:d0dfbce63a89 457 /* Check the parameters */
elmot 1:d0dfbce63a89 458 assert_param(IS_CAN_ALL_INSTANCE(hcan->Instance));
elmot 1:d0dfbce63a89 459
elmot 1:d0dfbce63a89 460 /* Change CAN state */
elmot 1:d0dfbce63a89 461 hcan->State = HAL_CAN_STATE_BUSY;
elmot 1:d0dfbce63a89 462
elmot 1:d0dfbce63a89 463 /* DeInit the low level hardware */
elmot 1:d0dfbce63a89 464 HAL_CAN_MspDeInit(hcan);
elmot 1:d0dfbce63a89 465
elmot 1:d0dfbce63a89 466 /* Change CAN state */
elmot 1:d0dfbce63a89 467 hcan->State = HAL_CAN_STATE_RESET;
elmot 1:d0dfbce63a89 468
elmot 1:d0dfbce63a89 469 /* Release Lock */
elmot 1:d0dfbce63a89 470 __HAL_UNLOCK(hcan);
elmot 1:d0dfbce63a89 471
elmot 1:d0dfbce63a89 472 /* Return function status */
elmot 1:d0dfbce63a89 473 return HAL_OK;
elmot 1:d0dfbce63a89 474 }
elmot 1:d0dfbce63a89 475
elmot 1:d0dfbce63a89 476 /**
elmot 1:d0dfbce63a89 477 * @brief Initialize the CAN MSP.
elmot 1:d0dfbce63a89 478 * @param hcan: pointer to a CAN_HandleTypeDef structure that contains
elmot 1:d0dfbce63a89 479 * the configuration information for the specified CAN.
elmot 1:d0dfbce63a89 480 * @retval None
elmot 1:d0dfbce63a89 481 */
elmot 1:d0dfbce63a89 482 __weak void HAL_CAN_MspInit(CAN_HandleTypeDef* hcan)
elmot 1:d0dfbce63a89 483 {
elmot 1:d0dfbce63a89 484 /* Prevent unused argument(s) compilation warning */
elmot 1:d0dfbce63a89 485 UNUSED(hcan);
elmot 1:d0dfbce63a89 486
elmot 1:d0dfbce63a89 487 /* NOTE : This function should not be modified, when the callback is needed,
elmot 1:d0dfbce63a89 488 the HAL_CAN_MspInit could be implemented in the user file
elmot 1:d0dfbce63a89 489 */
elmot 1:d0dfbce63a89 490 }
elmot 1:d0dfbce63a89 491
elmot 1:d0dfbce63a89 492 /**
elmot 1:d0dfbce63a89 493 * @brief DeInitialize the CAN MSP.
elmot 1:d0dfbce63a89 494 * @param hcan: pointer to a CAN_HandleTypeDef structure that contains
elmot 1:d0dfbce63a89 495 * the configuration information for the specified CAN.
elmot 1:d0dfbce63a89 496 * @retval None
elmot 1:d0dfbce63a89 497 */
elmot 1:d0dfbce63a89 498 __weak void HAL_CAN_MspDeInit(CAN_HandleTypeDef* hcan)
elmot 1:d0dfbce63a89 499 {
elmot 1:d0dfbce63a89 500 /* Prevent unused argument(s) compilation warning */
elmot 1:d0dfbce63a89 501 UNUSED(hcan);
elmot 1:d0dfbce63a89 502
elmot 1:d0dfbce63a89 503 /* NOTE : This function should not be modified, when the callback is needed,
elmot 1:d0dfbce63a89 504 the HAL_CAN_MspDeInit could be implemented in the user file
elmot 1:d0dfbce63a89 505 */
elmot 1:d0dfbce63a89 506 }
elmot 1:d0dfbce63a89 507
elmot 1:d0dfbce63a89 508 /**
elmot 1:d0dfbce63a89 509 * @}
elmot 1:d0dfbce63a89 510 */
elmot 1:d0dfbce63a89 511
elmot 1:d0dfbce63a89 512 /** @defgroup CAN_Exported_Functions_Group2 Input and Output operation functions
elmot 1:d0dfbce63a89 513 * @brief I/O operation functions
elmot 1:d0dfbce63a89 514 *
elmot 1:d0dfbce63a89 515 @verbatim
elmot 1:d0dfbce63a89 516 ==============================================================================
elmot 1:d0dfbce63a89 517 ##### IO operation functions #####
elmot 1:d0dfbce63a89 518 ==============================================================================
elmot 1:d0dfbce63a89 519 [..] This section provides functions allowing to:
elmot 1:d0dfbce63a89 520 (+) Transmit a CAN frame message.
elmot 1:d0dfbce63a89 521 (+) Receive a CAN frame message.
elmot 1:d0dfbce63a89 522 (+) Enter CAN peripheral in sleep mode.
elmot 1:d0dfbce63a89 523 (+) Wake up the CAN peripheral from sleep mode.
elmot 1:d0dfbce63a89 524
elmot 1:d0dfbce63a89 525 @endverbatim
elmot 1:d0dfbce63a89 526 * @{
elmot 1:d0dfbce63a89 527 */
elmot 1:d0dfbce63a89 528
elmot 1:d0dfbce63a89 529 /**
elmot 1:d0dfbce63a89 530 * @brief Initiate and transmit a CAN frame message.
elmot 1:d0dfbce63a89 531 * @param hcan: pointer to a CAN_HandleTypeDef structure that contains
elmot 1:d0dfbce63a89 532 * the configuration information for the specified CAN.
elmot 1:d0dfbce63a89 533 * @param Timeout: Timeout duration.
elmot 1:d0dfbce63a89 534 * @retval HAL status
elmot 1:d0dfbce63a89 535 */
elmot 1:d0dfbce63a89 536 HAL_StatusTypeDef HAL_CAN_Transmit(CAN_HandleTypeDef* hcan, uint32_t Timeout)
elmot 1:d0dfbce63a89 537 {
elmot 1:d0dfbce63a89 538 uint32_t transmitmailbox = CAN_TXSTATUS_NOMAILBOX;
elmot 1:d0dfbce63a89 539 uint32_t tickstart = 0;
elmot 1:d0dfbce63a89 540
elmot 1:d0dfbce63a89 541 /* Check the parameters */
elmot 1:d0dfbce63a89 542 assert_param(IS_CAN_IDTYPE(hcan->pTxMsg->IDE));
elmot 1:d0dfbce63a89 543 assert_param(IS_CAN_RTR(hcan->pTxMsg->RTR));
elmot 1:d0dfbce63a89 544 assert_param(IS_CAN_DLC(hcan->pTxMsg->DLC));
elmot 1:d0dfbce63a89 545
elmot 1:d0dfbce63a89 546 /* Process locked */
elmot 1:d0dfbce63a89 547 __HAL_LOCK(hcan);
elmot 1:d0dfbce63a89 548
elmot 1:d0dfbce63a89 549 if(hcan->State == HAL_CAN_STATE_BUSY_RX)
elmot 1:d0dfbce63a89 550 {
elmot 1:d0dfbce63a89 551 /* Change CAN state */
elmot 1:d0dfbce63a89 552 hcan->State = HAL_CAN_STATE_BUSY_TX_RX;
elmot 1:d0dfbce63a89 553 }
elmot 1:d0dfbce63a89 554 else
elmot 1:d0dfbce63a89 555 {
elmot 1:d0dfbce63a89 556 /* Change CAN state */
elmot 1:d0dfbce63a89 557 hcan->State = HAL_CAN_STATE_BUSY_TX;
elmot 1:d0dfbce63a89 558 }
elmot 1:d0dfbce63a89 559
elmot 1:d0dfbce63a89 560 /* Select one empty transmit mailbox */
elmot 1:d0dfbce63a89 561 if ((hcan->Instance->TSR&CAN_TSR_TME0) == CAN_TSR_TME0)
elmot 1:d0dfbce63a89 562 {
elmot 1:d0dfbce63a89 563 transmitmailbox = 0;
elmot 1:d0dfbce63a89 564 }
elmot 1:d0dfbce63a89 565 else if ((hcan->Instance->TSR&CAN_TSR_TME1) == CAN_TSR_TME1)
elmot 1:d0dfbce63a89 566 {
elmot 1:d0dfbce63a89 567 transmitmailbox = 1;
elmot 1:d0dfbce63a89 568 }
elmot 1:d0dfbce63a89 569 else if ((hcan->Instance->TSR&CAN_TSR_TME2) == CAN_TSR_TME2)
elmot 1:d0dfbce63a89 570 {
elmot 1:d0dfbce63a89 571 transmitmailbox = 2;
elmot 1:d0dfbce63a89 572 }
elmot 1:d0dfbce63a89 573
elmot 1:d0dfbce63a89 574 if (transmitmailbox != CAN_TXSTATUS_NOMAILBOX)
elmot 1:d0dfbce63a89 575 {
elmot 1:d0dfbce63a89 576 /* Set up the Id */
elmot 1:d0dfbce63a89 577 hcan->Instance->sTxMailBox[transmitmailbox].TIR &= CAN_TI0R_TXRQ;
elmot 1:d0dfbce63a89 578 if (hcan->pTxMsg->IDE == CAN_ID_STD)
elmot 1:d0dfbce63a89 579 {
elmot 1:d0dfbce63a89 580 assert_param(IS_CAN_STDID(hcan->pTxMsg->StdId));
elmot 1:d0dfbce63a89 581 hcan->Instance->sTxMailBox[transmitmailbox].TIR |= ((hcan->pTxMsg->StdId << 21) | \
elmot 1:d0dfbce63a89 582 hcan->pTxMsg->RTR);
elmot 1:d0dfbce63a89 583 }
elmot 1:d0dfbce63a89 584 else
elmot 1:d0dfbce63a89 585 {
elmot 1:d0dfbce63a89 586 assert_param(IS_CAN_EXTID(hcan->pTxMsg->ExtId));
elmot 1:d0dfbce63a89 587 hcan->Instance->sTxMailBox[transmitmailbox].TIR |= ((hcan->pTxMsg->ExtId << 3) | \
elmot 1:d0dfbce63a89 588 hcan->pTxMsg->IDE | \
elmot 1:d0dfbce63a89 589 hcan->pTxMsg->RTR);
elmot 1:d0dfbce63a89 590 }
elmot 1:d0dfbce63a89 591
elmot 1:d0dfbce63a89 592 /* Set up the DLC */
elmot 1:d0dfbce63a89 593 hcan->pTxMsg->DLC &= (uint8_t)0x0000000F;
elmot 1:d0dfbce63a89 594 hcan->Instance->sTxMailBox[transmitmailbox].TDTR &= (uint32_t)0xFFFFFFF0;
elmot 1:d0dfbce63a89 595 hcan->Instance->sTxMailBox[transmitmailbox].TDTR |= hcan->pTxMsg->DLC;
elmot 1:d0dfbce63a89 596
elmot 1:d0dfbce63a89 597 /* Set up the data field */
elmot 1:d0dfbce63a89 598 hcan->Instance->sTxMailBox[transmitmailbox].TDLR = (((uint32_t)hcan->pTxMsg->Data[3] << 24) |
elmot 1:d0dfbce63a89 599 ((uint32_t)hcan->pTxMsg->Data[2] << 16) |
elmot 1:d0dfbce63a89 600 ((uint32_t)hcan->pTxMsg->Data[1] << 8) |
elmot 1:d0dfbce63a89 601 ((uint32_t)hcan->pTxMsg->Data[0]));
elmot 1:d0dfbce63a89 602 hcan->Instance->sTxMailBox[transmitmailbox].TDHR = (((uint32_t)hcan->pTxMsg->Data[7] << 24) |
elmot 1:d0dfbce63a89 603 ((uint32_t)hcan->pTxMsg->Data[6] << 16) |
elmot 1:d0dfbce63a89 604 ((uint32_t)hcan->pTxMsg->Data[5] << 8) |
elmot 1:d0dfbce63a89 605 ((uint32_t)hcan->pTxMsg->Data[4]));
elmot 1:d0dfbce63a89 606 /* Request transmission */
elmot 1:d0dfbce63a89 607 hcan->Instance->sTxMailBox[transmitmailbox].TIR |= CAN_TI0R_TXRQ;
elmot 1:d0dfbce63a89 608
elmot 1:d0dfbce63a89 609 /* Get tick */
elmot 1:d0dfbce63a89 610 tickstart = HAL_GetTick();
elmot 1:d0dfbce63a89 611
elmot 1:d0dfbce63a89 612 /* Check End of transmission flag */
elmot 1:d0dfbce63a89 613 while(!(__HAL_CAN_TRANSMIT_STATUS(hcan, transmitmailbox)))
elmot 1:d0dfbce63a89 614 {
elmot 1:d0dfbce63a89 615 /* Check for the Timeout */
elmot 1:d0dfbce63a89 616 if(Timeout != HAL_MAX_DELAY)
elmot 1:d0dfbce63a89 617 {
elmot 1:d0dfbce63a89 618 if((Timeout == 0) || ((HAL_GetTick()-tickstart) > Timeout))
elmot 1:d0dfbce63a89 619 {
elmot 1:d0dfbce63a89 620 hcan->State = HAL_CAN_STATE_TIMEOUT;
elmot 1:d0dfbce63a89 621 /* Process unlocked */
elmot 1:d0dfbce63a89 622 __HAL_UNLOCK(hcan);
elmot 1:d0dfbce63a89 623 return HAL_TIMEOUT;
elmot 1:d0dfbce63a89 624 }
elmot 1:d0dfbce63a89 625 }
elmot 1:d0dfbce63a89 626 }
elmot 1:d0dfbce63a89 627 if(hcan->State == HAL_CAN_STATE_BUSY_TX_RX)
elmot 1:d0dfbce63a89 628 {
elmot 1:d0dfbce63a89 629 /* Change CAN state */
elmot 1:d0dfbce63a89 630 hcan->State = HAL_CAN_STATE_BUSY_RX;
elmot 1:d0dfbce63a89 631 }
elmot 1:d0dfbce63a89 632 else
elmot 1:d0dfbce63a89 633 {
elmot 1:d0dfbce63a89 634 /* Change CAN state */
elmot 1:d0dfbce63a89 635 hcan->State = HAL_CAN_STATE_READY;
elmot 1:d0dfbce63a89 636 }
elmot 1:d0dfbce63a89 637
elmot 1:d0dfbce63a89 638 /* Process unlocked */
elmot 1:d0dfbce63a89 639 __HAL_UNLOCK(hcan);
elmot 1:d0dfbce63a89 640
elmot 1:d0dfbce63a89 641 /* Return function status */
elmot 1:d0dfbce63a89 642 return HAL_OK;
elmot 1:d0dfbce63a89 643 }
elmot 1:d0dfbce63a89 644 else
elmot 1:d0dfbce63a89 645 {
elmot 1:d0dfbce63a89 646 /* Change CAN state */
elmot 1:d0dfbce63a89 647 hcan->State = HAL_CAN_STATE_ERROR;
elmot 1:d0dfbce63a89 648
elmot 1:d0dfbce63a89 649 /* Process unlocked */
elmot 1:d0dfbce63a89 650 __HAL_UNLOCK(hcan);
elmot 1:d0dfbce63a89 651
elmot 1:d0dfbce63a89 652 /* Return function status */
elmot 1:d0dfbce63a89 653 return HAL_ERROR;
elmot 1:d0dfbce63a89 654 }
elmot 1:d0dfbce63a89 655 }
elmot 1:d0dfbce63a89 656
elmot 1:d0dfbce63a89 657 /**
elmot 1:d0dfbce63a89 658 * @brief Initiate and transmit a CAN frame message in Interrupt mode.
elmot 1:d0dfbce63a89 659 * @param hcan: pointer to a CAN_HandleTypeDef structure that contains
elmot 1:d0dfbce63a89 660 * the configuration information for the specified CAN.
elmot 1:d0dfbce63a89 661 * @retval HAL status
elmot 1:d0dfbce63a89 662 */
elmot 1:d0dfbce63a89 663 HAL_StatusTypeDef HAL_CAN_Transmit_IT(CAN_HandleTypeDef* hcan)
elmot 1:d0dfbce63a89 664 {
elmot 1:d0dfbce63a89 665 uint32_t transmitmailbox = CAN_TXSTATUS_NOMAILBOX;
elmot 1:d0dfbce63a89 666
elmot 1:d0dfbce63a89 667 /* Check the parameters */
elmot 1:d0dfbce63a89 668 assert_param(IS_CAN_IDTYPE(hcan->pTxMsg->IDE));
elmot 1:d0dfbce63a89 669 assert_param(IS_CAN_RTR(hcan->pTxMsg->RTR));
elmot 1:d0dfbce63a89 670 assert_param(IS_CAN_DLC(hcan->pTxMsg->DLC));
elmot 1:d0dfbce63a89 671
elmot 1:d0dfbce63a89 672 if((hcan->State == HAL_CAN_STATE_READY) || (hcan->State == HAL_CAN_STATE_BUSY_RX))
elmot 1:d0dfbce63a89 673 {
elmot 1:d0dfbce63a89 674 /* Process Locked */
elmot 1:d0dfbce63a89 675 __HAL_LOCK(hcan);
elmot 1:d0dfbce63a89 676
elmot 1:d0dfbce63a89 677 /* Select one empty transmit mailbox */
elmot 1:d0dfbce63a89 678 if((hcan->Instance->TSR&CAN_TSR_TME0) == CAN_TSR_TME0)
elmot 1:d0dfbce63a89 679 {
elmot 1:d0dfbce63a89 680 transmitmailbox = 0;
elmot 1:d0dfbce63a89 681 }
elmot 1:d0dfbce63a89 682 else if((hcan->Instance->TSR&CAN_TSR_TME1) == CAN_TSR_TME1)
elmot 1:d0dfbce63a89 683 {
elmot 1:d0dfbce63a89 684 transmitmailbox = 1;
elmot 1:d0dfbce63a89 685 }
elmot 1:d0dfbce63a89 686 else if((hcan->Instance->TSR&CAN_TSR_TME2) == CAN_TSR_TME2)
elmot 1:d0dfbce63a89 687 {
elmot 1:d0dfbce63a89 688 transmitmailbox = 2;
elmot 1:d0dfbce63a89 689 }
elmot 1:d0dfbce63a89 690
elmot 1:d0dfbce63a89 691 if(transmitmailbox != CAN_TXSTATUS_NOMAILBOX)
elmot 1:d0dfbce63a89 692 {
elmot 1:d0dfbce63a89 693 /* Set up the Id */
elmot 1:d0dfbce63a89 694 hcan->Instance->sTxMailBox[transmitmailbox].TIR &= CAN_TI0R_TXRQ;
elmot 1:d0dfbce63a89 695 if(hcan->pTxMsg->IDE == CAN_ID_STD)
elmot 1:d0dfbce63a89 696 {
elmot 1:d0dfbce63a89 697 assert_param(IS_CAN_STDID(hcan->pTxMsg->StdId));
elmot 1:d0dfbce63a89 698 hcan->Instance->sTxMailBox[transmitmailbox].TIR |= ((hcan->pTxMsg->StdId << 21) | \
elmot 1:d0dfbce63a89 699 hcan->pTxMsg->RTR);
elmot 1:d0dfbce63a89 700 }
elmot 1:d0dfbce63a89 701 else
elmot 1:d0dfbce63a89 702 {
elmot 1:d0dfbce63a89 703 assert_param(IS_CAN_EXTID(hcan->pTxMsg->ExtId));
elmot 1:d0dfbce63a89 704 hcan->Instance->sTxMailBox[transmitmailbox].TIR |= ((hcan->pTxMsg->ExtId << 3) | \
elmot 1:d0dfbce63a89 705 hcan->pTxMsg->IDE | \
elmot 1:d0dfbce63a89 706 hcan->pTxMsg->RTR);
elmot 1:d0dfbce63a89 707 }
elmot 1:d0dfbce63a89 708
elmot 1:d0dfbce63a89 709 /* Set up the DLC */
elmot 1:d0dfbce63a89 710 hcan->pTxMsg->DLC &= (uint8_t)0x0000000F;
elmot 1:d0dfbce63a89 711 hcan->Instance->sTxMailBox[transmitmailbox].TDTR &= (uint32_t)0xFFFFFFF0;
elmot 1:d0dfbce63a89 712 hcan->Instance->sTxMailBox[transmitmailbox].TDTR |= hcan->pTxMsg->DLC;
elmot 1:d0dfbce63a89 713
elmot 1:d0dfbce63a89 714 /* Set up the data field */
elmot 1:d0dfbce63a89 715 hcan->Instance->sTxMailBox[transmitmailbox].TDLR = (((uint32_t)hcan->pTxMsg->Data[3] << 24) |
elmot 1:d0dfbce63a89 716 ((uint32_t)hcan->pTxMsg->Data[2] << 16) |
elmot 1:d0dfbce63a89 717 ((uint32_t)hcan->pTxMsg->Data[1] << 8) |
elmot 1:d0dfbce63a89 718 ((uint32_t)hcan->pTxMsg->Data[0]));
elmot 1:d0dfbce63a89 719 hcan->Instance->sTxMailBox[transmitmailbox].TDHR = (((uint32_t)hcan->pTxMsg->Data[7] << 24) |
elmot 1:d0dfbce63a89 720 ((uint32_t)hcan->pTxMsg->Data[6] << 16) |
elmot 1:d0dfbce63a89 721 ((uint32_t)hcan->pTxMsg->Data[5] << 8) |
elmot 1:d0dfbce63a89 722 ((uint32_t)hcan->pTxMsg->Data[4]));
elmot 1:d0dfbce63a89 723
elmot 1:d0dfbce63a89 724 if(hcan->State == HAL_CAN_STATE_BUSY_RX)
elmot 1:d0dfbce63a89 725 {
elmot 1:d0dfbce63a89 726 /* Change CAN state */
elmot 1:d0dfbce63a89 727 hcan->State = HAL_CAN_STATE_BUSY_TX_RX;
elmot 1:d0dfbce63a89 728 }
elmot 1:d0dfbce63a89 729 else
elmot 1:d0dfbce63a89 730 {
elmot 1:d0dfbce63a89 731 /* Change CAN state */
elmot 1:d0dfbce63a89 732 hcan->State = HAL_CAN_STATE_BUSY_TX;
elmot 1:d0dfbce63a89 733 }
elmot 1:d0dfbce63a89 734
elmot 1:d0dfbce63a89 735 /* Set CAN error code to none */
elmot 1:d0dfbce63a89 736 hcan->ErrorCode = HAL_CAN_ERROR_NONE;
elmot 1:d0dfbce63a89 737
elmot 1:d0dfbce63a89 738 /* Process Unlocked */
elmot 1:d0dfbce63a89 739 __HAL_UNLOCK(hcan);
elmot 1:d0dfbce63a89 740
elmot 1:d0dfbce63a89 741 /* Enable interrupts: */
elmot 1:d0dfbce63a89 742 /* - Enable Error warning Interrupt */
elmot 1:d0dfbce63a89 743 /* - Enable Error passive Interrupt */
elmot 1:d0dfbce63a89 744 /* - Enable Bus-off Interrupt */
elmot 1:d0dfbce63a89 745 /* - Enable Last error code Interrupt */
elmot 1:d0dfbce63a89 746 /* - Enable Error Interrupt */
elmot 1:d0dfbce63a89 747 /* - Enable Transmit mailbox empty Interrupt */
elmot 1:d0dfbce63a89 748 __HAL_CAN_ENABLE_IT(hcan, CAN_IT_EWG |
elmot 1:d0dfbce63a89 749 CAN_IT_EPV |
elmot 1:d0dfbce63a89 750 CAN_IT_BOF |
elmot 1:d0dfbce63a89 751 CAN_IT_LEC |
elmot 1:d0dfbce63a89 752 CAN_IT_ERR |
elmot 1:d0dfbce63a89 753 CAN_IT_TME );
elmot 1:d0dfbce63a89 754
elmot 1:d0dfbce63a89 755 /* Request transmission */
elmot 1:d0dfbce63a89 756 hcan->Instance->sTxMailBox[transmitmailbox].TIR |= CAN_TI0R_TXRQ;
elmot 1:d0dfbce63a89 757 }
elmot 1:d0dfbce63a89 758 }
elmot 1:d0dfbce63a89 759 else
elmot 1:d0dfbce63a89 760 {
elmot 1:d0dfbce63a89 761 return HAL_BUSY;
elmot 1:d0dfbce63a89 762 }
elmot 1:d0dfbce63a89 763
elmot 1:d0dfbce63a89 764 return HAL_OK;
elmot 1:d0dfbce63a89 765 }
elmot 1:d0dfbce63a89 766
elmot 1:d0dfbce63a89 767 /**
elmot 1:d0dfbce63a89 768 * @brief Receive a correct CAN frame.
elmot 1:d0dfbce63a89 769 * @param hcan: pointer to a CAN_HandleTypeDef structure that contains
elmot 1:d0dfbce63a89 770 * the configuration information for the specified CAN.
elmot 1:d0dfbce63a89 771 * @param FIFONumber: FIFO number.
elmot 1:d0dfbce63a89 772 * @param Timeout: Timeout duration.
elmot 1:d0dfbce63a89 773 * @retval HAL status
elmot 1:d0dfbce63a89 774 */
elmot 1:d0dfbce63a89 775 HAL_StatusTypeDef HAL_CAN_Receive(CAN_HandleTypeDef* hcan, uint8_t FIFONumber, uint32_t Timeout)
elmot 1:d0dfbce63a89 776 {
elmot 1:d0dfbce63a89 777 uint32_t tickstart = 0;
elmot 1:d0dfbce63a89 778
elmot 1:d0dfbce63a89 779 /* Check the parameters */
elmot 1:d0dfbce63a89 780 assert_param(IS_CAN_FIFO(FIFONumber));
elmot 1:d0dfbce63a89 781
elmot 1:d0dfbce63a89 782 /* Process locked */
elmot 1:d0dfbce63a89 783 __HAL_LOCK(hcan);
elmot 1:d0dfbce63a89 784
elmot 1:d0dfbce63a89 785 if(hcan->State == HAL_CAN_STATE_BUSY_TX)
elmot 1:d0dfbce63a89 786 {
elmot 1:d0dfbce63a89 787 /* Change CAN state */
elmot 1:d0dfbce63a89 788 hcan->State = HAL_CAN_STATE_BUSY_TX_RX;
elmot 1:d0dfbce63a89 789 }
elmot 1:d0dfbce63a89 790 else
elmot 1:d0dfbce63a89 791 {
elmot 1:d0dfbce63a89 792 /* Change CAN state */
elmot 1:d0dfbce63a89 793 hcan->State = HAL_CAN_STATE_BUSY_RX;
elmot 1:d0dfbce63a89 794 }
elmot 1:d0dfbce63a89 795
elmot 1:d0dfbce63a89 796 /* Get tick */
elmot 1:d0dfbce63a89 797 tickstart = HAL_GetTick();
elmot 1:d0dfbce63a89 798
elmot 1:d0dfbce63a89 799 /* Check pending message */
elmot 1:d0dfbce63a89 800 while(__HAL_CAN_MSG_PENDING(hcan, FIFONumber) == 0)
elmot 1:d0dfbce63a89 801 {
elmot 1:d0dfbce63a89 802 /* Check for the Timeout */
elmot 1:d0dfbce63a89 803 if(Timeout != HAL_MAX_DELAY)
elmot 1:d0dfbce63a89 804 {
elmot 1:d0dfbce63a89 805 if((Timeout == 0) || ((HAL_GetTick()-tickstart) > Timeout))
elmot 1:d0dfbce63a89 806 {
elmot 1:d0dfbce63a89 807 hcan->State = HAL_CAN_STATE_TIMEOUT;
elmot 1:d0dfbce63a89 808 /* Process unlocked */
elmot 1:d0dfbce63a89 809 __HAL_UNLOCK(hcan);
elmot 1:d0dfbce63a89 810 return HAL_TIMEOUT;
elmot 1:d0dfbce63a89 811 }
elmot 1:d0dfbce63a89 812 }
elmot 1:d0dfbce63a89 813 }
elmot 1:d0dfbce63a89 814
elmot 1:d0dfbce63a89 815 /* Get the Id */
elmot 1:d0dfbce63a89 816 hcan->pRxMsg->IDE = (uint8_t)0x04 & hcan->Instance->sFIFOMailBox[FIFONumber].RIR;
elmot 1:d0dfbce63a89 817 if (hcan->pRxMsg->IDE == CAN_ID_STD)
elmot 1:d0dfbce63a89 818 {
elmot 1:d0dfbce63a89 819 hcan->pRxMsg->StdId = (uint32_t)0x000007FF & (hcan->Instance->sFIFOMailBox[FIFONumber].RIR >> 21);
elmot 1:d0dfbce63a89 820 }
elmot 1:d0dfbce63a89 821 else
elmot 1:d0dfbce63a89 822 {
elmot 1:d0dfbce63a89 823 hcan->pRxMsg->ExtId = (uint32_t)0x1FFFFFFF & (hcan->Instance->sFIFOMailBox[FIFONumber].RIR >> 3);
elmot 1:d0dfbce63a89 824 }
elmot 1:d0dfbce63a89 825
elmot 1:d0dfbce63a89 826 hcan->pRxMsg->RTR = (uint8_t)0x02 & hcan->Instance->sFIFOMailBox[FIFONumber].RIR;
elmot 1:d0dfbce63a89 827 /* Get the DLC */
elmot 1:d0dfbce63a89 828 hcan->pRxMsg->DLC = (uint8_t)0x0F & hcan->Instance->sFIFOMailBox[FIFONumber].RDTR;
elmot 1:d0dfbce63a89 829 /* Get the FMI */
elmot 1:d0dfbce63a89 830 hcan->pRxMsg->FMI = (uint8_t)0xFF & (hcan->Instance->sFIFOMailBox[FIFONumber].RDTR >> 8);
elmot 1:d0dfbce63a89 831 /* Get the data field */
elmot 1:d0dfbce63a89 832 hcan->pRxMsg->Data[0] = (uint8_t)0xFF & hcan->Instance->sFIFOMailBox[FIFONumber].RDLR;
elmot 1:d0dfbce63a89 833 hcan->pRxMsg->Data[1] = (uint8_t)0xFF & (hcan->Instance->sFIFOMailBox[FIFONumber].RDLR >> 8);
elmot 1:d0dfbce63a89 834 hcan->pRxMsg->Data[2] = (uint8_t)0xFF & (hcan->Instance->sFIFOMailBox[FIFONumber].RDLR >> 16);
elmot 1:d0dfbce63a89 835 hcan->pRxMsg->Data[3] = (uint8_t)0xFF & (hcan->Instance->sFIFOMailBox[FIFONumber].RDLR >> 24);
elmot 1:d0dfbce63a89 836 hcan->pRxMsg->Data[4] = (uint8_t)0xFF & hcan->Instance->sFIFOMailBox[FIFONumber].RDHR;
elmot 1:d0dfbce63a89 837 hcan->pRxMsg->Data[5] = (uint8_t)0xFF & (hcan->Instance->sFIFOMailBox[FIFONumber].RDHR >> 8);
elmot 1:d0dfbce63a89 838 hcan->pRxMsg->Data[6] = (uint8_t)0xFF & (hcan->Instance->sFIFOMailBox[FIFONumber].RDHR >> 16);
elmot 1:d0dfbce63a89 839 hcan->pRxMsg->Data[7] = (uint8_t)0xFF & (hcan->Instance->sFIFOMailBox[FIFONumber].RDHR >> 24);
elmot 1:d0dfbce63a89 840
elmot 1:d0dfbce63a89 841 /* Release the FIFO */
elmot 1:d0dfbce63a89 842 if(FIFONumber == CAN_FIFO0)
elmot 1:d0dfbce63a89 843 {
elmot 1:d0dfbce63a89 844 /* Release FIFO0 */
elmot 1:d0dfbce63a89 845 __HAL_CAN_FIFO_RELEASE(hcan, CAN_FIFO0);
elmot 1:d0dfbce63a89 846 }
elmot 1:d0dfbce63a89 847 else /* FIFONumber == CAN_FIFO1 */
elmot 1:d0dfbce63a89 848 {
elmot 1:d0dfbce63a89 849 /* Release FIFO1 */
elmot 1:d0dfbce63a89 850 __HAL_CAN_FIFO_RELEASE(hcan, CAN_FIFO1);
elmot 1:d0dfbce63a89 851 }
elmot 1:d0dfbce63a89 852
elmot 1:d0dfbce63a89 853 if(hcan->State == HAL_CAN_STATE_BUSY_TX_RX)
elmot 1:d0dfbce63a89 854 {
elmot 1:d0dfbce63a89 855 /* Change CAN state */
elmot 1:d0dfbce63a89 856 hcan->State = HAL_CAN_STATE_BUSY_TX;
elmot 1:d0dfbce63a89 857 }
elmot 1:d0dfbce63a89 858 else
elmot 1:d0dfbce63a89 859 {
elmot 1:d0dfbce63a89 860 /* Change CAN state */
elmot 1:d0dfbce63a89 861 hcan->State = HAL_CAN_STATE_READY;
elmot 1:d0dfbce63a89 862 }
elmot 1:d0dfbce63a89 863
elmot 1:d0dfbce63a89 864 /* Process unlocked */
elmot 1:d0dfbce63a89 865 __HAL_UNLOCK(hcan);
elmot 1:d0dfbce63a89 866
elmot 1:d0dfbce63a89 867 /* Return function status */
elmot 1:d0dfbce63a89 868 return HAL_OK;
elmot 1:d0dfbce63a89 869 }
elmot 1:d0dfbce63a89 870
elmot 1:d0dfbce63a89 871 /**
elmot 1:d0dfbce63a89 872 * @brief Receive a correct CAN frame in Interrupt mode.
elmot 1:d0dfbce63a89 873 * @param hcan: pointer to a CAN_HandleTypeDef structure that contains
elmot 1:d0dfbce63a89 874 * the configuration information for the specified CAN.
elmot 1:d0dfbce63a89 875 * @param FIFONumber: FIFO number.
elmot 1:d0dfbce63a89 876 * @retval HAL status
elmot 1:d0dfbce63a89 877 */
elmot 1:d0dfbce63a89 878 HAL_StatusTypeDef HAL_CAN_Receive_IT(CAN_HandleTypeDef* hcan, uint8_t FIFONumber)
elmot 1:d0dfbce63a89 879 {
elmot 1:d0dfbce63a89 880 /* Check the parameters */
elmot 1:d0dfbce63a89 881 assert_param(IS_CAN_FIFO(FIFONumber));
elmot 1:d0dfbce63a89 882
elmot 1:d0dfbce63a89 883 if((hcan->State == HAL_CAN_STATE_READY) || (hcan->State == HAL_CAN_STATE_BUSY_TX))
elmot 1:d0dfbce63a89 884 {
elmot 1:d0dfbce63a89 885 /* Process locked */
elmot 1:d0dfbce63a89 886 __HAL_LOCK(hcan);
elmot 1:d0dfbce63a89 887
elmot 1:d0dfbce63a89 888 if(hcan->State == HAL_CAN_STATE_BUSY_TX)
elmot 1:d0dfbce63a89 889 {
elmot 1:d0dfbce63a89 890 /* Change CAN state */
elmot 1:d0dfbce63a89 891 hcan->State = HAL_CAN_STATE_BUSY_TX_RX;
elmot 1:d0dfbce63a89 892 }
elmot 1:d0dfbce63a89 893 else
elmot 1:d0dfbce63a89 894 {
elmot 1:d0dfbce63a89 895 /* Change CAN state */
elmot 1:d0dfbce63a89 896 hcan->State = HAL_CAN_STATE_BUSY_RX;
elmot 1:d0dfbce63a89 897 }
elmot 1:d0dfbce63a89 898
elmot 1:d0dfbce63a89 899 /* Set CAN error code to none */
elmot 1:d0dfbce63a89 900 hcan->ErrorCode = HAL_CAN_ERROR_NONE;
elmot 1:d0dfbce63a89 901
elmot 1:d0dfbce63a89 902 /* Enable interrupts: */
elmot 1:d0dfbce63a89 903 /* - Enable Error warning Interrupt */
elmot 1:d0dfbce63a89 904 /* - Enable Error passive Interrupt */
elmot 1:d0dfbce63a89 905 /* - Enable Bus-off Interrupt */
elmot 1:d0dfbce63a89 906 /* - Enable Last error code Interrupt */
elmot 1:d0dfbce63a89 907 /* - Enable Error Interrupt */
elmot 1:d0dfbce63a89 908 __HAL_CAN_ENABLE_IT(hcan, CAN_IT_EWG |
elmot 1:d0dfbce63a89 909 CAN_IT_EPV |
elmot 1:d0dfbce63a89 910 CAN_IT_BOF |
elmot 1:d0dfbce63a89 911 CAN_IT_LEC |
elmot 1:d0dfbce63a89 912 CAN_IT_ERR );
elmot 1:d0dfbce63a89 913
elmot 1:d0dfbce63a89 914 /* Process unlocked */
elmot 1:d0dfbce63a89 915 __HAL_UNLOCK(hcan);
elmot 1:d0dfbce63a89 916
elmot 1:d0dfbce63a89 917 if(FIFONumber == CAN_FIFO0)
elmot 1:d0dfbce63a89 918 {
elmot 1:d0dfbce63a89 919 /* Enable FIFO 0 message pending Interrupt */
elmot 1:d0dfbce63a89 920 __HAL_CAN_ENABLE_IT(hcan, CAN_IT_FMP0);
elmot 1:d0dfbce63a89 921 }
elmot 1:d0dfbce63a89 922 else
elmot 1:d0dfbce63a89 923 {
elmot 1:d0dfbce63a89 924 /* Enable FIFO 1 message pending Interrupt */
elmot 1:d0dfbce63a89 925 __HAL_CAN_ENABLE_IT(hcan, CAN_IT_FMP1);
elmot 1:d0dfbce63a89 926 }
elmot 1:d0dfbce63a89 927
elmot 1:d0dfbce63a89 928 }
elmot 1:d0dfbce63a89 929 else
elmot 1:d0dfbce63a89 930 {
elmot 1:d0dfbce63a89 931 return HAL_BUSY;
elmot 1:d0dfbce63a89 932 }
elmot 1:d0dfbce63a89 933
elmot 1:d0dfbce63a89 934 /* Return function status */
elmot 1:d0dfbce63a89 935 return HAL_OK;
elmot 1:d0dfbce63a89 936 }
elmot 1:d0dfbce63a89 937
elmot 1:d0dfbce63a89 938 /**
elmot 1:d0dfbce63a89 939 * @brief Enter the Sleep (low power) mode.
elmot 1:d0dfbce63a89 940 * @param hcan: pointer to a CAN_HandleTypeDef structure that contains
elmot 1:d0dfbce63a89 941 * the configuration information for the specified CAN.
elmot 1:d0dfbce63a89 942 * @retval HAL status.
elmot 1:d0dfbce63a89 943 */
elmot 1:d0dfbce63a89 944 HAL_StatusTypeDef HAL_CAN_Sleep(CAN_HandleTypeDef* hcan)
elmot 1:d0dfbce63a89 945 {
elmot 1:d0dfbce63a89 946 uint32_t tickstart = 0;
elmot 1:d0dfbce63a89 947
elmot 1:d0dfbce63a89 948 /* Process locked */
elmot 1:d0dfbce63a89 949 __HAL_LOCK(hcan);
elmot 1:d0dfbce63a89 950
elmot 1:d0dfbce63a89 951 /* Change CAN state */
elmot 1:d0dfbce63a89 952 hcan->State = HAL_CAN_STATE_BUSY;
elmot 1:d0dfbce63a89 953
elmot 1:d0dfbce63a89 954 /* Request Sleep mode */
elmot 1:d0dfbce63a89 955 hcan->Instance->MCR = (((hcan->Instance->MCR) & (uint32_t)(~(uint32_t)CAN_MCR_INRQ)) | CAN_MCR_SLEEP);
elmot 1:d0dfbce63a89 956
elmot 1:d0dfbce63a89 957 /* Sleep mode status */
elmot 1:d0dfbce63a89 958 if ((hcan->Instance->MSR & (CAN_MSR_SLAK|CAN_MSR_INAK)) != CAN_MSR_SLAK)
elmot 1:d0dfbce63a89 959 {
elmot 1:d0dfbce63a89 960 /* Process unlocked */
elmot 1:d0dfbce63a89 961 __HAL_UNLOCK(hcan);
elmot 1:d0dfbce63a89 962
elmot 1:d0dfbce63a89 963 /* Return function status */
elmot 1:d0dfbce63a89 964 return HAL_ERROR;
elmot 1:d0dfbce63a89 965 }
elmot 1:d0dfbce63a89 966
elmot 1:d0dfbce63a89 967 /* Get tick */
elmot 1:d0dfbce63a89 968 tickstart = HAL_GetTick();
elmot 1:d0dfbce63a89 969
elmot 1:d0dfbce63a89 970 /* Wait the acknowledge */
elmot 1:d0dfbce63a89 971 while((hcan->Instance->MSR & (CAN_MSR_SLAK|CAN_MSR_INAK)) != CAN_MSR_SLAK)
elmot 1:d0dfbce63a89 972 {
elmot 1:d0dfbce63a89 973 if((HAL_GetTick()-tickstart) > CAN_TIMEOUT_VALUE)
elmot 1:d0dfbce63a89 974 {
elmot 1:d0dfbce63a89 975 hcan->State = HAL_CAN_STATE_TIMEOUT;
elmot 1:d0dfbce63a89 976 /* Process unlocked */
elmot 1:d0dfbce63a89 977 __HAL_UNLOCK(hcan);
elmot 1:d0dfbce63a89 978 return HAL_TIMEOUT;
elmot 1:d0dfbce63a89 979 }
elmot 1:d0dfbce63a89 980 }
elmot 1:d0dfbce63a89 981
elmot 1:d0dfbce63a89 982 /* Change CAN state */
elmot 1:d0dfbce63a89 983 hcan->State = HAL_CAN_STATE_READY;
elmot 1:d0dfbce63a89 984
elmot 1:d0dfbce63a89 985 /* Process unlocked */
elmot 1:d0dfbce63a89 986 __HAL_UNLOCK(hcan);
elmot 1:d0dfbce63a89 987
elmot 1:d0dfbce63a89 988 /* Return function status */
elmot 1:d0dfbce63a89 989 return HAL_OK;
elmot 1:d0dfbce63a89 990 }
elmot 1:d0dfbce63a89 991
elmot 1:d0dfbce63a89 992 /**
elmot 1:d0dfbce63a89 993 * @brief Wake up the CAN peripheral from sleep mode (after that the CAN peripheral
elmot 1:d0dfbce63a89 994 * is in the normal mode).
elmot 1:d0dfbce63a89 995 * @param hcan: pointer to a CAN_HandleTypeDef structure that contains
elmot 1:d0dfbce63a89 996 * the configuration information for the specified CAN.
elmot 1:d0dfbce63a89 997 * @retval HAL status.
elmot 1:d0dfbce63a89 998 */
elmot 1:d0dfbce63a89 999 HAL_StatusTypeDef HAL_CAN_WakeUp(CAN_HandleTypeDef* hcan)
elmot 1:d0dfbce63a89 1000 {
elmot 1:d0dfbce63a89 1001 uint32_t tickstart = 0;
elmot 1:d0dfbce63a89 1002
elmot 1:d0dfbce63a89 1003 /* Process locked */
elmot 1:d0dfbce63a89 1004 __HAL_LOCK(hcan);
elmot 1:d0dfbce63a89 1005
elmot 1:d0dfbce63a89 1006 /* Change CAN state */
elmot 1:d0dfbce63a89 1007 hcan->State = HAL_CAN_STATE_BUSY;
elmot 1:d0dfbce63a89 1008
elmot 1:d0dfbce63a89 1009 /* Wake up request */
elmot 1:d0dfbce63a89 1010 hcan->Instance->MCR &= ~(uint32_t)CAN_MCR_SLEEP;
elmot 1:d0dfbce63a89 1011
elmot 1:d0dfbce63a89 1012 /* Get tick */
elmot 1:d0dfbce63a89 1013 tickstart = HAL_GetTick();
elmot 1:d0dfbce63a89 1014
elmot 1:d0dfbce63a89 1015 /* Sleep mode status */
elmot 1:d0dfbce63a89 1016 while((hcan->Instance->MSR & CAN_MSR_SLAK) == CAN_MSR_SLAK)
elmot 1:d0dfbce63a89 1017 {
elmot 1:d0dfbce63a89 1018 if((HAL_GetTick()-tickstart) > CAN_TIMEOUT_VALUE)
elmot 1:d0dfbce63a89 1019 {
elmot 1:d0dfbce63a89 1020 hcan->State= HAL_CAN_STATE_TIMEOUT;
elmot 1:d0dfbce63a89 1021 /* Process unlocked */
elmot 1:d0dfbce63a89 1022 __HAL_UNLOCK(hcan);
elmot 1:d0dfbce63a89 1023 return HAL_TIMEOUT;
elmot 1:d0dfbce63a89 1024 }
elmot 1:d0dfbce63a89 1025 }
elmot 1:d0dfbce63a89 1026 if((hcan->Instance->MSR & CAN_MSR_SLAK) == CAN_MSR_SLAK)
elmot 1:d0dfbce63a89 1027 {
elmot 1:d0dfbce63a89 1028 /* Process unlocked */
elmot 1:d0dfbce63a89 1029 __HAL_UNLOCK(hcan);
elmot 1:d0dfbce63a89 1030
elmot 1:d0dfbce63a89 1031 /* Return function status */
elmot 1:d0dfbce63a89 1032 return HAL_ERROR;
elmot 1:d0dfbce63a89 1033 }
elmot 1:d0dfbce63a89 1034
elmot 1:d0dfbce63a89 1035 /* Change CAN state */
elmot 1:d0dfbce63a89 1036 hcan->State = HAL_CAN_STATE_READY;
elmot 1:d0dfbce63a89 1037
elmot 1:d0dfbce63a89 1038 /* Process unlocked */
elmot 1:d0dfbce63a89 1039 __HAL_UNLOCK(hcan);
elmot 1:d0dfbce63a89 1040
elmot 1:d0dfbce63a89 1041 /* Return function status */
elmot 1:d0dfbce63a89 1042 return HAL_OK;
elmot 1:d0dfbce63a89 1043 }
elmot 1:d0dfbce63a89 1044
elmot 1:d0dfbce63a89 1045 /**
elmot 1:d0dfbce63a89 1046 * @brief Handle CAN interrupt request.
elmot 1:d0dfbce63a89 1047 * @param hcan: pointer to a CAN_HandleTypeDef structure that contains
elmot 1:d0dfbce63a89 1048 * the configuration information for the specified CAN.
elmot 1:d0dfbce63a89 1049 * @retval None
elmot 1:d0dfbce63a89 1050 */
elmot 1:d0dfbce63a89 1051 void HAL_CAN_IRQHandler(CAN_HandleTypeDef* hcan)
elmot 1:d0dfbce63a89 1052 {
elmot 1:d0dfbce63a89 1053 /* Check End of transmission flag */
elmot 1:d0dfbce63a89 1054 if(__HAL_CAN_GET_IT_SOURCE(hcan, CAN_IT_TME))
elmot 1:d0dfbce63a89 1055 {
elmot 1:d0dfbce63a89 1056 if((__HAL_CAN_TRANSMIT_STATUS(hcan, CAN_TXMAILBOX_0)) ||
elmot 1:d0dfbce63a89 1057 (__HAL_CAN_TRANSMIT_STATUS(hcan, CAN_TXMAILBOX_1)) ||
elmot 1:d0dfbce63a89 1058 (__HAL_CAN_TRANSMIT_STATUS(hcan, CAN_TXMAILBOX_2)))
elmot 1:d0dfbce63a89 1059 {
elmot 1:d0dfbce63a89 1060 /* Call transmit function */
elmot 1:d0dfbce63a89 1061 CAN_Transmit_IT(hcan);
elmot 1:d0dfbce63a89 1062 }
elmot 1:d0dfbce63a89 1063 }
elmot 1:d0dfbce63a89 1064
elmot 1:d0dfbce63a89 1065 /* Check End of reception flag for FIFO0 */
elmot 1:d0dfbce63a89 1066 if((__HAL_CAN_GET_IT_SOURCE(hcan, CAN_IT_FMP0)) &&
elmot 1:d0dfbce63a89 1067 (__HAL_CAN_MSG_PENDING(hcan, CAN_FIFO0) != 0))
elmot 1:d0dfbce63a89 1068 {
elmot 1:d0dfbce63a89 1069 /* Call receive function */
elmot 1:d0dfbce63a89 1070 CAN_Receive_IT(hcan, CAN_FIFO0);
elmot 1:d0dfbce63a89 1071 }
elmot 1:d0dfbce63a89 1072
elmot 1:d0dfbce63a89 1073 /* Check End of reception flag for FIFO1 */
elmot 1:d0dfbce63a89 1074 if((__HAL_CAN_GET_IT_SOURCE(hcan, CAN_IT_FMP1)) &&
elmot 1:d0dfbce63a89 1075 (__HAL_CAN_MSG_PENDING(hcan, CAN_FIFO1) != 0))
elmot 1:d0dfbce63a89 1076 {
elmot 1:d0dfbce63a89 1077 /* Call receive function */
elmot 1:d0dfbce63a89 1078 CAN_Receive_IT(hcan, CAN_FIFO1);
elmot 1:d0dfbce63a89 1079 }
elmot 1:d0dfbce63a89 1080
elmot 1:d0dfbce63a89 1081 /* Check Error Warning Flag */
elmot 1:d0dfbce63a89 1082 if((__HAL_CAN_GET_FLAG(hcan, CAN_FLAG_EWG)) &&
elmot 1:d0dfbce63a89 1083 (__HAL_CAN_GET_IT_SOURCE(hcan, CAN_IT_EWG)) &&
elmot 1:d0dfbce63a89 1084 (__HAL_CAN_GET_IT_SOURCE(hcan, CAN_IT_ERR)))
elmot 1:d0dfbce63a89 1085 {
elmot 1:d0dfbce63a89 1086 /* Set CAN error code to EWG error */
elmot 1:d0dfbce63a89 1087 hcan->ErrorCode |= HAL_CAN_ERROR_EWG;
elmot 1:d0dfbce63a89 1088 /* No need for clear of Error Warning Flag as read-only */
elmot 1:d0dfbce63a89 1089 }
elmot 1:d0dfbce63a89 1090
elmot 1:d0dfbce63a89 1091 /* Check Error Passive Flag */
elmot 1:d0dfbce63a89 1092 if((__HAL_CAN_GET_FLAG(hcan, CAN_FLAG_EPV)) &&
elmot 1:d0dfbce63a89 1093 (__HAL_CAN_GET_IT_SOURCE(hcan, CAN_IT_EPV)) &&
elmot 1:d0dfbce63a89 1094 (__HAL_CAN_GET_IT_SOURCE(hcan, CAN_IT_ERR)))
elmot 1:d0dfbce63a89 1095 {
elmot 1:d0dfbce63a89 1096 /* Set CAN error code to EPV error */
elmot 1:d0dfbce63a89 1097 hcan->ErrorCode |= HAL_CAN_ERROR_EPV;
elmot 1:d0dfbce63a89 1098 /* No need for clear of Error Passive Flag as read-only */
elmot 1:d0dfbce63a89 1099 }
elmot 1:d0dfbce63a89 1100
elmot 1:d0dfbce63a89 1101 /* Check Bus-Off Flag */
elmot 1:d0dfbce63a89 1102 if((__HAL_CAN_GET_FLAG(hcan, CAN_FLAG_BOF)) &&
elmot 1:d0dfbce63a89 1103 (__HAL_CAN_GET_IT_SOURCE(hcan, CAN_IT_BOF)) &&
elmot 1:d0dfbce63a89 1104 (__HAL_CAN_GET_IT_SOURCE(hcan, CAN_IT_ERR)))
elmot 1:d0dfbce63a89 1105 {
elmot 1:d0dfbce63a89 1106 /* Set CAN error code to BOF error */
elmot 1:d0dfbce63a89 1107 hcan->ErrorCode |= HAL_CAN_ERROR_BOF;
elmot 1:d0dfbce63a89 1108 /* No need for clear of Bus-Off Flag as read-only */
elmot 1:d0dfbce63a89 1109 }
elmot 1:d0dfbce63a89 1110
elmot 1:d0dfbce63a89 1111 /* Check Last error code Flag */
elmot 1:d0dfbce63a89 1112 if((!HAL_IS_BIT_CLR(hcan->Instance->ESR, CAN_ESR_LEC)) &&
elmot 1:d0dfbce63a89 1113 (__HAL_CAN_GET_IT_SOURCE(hcan, CAN_IT_LEC)) &&
elmot 1:d0dfbce63a89 1114 (__HAL_CAN_GET_IT_SOURCE(hcan, CAN_IT_ERR)))
elmot 1:d0dfbce63a89 1115 {
elmot 1:d0dfbce63a89 1116 switch(hcan->Instance->ESR & CAN_ESR_LEC)
elmot 1:d0dfbce63a89 1117 {
elmot 1:d0dfbce63a89 1118 case(CAN_ESR_LEC_0):
elmot 1:d0dfbce63a89 1119 /* Set CAN error code to STF error */
elmot 1:d0dfbce63a89 1120 hcan->ErrorCode |= HAL_CAN_ERROR_STF;
elmot 1:d0dfbce63a89 1121 break;
elmot 1:d0dfbce63a89 1122 case(CAN_ESR_LEC_1):
elmot 1:d0dfbce63a89 1123 /* Set CAN error code to FOR error */
elmot 1:d0dfbce63a89 1124 hcan->ErrorCode |= HAL_CAN_ERROR_FOR;
elmot 1:d0dfbce63a89 1125 break;
elmot 1:d0dfbce63a89 1126 case(CAN_ESR_LEC_1 | CAN_ESR_LEC_0):
elmot 1:d0dfbce63a89 1127 /* Set CAN error code to ACK error */
elmot 1:d0dfbce63a89 1128 hcan->ErrorCode |= HAL_CAN_ERROR_ACK;
elmot 1:d0dfbce63a89 1129 break;
elmot 1:d0dfbce63a89 1130 case(CAN_ESR_LEC_2):
elmot 1:d0dfbce63a89 1131 /* Set CAN error code to BR error */
elmot 1:d0dfbce63a89 1132 hcan->ErrorCode |= HAL_CAN_ERROR_BR;
elmot 1:d0dfbce63a89 1133 break;
elmot 1:d0dfbce63a89 1134 case(CAN_ESR_LEC_2 | CAN_ESR_LEC_0):
elmot 1:d0dfbce63a89 1135 /* Set CAN error code to BD error */
elmot 1:d0dfbce63a89 1136 hcan->ErrorCode |= HAL_CAN_ERROR_BD;
elmot 1:d0dfbce63a89 1137 break;
elmot 1:d0dfbce63a89 1138 case(CAN_ESR_LEC_2 | CAN_ESR_LEC_1):
elmot 1:d0dfbce63a89 1139 /* Set CAN error code to CRC error */
elmot 1:d0dfbce63a89 1140 hcan->ErrorCode |= HAL_CAN_ERROR_CRC;
elmot 1:d0dfbce63a89 1141 break;
elmot 1:d0dfbce63a89 1142 default:
elmot 1:d0dfbce63a89 1143 break;
elmot 1:d0dfbce63a89 1144 }
elmot 1:d0dfbce63a89 1145
elmot 1:d0dfbce63a89 1146 /* Clear Last error code Flag */
elmot 1:d0dfbce63a89 1147 hcan->Instance->ESR &= ~(CAN_ESR_LEC);
elmot 1:d0dfbce63a89 1148 }
elmot 1:d0dfbce63a89 1149
elmot 1:d0dfbce63a89 1150 /* Call the Error call Back in case of Errors */
elmot 1:d0dfbce63a89 1151 if(hcan->ErrorCode != HAL_CAN_ERROR_NONE)
elmot 1:d0dfbce63a89 1152 {
elmot 1:d0dfbce63a89 1153 /* Clear ERRI bit */
elmot 1:d0dfbce63a89 1154 SET_BIT(hcan->Instance->MSR, CAN_MSR_ERRI);
elmot 1:d0dfbce63a89 1155 /* Set the CAN state ready to be able to start again the process */
elmot 1:d0dfbce63a89 1156 hcan->State = HAL_CAN_STATE_READY;
elmot 1:d0dfbce63a89 1157 /* Call Error callback function */
elmot 1:d0dfbce63a89 1158 HAL_CAN_ErrorCallback(hcan);
elmot 1:d0dfbce63a89 1159 }
elmot 1:d0dfbce63a89 1160 }
elmot 1:d0dfbce63a89 1161
elmot 1:d0dfbce63a89 1162 /**
elmot 1:d0dfbce63a89 1163 * @brief Transmission complete callback in non-blocking mode.
elmot 1:d0dfbce63a89 1164 * @param hcan: pointer to a CAN_HandleTypeDef structure that contains
elmot 1:d0dfbce63a89 1165 * the configuration information for the specified CAN.
elmot 1:d0dfbce63a89 1166 * @retval None
elmot 1:d0dfbce63a89 1167 */
elmot 1:d0dfbce63a89 1168 __weak void HAL_CAN_TxCpltCallback(CAN_HandleTypeDef* hcan)
elmot 1:d0dfbce63a89 1169 {
elmot 1:d0dfbce63a89 1170 /* Prevent unused argument(s) compilation warning */
elmot 1:d0dfbce63a89 1171 UNUSED(hcan);
elmot 1:d0dfbce63a89 1172
elmot 1:d0dfbce63a89 1173 /* NOTE : This function should not be modified, when the callback is needed,
elmot 1:d0dfbce63a89 1174 the HAL_CAN_TxCpltCallback could be implemented in the user file
elmot 1:d0dfbce63a89 1175 */
elmot 1:d0dfbce63a89 1176 }
elmot 1:d0dfbce63a89 1177
elmot 1:d0dfbce63a89 1178 /**
elmot 1:d0dfbce63a89 1179 * @brief Reception complete callback in non-blocking mode.
elmot 1:d0dfbce63a89 1180 * @param hcan: pointer to a CAN_HandleTypeDef structure that contains
elmot 1:d0dfbce63a89 1181 * the configuration information for the specified CAN.
elmot 1:d0dfbce63a89 1182 * @retval None
elmot 1:d0dfbce63a89 1183 */
elmot 1:d0dfbce63a89 1184 __weak void HAL_CAN_RxCpltCallback(CAN_HandleTypeDef* hcan)
elmot 1:d0dfbce63a89 1185 {
elmot 1:d0dfbce63a89 1186 /* Prevent unused argument(s) compilation warning */
elmot 1:d0dfbce63a89 1187 UNUSED(hcan);
elmot 1:d0dfbce63a89 1188
elmot 1:d0dfbce63a89 1189 /* NOTE : This function should not be modified, when the callback is needed,
elmot 1:d0dfbce63a89 1190 the HAL_CAN_RxCpltCallback could be implemented in the user file
elmot 1:d0dfbce63a89 1191 */
elmot 1:d0dfbce63a89 1192 }
elmot 1:d0dfbce63a89 1193
elmot 1:d0dfbce63a89 1194 /**
elmot 1:d0dfbce63a89 1195 * @brief Error CAN callback.
elmot 1:d0dfbce63a89 1196 * @param hcan: pointer to a CAN_HandleTypeDef structure that contains
elmot 1:d0dfbce63a89 1197 * the configuration information for the specified CAN.
elmot 1:d0dfbce63a89 1198 * @retval None
elmot 1:d0dfbce63a89 1199 */
elmot 1:d0dfbce63a89 1200 __weak void HAL_CAN_ErrorCallback(CAN_HandleTypeDef *hcan)
elmot 1:d0dfbce63a89 1201 {
elmot 1:d0dfbce63a89 1202 /* Prevent unused argument(s) compilation warning */
elmot 1:d0dfbce63a89 1203 UNUSED(hcan);
elmot 1:d0dfbce63a89 1204
elmot 1:d0dfbce63a89 1205 /* NOTE : This function should not be modified, when the callback is needed,
elmot 1:d0dfbce63a89 1206 the HAL_CAN_ErrorCallback could be implemented in the user file
elmot 1:d0dfbce63a89 1207 */
elmot 1:d0dfbce63a89 1208 }
elmot 1:d0dfbce63a89 1209
elmot 1:d0dfbce63a89 1210 /**
elmot 1:d0dfbce63a89 1211 * @}
elmot 1:d0dfbce63a89 1212 */
elmot 1:d0dfbce63a89 1213
elmot 1:d0dfbce63a89 1214 /** @defgroup CAN_Exported_Functions_Group3 Peripheral State and Error functions
elmot 1:d0dfbce63a89 1215 * @brief CAN Peripheral State functions
elmot 1:d0dfbce63a89 1216 *
elmot 1:d0dfbce63a89 1217 @verbatim
elmot 1:d0dfbce63a89 1218 ==============================================================================
elmot 1:d0dfbce63a89 1219 ##### Peripheral State and Error functions #####
elmot 1:d0dfbce63a89 1220 ==============================================================================
elmot 1:d0dfbce63a89 1221 [..]
elmot 1:d0dfbce63a89 1222 This subsection provides functions allowing to :
elmot 1:d0dfbce63a89 1223 (+) Check the CAN state.
elmot 1:d0dfbce63a89 1224 (+) Check CAN Errors detected during interrupt process.
elmot 1:d0dfbce63a89 1225
elmot 1:d0dfbce63a89 1226 @endverbatim
elmot 1:d0dfbce63a89 1227 * @{
elmot 1:d0dfbce63a89 1228 */
elmot 1:d0dfbce63a89 1229
elmot 1:d0dfbce63a89 1230 /**
elmot 1:d0dfbce63a89 1231 * @brief Return the CAN handle state.
elmot 1:d0dfbce63a89 1232 * @param hcan: pointer to a CAN_HandleTypeDef structure that contains
elmot 1:d0dfbce63a89 1233 * the configuration information for the specified CAN.
elmot 1:d0dfbce63a89 1234 * @retval HAL state
elmot 1:d0dfbce63a89 1235 */
elmot 1:d0dfbce63a89 1236 HAL_CAN_StateTypeDef HAL_CAN_GetState(CAN_HandleTypeDef* hcan)
elmot 1:d0dfbce63a89 1237 {
elmot 1:d0dfbce63a89 1238 /* Return CAN handle state */
elmot 1:d0dfbce63a89 1239 return hcan->State;
elmot 1:d0dfbce63a89 1240 }
elmot 1:d0dfbce63a89 1241
elmot 1:d0dfbce63a89 1242 /**
elmot 1:d0dfbce63a89 1243 * @brief Return the CAN error code.
elmot 1:d0dfbce63a89 1244 * @param hcan: pointer to a CAN_HandleTypeDef structure that contains
elmot 1:d0dfbce63a89 1245 * the configuration information for the specified CAN.
elmot 1:d0dfbce63a89 1246 * @retval CAN Error Code
elmot 1:d0dfbce63a89 1247 */
elmot 1:d0dfbce63a89 1248 uint32_t HAL_CAN_GetError(CAN_HandleTypeDef *hcan)
elmot 1:d0dfbce63a89 1249 {
elmot 1:d0dfbce63a89 1250 return hcan->ErrorCode;
elmot 1:d0dfbce63a89 1251 }
elmot 1:d0dfbce63a89 1252
elmot 1:d0dfbce63a89 1253 /**
elmot 1:d0dfbce63a89 1254 * @}
elmot 1:d0dfbce63a89 1255 */
elmot 1:d0dfbce63a89 1256
elmot 1:d0dfbce63a89 1257 /**
elmot 1:d0dfbce63a89 1258 * @}
elmot 1:d0dfbce63a89 1259 */
elmot 1:d0dfbce63a89 1260
elmot 1:d0dfbce63a89 1261 /** @defgroup CAN_Private_Functions CAN Private Functions
elmot 1:d0dfbce63a89 1262 * @{
elmot 1:d0dfbce63a89 1263 */
elmot 1:d0dfbce63a89 1264 /**
elmot 1:d0dfbce63a89 1265 * @brief Initiate and transmit a CAN frame message.
elmot 1:d0dfbce63a89 1266 * @param hcan: pointer to a CAN_HandleTypeDef structure that contains
elmot 1:d0dfbce63a89 1267 * the configuration information for the specified CAN.
elmot 1:d0dfbce63a89 1268 * @retval HAL status
elmot 1:d0dfbce63a89 1269 */
elmot 1:d0dfbce63a89 1270 static HAL_StatusTypeDef CAN_Transmit_IT(CAN_HandleTypeDef* hcan)
elmot 1:d0dfbce63a89 1271 {
elmot 1:d0dfbce63a89 1272 /* Disable Transmit mailbox empty Interrupt */
elmot 1:d0dfbce63a89 1273 __HAL_CAN_DISABLE_IT(hcan, CAN_IT_TME);
elmot 1:d0dfbce63a89 1274
elmot 1:d0dfbce63a89 1275 if(hcan->State == HAL_CAN_STATE_BUSY_TX)
elmot 1:d0dfbce63a89 1276 {
elmot 1:d0dfbce63a89 1277 /* Disable interrupts: */
elmot 1:d0dfbce63a89 1278 /* - Disable Error warning Interrupt */
elmot 1:d0dfbce63a89 1279 /* - Disable Error passive Interrupt */
elmot 1:d0dfbce63a89 1280 /* - Disable Bus-off Interrupt */
elmot 1:d0dfbce63a89 1281 /* - Disable Last error code Interrupt */
elmot 1:d0dfbce63a89 1282 /* - Disable Error Interrupt */
elmot 1:d0dfbce63a89 1283 __HAL_CAN_DISABLE_IT(hcan, CAN_IT_EWG |
elmot 1:d0dfbce63a89 1284 CAN_IT_EPV |
elmot 1:d0dfbce63a89 1285 CAN_IT_BOF |
elmot 1:d0dfbce63a89 1286 CAN_IT_LEC |
elmot 1:d0dfbce63a89 1287 CAN_IT_ERR );
elmot 1:d0dfbce63a89 1288 }
elmot 1:d0dfbce63a89 1289
elmot 1:d0dfbce63a89 1290 if(hcan->State == HAL_CAN_STATE_BUSY_TX_RX)
elmot 1:d0dfbce63a89 1291 {
elmot 1:d0dfbce63a89 1292 /* Change CAN state */
elmot 1:d0dfbce63a89 1293 hcan->State = HAL_CAN_STATE_BUSY_RX;
elmot 1:d0dfbce63a89 1294 }
elmot 1:d0dfbce63a89 1295 else
elmot 1:d0dfbce63a89 1296 {
elmot 1:d0dfbce63a89 1297 /* Change CAN state */
elmot 1:d0dfbce63a89 1298 hcan->State = HAL_CAN_STATE_READY;
elmot 1:d0dfbce63a89 1299 }
elmot 1:d0dfbce63a89 1300
elmot 1:d0dfbce63a89 1301 /* Transmission complete callback */
elmot 1:d0dfbce63a89 1302 HAL_CAN_TxCpltCallback(hcan);
elmot 1:d0dfbce63a89 1303
elmot 1:d0dfbce63a89 1304 return HAL_OK;
elmot 1:d0dfbce63a89 1305 }
elmot 1:d0dfbce63a89 1306
elmot 1:d0dfbce63a89 1307 /**
elmot 1:d0dfbce63a89 1308 * @brief Receive a correct CAN frame.
elmot 1:d0dfbce63a89 1309 * @param hcan: Pointer to a CAN_HandleTypeDef structure that contains
elmot 1:d0dfbce63a89 1310 * the configuration information for the specified CAN.
elmot 1:d0dfbce63a89 1311 * @param FIFONumber: Specify the FIFO number
elmot 1:d0dfbce63a89 1312 * @retval HAL status
elmot 1:d0dfbce63a89 1313 */
elmot 1:d0dfbce63a89 1314 static HAL_StatusTypeDef CAN_Receive_IT(CAN_HandleTypeDef* hcan, uint8_t FIFONumber)
elmot 1:d0dfbce63a89 1315 {
elmot 1:d0dfbce63a89 1316 /* Get the Id */
elmot 1:d0dfbce63a89 1317 hcan->pRxMsg->IDE = (uint8_t)0x04 & hcan->Instance->sFIFOMailBox[FIFONumber].RIR;
elmot 1:d0dfbce63a89 1318 if (hcan->pRxMsg->IDE == CAN_ID_STD)
elmot 1:d0dfbce63a89 1319 {
elmot 1:d0dfbce63a89 1320 hcan->pRxMsg->StdId = (uint32_t)0x000007FF & (hcan->Instance->sFIFOMailBox[FIFONumber].RIR >> 21);
elmot 1:d0dfbce63a89 1321 }
elmot 1:d0dfbce63a89 1322 else
elmot 1:d0dfbce63a89 1323 {
elmot 1:d0dfbce63a89 1324 hcan->pRxMsg->ExtId = (uint32_t)0x1FFFFFFF & (hcan->Instance->sFIFOMailBox[FIFONumber].RIR >> 3);
elmot 1:d0dfbce63a89 1325 }
elmot 1:d0dfbce63a89 1326
elmot 1:d0dfbce63a89 1327 hcan->pRxMsg->RTR = (uint8_t)0x02 & hcan->Instance->sFIFOMailBox[FIFONumber].RIR;
elmot 1:d0dfbce63a89 1328 /* Get the DLC */
elmot 1:d0dfbce63a89 1329 hcan->pRxMsg->DLC = (uint8_t)0x0F & hcan->Instance->sFIFOMailBox[FIFONumber].RDTR;
elmot 1:d0dfbce63a89 1330 /* Get the FMI */
elmot 1:d0dfbce63a89 1331 hcan->pRxMsg->FMI = (uint8_t)0xFF & (hcan->Instance->sFIFOMailBox[FIFONumber].RDTR >> 8);
elmot 1:d0dfbce63a89 1332 /* Get the data field */
elmot 1:d0dfbce63a89 1333 hcan->pRxMsg->Data[0] = (uint8_t)0xFF & hcan->Instance->sFIFOMailBox[FIFONumber].RDLR;
elmot 1:d0dfbce63a89 1334 hcan->pRxMsg->Data[1] = (uint8_t)0xFF & (hcan->Instance->sFIFOMailBox[FIFONumber].RDLR >> 8);
elmot 1:d0dfbce63a89 1335 hcan->pRxMsg->Data[2] = (uint8_t)0xFF & (hcan->Instance->sFIFOMailBox[FIFONumber].RDLR >> 16);
elmot 1:d0dfbce63a89 1336 hcan->pRxMsg->Data[3] = (uint8_t)0xFF & (hcan->Instance->sFIFOMailBox[FIFONumber].RDLR >> 24);
elmot 1:d0dfbce63a89 1337 hcan->pRxMsg->Data[4] = (uint8_t)0xFF & hcan->Instance->sFIFOMailBox[FIFONumber].RDHR;
elmot 1:d0dfbce63a89 1338 hcan->pRxMsg->Data[5] = (uint8_t)0xFF & (hcan->Instance->sFIFOMailBox[FIFONumber].RDHR >> 8);
elmot 1:d0dfbce63a89 1339 hcan->pRxMsg->Data[6] = (uint8_t)0xFF & (hcan->Instance->sFIFOMailBox[FIFONumber].RDHR >> 16);
elmot 1:d0dfbce63a89 1340 hcan->pRxMsg->Data[7] = (uint8_t)0xFF & (hcan->Instance->sFIFOMailBox[FIFONumber].RDHR >> 24);
elmot 1:d0dfbce63a89 1341 /* Release the FIFO */
elmot 1:d0dfbce63a89 1342 /* Release FIFO0 */
elmot 1:d0dfbce63a89 1343 if (FIFONumber == CAN_FIFO0)
elmot 1:d0dfbce63a89 1344 {
elmot 1:d0dfbce63a89 1345 __HAL_CAN_FIFO_RELEASE(hcan, CAN_FIFO0);
elmot 1:d0dfbce63a89 1346
elmot 1:d0dfbce63a89 1347 /* Disable FIFO 0 message pending Interrupt */
elmot 1:d0dfbce63a89 1348 __HAL_CAN_DISABLE_IT(hcan, CAN_IT_FMP0);
elmot 1:d0dfbce63a89 1349 }
elmot 1:d0dfbce63a89 1350 /* Release FIFO1 */
elmot 1:d0dfbce63a89 1351 else /* FIFONumber == CAN_FIFO1 */
elmot 1:d0dfbce63a89 1352 {
elmot 1:d0dfbce63a89 1353 __HAL_CAN_FIFO_RELEASE(hcan, CAN_FIFO1);
elmot 1:d0dfbce63a89 1354
elmot 1:d0dfbce63a89 1355 /* Disable FIFO 1 message pending Interrupt */
elmot 1:d0dfbce63a89 1356 __HAL_CAN_DISABLE_IT(hcan, CAN_IT_FMP1);
elmot 1:d0dfbce63a89 1357 }
elmot 1:d0dfbce63a89 1358
elmot 1:d0dfbce63a89 1359 if(hcan->State == HAL_CAN_STATE_BUSY_RX)
elmot 1:d0dfbce63a89 1360 {
elmot 1:d0dfbce63a89 1361 /* Disable interrupts: */
elmot 1:d0dfbce63a89 1362 /* - Disable Error warning Interrupt */
elmot 1:d0dfbce63a89 1363 /* - Disable Error passive Interrupt */
elmot 1:d0dfbce63a89 1364 /* - Disable Bus-off Interrupt */
elmot 1:d0dfbce63a89 1365 /* - Disable Last error code Interrupt */
elmot 1:d0dfbce63a89 1366 /* - Disable Error Interrupt */
elmot 1:d0dfbce63a89 1367 __HAL_CAN_DISABLE_IT(hcan, CAN_IT_EWG |
elmot 1:d0dfbce63a89 1368 CAN_IT_EPV |
elmot 1:d0dfbce63a89 1369 CAN_IT_BOF |
elmot 1:d0dfbce63a89 1370 CAN_IT_LEC |
elmot 1:d0dfbce63a89 1371 CAN_IT_ERR );
elmot 1:d0dfbce63a89 1372 }
elmot 1:d0dfbce63a89 1373
elmot 1:d0dfbce63a89 1374 if(hcan->State == HAL_CAN_STATE_BUSY_TX_RX)
elmot 1:d0dfbce63a89 1375 {
elmot 1:d0dfbce63a89 1376 /* Disable CAN state */
elmot 1:d0dfbce63a89 1377 hcan->State = HAL_CAN_STATE_BUSY_TX;
elmot 1:d0dfbce63a89 1378 }
elmot 1:d0dfbce63a89 1379 else
elmot 1:d0dfbce63a89 1380 {
elmot 1:d0dfbce63a89 1381 /* Change CAN state */
elmot 1:d0dfbce63a89 1382 hcan->State = HAL_CAN_STATE_READY;
elmot 1:d0dfbce63a89 1383 }
elmot 1:d0dfbce63a89 1384
elmot 1:d0dfbce63a89 1385 /* Receive complete callback */
elmot 1:d0dfbce63a89 1386 HAL_CAN_RxCpltCallback(hcan);
elmot 1:d0dfbce63a89 1387
elmot 1:d0dfbce63a89 1388 /* Return function status */
elmot 1:d0dfbce63a89 1389 return HAL_OK;
elmot 1:d0dfbce63a89 1390 }
elmot 1:d0dfbce63a89 1391 /**
elmot 1:d0dfbce63a89 1392 * @}
elmot 1:d0dfbce63a89 1393 */
elmot 1:d0dfbce63a89 1394
elmot 1:d0dfbce63a89 1395 #endif /* HAL_CAN_MODULE_ENABLED */
elmot 1:d0dfbce63a89 1396 /**
elmot 1:d0dfbce63a89 1397 * @}
elmot 1:d0dfbce63a89 1398 */
elmot 1:d0dfbce63a89 1399
elmot 1:d0dfbce63a89 1400 /**
elmot 1:d0dfbce63a89 1401 * @}
elmot 1:d0dfbce63a89 1402 */
elmot 1:d0dfbce63a89 1403
elmot 1:d0dfbce63a89 1404 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/