Eric Lewiston / STM32L4xx_HAL_Driver

Important changes to repositories hosted on mbed.com

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

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

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

Dependents:   BSP OneHopeOnePrayer FINAL_AUDIO_RECORD AudioDemo

Fork of STM32L4xx_HAL_Driver by Senior Design: Sound Monitor

Src/stm32l4xx_hal_can.c@0:80ee8f3b695e, 2015-11-02 (annotated)

Committer:
EricLew
Date:
Mon Nov 02 19:37:23 2015 +0000
Revision:
0:80ee8f3b695e
Errors are with definitions of LCD and QSPI functions. I believe all .h and .c files are  uploaded, but there may need to be certain functions called.

Who changed what in which revision?

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