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@610:813dcc80987e, 2015-08-14 (annotated)

Committer:
mbed_official
Date:
Fri Aug 14 13:15:17 2015 +0100
Revision:
610:813dcc80987e
Parent:
573:ad23fe03a082 
Synchronized with git revision 6d84db41c6833e0b9b024741eb0616a5f62d5599



Full URL: https://github.com/mbedmicro/mbed/commit/6d84db41c6833e0b9b024741eb0616a5f62d5599/



DISCO_F746NG - Improvements

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