Joris Aerts / mbed-src

mbed library sources

Dependents:   Marvino mbot

Fork of mbed-src 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****/