mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

This library was superseded by mbed-dev - https://os.mbed.com/users/mbed_official/code/mbed-dev/.

Development branch of the mbed library sources. This library is kept in synch with the latest changes from the mbed SDK and it is not guaranteed to work.

If you are looking for a stable and tested release, please import one of the official mbed library releases:

Import librarymbed

The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_STM32F7/stm32f7xx_hal_can.c@573:ad23fe03a082, 2015-06-19 (annotated)

Committer:
mbed_official
Date:
Fri Jun 19 09:15:11 2015 +0100
Revision:
573:ad23fe03a082
Child:
610:813dcc80987e
Synchronized with git revision d47834cd4d729e5b36b4c1ad4650f8b8f6a9ab86



Full URL: https://github.com/mbedmicro/mbed/commit/d47834cd4d729e5b36b4c1ad4650f8b8f6a9ab86/



DISCO_F746NG - Add new target

Who changed what in which revision?

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