shao ziyang / mbed-src-kl05

mbed library sources

Dependents:   frdm_kl05z_gpio_test

Fork of mbed-src by mbed official

targets/cmsis/TARGET_STM/TARGET_DISCO_F100RB/stm32f10x_can.c@126:549ba18ddd81, 2014-03-19 (annotated)

Committer:
mbed_official
Date:
Wed Mar 19 16:00:09 2014 +0000
Revision:
126:549ba18ddd81
Synchronized with git revision cf8fd1cf86b0cd85131dd24a6ded21cc6fe04827



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



Conflicts:

	workspace_tools/targets.py

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 126:549ba18ddd81 1 /**
mbed_official 126:549ba18ddd81 2 ******************************************************************************
mbed_official 126:549ba18ddd81 3 * @file stm32f10x_can.c
mbed_official 126:549ba18ddd81 4 * @author MCD Application Team
mbed_official 126:549ba18ddd81 5 * @version V3.6.1
mbed_official 126:549ba18ddd81 6 * @date 05-March-2012
mbed_official 126:549ba18ddd81 7 * @brief This file provides all the CAN firmware functions.
mbed_official 126:549ba18ddd81 8 *******************************************************************************
mbed_official 126:549ba18ddd81 9 * Copyright (c) 2014, STMicroelectronics
mbed_official 126:549ba18ddd81 10 * All rights reserved.
mbed_official 126:549ba18ddd81 11 *
mbed_official 126:549ba18ddd81 12 * Redistribution and use in source and binary forms, with or without
mbed_official 126:549ba18ddd81 13 * modification, are permitted provided that the following conditions are met:
mbed_official 126:549ba18ddd81 14 *
mbed_official 126:549ba18ddd81 15 * 1. Redistributions of source code must retain the above copyright notice,
mbed_official 126:549ba18ddd81 16 * this list of conditions and the following disclaimer.
mbed_official 126:549ba18ddd81 17 * 2. Redistributions in binary form must reproduce the above copyright notice,
mbed_official 126:549ba18ddd81 18 * this list of conditions and the following disclaimer in the documentation
mbed_official 126:549ba18ddd81 19 * and/or other materials provided with the distribution.
mbed_official 126:549ba18ddd81 20 * 3. Neither the name of STMicroelectronics nor the names of its contributors
mbed_official 126:549ba18ddd81 21 * may be used to endorse or promote products derived from this software
mbed_official 126:549ba18ddd81 22 * without specific prior written permission.
mbed_official 126:549ba18ddd81 23 *
mbed_official 126:549ba18ddd81 24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
mbed_official 126:549ba18ddd81 25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
mbed_official 126:549ba18ddd81 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
mbed_official 126:549ba18ddd81 27 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
mbed_official 126:549ba18ddd81 28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
mbed_official 126:549ba18ddd81 29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
mbed_official 126:549ba18ddd81 30 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
mbed_official 126:549ba18ddd81 31 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
mbed_official 126:549ba18ddd81 32 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
mbed_official 126:549ba18ddd81 33 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
mbed_official 126:549ba18ddd81 34 *******************************************************************************
mbed_official 126:549ba18ddd81 35 */
mbed_official 126:549ba18ddd81 36
mbed_official 126:549ba18ddd81 37 /* Includes ------------------------------------------------------------------*/
mbed_official 126:549ba18ddd81 38 #include "stm32f10x_can.h"
mbed_official 126:549ba18ddd81 39 #include "stm32f10x_rcc.h"
mbed_official 126:549ba18ddd81 40
mbed_official 126:549ba18ddd81 41 /** @addtogroup STM32F10x_StdPeriph_Driver
mbed_official 126:549ba18ddd81 42 * @{
mbed_official 126:549ba18ddd81 43 */
mbed_official 126:549ba18ddd81 44
mbed_official 126:549ba18ddd81 45 /** @defgroup CAN
mbed_official 126:549ba18ddd81 46 * @brief CAN driver modules
mbed_official 126:549ba18ddd81 47 * @{
mbed_official 126:549ba18ddd81 48 */
mbed_official 126:549ba18ddd81 49
mbed_official 126:549ba18ddd81 50 /** @defgroup CAN_Private_TypesDefinitions
mbed_official 126:549ba18ddd81 51 * @{
mbed_official 126:549ba18ddd81 52 */
mbed_official 126:549ba18ddd81 53
mbed_official 126:549ba18ddd81 54 /**
mbed_official 126:549ba18ddd81 55 * @}
mbed_official 126:549ba18ddd81 56 */
mbed_official 126:549ba18ddd81 57
mbed_official 126:549ba18ddd81 58 /** @defgroup CAN_Private_Defines
mbed_official 126:549ba18ddd81 59 * @{
mbed_official 126:549ba18ddd81 60 */
mbed_official 126:549ba18ddd81 61
mbed_official 126:549ba18ddd81 62 /* CAN Master Control Register bits */
mbed_official 126:549ba18ddd81 63
mbed_official 126:549ba18ddd81 64 #define MCR_DBF ((uint32_t)0x00010000) /* software master reset */
mbed_official 126:549ba18ddd81 65
mbed_official 126:549ba18ddd81 66 /* CAN Mailbox Transmit Request */
mbed_official 126:549ba18ddd81 67 #define TMIDxR_TXRQ ((uint32_t)0x00000001) /* Transmit mailbox request */
mbed_official 126:549ba18ddd81 68
mbed_official 126:549ba18ddd81 69 /* CAN Filter Master Register bits */
mbed_official 126:549ba18ddd81 70 #define FMR_FINIT ((uint32_t)0x00000001) /* Filter init mode */
mbed_official 126:549ba18ddd81 71
mbed_official 126:549ba18ddd81 72 /* Time out for INAK bit */
mbed_official 126:549ba18ddd81 73 #define INAK_TIMEOUT ((uint32_t)0x0000FFFF)
mbed_official 126:549ba18ddd81 74 /* Time out for SLAK bit */
mbed_official 126:549ba18ddd81 75 #define SLAK_TIMEOUT ((uint32_t)0x0000FFFF)
mbed_official 126:549ba18ddd81 76
mbed_official 126:549ba18ddd81 77
mbed_official 126:549ba18ddd81 78
mbed_official 126:549ba18ddd81 79 /* Flags in TSR register */
mbed_official 126:549ba18ddd81 80 #define CAN_FLAGS_TSR ((uint32_t)0x08000000)
mbed_official 126:549ba18ddd81 81 /* Flags in RF1R register */
mbed_official 126:549ba18ddd81 82 #define CAN_FLAGS_RF1R ((uint32_t)0x04000000)
mbed_official 126:549ba18ddd81 83 /* Flags in RF0R register */
mbed_official 126:549ba18ddd81 84 #define CAN_FLAGS_RF0R ((uint32_t)0x02000000)
mbed_official 126:549ba18ddd81 85 /* Flags in MSR register */
mbed_official 126:549ba18ddd81 86 #define CAN_FLAGS_MSR ((uint32_t)0x01000000)
mbed_official 126:549ba18ddd81 87 /* Flags in ESR register */
mbed_official 126:549ba18ddd81 88 #define CAN_FLAGS_ESR ((uint32_t)0x00F00000)
mbed_official 126:549ba18ddd81 89
mbed_official 126:549ba18ddd81 90 /* Mailboxes definition */
mbed_official 126:549ba18ddd81 91 #define CAN_TXMAILBOX_0 ((uint8_t)0x00)
mbed_official 126:549ba18ddd81 92 #define CAN_TXMAILBOX_1 ((uint8_t)0x01)
mbed_official 126:549ba18ddd81 93 #define CAN_TXMAILBOX_2 ((uint8_t)0x02)
mbed_official 126:549ba18ddd81 94
mbed_official 126:549ba18ddd81 95
mbed_official 126:549ba18ddd81 96
mbed_official 126:549ba18ddd81 97 #define CAN_MODE_MASK ((uint32_t) 0x00000003)
mbed_official 126:549ba18ddd81 98 /**
mbed_official 126:549ba18ddd81 99 * @}
mbed_official 126:549ba18ddd81 100 */
mbed_official 126:549ba18ddd81 101
mbed_official 126:549ba18ddd81 102 /** @defgroup CAN_Private_Macros
mbed_official 126:549ba18ddd81 103 * @{
mbed_official 126:549ba18ddd81 104 */
mbed_official 126:549ba18ddd81 105
mbed_official 126:549ba18ddd81 106 /**
mbed_official 126:549ba18ddd81 107 * @}
mbed_official 126:549ba18ddd81 108 */
mbed_official 126:549ba18ddd81 109
mbed_official 126:549ba18ddd81 110 /** @defgroup CAN_Private_Variables
mbed_official 126:549ba18ddd81 111 * @{
mbed_official 126:549ba18ddd81 112 */
mbed_official 126:549ba18ddd81 113
mbed_official 126:549ba18ddd81 114 /**
mbed_official 126:549ba18ddd81 115 * @}
mbed_official 126:549ba18ddd81 116 */
mbed_official 126:549ba18ddd81 117
mbed_official 126:549ba18ddd81 118 /** @defgroup CAN_Private_FunctionPrototypes
mbed_official 126:549ba18ddd81 119 * @{
mbed_official 126:549ba18ddd81 120 */
mbed_official 126:549ba18ddd81 121
mbed_official 126:549ba18ddd81 122 static ITStatus CheckITStatus(uint32_t CAN_Reg, uint32_t It_Bit);
mbed_official 126:549ba18ddd81 123
mbed_official 126:549ba18ddd81 124 /**
mbed_official 126:549ba18ddd81 125 * @}
mbed_official 126:549ba18ddd81 126 */
mbed_official 126:549ba18ddd81 127
mbed_official 126:549ba18ddd81 128 /** @defgroup CAN_Private_Functions
mbed_official 126:549ba18ddd81 129 * @{
mbed_official 126:549ba18ddd81 130 */
mbed_official 126:549ba18ddd81 131
mbed_official 126:549ba18ddd81 132 /**
mbed_official 126:549ba18ddd81 133 * @brief Deinitializes the CAN peripheral registers to their default reset values.
mbed_official 126:549ba18ddd81 134 * @param CANx: where x can be 1 or 2 to select the CAN peripheral.
mbed_official 126:549ba18ddd81 135 * @retval None.
mbed_official 126:549ba18ddd81 136 */
mbed_official 126:549ba18ddd81 137 void CAN_DeInit(CAN_TypeDef* CANx)
mbed_official 126:549ba18ddd81 138 {
mbed_official 126:549ba18ddd81 139 /* Check the parameters */
mbed_official 126:549ba18ddd81 140 assert_param(IS_CAN_ALL_PERIPH(CANx));
mbed_official 126:549ba18ddd81 141
mbed_official 126:549ba18ddd81 142 if (CANx == CAN1)
mbed_official 126:549ba18ddd81 143 {
mbed_official 126:549ba18ddd81 144 /* Enable CAN1 reset state */
mbed_official 126:549ba18ddd81 145 RCC_APB1PeriphResetCmd(RCC_APB1Periph_CAN1, ENABLE);
mbed_official 126:549ba18ddd81 146 /* Release CAN1 from reset state */
mbed_official 126:549ba18ddd81 147 RCC_APB1PeriphResetCmd(RCC_APB1Periph_CAN1, DISABLE);
mbed_official 126:549ba18ddd81 148 }
mbed_official 126:549ba18ddd81 149 else
mbed_official 126:549ba18ddd81 150 {
mbed_official 126:549ba18ddd81 151 /* Enable CAN2 reset state */
mbed_official 126:549ba18ddd81 152 RCC_APB1PeriphResetCmd(RCC_APB1Periph_CAN2, ENABLE);
mbed_official 126:549ba18ddd81 153 /* Release CAN2 from reset state */
mbed_official 126:549ba18ddd81 154 RCC_APB1PeriphResetCmd(RCC_APB1Periph_CAN2, DISABLE);
mbed_official 126:549ba18ddd81 155 }
mbed_official 126:549ba18ddd81 156 }
mbed_official 126:549ba18ddd81 157
mbed_official 126:549ba18ddd81 158 /**
mbed_official 126:549ba18ddd81 159 * @brief Initializes the CAN peripheral according to the specified
mbed_official 126:549ba18ddd81 160 * parameters in the CAN_InitStruct.
mbed_official 126:549ba18ddd81 161 * @param CANx: where x can be 1 or 2 to to select the CAN
mbed_official 126:549ba18ddd81 162 * peripheral.
mbed_official 126:549ba18ddd81 163 * @param CAN_InitStruct: pointer to a CAN_InitTypeDef structure that
mbed_official 126:549ba18ddd81 164 * contains the configuration information for the
mbed_official 126:549ba18ddd81 165 * CAN peripheral.
mbed_official 126:549ba18ddd81 166 * @retval Constant indicates initialization succeed which will be
mbed_official 126:549ba18ddd81 167 * CAN_InitStatus_Failed or CAN_InitStatus_Success.
mbed_official 126:549ba18ddd81 168 */
mbed_official 126:549ba18ddd81 169 uint8_t CAN_Init(CAN_TypeDef* CANx, CAN_InitTypeDef* CAN_InitStruct)
mbed_official 126:549ba18ddd81 170 {
mbed_official 126:549ba18ddd81 171 uint8_t InitStatus = CAN_InitStatus_Failed;
mbed_official 126:549ba18ddd81 172 uint32_t wait_ack = 0x00000000;
mbed_official 126:549ba18ddd81 173 /* Check the parameters */
mbed_official 126:549ba18ddd81 174 assert_param(IS_CAN_ALL_PERIPH(CANx));
mbed_official 126:549ba18ddd81 175 assert_param(IS_FUNCTIONAL_STATE(CAN_InitStruct->CAN_TTCM));
mbed_official 126:549ba18ddd81 176 assert_param(IS_FUNCTIONAL_STATE(CAN_InitStruct->CAN_ABOM));
mbed_official 126:549ba18ddd81 177 assert_param(IS_FUNCTIONAL_STATE(CAN_InitStruct->CAN_AWUM));
mbed_official 126:549ba18ddd81 178 assert_param(IS_FUNCTIONAL_STATE(CAN_InitStruct->CAN_NART));
mbed_official 126:549ba18ddd81 179 assert_param(IS_FUNCTIONAL_STATE(CAN_InitStruct->CAN_RFLM));
mbed_official 126:549ba18ddd81 180 assert_param(IS_FUNCTIONAL_STATE(CAN_InitStruct->CAN_TXFP));
mbed_official 126:549ba18ddd81 181 assert_param(IS_CAN_MODE(CAN_InitStruct->CAN_Mode));
mbed_official 126:549ba18ddd81 182 assert_param(IS_CAN_SJW(CAN_InitStruct->CAN_SJW));
mbed_official 126:549ba18ddd81 183 assert_param(IS_CAN_BS1(CAN_InitStruct->CAN_BS1));
mbed_official 126:549ba18ddd81 184 assert_param(IS_CAN_BS2(CAN_InitStruct->CAN_BS2));
mbed_official 126:549ba18ddd81 185 assert_param(IS_CAN_PRESCALER(CAN_InitStruct->CAN_Prescaler));
mbed_official 126:549ba18ddd81 186
mbed_official 126:549ba18ddd81 187 /* Exit from sleep mode */
mbed_official 126:549ba18ddd81 188 CANx->MCR &= (~(uint32_t)CAN_MCR_SLEEP);
mbed_official 126:549ba18ddd81 189
mbed_official 126:549ba18ddd81 190 /* Request initialisation */
mbed_official 126:549ba18ddd81 191 CANx->MCR |= CAN_MCR_INRQ ;
mbed_official 126:549ba18ddd81 192
mbed_official 126:549ba18ddd81 193 /* Wait the acknowledge */
mbed_official 126:549ba18ddd81 194 while (((CANx->MSR & CAN_MSR_INAK) != CAN_MSR_INAK) && (wait_ack != INAK_TIMEOUT))
mbed_official 126:549ba18ddd81 195 {
mbed_official 126:549ba18ddd81 196 wait_ack++;
mbed_official 126:549ba18ddd81 197 }
mbed_official 126:549ba18ddd81 198
mbed_official 126:549ba18ddd81 199 /* Check acknowledge */
mbed_official 126:549ba18ddd81 200 if ((CANx->MSR & CAN_MSR_INAK) != CAN_MSR_INAK)
mbed_official 126:549ba18ddd81 201 {
mbed_official 126:549ba18ddd81 202 InitStatus = CAN_InitStatus_Failed;
mbed_official 126:549ba18ddd81 203 }
mbed_official 126:549ba18ddd81 204 else
mbed_official 126:549ba18ddd81 205 {
mbed_official 126:549ba18ddd81 206 /* Set the time triggered communication mode */
mbed_official 126:549ba18ddd81 207 if (CAN_InitStruct->CAN_TTCM == ENABLE)
mbed_official 126:549ba18ddd81 208 {
mbed_official 126:549ba18ddd81 209 CANx->MCR |= CAN_MCR_TTCM;
mbed_official 126:549ba18ddd81 210 }
mbed_official 126:549ba18ddd81 211 else
mbed_official 126:549ba18ddd81 212 {
mbed_official 126:549ba18ddd81 213 CANx->MCR &= ~(uint32_t)CAN_MCR_TTCM;
mbed_official 126:549ba18ddd81 214 }
mbed_official 126:549ba18ddd81 215
mbed_official 126:549ba18ddd81 216 /* Set the automatic bus-off management */
mbed_official 126:549ba18ddd81 217 if (CAN_InitStruct->CAN_ABOM == ENABLE)
mbed_official 126:549ba18ddd81 218 {
mbed_official 126:549ba18ddd81 219 CANx->MCR |= CAN_MCR_ABOM;
mbed_official 126:549ba18ddd81 220 }
mbed_official 126:549ba18ddd81 221 else
mbed_official 126:549ba18ddd81 222 {
mbed_official 126:549ba18ddd81 223 CANx->MCR &= ~(uint32_t)CAN_MCR_ABOM;
mbed_official 126:549ba18ddd81 224 }
mbed_official 126:549ba18ddd81 225
mbed_official 126:549ba18ddd81 226 /* Set the automatic wake-up mode */
mbed_official 126:549ba18ddd81 227 if (CAN_InitStruct->CAN_AWUM == ENABLE)
mbed_official 126:549ba18ddd81 228 {
mbed_official 126:549ba18ddd81 229 CANx->MCR |= CAN_MCR_AWUM;
mbed_official 126:549ba18ddd81 230 }
mbed_official 126:549ba18ddd81 231 else
mbed_official 126:549ba18ddd81 232 {
mbed_official 126:549ba18ddd81 233 CANx->MCR &= ~(uint32_t)CAN_MCR_AWUM;
mbed_official 126:549ba18ddd81 234 }
mbed_official 126:549ba18ddd81 235
mbed_official 126:549ba18ddd81 236 /* Set the no automatic retransmission */
mbed_official 126:549ba18ddd81 237 if (CAN_InitStruct->CAN_NART == ENABLE)
mbed_official 126:549ba18ddd81 238 {
mbed_official 126:549ba18ddd81 239 CANx->MCR |= CAN_MCR_NART;
mbed_official 126:549ba18ddd81 240 }
mbed_official 126:549ba18ddd81 241 else
mbed_official 126:549ba18ddd81 242 {
mbed_official 126:549ba18ddd81 243 CANx->MCR &= ~(uint32_t)CAN_MCR_NART;
mbed_official 126:549ba18ddd81 244 }
mbed_official 126:549ba18ddd81 245
mbed_official 126:549ba18ddd81 246 /* Set the receive FIFO locked mode */
mbed_official 126:549ba18ddd81 247 if (CAN_InitStruct->CAN_RFLM == ENABLE)
mbed_official 126:549ba18ddd81 248 {
mbed_official 126:549ba18ddd81 249 CANx->MCR |= CAN_MCR_RFLM;
mbed_official 126:549ba18ddd81 250 }
mbed_official 126:549ba18ddd81 251 else
mbed_official 126:549ba18ddd81 252 {
mbed_official 126:549ba18ddd81 253 CANx->MCR &= ~(uint32_t)CAN_MCR_RFLM;
mbed_official 126:549ba18ddd81 254 }
mbed_official 126:549ba18ddd81 255
mbed_official 126:549ba18ddd81 256 /* Set the transmit FIFO priority */
mbed_official 126:549ba18ddd81 257 if (CAN_InitStruct->CAN_TXFP == ENABLE)
mbed_official 126:549ba18ddd81 258 {
mbed_official 126:549ba18ddd81 259 CANx->MCR |= CAN_MCR_TXFP;
mbed_official 126:549ba18ddd81 260 }
mbed_official 126:549ba18ddd81 261 else
mbed_official 126:549ba18ddd81 262 {
mbed_official 126:549ba18ddd81 263 CANx->MCR &= ~(uint32_t)CAN_MCR_TXFP;
mbed_official 126:549ba18ddd81 264 }
mbed_official 126:549ba18ddd81 265
mbed_official 126:549ba18ddd81 266 /* Set the bit timing register */
mbed_official 126:549ba18ddd81 267 CANx->BTR = (uint32_t)((uint32_t)CAN_InitStruct->CAN_Mode << 30) | \
mbed_official 126:549ba18ddd81 268 ((uint32_t)CAN_InitStruct->CAN_SJW << 24) | \
mbed_official 126:549ba18ddd81 269 ((uint32_t)CAN_InitStruct->CAN_BS1 << 16) | \
mbed_official 126:549ba18ddd81 270 ((uint32_t)CAN_InitStruct->CAN_BS2 << 20) | \
mbed_official 126:549ba18ddd81 271 ((uint32_t)CAN_InitStruct->CAN_Prescaler - 1);
mbed_official 126:549ba18ddd81 272
mbed_official 126:549ba18ddd81 273 /* Request leave initialisation */
mbed_official 126:549ba18ddd81 274 CANx->MCR &= ~(uint32_t)CAN_MCR_INRQ;
mbed_official 126:549ba18ddd81 275
mbed_official 126:549ba18ddd81 276 /* Wait the acknowledge */
mbed_official 126:549ba18ddd81 277 wait_ack = 0;
mbed_official 126:549ba18ddd81 278
mbed_official 126:549ba18ddd81 279 while (((CANx->MSR & CAN_MSR_INAK) == CAN_MSR_INAK) && (wait_ack != INAK_TIMEOUT))
mbed_official 126:549ba18ddd81 280 {
mbed_official 126:549ba18ddd81 281 wait_ack++;
mbed_official 126:549ba18ddd81 282 }
mbed_official 126:549ba18ddd81 283
mbed_official 126:549ba18ddd81 284 /* ...and check acknowledged */
mbed_official 126:549ba18ddd81 285 if ((CANx->MSR & CAN_MSR_INAK) == CAN_MSR_INAK)
mbed_official 126:549ba18ddd81 286 {
mbed_official 126:549ba18ddd81 287 InitStatus = CAN_InitStatus_Failed;
mbed_official 126:549ba18ddd81 288 }
mbed_official 126:549ba18ddd81 289 else
mbed_official 126:549ba18ddd81 290 {
mbed_official 126:549ba18ddd81 291 InitStatus = CAN_InitStatus_Success ;
mbed_official 126:549ba18ddd81 292 }
mbed_official 126:549ba18ddd81 293 }
mbed_official 126:549ba18ddd81 294
mbed_official 126:549ba18ddd81 295 /* At this step, return the status of initialization */
mbed_official 126:549ba18ddd81 296 return InitStatus;
mbed_official 126:549ba18ddd81 297 }
mbed_official 126:549ba18ddd81 298
mbed_official 126:549ba18ddd81 299 /**
mbed_official 126:549ba18ddd81 300 * @brief Initializes the CAN peripheral according to the specified
mbed_official 126:549ba18ddd81 301 * parameters in the CAN_FilterInitStruct.
mbed_official 126:549ba18ddd81 302 * @param CAN_FilterInitStruct: pointer to a CAN_FilterInitTypeDef
mbed_official 126:549ba18ddd81 303 * structure that contains the configuration
mbed_official 126:549ba18ddd81 304 * information.
mbed_official 126:549ba18ddd81 305 * @retval None.
mbed_official 126:549ba18ddd81 306 */
mbed_official 126:549ba18ddd81 307 void CAN_FilterInit(CAN_FilterInitTypeDef* CAN_FilterInitStruct)
mbed_official 126:549ba18ddd81 308 {
mbed_official 126:549ba18ddd81 309 uint32_t filter_number_bit_pos = 0;
mbed_official 126:549ba18ddd81 310 /* Check the parameters */
mbed_official 126:549ba18ddd81 311 assert_param(IS_CAN_FILTER_NUMBER(CAN_FilterInitStruct->CAN_FilterNumber));
mbed_official 126:549ba18ddd81 312 assert_param(IS_CAN_FILTER_MODE(CAN_FilterInitStruct->CAN_FilterMode));
mbed_official 126:549ba18ddd81 313 assert_param(IS_CAN_FILTER_SCALE(CAN_FilterInitStruct->CAN_FilterScale));
mbed_official 126:549ba18ddd81 314 assert_param(IS_CAN_FILTER_FIFO(CAN_FilterInitStruct->CAN_FilterFIFOAssignment));
mbed_official 126:549ba18ddd81 315 assert_param(IS_FUNCTIONAL_STATE(CAN_FilterInitStruct->CAN_FilterActivation));
mbed_official 126:549ba18ddd81 316
mbed_official 126:549ba18ddd81 317 filter_number_bit_pos = ((uint32_t)1) << CAN_FilterInitStruct->CAN_FilterNumber;
mbed_official 126:549ba18ddd81 318
mbed_official 126:549ba18ddd81 319 /* Initialisation mode for the filter */
mbed_official 126:549ba18ddd81 320 CAN1->FMR |= FMR_FINIT;
mbed_official 126:549ba18ddd81 321
mbed_official 126:549ba18ddd81 322 /* Filter Deactivation */
mbed_official 126:549ba18ddd81 323 CAN1->FA1R &= ~(uint32_t)filter_number_bit_pos;
mbed_official 126:549ba18ddd81 324
mbed_official 126:549ba18ddd81 325 /* Filter Scale */
mbed_official 126:549ba18ddd81 326 if (CAN_FilterInitStruct->CAN_FilterScale == CAN_FilterScale_16bit)
mbed_official 126:549ba18ddd81 327 {
mbed_official 126:549ba18ddd81 328 /* 16-bit scale for the filter */
mbed_official 126:549ba18ddd81 329 CAN1->FS1R &= ~(uint32_t)filter_number_bit_pos;
mbed_official 126:549ba18ddd81 330
mbed_official 126:549ba18ddd81 331 /* First 16-bit identifier and First 16-bit mask */
mbed_official 126:549ba18ddd81 332 /* Or First 16-bit identifier and Second 16-bit identifier */
mbed_official 126:549ba18ddd81 333 CAN1->sFilterRegister[CAN_FilterInitStruct->CAN_FilterNumber].FR1 =
mbed_official 126:549ba18ddd81 334 ((0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterMaskIdLow) << 16) |
mbed_official 126:549ba18ddd81 335 (0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterIdLow);
mbed_official 126:549ba18ddd81 336
mbed_official 126:549ba18ddd81 337 /* Second 16-bit identifier and Second 16-bit mask */
mbed_official 126:549ba18ddd81 338 /* Or Third 16-bit identifier and Fourth 16-bit identifier */
mbed_official 126:549ba18ddd81 339 CAN1->sFilterRegister[CAN_FilterInitStruct->CAN_FilterNumber].FR2 =
mbed_official 126:549ba18ddd81 340 ((0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterMaskIdHigh) << 16) |
mbed_official 126:549ba18ddd81 341 (0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterIdHigh);
mbed_official 126:549ba18ddd81 342 }
mbed_official 126:549ba18ddd81 343
mbed_official 126:549ba18ddd81 344 if (CAN_FilterInitStruct->CAN_FilterScale == CAN_FilterScale_32bit)
mbed_official 126:549ba18ddd81 345 {
mbed_official 126:549ba18ddd81 346 /* 32-bit scale for the filter */
mbed_official 126:549ba18ddd81 347 CAN1->FS1R |= filter_number_bit_pos;
mbed_official 126:549ba18ddd81 348 /* 32-bit identifier or First 32-bit identifier */
mbed_official 126:549ba18ddd81 349 CAN1->sFilterRegister[CAN_FilterInitStruct->CAN_FilterNumber].FR1 =
mbed_official 126:549ba18ddd81 350 ((0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterIdHigh) << 16) |
mbed_official 126:549ba18ddd81 351 (0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterIdLow);
mbed_official 126:549ba18ddd81 352 /* 32-bit mask or Second 32-bit identifier */
mbed_official 126:549ba18ddd81 353 CAN1->sFilterRegister[CAN_FilterInitStruct->CAN_FilterNumber].FR2 =
mbed_official 126:549ba18ddd81 354 ((0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterMaskIdHigh) << 16) |
mbed_official 126:549ba18ddd81 355 (0x0000FFFF & (uint32_t)CAN_FilterInitStruct->CAN_FilterMaskIdLow);
mbed_official 126:549ba18ddd81 356 }
mbed_official 126:549ba18ddd81 357
mbed_official 126:549ba18ddd81 358 /* Filter Mode */
mbed_official 126:549ba18ddd81 359 if (CAN_FilterInitStruct->CAN_FilterMode == CAN_FilterMode_IdMask)
mbed_official 126:549ba18ddd81 360 {
mbed_official 126:549ba18ddd81 361 /*Id/Mask mode for the filter*/
mbed_official 126:549ba18ddd81 362 CAN1->FM1R &= ~(uint32_t)filter_number_bit_pos;
mbed_official 126:549ba18ddd81 363 }
mbed_official 126:549ba18ddd81 364 else /* CAN_FilterInitStruct->CAN_FilterMode == CAN_FilterMode_IdList */
mbed_official 126:549ba18ddd81 365 {
mbed_official 126:549ba18ddd81 366 /*Identifier list mode for the filter*/
mbed_official 126:549ba18ddd81 367 CAN1->FM1R |= (uint32_t)filter_number_bit_pos;
mbed_official 126:549ba18ddd81 368 }
mbed_official 126:549ba18ddd81 369
mbed_official 126:549ba18ddd81 370 /* Filter FIFO assignment */
mbed_official 126:549ba18ddd81 371 if (CAN_FilterInitStruct->CAN_FilterFIFOAssignment == CAN_Filter_FIFO0)
mbed_official 126:549ba18ddd81 372 {
mbed_official 126:549ba18ddd81 373 /* FIFO 0 assignation for the filter */
mbed_official 126:549ba18ddd81 374 CAN1->FFA1R &= ~(uint32_t)filter_number_bit_pos;
mbed_official 126:549ba18ddd81 375 }
mbed_official 126:549ba18ddd81 376
mbed_official 126:549ba18ddd81 377 if (CAN_FilterInitStruct->CAN_FilterFIFOAssignment == CAN_Filter_FIFO1)
mbed_official 126:549ba18ddd81 378 {
mbed_official 126:549ba18ddd81 379 /* FIFO 1 assignation for the filter */
mbed_official 126:549ba18ddd81 380 CAN1->FFA1R |= (uint32_t)filter_number_bit_pos;
mbed_official 126:549ba18ddd81 381 }
mbed_official 126:549ba18ddd81 382
mbed_official 126:549ba18ddd81 383 /* Filter activation */
mbed_official 126:549ba18ddd81 384 if (CAN_FilterInitStruct->CAN_FilterActivation == ENABLE)
mbed_official 126:549ba18ddd81 385 {
mbed_official 126:549ba18ddd81 386 CAN1->FA1R |= filter_number_bit_pos;
mbed_official 126:549ba18ddd81 387 }
mbed_official 126:549ba18ddd81 388
mbed_official 126:549ba18ddd81 389 /* Leave the initialisation mode for the filter */
mbed_official 126:549ba18ddd81 390 CAN1->FMR &= ~FMR_FINIT;
mbed_official 126:549ba18ddd81 391 }
mbed_official 126:549ba18ddd81 392
mbed_official 126:549ba18ddd81 393 /**
mbed_official 126:549ba18ddd81 394 * @brief Fills each CAN_InitStruct member with its default value.
mbed_official 126:549ba18ddd81 395 * @param CAN_InitStruct: pointer to a CAN_InitTypeDef structure which
mbed_official 126:549ba18ddd81 396 * will be initialized.
mbed_official 126:549ba18ddd81 397 * @retval None.
mbed_official 126:549ba18ddd81 398 */
mbed_official 126:549ba18ddd81 399 void CAN_StructInit(CAN_InitTypeDef* CAN_InitStruct)
mbed_official 126:549ba18ddd81 400 {
mbed_official 126:549ba18ddd81 401 /* Reset CAN init structure parameters values */
mbed_official 126:549ba18ddd81 402
mbed_official 126:549ba18ddd81 403 /* Initialize the time triggered communication mode */
mbed_official 126:549ba18ddd81 404 CAN_InitStruct->CAN_TTCM = DISABLE;
mbed_official 126:549ba18ddd81 405
mbed_official 126:549ba18ddd81 406 /* Initialize the automatic bus-off management */
mbed_official 126:549ba18ddd81 407 CAN_InitStruct->CAN_ABOM = DISABLE;
mbed_official 126:549ba18ddd81 408
mbed_official 126:549ba18ddd81 409 /* Initialize the automatic wake-up mode */
mbed_official 126:549ba18ddd81 410 CAN_InitStruct->CAN_AWUM = DISABLE;
mbed_official 126:549ba18ddd81 411
mbed_official 126:549ba18ddd81 412 /* Initialize the no automatic retransmission */
mbed_official 126:549ba18ddd81 413 CAN_InitStruct->CAN_NART = DISABLE;
mbed_official 126:549ba18ddd81 414
mbed_official 126:549ba18ddd81 415 /* Initialize the receive FIFO locked mode */
mbed_official 126:549ba18ddd81 416 CAN_InitStruct->CAN_RFLM = DISABLE;
mbed_official 126:549ba18ddd81 417
mbed_official 126:549ba18ddd81 418 /* Initialize the transmit FIFO priority */
mbed_official 126:549ba18ddd81 419 CAN_InitStruct->CAN_TXFP = DISABLE;
mbed_official 126:549ba18ddd81 420
mbed_official 126:549ba18ddd81 421 /* Initialize the CAN_Mode member */
mbed_official 126:549ba18ddd81 422 CAN_InitStruct->CAN_Mode = CAN_Mode_Normal;
mbed_official 126:549ba18ddd81 423
mbed_official 126:549ba18ddd81 424 /* Initialize the CAN_SJW member */
mbed_official 126:549ba18ddd81 425 CAN_InitStruct->CAN_SJW = CAN_SJW_1tq;
mbed_official 126:549ba18ddd81 426
mbed_official 126:549ba18ddd81 427 /* Initialize the CAN_BS1 member */
mbed_official 126:549ba18ddd81 428 CAN_InitStruct->CAN_BS1 = CAN_BS1_4tq;
mbed_official 126:549ba18ddd81 429
mbed_official 126:549ba18ddd81 430 /* Initialize the CAN_BS2 member */
mbed_official 126:549ba18ddd81 431 CAN_InitStruct->CAN_BS2 = CAN_BS2_3tq;
mbed_official 126:549ba18ddd81 432
mbed_official 126:549ba18ddd81 433 /* Initialize the CAN_Prescaler member */
mbed_official 126:549ba18ddd81 434 CAN_InitStruct->CAN_Prescaler = 1;
mbed_official 126:549ba18ddd81 435 }
mbed_official 126:549ba18ddd81 436
mbed_official 126:549ba18ddd81 437 /**
mbed_official 126:549ba18ddd81 438 * @brief Select the start bank filter for slave CAN.
mbed_official 126:549ba18ddd81 439 * @note This function applies only to STM32 Connectivity line devices.
mbed_official 126:549ba18ddd81 440 * @param CAN_BankNumber: Select the start slave bank filter from 1..27.
mbed_official 126:549ba18ddd81 441 * @retval None.
mbed_official 126:549ba18ddd81 442 */
mbed_official 126:549ba18ddd81 443 void CAN_SlaveStartBank(uint8_t CAN_BankNumber)
mbed_official 126:549ba18ddd81 444 {
mbed_official 126:549ba18ddd81 445 /* Check the parameters */
mbed_official 126:549ba18ddd81 446 assert_param(IS_CAN_BANKNUMBER(CAN_BankNumber));
mbed_official 126:549ba18ddd81 447
mbed_official 126:549ba18ddd81 448 /* Enter Initialisation mode for the filter */
mbed_official 126:549ba18ddd81 449 CAN1->FMR |= FMR_FINIT;
mbed_official 126:549ba18ddd81 450
mbed_official 126:549ba18ddd81 451 /* Select the start slave bank */
mbed_official 126:549ba18ddd81 452 CAN1->FMR &= (uint32_t)0xFFFFC0F1 ;
mbed_official 126:549ba18ddd81 453 CAN1->FMR |= (uint32_t)(CAN_BankNumber)<<8;
mbed_official 126:549ba18ddd81 454
mbed_official 126:549ba18ddd81 455 /* Leave Initialisation mode for the filter */
mbed_official 126:549ba18ddd81 456 CAN1->FMR &= ~FMR_FINIT;
mbed_official 126:549ba18ddd81 457 }
mbed_official 126:549ba18ddd81 458
mbed_official 126:549ba18ddd81 459 /**
mbed_official 126:549ba18ddd81 460 * @brief Enables or disables the DBG Freeze for CAN.
mbed_official 126:549ba18ddd81 461 * @param CANx: where x can be 1 or 2 to to select the CAN peripheral.
mbed_official 126:549ba18ddd81 462 * @param NewState: new state of the CAN peripheral. This parameter can
mbed_official 126:549ba18ddd81 463 * be: ENABLE or DISABLE.
mbed_official 126:549ba18ddd81 464 * @retval None.
mbed_official 126:549ba18ddd81 465 */
mbed_official 126:549ba18ddd81 466 void CAN_DBGFreeze(CAN_TypeDef* CANx, FunctionalState NewState)
mbed_official 126:549ba18ddd81 467 {
mbed_official 126:549ba18ddd81 468 /* Check the parameters */
mbed_official 126:549ba18ddd81 469 assert_param(IS_CAN_ALL_PERIPH(CANx));
mbed_official 126:549ba18ddd81 470 assert_param(IS_FUNCTIONAL_STATE(NewState));
mbed_official 126:549ba18ddd81 471
mbed_official 126:549ba18ddd81 472 if (NewState != DISABLE)
mbed_official 126:549ba18ddd81 473 {
mbed_official 126:549ba18ddd81 474 /* Enable Debug Freeze */
mbed_official 126:549ba18ddd81 475 CANx->MCR |= MCR_DBF;
mbed_official 126:549ba18ddd81 476 }
mbed_official 126:549ba18ddd81 477 else
mbed_official 126:549ba18ddd81 478 {
mbed_official 126:549ba18ddd81 479 /* Disable Debug Freeze */
mbed_official 126:549ba18ddd81 480 CANx->MCR &= ~MCR_DBF;
mbed_official 126:549ba18ddd81 481 }
mbed_official 126:549ba18ddd81 482 }
mbed_official 126:549ba18ddd81 483
mbed_official 126:549ba18ddd81 484
mbed_official 126:549ba18ddd81 485 /**
mbed_official 126:549ba18ddd81 486 * @brief Enables or disabes the CAN Time TriggerOperation communication mode.
mbed_official 126:549ba18ddd81 487 * @param CANx: where x can be 1 or 2 to to select the CAN peripheral.
mbed_official 126:549ba18ddd81 488 * @param NewState : Mode new state , can be one of @ref FunctionalState.
mbed_official 126:549ba18ddd81 489 * @note when enabled, Time stamp (TIME[15:0]) value is sent in the last
mbed_official 126:549ba18ddd81 490 * two data bytes of the 8-byte message: TIME[7:0] in data byte 6
mbed_official 126:549ba18ddd81 491 * and TIME[15:8] in data byte 7
mbed_official 126:549ba18ddd81 492 * @note DLC must be programmed as 8 in order Time Stamp (2 bytes) to be
mbed_official 126:549ba18ddd81 493 * sent over the CAN bus.
mbed_official 126:549ba18ddd81 494 * @retval None
mbed_official 126:549ba18ddd81 495 */
mbed_official 126:549ba18ddd81 496 void CAN_TTComModeCmd(CAN_TypeDef* CANx, FunctionalState NewState)
mbed_official 126:549ba18ddd81 497 {
mbed_official 126:549ba18ddd81 498 /* Check the parameters */
mbed_official 126:549ba18ddd81 499 assert_param(IS_CAN_ALL_PERIPH(CANx));
mbed_official 126:549ba18ddd81 500 assert_param(IS_FUNCTIONAL_STATE(NewState));
mbed_official 126:549ba18ddd81 501 if (NewState != DISABLE)
mbed_official 126:549ba18ddd81 502 {
mbed_official 126:549ba18ddd81 503 /* Enable the TTCM mode */
mbed_official 126:549ba18ddd81 504 CANx->MCR |= CAN_MCR_TTCM;
mbed_official 126:549ba18ddd81 505
mbed_official 126:549ba18ddd81 506 /* Set TGT bits */
mbed_official 126:549ba18ddd81 507 CANx->sTxMailBox[0].TDTR |= ((uint32_t)CAN_TDT0R_TGT);
mbed_official 126:549ba18ddd81 508 CANx->sTxMailBox[1].TDTR |= ((uint32_t)CAN_TDT1R_TGT);
mbed_official 126:549ba18ddd81 509 CANx->sTxMailBox[2].TDTR |= ((uint32_t)CAN_TDT2R_TGT);
mbed_official 126:549ba18ddd81 510 }
mbed_official 126:549ba18ddd81 511 else
mbed_official 126:549ba18ddd81 512 {
mbed_official 126:549ba18ddd81 513 /* Disable the TTCM mode */
mbed_official 126:549ba18ddd81 514 CANx->MCR &= (uint32_t)(~(uint32_t)CAN_MCR_TTCM);
mbed_official 126:549ba18ddd81 515
mbed_official 126:549ba18ddd81 516 /* Reset TGT bits */
mbed_official 126:549ba18ddd81 517 CANx->sTxMailBox[0].TDTR &= ((uint32_t)~CAN_TDT0R_TGT);
mbed_official 126:549ba18ddd81 518 CANx->sTxMailBox[1].TDTR &= ((uint32_t)~CAN_TDT1R_TGT);
mbed_official 126:549ba18ddd81 519 CANx->sTxMailBox[2].TDTR &= ((uint32_t)~CAN_TDT2R_TGT);
mbed_official 126:549ba18ddd81 520 }
mbed_official 126:549ba18ddd81 521 }
mbed_official 126:549ba18ddd81 522 /**
mbed_official 126:549ba18ddd81 523 * @brief Initiates the transmission of a message.
mbed_official 126:549ba18ddd81 524 * @param CANx: where x can be 1 or 2 to to select the CAN peripheral.
mbed_official 126:549ba18ddd81 525 * @param TxMessage: pointer to a structure which contains CAN Id, CAN
mbed_official 126:549ba18ddd81 526 * DLC and CAN data.
mbed_official 126:549ba18ddd81 527 * @retval The number of the mailbox that is used for transmission
mbed_official 126:549ba18ddd81 528 * or CAN_TxStatus_NoMailBox if there is no empty mailbox.
mbed_official 126:549ba18ddd81 529 */
mbed_official 126:549ba18ddd81 530 uint8_t CAN_Transmit(CAN_TypeDef* CANx, CanTxMsg* TxMessage)
mbed_official 126:549ba18ddd81 531 {
mbed_official 126:549ba18ddd81 532 uint8_t transmit_mailbox = 0;
mbed_official 126:549ba18ddd81 533 /* Check the parameters */
mbed_official 126:549ba18ddd81 534 assert_param(IS_CAN_ALL_PERIPH(CANx));
mbed_official 126:549ba18ddd81 535 assert_param(IS_CAN_IDTYPE(TxMessage->IDE));
mbed_official 126:549ba18ddd81 536 assert_param(IS_CAN_RTR(TxMessage->RTR));
mbed_official 126:549ba18ddd81 537 assert_param(IS_CAN_DLC(TxMessage->DLC));
mbed_official 126:549ba18ddd81 538
mbed_official 126:549ba18ddd81 539 /* Select one empty transmit mailbox */
mbed_official 126:549ba18ddd81 540 if ((CANx->TSR&CAN_TSR_TME0) == CAN_TSR_TME0)
mbed_official 126:549ba18ddd81 541 {
mbed_official 126:549ba18ddd81 542 transmit_mailbox = 0;
mbed_official 126:549ba18ddd81 543 }
mbed_official 126:549ba18ddd81 544 else if ((CANx->TSR&CAN_TSR_TME1) == CAN_TSR_TME1)
mbed_official 126:549ba18ddd81 545 {
mbed_official 126:549ba18ddd81 546 transmit_mailbox = 1;
mbed_official 126:549ba18ddd81 547 }
mbed_official 126:549ba18ddd81 548 else if ((CANx->TSR&CAN_TSR_TME2) == CAN_TSR_TME2)
mbed_official 126:549ba18ddd81 549 {
mbed_official 126:549ba18ddd81 550 transmit_mailbox = 2;
mbed_official 126:549ba18ddd81 551 }
mbed_official 126:549ba18ddd81 552 else
mbed_official 126:549ba18ddd81 553 {
mbed_official 126:549ba18ddd81 554 transmit_mailbox = CAN_TxStatus_NoMailBox;
mbed_official 126:549ba18ddd81 555 }
mbed_official 126:549ba18ddd81 556
mbed_official 126:549ba18ddd81 557 if (transmit_mailbox != CAN_TxStatus_NoMailBox)
mbed_official 126:549ba18ddd81 558 {
mbed_official 126:549ba18ddd81 559 /* Set up the Id */
mbed_official 126:549ba18ddd81 560 CANx->sTxMailBox[transmit_mailbox].TIR &= TMIDxR_TXRQ;
mbed_official 126:549ba18ddd81 561 if (TxMessage->IDE == CAN_Id_Standard)
mbed_official 126:549ba18ddd81 562 {
mbed_official 126:549ba18ddd81 563 assert_param(IS_CAN_STDID(TxMessage->StdId));
mbed_official 126:549ba18ddd81 564 CANx->sTxMailBox[transmit_mailbox].TIR |= ((TxMessage->StdId << 21) | \
mbed_official 126:549ba18ddd81 565 TxMessage->RTR);
mbed_official 126:549ba18ddd81 566 }
mbed_official 126:549ba18ddd81 567 else
mbed_official 126:549ba18ddd81 568 {
mbed_official 126:549ba18ddd81 569 assert_param(IS_CAN_EXTID(TxMessage->ExtId));
mbed_official 126:549ba18ddd81 570 CANx->sTxMailBox[transmit_mailbox].TIR |= ((TxMessage->ExtId << 3) | \
mbed_official 126:549ba18ddd81 571 TxMessage->IDE | \
mbed_official 126:549ba18ddd81 572 TxMessage->RTR);
mbed_official 126:549ba18ddd81 573 }
mbed_official 126:549ba18ddd81 574
mbed_official 126:549ba18ddd81 575 /* Set up the DLC */
mbed_official 126:549ba18ddd81 576 TxMessage->DLC &= (uint8_t)0x0000000F;
mbed_official 126:549ba18ddd81 577 CANx->sTxMailBox[transmit_mailbox].TDTR &= (uint32_t)0xFFFFFFF0;
mbed_official 126:549ba18ddd81 578 CANx->sTxMailBox[transmit_mailbox].TDTR |= TxMessage->DLC;
mbed_official 126:549ba18ddd81 579
mbed_official 126:549ba18ddd81 580 /* Set up the data field */
mbed_official 126:549ba18ddd81 581 CANx->sTxMailBox[transmit_mailbox].TDLR = (((uint32_t)TxMessage->Data[3] << 24) |
mbed_official 126:549ba18ddd81 582 ((uint32_t)TxMessage->Data[2] << 16) |
mbed_official 126:549ba18ddd81 583 ((uint32_t)TxMessage->Data[1] << 8) |
mbed_official 126:549ba18ddd81 584 ((uint32_t)TxMessage->Data[0]));
mbed_official 126:549ba18ddd81 585 CANx->sTxMailBox[transmit_mailbox].TDHR = (((uint32_t)TxMessage->Data[7] << 24) |
mbed_official 126:549ba18ddd81 586 ((uint32_t)TxMessage->Data[6] << 16) |
mbed_official 126:549ba18ddd81 587 ((uint32_t)TxMessage->Data[5] << 8) |
mbed_official 126:549ba18ddd81 588 ((uint32_t)TxMessage->Data[4]));
mbed_official 126:549ba18ddd81 589 /* Request transmission */
mbed_official 126:549ba18ddd81 590 CANx->sTxMailBox[transmit_mailbox].TIR |= TMIDxR_TXRQ;
mbed_official 126:549ba18ddd81 591 }
mbed_official 126:549ba18ddd81 592 return transmit_mailbox;
mbed_official 126:549ba18ddd81 593 }
mbed_official 126:549ba18ddd81 594
mbed_official 126:549ba18ddd81 595 /**
mbed_official 126:549ba18ddd81 596 * @brief Checks the transmission of a message.
mbed_official 126:549ba18ddd81 597 * @param CANx: where x can be 1 or 2 to to select the
mbed_official 126:549ba18ddd81 598 * CAN peripheral.
mbed_official 126:549ba18ddd81 599 * @param TransmitMailbox: the number of the mailbox that is used for
mbed_official 126:549ba18ddd81 600 * transmission.
mbed_official 126:549ba18ddd81 601 * @retval CAN_TxStatus_Ok if the CAN driver transmits the message, CAN_TxStatus_Failed
mbed_official 126:549ba18ddd81 602 * in an other case.
mbed_official 126:549ba18ddd81 603 */
mbed_official 126:549ba18ddd81 604 uint8_t CAN_TransmitStatus(CAN_TypeDef* CANx, uint8_t TransmitMailbox)
mbed_official 126:549ba18ddd81 605 {
mbed_official 126:549ba18ddd81 606 uint32_t state = 0;
mbed_official 126:549ba18ddd81 607
mbed_official 126:549ba18ddd81 608 /* Check the parameters */
mbed_official 126:549ba18ddd81 609 assert_param(IS_CAN_ALL_PERIPH(CANx));
mbed_official 126:549ba18ddd81 610 assert_param(IS_CAN_TRANSMITMAILBOX(TransmitMailbox));
mbed_official 126:549ba18ddd81 611
mbed_official 126:549ba18ddd81 612 switch (TransmitMailbox)
mbed_official 126:549ba18ddd81 613 {
mbed_official 126:549ba18ddd81 614 case (CAN_TXMAILBOX_0):
mbed_official 126:549ba18ddd81 615 state = CANx->TSR & (CAN_TSR_RQCP0 | CAN_TSR_TXOK0 | CAN_TSR_TME0);
mbed_official 126:549ba18ddd81 616 break;
mbed_official 126:549ba18ddd81 617 case (CAN_TXMAILBOX_1):
mbed_official 126:549ba18ddd81 618 state = CANx->TSR & (CAN_TSR_RQCP1 | CAN_TSR_TXOK1 | CAN_TSR_TME1);
mbed_official 126:549ba18ddd81 619 break;
mbed_official 126:549ba18ddd81 620 case (CAN_TXMAILBOX_2):
mbed_official 126:549ba18ddd81 621 state = CANx->TSR & (CAN_TSR_RQCP2 | CAN_TSR_TXOK2 | CAN_TSR_TME2);
mbed_official 126:549ba18ddd81 622 break;
mbed_official 126:549ba18ddd81 623 default:
mbed_official 126:549ba18ddd81 624 state = CAN_TxStatus_Failed;
mbed_official 126:549ba18ddd81 625 break;
mbed_official 126:549ba18ddd81 626 }
mbed_official 126:549ba18ddd81 627 switch (state)
mbed_official 126:549ba18ddd81 628 {
mbed_official 126:549ba18ddd81 629 /* transmit pending */
mbed_official 126:549ba18ddd81 630 case (0x0): state = CAN_TxStatus_Pending;
mbed_official 126:549ba18ddd81 631 break;
mbed_official 126:549ba18ddd81 632 /* transmit failed */
mbed_official 126:549ba18ddd81 633 case (CAN_TSR_RQCP0 | CAN_TSR_TME0): state = CAN_TxStatus_Failed;
mbed_official 126:549ba18ddd81 634 break;
mbed_official 126:549ba18ddd81 635 case (CAN_TSR_RQCP1 | CAN_TSR_TME1): state = CAN_TxStatus_Failed;
mbed_official 126:549ba18ddd81 636 break;
mbed_official 126:549ba18ddd81 637 case (CAN_TSR_RQCP2 | CAN_TSR_TME2): state = CAN_TxStatus_Failed;
mbed_official 126:549ba18ddd81 638 break;
mbed_official 126:549ba18ddd81 639 /* transmit succeeded */
mbed_official 126:549ba18ddd81 640 case (CAN_TSR_RQCP0 | CAN_TSR_TXOK0 | CAN_TSR_TME0):state = CAN_TxStatus_Ok;
mbed_official 126:549ba18ddd81 641 break;
mbed_official 126:549ba18ddd81 642 case (CAN_TSR_RQCP1 | CAN_TSR_TXOK1 | CAN_TSR_TME1):state = CAN_TxStatus_Ok;
mbed_official 126:549ba18ddd81 643 break;
mbed_official 126:549ba18ddd81 644 case (CAN_TSR_RQCP2 | CAN_TSR_TXOK2 | CAN_TSR_TME2):state = CAN_TxStatus_Ok;
mbed_official 126:549ba18ddd81 645 break;
mbed_official 126:549ba18ddd81 646 default: state = CAN_TxStatus_Failed;
mbed_official 126:549ba18ddd81 647 break;
mbed_official 126:549ba18ddd81 648 }
mbed_official 126:549ba18ddd81 649 return (uint8_t) state;
mbed_official 126:549ba18ddd81 650 }
mbed_official 126:549ba18ddd81 651
mbed_official 126:549ba18ddd81 652 /**
mbed_official 126:549ba18ddd81 653 * @brief Cancels a transmit request.
mbed_official 126:549ba18ddd81 654 * @param CANx: where x can be 1 or 2 to to select the CAN peripheral.
mbed_official 126:549ba18ddd81 655 * @param Mailbox: Mailbox number.
mbed_official 126:549ba18ddd81 656 * @retval None.
mbed_official 126:549ba18ddd81 657 */
mbed_official 126:549ba18ddd81 658 void CAN_CancelTransmit(CAN_TypeDef* CANx, uint8_t Mailbox)
mbed_official 126:549ba18ddd81 659 {
mbed_official 126:549ba18ddd81 660 /* Check the parameters */
mbed_official 126:549ba18ddd81 661 assert_param(IS_CAN_ALL_PERIPH(CANx));
mbed_official 126:549ba18ddd81 662 assert_param(IS_CAN_TRANSMITMAILBOX(Mailbox));
mbed_official 126:549ba18ddd81 663 /* abort transmission */
mbed_official 126:549ba18ddd81 664 switch (Mailbox)
mbed_official 126:549ba18ddd81 665 {
mbed_official 126:549ba18ddd81 666 case (CAN_TXMAILBOX_0): CANx->TSR |= CAN_TSR_ABRQ0;
mbed_official 126:549ba18ddd81 667 break;
mbed_official 126:549ba18ddd81 668 case (CAN_TXMAILBOX_1): CANx->TSR |= CAN_TSR_ABRQ1;
mbed_official 126:549ba18ddd81 669 break;
mbed_official 126:549ba18ddd81 670 case (CAN_TXMAILBOX_2): CANx->TSR |= CAN_TSR_ABRQ2;
mbed_official 126:549ba18ddd81 671 break;
mbed_official 126:549ba18ddd81 672 default:
mbed_official 126:549ba18ddd81 673 break;
mbed_official 126:549ba18ddd81 674 }
mbed_official 126:549ba18ddd81 675 }
mbed_official 126:549ba18ddd81 676
mbed_official 126:549ba18ddd81 677
mbed_official 126:549ba18ddd81 678 /**
mbed_official 126:549ba18ddd81 679 * @brief Receives a message.
mbed_official 126:549ba18ddd81 680 * @param CANx: where x can be 1 or 2 to to select the CAN peripheral.
mbed_official 126:549ba18ddd81 681 * @param FIFONumber: Receive FIFO number, CAN_FIFO0 or CAN_FIFO1.
mbed_official 126:549ba18ddd81 682 * @param RxMessage: pointer to a structure receive message which contains
mbed_official 126:549ba18ddd81 683 * CAN Id, CAN DLC, CAN datas and FMI number.
mbed_official 126:549ba18ddd81 684 * @retval None.
mbed_official 126:549ba18ddd81 685 */
mbed_official 126:549ba18ddd81 686 void CAN_Receive(CAN_TypeDef* CANx, uint8_t FIFONumber, CanRxMsg* RxMessage)
mbed_official 126:549ba18ddd81 687 {
mbed_official 126:549ba18ddd81 688 /* Check the parameters */
mbed_official 126:549ba18ddd81 689 assert_param(IS_CAN_ALL_PERIPH(CANx));
mbed_official 126:549ba18ddd81 690 assert_param(IS_CAN_FIFO(FIFONumber));
mbed_official 126:549ba18ddd81 691 /* Get the Id */
mbed_official 126:549ba18ddd81 692 RxMessage->IDE = (uint8_t)0x04 & CANx->sFIFOMailBox[FIFONumber].RIR;
mbed_official 126:549ba18ddd81 693 if (RxMessage->IDE == CAN_Id_Standard)
mbed_official 126:549ba18ddd81 694 {
mbed_official 126:549ba18ddd81 695 RxMessage->StdId = (uint32_t)0x000007FF & (CANx->sFIFOMailBox[FIFONumber].RIR >> 21);
mbed_official 126:549ba18ddd81 696 }
mbed_official 126:549ba18ddd81 697 else
mbed_official 126:549ba18ddd81 698 {
mbed_official 126:549ba18ddd81 699 RxMessage->ExtId = (uint32_t)0x1FFFFFFF & (CANx->sFIFOMailBox[FIFONumber].RIR >> 3);
mbed_official 126:549ba18ddd81 700 }
mbed_official 126:549ba18ddd81 701
mbed_official 126:549ba18ddd81 702 RxMessage->RTR = (uint8_t)0x02 & CANx->sFIFOMailBox[FIFONumber].RIR;
mbed_official 126:549ba18ddd81 703 /* Get the DLC */
mbed_official 126:549ba18ddd81 704 RxMessage->DLC = (uint8_t)0x0F & CANx->sFIFOMailBox[FIFONumber].RDTR;
mbed_official 126:549ba18ddd81 705 /* Get the FMI */
mbed_official 126:549ba18ddd81 706 RxMessage->FMI = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDTR >> 8);
mbed_official 126:549ba18ddd81 707 /* Get the data field */
mbed_official 126:549ba18ddd81 708 RxMessage->Data[0] = (uint8_t)0xFF & CANx->sFIFOMailBox[FIFONumber].RDLR;
mbed_official 126:549ba18ddd81 709 RxMessage->Data[1] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDLR >> 8);
mbed_official 126:549ba18ddd81 710 RxMessage->Data[2] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDLR >> 16);
mbed_official 126:549ba18ddd81 711 RxMessage->Data[3] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDLR >> 24);
mbed_official 126:549ba18ddd81 712 RxMessage->Data[4] = (uint8_t)0xFF & CANx->sFIFOMailBox[FIFONumber].RDHR;
mbed_official 126:549ba18ddd81 713 RxMessage->Data[5] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDHR >> 8);
mbed_official 126:549ba18ddd81 714 RxMessage->Data[6] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDHR >> 16);
mbed_official 126:549ba18ddd81 715 RxMessage->Data[7] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDHR >> 24);
mbed_official 126:549ba18ddd81 716 /* Release the FIFO */
mbed_official 126:549ba18ddd81 717 /* Release FIFO0 */
mbed_official 126:549ba18ddd81 718 if (FIFONumber == CAN_FIFO0)
mbed_official 126:549ba18ddd81 719 {
mbed_official 126:549ba18ddd81 720 CANx->RF0R |= CAN_RF0R_RFOM0;
mbed_official 126:549ba18ddd81 721 }
mbed_official 126:549ba18ddd81 722 /* Release FIFO1 */
mbed_official 126:549ba18ddd81 723 else /* FIFONumber == CAN_FIFO1 */
mbed_official 126:549ba18ddd81 724 {
mbed_official 126:549ba18ddd81 725 CANx->RF1R |= CAN_RF1R_RFOM1;
mbed_official 126:549ba18ddd81 726 }
mbed_official 126:549ba18ddd81 727 }
mbed_official 126:549ba18ddd81 728
mbed_official 126:549ba18ddd81 729 /**
mbed_official 126:549ba18ddd81 730 * @brief Releases the specified FIFO.
mbed_official 126:549ba18ddd81 731 * @param CANx: where x can be 1 or 2 to to select the CAN peripheral.
mbed_official 126:549ba18ddd81 732 * @param FIFONumber: FIFO to release, CAN_FIFO0 or CAN_FIFO1.
mbed_official 126:549ba18ddd81 733 * @retval None.
mbed_official 126:549ba18ddd81 734 */
mbed_official 126:549ba18ddd81 735 void CAN_FIFORelease(CAN_TypeDef* CANx, uint8_t FIFONumber)
mbed_official 126:549ba18ddd81 736 {
mbed_official 126:549ba18ddd81 737 /* Check the parameters */
mbed_official 126:549ba18ddd81 738 assert_param(IS_CAN_ALL_PERIPH(CANx));
mbed_official 126:549ba18ddd81 739 assert_param(IS_CAN_FIFO(FIFONumber));
mbed_official 126:549ba18ddd81 740 /* Release FIFO0 */
mbed_official 126:549ba18ddd81 741 if (FIFONumber == CAN_FIFO0)
mbed_official 126:549ba18ddd81 742 {
mbed_official 126:549ba18ddd81 743 CANx->RF0R |= CAN_RF0R_RFOM0;
mbed_official 126:549ba18ddd81 744 }
mbed_official 126:549ba18ddd81 745 /* Release FIFO1 */
mbed_official 126:549ba18ddd81 746 else /* FIFONumber == CAN_FIFO1 */
mbed_official 126:549ba18ddd81 747 {
mbed_official 126:549ba18ddd81 748 CANx->RF1R |= CAN_RF1R_RFOM1;
mbed_official 126:549ba18ddd81 749 }
mbed_official 126:549ba18ddd81 750 }
mbed_official 126:549ba18ddd81 751
mbed_official 126:549ba18ddd81 752 /**
mbed_official 126:549ba18ddd81 753 * @brief Returns the number of pending messages.
mbed_official 126:549ba18ddd81 754 * @param CANx: where x can be 1 or 2 to to select the CAN peripheral.
mbed_official 126:549ba18ddd81 755 * @param FIFONumber: Receive FIFO number, CAN_FIFO0 or CAN_FIFO1.
mbed_official 126:549ba18ddd81 756 * @retval NbMessage : which is the number of pending message.
mbed_official 126:549ba18ddd81 757 */
mbed_official 126:549ba18ddd81 758 uint8_t CAN_MessagePending(CAN_TypeDef* CANx, uint8_t FIFONumber)
mbed_official 126:549ba18ddd81 759 {
mbed_official 126:549ba18ddd81 760 uint8_t message_pending=0;
mbed_official 126:549ba18ddd81 761 /* Check the parameters */
mbed_official 126:549ba18ddd81 762 assert_param(IS_CAN_ALL_PERIPH(CANx));
mbed_official 126:549ba18ddd81 763 assert_param(IS_CAN_FIFO(FIFONumber));
mbed_official 126:549ba18ddd81 764 if (FIFONumber == CAN_FIFO0)
mbed_official 126:549ba18ddd81 765 {
mbed_official 126:549ba18ddd81 766 message_pending = (uint8_t)(CANx->RF0R&(uint32_t)0x03);
mbed_official 126:549ba18ddd81 767 }
mbed_official 126:549ba18ddd81 768 else if (FIFONumber == CAN_FIFO1)
mbed_official 126:549ba18ddd81 769 {
mbed_official 126:549ba18ddd81 770 message_pending = (uint8_t)(CANx->RF1R&(uint32_t)0x03);
mbed_official 126:549ba18ddd81 771 }
mbed_official 126:549ba18ddd81 772 else
mbed_official 126:549ba18ddd81 773 {
mbed_official 126:549ba18ddd81 774 message_pending = 0;
mbed_official 126:549ba18ddd81 775 }
mbed_official 126:549ba18ddd81 776 return message_pending;
mbed_official 126:549ba18ddd81 777 }
mbed_official 126:549ba18ddd81 778
mbed_official 126:549ba18ddd81 779
mbed_official 126:549ba18ddd81 780 /**
mbed_official 126:549ba18ddd81 781 * @brief Select the CAN Operation mode.
mbed_official 126:549ba18ddd81 782 * @param CAN_OperatingMode : CAN Operating Mode. This parameter can be one
mbed_official 126:549ba18ddd81 783 * of @ref CAN_OperatingMode_TypeDef enumeration.
mbed_official 126:549ba18ddd81 784 * @retval status of the requested mode which can be
mbed_official 126:549ba18ddd81 785 * - CAN_ModeStatus_Failed CAN failed entering the specific mode
mbed_official 126:549ba18ddd81 786 * - CAN_ModeStatus_Success CAN Succeed entering the specific mode
mbed_official 126:549ba18ddd81 787
mbed_official 126:549ba18ddd81 788 */
mbed_official 126:549ba18ddd81 789 uint8_t CAN_OperatingModeRequest(CAN_TypeDef* CANx, uint8_t CAN_OperatingMode)
mbed_official 126:549ba18ddd81 790 {
mbed_official 126:549ba18ddd81 791 uint8_t status = CAN_ModeStatus_Failed;
mbed_official 126:549ba18ddd81 792
mbed_official 126:549ba18ddd81 793 /* Timeout for INAK or also for SLAK bits*/
mbed_official 126:549ba18ddd81 794 uint32_t timeout = INAK_TIMEOUT;
mbed_official 126:549ba18ddd81 795
mbed_official 126:549ba18ddd81 796 /* Check the parameters */
mbed_official 126:549ba18ddd81 797 assert_param(IS_CAN_ALL_PERIPH(CANx));
mbed_official 126:549ba18ddd81 798 assert_param(IS_CAN_OPERATING_MODE(CAN_OperatingMode));
mbed_official 126:549ba18ddd81 799
mbed_official 126:549ba18ddd81 800 if (CAN_OperatingMode == CAN_OperatingMode_Initialization)
mbed_official 126:549ba18ddd81 801 {
mbed_official 126:549ba18ddd81 802 /* Request initialisation */
mbed_official 126:549ba18ddd81 803 CANx->MCR = (uint32_t)((CANx->MCR & (uint32_t)(~(uint32_t)CAN_MCR_SLEEP)) | CAN_MCR_INRQ);
mbed_official 126:549ba18ddd81 804
mbed_official 126:549ba18ddd81 805 /* Wait the acknowledge */
mbed_official 126:549ba18ddd81 806 while (((CANx->MSR & CAN_MODE_MASK) != CAN_MSR_INAK) && (timeout != 0))
mbed_official 126:549ba18ddd81 807 {
mbed_official 126:549ba18ddd81 808 timeout--;
mbed_official 126:549ba18ddd81 809 }
mbed_official 126:549ba18ddd81 810 if ((CANx->MSR & CAN_MODE_MASK) != CAN_MSR_INAK)
mbed_official 126:549ba18ddd81 811 {
mbed_official 126:549ba18ddd81 812 status = CAN_ModeStatus_Failed;
mbed_official 126:549ba18ddd81 813 }
mbed_official 126:549ba18ddd81 814 else
mbed_official 126:549ba18ddd81 815 {
mbed_official 126:549ba18ddd81 816 status = CAN_ModeStatus_Success;
mbed_official 126:549ba18ddd81 817 }
mbed_official 126:549ba18ddd81 818 }
mbed_official 126:549ba18ddd81 819 else if (CAN_OperatingMode == CAN_OperatingMode_Normal)
mbed_official 126:549ba18ddd81 820 {
mbed_official 126:549ba18ddd81 821 /* Request leave initialisation and sleep mode and enter Normal mode */
mbed_official 126:549ba18ddd81 822 CANx->MCR &= (uint32_t)(~(CAN_MCR_SLEEP|CAN_MCR_INRQ));
mbed_official 126:549ba18ddd81 823
mbed_official 126:549ba18ddd81 824 /* Wait the acknowledge */
mbed_official 126:549ba18ddd81 825 while (((CANx->MSR & CAN_MODE_MASK) != 0) && (timeout!=0))
mbed_official 126:549ba18ddd81 826 {
mbed_official 126:549ba18ddd81 827 timeout--;
mbed_official 126:549ba18ddd81 828 }
mbed_official 126:549ba18ddd81 829 if ((CANx->MSR & CAN_MODE_MASK) != 0)
mbed_official 126:549ba18ddd81 830 {
mbed_official 126:549ba18ddd81 831 status = CAN_ModeStatus_Failed;
mbed_official 126:549ba18ddd81 832 }
mbed_official 126:549ba18ddd81 833 else
mbed_official 126:549ba18ddd81 834 {
mbed_official 126:549ba18ddd81 835 status = CAN_ModeStatus_Success;
mbed_official 126:549ba18ddd81 836 }
mbed_official 126:549ba18ddd81 837 }
mbed_official 126:549ba18ddd81 838 else if (CAN_OperatingMode == CAN_OperatingMode_Sleep)
mbed_official 126:549ba18ddd81 839 {
mbed_official 126:549ba18ddd81 840 /* Request Sleep mode */
mbed_official 126:549ba18ddd81 841 CANx->MCR = (uint32_t)((CANx->MCR & (uint32_t)(~(uint32_t)CAN_MCR_INRQ)) | CAN_MCR_SLEEP);
mbed_official 126:549ba18ddd81 842
mbed_official 126:549ba18ddd81 843 /* Wait the acknowledge */
mbed_official 126:549ba18ddd81 844 while (((CANx->MSR & CAN_MODE_MASK) != CAN_MSR_SLAK) && (timeout!=0))
mbed_official 126:549ba18ddd81 845 {
mbed_official 126:549ba18ddd81 846 timeout--;
mbed_official 126:549ba18ddd81 847 }
mbed_official 126:549ba18ddd81 848 if ((CANx->MSR & CAN_MODE_MASK) != CAN_MSR_SLAK)
mbed_official 126:549ba18ddd81 849 {
mbed_official 126:549ba18ddd81 850 status = CAN_ModeStatus_Failed;
mbed_official 126:549ba18ddd81 851 }
mbed_official 126:549ba18ddd81 852 else
mbed_official 126:549ba18ddd81 853 {
mbed_official 126:549ba18ddd81 854 status = CAN_ModeStatus_Success;
mbed_official 126:549ba18ddd81 855 }
mbed_official 126:549ba18ddd81 856 }
mbed_official 126:549ba18ddd81 857 else
mbed_official 126:549ba18ddd81 858 {
mbed_official 126:549ba18ddd81 859 status = CAN_ModeStatus_Failed;
mbed_official 126:549ba18ddd81 860 }
mbed_official 126:549ba18ddd81 861
mbed_official 126:549ba18ddd81 862 return (uint8_t) status;
mbed_official 126:549ba18ddd81 863 }
mbed_official 126:549ba18ddd81 864
mbed_official 126:549ba18ddd81 865 /**
mbed_official 126:549ba18ddd81 866 * @brief Enters the low power mode.
mbed_official 126:549ba18ddd81 867 * @param CANx: where x can be 1 or 2 to to select the CAN peripheral.
mbed_official 126:549ba18ddd81 868 * @retval status: CAN_Sleep_Ok if sleep entered, CAN_Sleep_Failed in an
mbed_official 126:549ba18ddd81 869 * other case.
mbed_official 126:549ba18ddd81 870 */
mbed_official 126:549ba18ddd81 871 uint8_t CAN_Sleep(CAN_TypeDef* CANx)
mbed_official 126:549ba18ddd81 872 {
mbed_official 126:549ba18ddd81 873 uint8_t sleepstatus = CAN_Sleep_Failed;
mbed_official 126:549ba18ddd81 874
mbed_official 126:549ba18ddd81 875 /* Check the parameters */
mbed_official 126:549ba18ddd81 876 assert_param(IS_CAN_ALL_PERIPH(CANx));
mbed_official 126:549ba18ddd81 877
mbed_official 126:549ba18ddd81 878 /* Request Sleep mode */
mbed_official 126:549ba18ddd81 879 CANx->MCR = (((CANx->MCR) & (uint32_t)(~(uint32_t)CAN_MCR_INRQ)) | CAN_MCR_SLEEP);
mbed_official 126:549ba18ddd81 880
mbed_official 126:549ba18ddd81 881 /* Sleep mode status */
mbed_official 126:549ba18ddd81 882 if ((CANx->MSR & (CAN_MSR_SLAK|CAN_MSR_INAK)) == CAN_MSR_SLAK)
mbed_official 126:549ba18ddd81 883 {
mbed_official 126:549ba18ddd81 884 /* Sleep mode not entered */
mbed_official 126:549ba18ddd81 885 sleepstatus = CAN_Sleep_Ok;
mbed_official 126:549ba18ddd81 886 }
mbed_official 126:549ba18ddd81 887 /* return sleep mode status */
mbed_official 126:549ba18ddd81 888 return (uint8_t)sleepstatus;
mbed_official 126:549ba18ddd81 889 }
mbed_official 126:549ba18ddd81 890
mbed_official 126:549ba18ddd81 891 /**
mbed_official 126:549ba18ddd81 892 * @brief Wakes the CAN up.
mbed_official 126:549ba18ddd81 893 * @param CANx: where x can be 1 or 2 to to select the CAN peripheral.
mbed_official 126:549ba18ddd81 894 * @retval status: CAN_WakeUp_Ok if sleep mode left, CAN_WakeUp_Failed in an
mbed_official 126:549ba18ddd81 895 * other case.
mbed_official 126:549ba18ddd81 896 */
mbed_official 126:549ba18ddd81 897 uint8_t CAN_WakeUp(CAN_TypeDef* CANx)
mbed_official 126:549ba18ddd81 898 {
mbed_official 126:549ba18ddd81 899 uint32_t wait_slak = SLAK_TIMEOUT;
mbed_official 126:549ba18ddd81 900 uint8_t wakeupstatus = CAN_WakeUp_Failed;
mbed_official 126:549ba18ddd81 901
mbed_official 126:549ba18ddd81 902 /* Check the parameters */
mbed_official 126:549ba18ddd81 903 assert_param(IS_CAN_ALL_PERIPH(CANx));
mbed_official 126:549ba18ddd81 904
mbed_official 126:549ba18ddd81 905 /* Wake up request */
mbed_official 126:549ba18ddd81 906 CANx->MCR &= ~(uint32_t)CAN_MCR_SLEEP;
mbed_official 126:549ba18ddd81 907
mbed_official 126:549ba18ddd81 908 /* Sleep mode status */
mbed_official 126:549ba18ddd81 909 while(((CANx->MSR & CAN_MSR_SLAK) == CAN_MSR_SLAK)&&(wait_slak!=0x00))
mbed_official 126:549ba18ddd81 910 {
mbed_official 126:549ba18ddd81 911 wait_slak--;
mbed_official 126:549ba18ddd81 912 }
mbed_official 126:549ba18ddd81 913 if((CANx->MSR & CAN_MSR_SLAK) != CAN_MSR_SLAK)
mbed_official 126:549ba18ddd81 914 {
mbed_official 126:549ba18ddd81 915 /* wake up done : Sleep mode exited */
mbed_official 126:549ba18ddd81 916 wakeupstatus = CAN_WakeUp_Ok;
mbed_official 126:549ba18ddd81 917 }
mbed_official 126:549ba18ddd81 918 /* return wakeup status */
mbed_official 126:549ba18ddd81 919 return (uint8_t)wakeupstatus;
mbed_official 126:549ba18ddd81 920 }
mbed_official 126:549ba18ddd81 921
mbed_official 126:549ba18ddd81 922
mbed_official 126:549ba18ddd81 923 /**
mbed_official 126:549ba18ddd81 924 * @brief Returns the CANx's last error code (LEC).
mbed_official 126:549ba18ddd81 925 * @param CANx: where x can be 1 or 2 to to select the CAN peripheral.
mbed_official 126:549ba18ddd81 926 * @retval CAN_ErrorCode: specifies the Error code :
mbed_official 126:549ba18ddd81 927 * - CAN_ERRORCODE_NoErr No Error
mbed_official 126:549ba18ddd81 928 * - CAN_ERRORCODE_StuffErr Stuff Error
mbed_official 126:549ba18ddd81 929 * - CAN_ERRORCODE_FormErr Form Error
mbed_official 126:549ba18ddd81 930 * - CAN_ERRORCODE_ACKErr Acknowledgment Error
mbed_official 126:549ba18ddd81 931 * - CAN_ERRORCODE_BitRecessiveErr Bit Recessive Error
mbed_official 126:549ba18ddd81 932 * - CAN_ERRORCODE_BitDominantErr Bit Dominant Error
mbed_official 126:549ba18ddd81 933 * - CAN_ERRORCODE_CRCErr CRC Error
mbed_official 126:549ba18ddd81 934 * - CAN_ERRORCODE_SoftwareSetErr Software Set Error
mbed_official 126:549ba18ddd81 935 */
mbed_official 126:549ba18ddd81 936
mbed_official 126:549ba18ddd81 937 uint8_t CAN_GetLastErrorCode(CAN_TypeDef* CANx)
mbed_official 126:549ba18ddd81 938 {
mbed_official 126:549ba18ddd81 939 uint8_t errorcode=0;
mbed_official 126:549ba18ddd81 940
mbed_official 126:549ba18ddd81 941 /* Check the parameters */
mbed_official 126:549ba18ddd81 942 assert_param(IS_CAN_ALL_PERIPH(CANx));
mbed_official 126:549ba18ddd81 943
mbed_official 126:549ba18ddd81 944 /* Get the error code*/
mbed_official 126:549ba18ddd81 945 errorcode = (((uint8_t)CANx->ESR) & (uint8_t)CAN_ESR_LEC);
mbed_official 126:549ba18ddd81 946
mbed_official 126:549ba18ddd81 947 /* Return the error code*/
mbed_official 126:549ba18ddd81 948 return errorcode;
mbed_official 126:549ba18ddd81 949 }
mbed_official 126:549ba18ddd81 950 /**
mbed_official 126:549ba18ddd81 951 * @brief Returns the CANx Receive Error Counter (REC).
mbed_official 126:549ba18ddd81 952 * @note In case of an error during reception, this counter is incremented
mbed_official 126:549ba18ddd81 953 * by 1 or by 8 depending on the error condition as defined by the CAN
mbed_official 126:549ba18ddd81 954 * standard. After every successful reception, the counter is
mbed_official 126:549ba18ddd81 955 * decremented by 1 or reset to 120 if its value was higher than 128.
mbed_official 126:549ba18ddd81 956 * When the counter value exceeds 127, the CAN controller enters the
mbed_official 126:549ba18ddd81 957 * error passive state.
mbed_official 126:549ba18ddd81 958 * @param CANx: where x can be 1 or 2 to to select the CAN peripheral.
mbed_official 126:549ba18ddd81 959 * @retval CAN Receive Error Counter.
mbed_official 126:549ba18ddd81 960 */
mbed_official 126:549ba18ddd81 961 uint8_t CAN_GetReceiveErrorCounter(CAN_TypeDef* CANx)
mbed_official 126:549ba18ddd81 962 {
mbed_official 126:549ba18ddd81 963 uint8_t counter=0;
mbed_official 126:549ba18ddd81 964
mbed_official 126:549ba18ddd81 965 /* Check the parameters */
mbed_official 126:549ba18ddd81 966 assert_param(IS_CAN_ALL_PERIPH(CANx));
mbed_official 126:549ba18ddd81 967
mbed_official 126:549ba18ddd81 968 /* Get the Receive Error Counter*/
mbed_official 126:549ba18ddd81 969 counter = (uint8_t)((CANx->ESR & CAN_ESR_REC)>> 24);
mbed_official 126:549ba18ddd81 970
mbed_official 126:549ba18ddd81 971 /* Return the Receive Error Counter*/
mbed_official 126:549ba18ddd81 972 return counter;
mbed_official 126:549ba18ddd81 973 }
mbed_official 126:549ba18ddd81 974
mbed_official 126:549ba18ddd81 975
mbed_official 126:549ba18ddd81 976 /**
mbed_official 126:549ba18ddd81 977 * @brief Returns the LSB of the 9-bit CANx Transmit Error Counter(TEC).
mbed_official 126:549ba18ddd81 978 * @param CANx: where x can be 1 or 2 to to select the CAN peripheral.
mbed_official 126:549ba18ddd81 979 * @retval LSB of the 9-bit CAN Transmit Error Counter.
mbed_official 126:549ba18ddd81 980 */
mbed_official 126:549ba18ddd81 981 uint8_t CAN_GetLSBTransmitErrorCounter(CAN_TypeDef* CANx)
mbed_official 126:549ba18ddd81 982 {
mbed_official 126:549ba18ddd81 983 uint8_t counter=0;
mbed_official 126:549ba18ddd81 984
mbed_official 126:549ba18ddd81 985 /* Check the parameters */
mbed_official 126:549ba18ddd81 986 assert_param(IS_CAN_ALL_PERIPH(CANx));
mbed_official 126:549ba18ddd81 987
mbed_official 126:549ba18ddd81 988 /* Get the LSB of the 9-bit CANx Transmit Error Counter(TEC) */
mbed_official 126:549ba18ddd81 989 counter = (uint8_t)((CANx->ESR & CAN_ESR_TEC)>> 16);
mbed_official 126:549ba18ddd81 990
mbed_official 126:549ba18ddd81 991 /* Return the LSB of the 9-bit CANx Transmit Error Counter(TEC) */
mbed_official 126:549ba18ddd81 992 return counter;
mbed_official 126:549ba18ddd81 993 }
mbed_official 126:549ba18ddd81 994
mbed_official 126:549ba18ddd81 995
mbed_official 126:549ba18ddd81 996 /**
mbed_official 126:549ba18ddd81 997 * @brief Enables or disables the specified CANx interrupts.
mbed_official 126:549ba18ddd81 998 * @param CANx: where x can be 1 or 2 to to select the CAN peripheral.
mbed_official 126:549ba18ddd81 999 * @param CAN_IT: specifies the CAN interrupt sources to be enabled or disabled.
mbed_official 126:549ba18ddd81 1000 * This parameter can be:
mbed_official 126:549ba18ddd81 1001 * - CAN_IT_TME,
mbed_official 126:549ba18ddd81 1002 * - CAN_IT_FMP0,
mbed_official 126:549ba18ddd81 1003 * - CAN_IT_FF0,
mbed_official 126:549ba18ddd81 1004 * - CAN_IT_FOV0,
mbed_official 126:549ba18ddd81 1005 * - CAN_IT_FMP1,
mbed_official 126:549ba18ddd81 1006 * - CAN_IT_FF1,
mbed_official 126:549ba18ddd81 1007 * - CAN_IT_FOV1,
mbed_official 126:549ba18ddd81 1008 * - CAN_IT_EWG,
mbed_official 126:549ba18ddd81 1009 * - CAN_IT_EPV,
mbed_official 126:549ba18ddd81 1010 * - CAN_IT_LEC,
mbed_official 126:549ba18ddd81 1011 * - CAN_IT_ERR,
mbed_official 126:549ba18ddd81 1012 * - CAN_IT_WKU or
mbed_official 126:549ba18ddd81 1013 * - CAN_IT_SLK.
mbed_official 126:549ba18ddd81 1014 * @param NewState: new state of the CAN interrupts.
mbed_official 126:549ba18ddd81 1015 * This parameter can be: ENABLE or DISABLE.
mbed_official 126:549ba18ddd81 1016 * @retval None.
mbed_official 126:549ba18ddd81 1017 */
mbed_official 126:549ba18ddd81 1018 void CAN_ITConfig(CAN_TypeDef* CANx, uint32_t CAN_IT, FunctionalState NewState)
mbed_official 126:549ba18ddd81 1019 {
mbed_official 126:549ba18ddd81 1020 /* Check the parameters */
mbed_official 126:549ba18ddd81 1021 assert_param(IS_CAN_ALL_PERIPH(CANx));
mbed_official 126:549ba18ddd81 1022 assert_param(IS_CAN_IT(CAN_IT));
mbed_official 126:549ba18ddd81 1023 assert_param(IS_FUNCTIONAL_STATE(NewState));
mbed_official 126:549ba18ddd81 1024
mbed_official 126:549ba18ddd81 1025 if (NewState != DISABLE)
mbed_official 126:549ba18ddd81 1026 {
mbed_official 126:549ba18ddd81 1027 /* Enable the selected CANx interrupt */
mbed_official 126:549ba18ddd81 1028 CANx->IER |= CAN_IT;
mbed_official 126:549ba18ddd81 1029 }
mbed_official 126:549ba18ddd81 1030 else
mbed_official 126:549ba18ddd81 1031 {
mbed_official 126:549ba18ddd81 1032 /* Disable the selected CANx interrupt */
mbed_official 126:549ba18ddd81 1033 CANx->IER &= ~CAN_IT;
mbed_official 126:549ba18ddd81 1034 }
mbed_official 126:549ba18ddd81 1035 }
mbed_official 126:549ba18ddd81 1036 /**
mbed_official 126:549ba18ddd81 1037 * @brief Checks whether the specified CAN flag is set or not.
mbed_official 126:549ba18ddd81 1038 * @param CANx: where x can be 1 or 2 to to select the CAN peripheral.
mbed_official 126:549ba18ddd81 1039 * @param CAN_FLAG: specifies the flag to check.
mbed_official 126:549ba18ddd81 1040 * This parameter can be one of the following flags:
mbed_official 126:549ba18ddd81 1041 * - CAN_FLAG_EWG
mbed_official 126:549ba18ddd81 1042 * - CAN_FLAG_EPV
mbed_official 126:549ba18ddd81 1043 * - CAN_FLAG_BOF
mbed_official 126:549ba18ddd81 1044 * - CAN_FLAG_RQCP0
mbed_official 126:549ba18ddd81 1045 * - CAN_FLAG_RQCP1
mbed_official 126:549ba18ddd81 1046 * - CAN_FLAG_RQCP2
mbed_official 126:549ba18ddd81 1047 * - CAN_FLAG_FMP1
mbed_official 126:549ba18ddd81 1048 * - CAN_FLAG_FF1
mbed_official 126:549ba18ddd81 1049 * - CAN_FLAG_FOV1
mbed_official 126:549ba18ddd81 1050 * - CAN_FLAG_FMP0
mbed_official 126:549ba18ddd81 1051 * - CAN_FLAG_FF0
mbed_official 126:549ba18ddd81 1052 * - CAN_FLAG_FOV0
mbed_official 126:549ba18ddd81 1053 * - CAN_FLAG_WKU
mbed_official 126:549ba18ddd81 1054 * - CAN_FLAG_SLAK
mbed_official 126:549ba18ddd81 1055 * - CAN_FLAG_LEC
mbed_official 126:549ba18ddd81 1056 * @retval The new state of CAN_FLAG (SET or RESET).
mbed_official 126:549ba18ddd81 1057 */
mbed_official 126:549ba18ddd81 1058 FlagStatus CAN_GetFlagStatus(CAN_TypeDef* CANx, uint32_t CAN_FLAG)
mbed_official 126:549ba18ddd81 1059 {
mbed_official 126:549ba18ddd81 1060 FlagStatus bitstatus = RESET;
mbed_official 126:549ba18ddd81 1061
mbed_official 126:549ba18ddd81 1062 /* Check the parameters */
mbed_official 126:549ba18ddd81 1063 assert_param(IS_CAN_ALL_PERIPH(CANx));
mbed_official 126:549ba18ddd81 1064 assert_param(IS_CAN_GET_FLAG(CAN_FLAG));
mbed_official 126:549ba18ddd81 1065
mbed_official 126:549ba18ddd81 1066
mbed_official 126:549ba18ddd81 1067 if((CAN_FLAG & CAN_FLAGS_ESR) != (uint32_t)RESET)
mbed_official 126:549ba18ddd81 1068 {
mbed_official 126:549ba18ddd81 1069 /* Check the status of the specified CAN flag */
mbed_official 126:549ba18ddd81 1070 if ((CANx->ESR & (CAN_FLAG & 0x000FFFFF)) != (uint32_t)RESET)
mbed_official 126:549ba18ddd81 1071 {
mbed_official 126:549ba18ddd81 1072 /* CAN_FLAG is set */
mbed_official 126:549ba18ddd81 1073 bitstatus = SET;
mbed_official 126:549ba18ddd81 1074 }
mbed_official 126:549ba18ddd81 1075 else
mbed_official 126:549ba18ddd81 1076 {
mbed_official 126:549ba18ddd81 1077 /* CAN_FLAG is reset */
mbed_official 126:549ba18ddd81 1078 bitstatus = RESET;
mbed_official 126:549ba18ddd81 1079 }
mbed_official 126:549ba18ddd81 1080 }
mbed_official 126:549ba18ddd81 1081 else if((CAN_FLAG & CAN_FLAGS_MSR) != (uint32_t)RESET)
mbed_official 126:549ba18ddd81 1082 {
mbed_official 126:549ba18ddd81 1083 /* Check the status of the specified CAN flag */
mbed_official 126:549ba18ddd81 1084 if ((CANx->MSR & (CAN_FLAG & 0x000FFFFF)) != (uint32_t)RESET)
mbed_official 126:549ba18ddd81 1085 {
mbed_official 126:549ba18ddd81 1086 /* CAN_FLAG is set */
mbed_official 126:549ba18ddd81 1087 bitstatus = SET;
mbed_official 126:549ba18ddd81 1088 }
mbed_official 126:549ba18ddd81 1089 else
mbed_official 126:549ba18ddd81 1090 {
mbed_official 126:549ba18ddd81 1091 /* CAN_FLAG is reset */
mbed_official 126:549ba18ddd81 1092 bitstatus = RESET;
mbed_official 126:549ba18ddd81 1093 }
mbed_official 126:549ba18ddd81 1094 }
mbed_official 126:549ba18ddd81 1095 else if((CAN_FLAG & CAN_FLAGS_TSR) != (uint32_t)RESET)
mbed_official 126:549ba18ddd81 1096 {
mbed_official 126:549ba18ddd81 1097 /* Check the status of the specified CAN flag */
mbed_official 126:549ba18ddd81 1098 if ((CANx->TSR & (CAN_FLAG & 0x000FFFFF)) != (uint32_t)RESET)
mbed_official 126:549ba18ddd81 1099 {
mbed_official 126:549ba18ddd81 1100 /* CAN_FLAG is set */
mbed_official 126:549ba18ddd81 1101 bitstatus = SET;
mbed_official 126:549ba18ddd81 1102 }
mbed_official 126:549ba18ddd81 1103 else
mbed_official 126:549ba18ddd81 1104 {
mbed_official 126:549ba18ddd81 1105 /* CAN_FLAG is reset */
mbed_official 126:549ba18ddd81 1106 bitstatus = RESET;
mbed_official 126:549ba18ddd81 1107 }
mbed_official 126:549ba18ddd81 1108 }
mbed_official 126:549ba18ddd81 1109 else if((CAN_FLAG & CAN_FLAGS_RF0R) != (uint32_t)RESET)
mbed_official 126:549ba18ddd81 1110 {
mbed_official 126:549ba18ddd81 1111 /* Check the status of the specified CAN flag */
mbed_official 126:549ba18ddd81 1112 if ((CANx->RF0R & (CAN_FLAG & 0x000FFFFF)) != (uint32_t)RESET)
mbed_official 126:549ba18ddd81 1113 {
mbed_official 126:549ba18ddd81 1114 /* CAN_FLAG is set */
mbed_official 126:549ba18ddd81 1115 bitstatus = SET;
mbed_official 126:549ba18ddd81 1116 }
mbed_official 126:549ba18ddd81 1117 else
mbed_official 126:549ba18ddd81 1118 {
mbed_official 126:549ba18ddd81 1119 /* CAN_FLAG is reset */
mbed_official 126:549ba18ddd81 1120 bitstatus = RESET;
mbed_official 126:549ba18ddd81 1121 }
mbed_official 126:549ba18ddd81 1122 }
mbed_official 126:549ba18ddd81 1123 else /* If(CAN_FLAG & CAN_FLAGS_RF1R != (uint32_t)RESET) */
mbed_official 126:549ba18ddd81 1124 {
mbed_official 126:549ba18ddd81 1125 /* Check the status of the specified CAN flag */
mbed_official 126:549ba18ddd81 1126 if ((uint32_t)(CANx->RF1R & (CAN_FLAG & 0x000FFFFF)) != (uint32_t)RESET)
mbed_official 126:549ba18ddd81 1127 {
mbed_official 126:549ba18ddd81 1128 /* CAN_FLAG is set */
mbed_official 126:549ba18ddd81 1129 bitstatus = SET;
mbed_official 126:549ba18ddd81 1130 }
mbed_official 126:549ba18ddd81 1131 else
mbed_official 126:549ba18ddd81 1132 {
mbed_official 126:549ba18ddd81 1133 /* CAN_FLAG is reset */
mbed_official 126:549ba18ddd81 1134 bitstatus = RESET;
mbed_official 126:549ba18ddd81 1135 }
mbed_official 126:549ba18ddd81 1136 }
mbed_official 126:549ba18ddd81 1137 /* Return the CAN_FLAG status */
mbed_official 126:549ba18ddd81 1138 return bitstatus;
mbed_official 126:549ba18ddd81 1139 }
mbed_official 126:549ba18ddd81 1140
mbed_official 126:549ba18ddd81 1141 /**
mbed_official 126:549ba18ddd81 1142 * @brief Clears the CAN's pending flags.
mbed_official 126:549ba18ddd81 1143 * @param CANx: where x can be 1 or 2 to to select the CAN peripheral.
mbed_official 126:549ba18ddd81 1144 * @param CAN_FLAG: specifies the flag to clear.
mbed_official 126:549ba18ddd81 1145 * This parameter can be one of the following flags:
mbed_official 126:549ba18ddd81 1146 * - CAN_FLAG_RQCP0
mbed_official 126:549ba18ddd81 1147 * - CAN_FLAG_RQCP1
mbed_official 126:549ba18ddd81 1148 * - CAN_FLAG_RQCP2
mbed_official 126:549ba18ddd81 1149 * - CAN_FLAG_FF1
mbed_official 126:549ba18ddd81 1150 * - CAN_FLAG_FOV1
mbed_official 126:549ba18ddd81 1151 * - CAN_FLAG_FF0
mbed_official 126:549ba18ddd81 1152 * - CAN_FLAG_FOV0
mbed_official 126:549ba18ddd81 1153 * - CAN_FLAG_WKU
mbed_official 126:549ba18ddd81 1154 * - CAN_FLAG_SLAK
mbed_official 126:549ba18ddd81 1155 * - CAN_FLAG_LEC
mbed_official 126:549ba18ddd81 1156 * @retval None.
mbed_official 126:549ba18ddd81 1157 */
mbed_official 126:549ba18ddd81 1158 void CAN_ClearFlag(CAN_TypeDef* CANx, uint32_t CAN_FLAG)
mbed_official 126:549ba18ddd81 1159 {
mbed_official 126:549ba18ddd81 1160 uint32_t flagtmp=0;
mbed_official 126:549ba18ddd81 1161 /* Check the parameters */
mbed_official 126:549ba18ddd81 1162 assert_param(IS_CAN_ALL_PERIPH(CANx));
mbed_official 126:549ba18ddd81 1163 assert_param(IS_CAN_CLEAR_FLAG(CAN_FLAG));
mbed_official 126:549ba18ddd81 1164
mbed_official 126:549ba18ddd81 1165 if (CAN_FLAG == CAN_FLAG_LEC) /* ESR register */
mbed_official 126:549ba18ddd81 1166 {
mbed_official 126:549ba18ddd81 1167 /* Clear the selected CAN flags */
mbed_official 126:549ba18ddd81 1168 CANx->ESR = (uint32_t)RESET;
mbed_official 126:549ba18ddd81 1169 }
mbed_official 126:549ba18ddd81 1170 else /* MSR or TSR or RF0R or RF1R */
mbed_official 126:549ba18ddd81 1171 {
mbed_official 126:549ba18ddd81 1172 flagtmp = CAN_FLAG & 0x000FFFFF;
mbed_official 126:549ba18ddd81 1173
mbed_official 126:549ba18ddd81 1174 if ((CAN_FLAG & CAN_FLAGS_RF0R)!=(uint32_t)RESET)
mbed_official 126:549ba18ddd81 1175 {
mbed_official 126:549ba18ddd81 1176 /* Receive Flags */
mbed_official 126:549ba18ddd81 1177 CANx->RF0R = (uint32_t)(flagtmp);
mbed_official 126:549ba18ddd81 1178 }
mbed_official 126:549ba18ddd81 1179 else if ((CAN_FLAG & CAN_FLAGS_RF1R)!=(uint32_t)RESET)
mbed_official 126:549ba18ddd81 1180 {
mbed_official 126:549ba18ddd81 1181 /* Receive Flags */
mbed_official 126:549ba18ddd81 1182 CANx->RF1R = (uint32_t)(flagtmp);
mbed_official 126:549ba18ddd81 1183 }
mbed_official 126:549ba18ddd81 1184 else if ((CAN_FLAG & CAN_FLAGS_TSR)!=(uint32_t)RESET)
mbed_official 126:549ba18ddd81 1185 {
mbed_official 126:549ba18ddd81 1186 /* Transmit Flags */
mbed_official 126:549ba18ddd81 1187 CANx->TSR = (uint32_t)(flagtmp);
mbed_official 126:549ba18ddd81 1188 }
mbed_official 126:549ba18ddd81 1189 else /* If((CAN_FLAG & CAN_FLAGS_MSR)!=(uint32_t)RESET) */
mbed_official 126:549ba18ddd81 1190 {
mbed_official 126:549ba18ddd81 1191 /* Operating mode Flags */
mbed_official 126:549ba18ddd81 1192 CANx->MSR = (uint32_t)(flagtmp);
mbed_official 126:549ba18ddd81 1193 }
mbed_official 126:549ba18ddd81 1194 }
mbed_official 126:549ba18ddd81 1195 }
mbed_official 126:549ba18ddd81 1196
mbed_official 126:549ba18ddd81 1197 /**
mbed_official 126:549ba18ddd81 1198 * @brief Checks whether the specified CANx interrupt has occurred or not.
mbed_official 126:549ba18ddd81 1199 * @param CANx: where x can be 1 or 2 to to select the CAN peripheral.
mbed_official 126:549ba18ddd81 1200 * @param CAN_IT: specifies the CAN interrupt source to check.
mbed_official 126:549ba18ddd81 1201 * This parameter can be one of the following flags:
mbed_official 126:549ba18ddd81 1202 * - CAN_IT_TME
mbed_official 126:549ba18ddd81 1203 * - CAN_IT_FMP0
mbed_official 126:549ba18ddd81 1204 * - CAN_IT_FF0
mbed_official 126:549ba18ddd81 1205 * - CAN_IT_FOV0
mbed_official 126:549ba18ddd81 1206 * - CAN_IT_FMP1
mbed_official 126:549ba18ddd81 1207 * - CAN_IT_FF1
mbed_official 126:549ba18ddd81 1208 * - CAN_IT_FOV1
mbed_official 126:549ba18ddd81 1209 * - CAN_IT_WKU
mbed_official 126:549ba18ddd81 1210 * - CAN_IT_SLK
mbed_official 126:549ba18ddd81 1211 * - CAN_IT_EWG
mbed_official 126:549ba18ddd81 1212 * - CAN_IT_EPV
mbed_official 126:549ba18ddd81 1213 * - CAN_IT_BOF
mbed_official 126:549ba18ddd81 1214 * - CAN_IT_LEC
mbed_official 126:549ba18ddd81 1215 * - CAN_IT_ERR
mbed_official 126:549ba18ddd81 1216 * @retval The current state of CAN_IT (SET or RESET).
mbed_official 126:549ba18ddd81 1217 */
mbed_official 126:549ba18ddd81 1218 ITStatus CAN_GetITStatus(CAN_TypeDef* CANx, uint32_t CAN_IT)
mbed_official 126:549ba18ddd81 1219 {
mbed_official 126:549ba18ddd81 1220 ITStatus itstatus = RESET;
mbed_official 126:549ba18ddd81 1221 /* Check the parameters */
mbed_official 126:549ba18ddd81 1222 assert_param(IS_CAN_ALL_PERIPH(CANx));
mbed_official 126:549ba18ddd81 1223 assert_param(IS_CAN_IT(CAN_IT));
mbed_official 126:549ba18ddd81 1224
mbed_official 126:549ba18ddd81 1225 /* check the enable interrupt bit */
mbed_official 126:549ba18ddd81 1226 if((CANx->IER & CAN_IT) != RESET)
mbed_official 126:549ba18ddd81 1227 {
mbed_official 126:549ba18ddd81 1228 /* in case the Interrupt is enabled, .... */
mbed_official 126:549ba18ddd81 1229 switch (CAN_IT)
mbed_official 126:549ba18ddd81 1230 {
mbed_official 126:549ba18ddd81 1231 case CAN_IT_TME:
mbed_official 126:549ba18ddd81 1232 /* Check CAN_TSR_RQCPx bits */
mbed_official 126:549ba18ddd81 1233 itstatus = CheckITStatus(CANx->TSR, CAN_TSR_RQCP0|CAN_TSR_RQCP1|CAN_TSR_RQCP2);
mbed_official 126:549ba18ddd81 1234 break;
mbed_official 126:549ba18ddd81 1235 case CAN_IT_FMP0:
mbed_official 126:549ba18ddd81 1236 /* Check CAN_RF0R_FMP0 bit */
mbed_official 126:549ba18ddd81 1237 itstatus = CheckITStatus(CANx->RF0R, CAN_RF0R_FMP0);
mbed_official 126:549ba18ddd81 1238 break;
mbed_official 126:549ba18ddd81 1239 case CAN_IT_FF0:
mbed_official 126:549ba18ddd81 1240 /* Check CAN_RF0R_FULL0 bit */
mbed_official 126:549ba18ddd81 1241 itstatus = CheckITStatus(CANx->RF0R, CAN_RF0R_FULL0);
mbed_official 126:549ba18ddd81 1242 break;
mbed_official 126:549ba18ddd81 1243 case CAN_IT_FOV0:
mbed_official 126:549ba18ddd81 1244 /* Check CAN_RF0R_FOVR0 bit */
mbed_official 126:549ba18ddd81 1245 itstatus = CheckITStatus(CANx->RF0R, CAN_RF0R_FOVR0);
mbed_official 126:549ba18ddd81 1246 break;
mbed_official 126:549ba18ddd81 1247 case CAN_IT_FMP1:
mbed_official 126:549ba18ddd81 1248 /* Check CAN_RF1R_FMP1 bit */
mbed_official 126:549ba18ddd81 1249 itstatus = CheckITStatus(CANx->RF1R, CAN_RF1R_FMP1);
mbed_official 126:549ba18ddd81 1250 break;
mbed_official 126:549ba18ddd81 1251 case CAN_IT_FF1:
mbed_official 126:549ba18ddd81 1252 /* Check CAN_RF1R_FULL1 bit */
mbed_official 126:549ba18ddd81 1253 itstatus = CheckITStatus(CANx->RF1R, CAN_RF1R_FULL1);
mbed_official 126:549ba18ddd81 1254 break;
mbed_official 126:549ba18ddd81 1255 case CAN_IT_FOV1:
mbed_official 126:549ba18ddd81 1256 /* Check CAN_RF1R_FOVR1 bit */
mbed_official 126:549ba18ddd81 1257 itstatus = CheckITStatus(CANx->RF1R, CAN_RF1R_FOVR1);
mbed_official 126:549ba18ddd81 1258 break;
mbed_official 126:549ba18ddd81 1259 case CAN_IT_WKU:
mbed_official 126:549ba18ddd81 1260 /* Check CAN_MSR_WKUI bit */
mbed_official 126:549ba18ddd81 1261 itstatus = CheckITStatus(CANx->MSR, CAN_MSR_WKUI);
mbed_official 126:549ba18ddd81 1262 break;
mbed_official 126:549ba18ddd81 1263 case CAN_IT_SLK:
mbed_official 126:549ba18ddd81 1264 /* Check CAN_MSR_SLAKI bit */
mbed_official 126:549ba18ddd81 1265 itstatus = CheckITStatus(CANx->MSR, CAN_MSR_SLAKI);
mbed_official 126:549ba18ddd81 1266 break;
mbed_official 126:549ba18ddd81 1267 case CAN_IT_EWG:
mbed_official 126:549ba18ddd81 1268 /* Check CAN_ESR_EWGF bit */
mbed_official 126:549ba18ddd81 1269 itstatus = CheckITStatus(CANx->ESR, CAN_ESR_EWGF);
mbed_official 126:549ba18ddd81 1270 break;
mbed_official 126:549ba18ddd81 1271 case CAN_IT_EPV:
mbed_official 126:549ba18ddd81 1272 /* Check CAN_ESR_EPVF bit */
mbed_official 126:549ba18ddd81 1273 itstatus = CheckITStatus(CANx->ESR, CAN_ESR_EPVF);
mbed_official 126:549ba18ddd81 1274 break;
mbed_official 126:549ba18ddd81 1275 case CAN_IT_BOF:
mbed_official 126:549ba18ddd81 1276 /* Check CAN_ESR_BOFF bit */
mbed_official 126:549ba18ddd81 1277 itstatus = CheckITStatus(CANx->ESR, CAN_ESR_BOFF);
mbed_official 126:549ba18ddd81 1278 break;
mbed_official 126:549ba18ddd81 1279 case CAN_IT_LEC:
mbed_official 126:549ba18ddd81 1280 /* Check CAN_ESR_LEC bit */
mbed_official 126:549ba18ddd81 1281 itstatus = CheckITStatus(CANx->ESR, CAN_ESR_LEC);
mbed_official 126:549ba18ddd81 1282 break;
mbed_official 126:549ba18ddd81 1283 case CAN_IT_ERR:
mbed_official 126:549ba18ddd81 1284 /* Check CAN_MSR_ERRI bit */
mbed_official 126:549ba18ddd81 1285 itstatus = CheckITStatus(CANx->MSR, CAN_MSR_ERRI);
mbed_official 126:549ba18ddd81 1286 break;
mbed_official 126:549ba18ddd81 1287 default :
mbed_official 126:549ba18ddd81 1288 /* in case of error, return RESET */
mbed_official 126:549ba18ddd81 1289 itstatus = RESET;
mbed_official 126:549ba18ddd81 1290 break;
mbed_official 126:549ba18ddd81 1291 }
mbed_official 126:549ba18ddd81 1292 }
mbed_official 126:549ba18ddd81 1293 else
mbed_official 126:549ba18ddd81 1294 {
mbed_official 126:549ba18ddd81 1295 /* in case the Interrupt is not enabled, return RESET */
mbed_official 126:549ba18ddd81 1296 itstatus = RESET;
mbed_official 126:549ba18ddd81 1297 }
mbed_official 126:549ba18ddd81 1298
mbed_official 126:549ba18ddd81 1299 /* Return the CAN_IT status */
mbed_official 126:549ba18ddd81 1300 return itstatus;
mbed_official 126:549ba18ddd81 1301 }
mbed_official 126:549ba18ddd81 1302
mbed_official 126:549ba18ddd81 1303 /**
mbed_official 126:549ba18ddd81 1304 * @brief Clears the CANx's interrupt pending bits.
mbed_official 126:549ba18ddd81 1305 * @param CANx: where x can be 1 or 2 to to select the CAN peripheral.
mbed_official 126:549ba18ddd81 1306 * @param CAN_IT: specifies the interrupt pending bit to clear.
mbed_official 126:549ba18ddd81 1307 * - CAN_IT_TME
mbed_official 126:549ba18ddd81 1308 * - CAN_IT_FF0
mbed_official 126:549ba18ddd81 1309 * - CAN_IT_FOV0
mbed_official 126:549ba18ddd81 1310 * - CAN_IT_FF1
mbed_official 126:549ba18ddd81 1311 * - CAN_IT_FOV1
mbed_official 126:549ba18ddd81 1312 * - CAN_IT_WKU
mbed_official 126:549ba18ddd81 1313 * - CAN_IT_SLK
mbed_official 126:549ba18ddd81 1314 * - CAN_IT_EWG
mbed_official 126:549ba18ddd81 1315 * - CAN_IT_EPV
mbed_official 126:549ba18ddd81 1316 * - CAN_IT_BOF
mbed_official 126:549ba18ddd81 1317 * - CAN_IT_LEC
mbed_official 126:549ba18ddd81 1318 * - CAN_IT_ERR
mbed_official 126:549ba18ddd81 1319 * @retval None.
mbed_official 126:549ba18ddd81 1320 */
mbed_official 126:549ba18ddd81 1321 void CAN_ClearITPendingBit(CAN_TypeDef* CANx, uint32_t CAN_IT)
mbed_official 126:549ba18ddd81 1322 {
mbed_official 126:549ba18ddd81 1323 /* Check the parameters */
mbed_official 126:549ba18ddd81 1324 assert_param(IS_CAN_ALL_PERIPH(CANx));
mbed_official 126:549ba18ddd81 1325 assert_param(IS_CAN_CLEAR_IT(CAN_IT));
mbed_official 126:549ba18ddd81 1326
mbed_official 126:549ba18ddd81 1327 switch (CAN_IT)
mbed_official 126:549ba18ddd81 1328 {
mbed_official 126:549ba18ddd81 1329 case CAN_IT_TME:
mbed_official 126:549ba18ddd81 1330 /* Clear CAN_TSR_RQCPx (rc_w1)*/
mbed_official 126:549ba18ddd81 1331 CANx->TSR = CAN_TSR_RQCP0|CAN_TSR_RQCP1|CAN_TSR_RQCP2;
mbed_official 126:549ba18ddd81 1332 break;
mbed_official 126:549ba18ddd81 1333 case CAN_IT_FF0:
mbed_official 126:549ba18ddd81 1334 /* Clear CAN_RF0R_FULL0 (rc_w1)*/
mbed_official 126:549ba18ddd81 1335 CANx->RF0R = CAN_RF0R_FULL0;
mbed_official 126:549ba18ddd81 1336 break;
mbed_official 126:549ba18ddd81 1337 case CAN_IT_FOV0:
mbed_official 126:549ba18ddd81 1338 /* Clear CAN_RF0R_FOVR0 (rc_w1)*/
mbed_official 126:549ba18ddd81 1339 CANx->RF0R = CAN_RF0R_FOVR0;
mbed_official 126:549ba18ddd81 1340 break;
mbed_official 126:549ba18ddd81 1341 case CAN_IT_FF1:
mbed_official 126:549ba18ddd81 1342 /* Clear CAN_RF1R_FULL1 (rc_w1)*/
mbed_official 126:549ba18ddd81 1343 CANx->RF1R = CAN_RF1R_FULL1;
mbed_official 126:549ba18ddd81 1344 break;
mbed_official 126:549ba18ddd81 1345 case CAN_IT_FOV1:
mbed_official 126:549ba18ddd81 1346 /* Clear CAN_RF1R_FOVR1 (rc_w1)*/
mbed_official 126:549ba18ddd81 1347 CANx->RF1R = CAN_RF1R_FOVR1;
mbed_official 126:549ba18ddd81 1348 break;
mbed_official 126:549ba18ddd81 1349 case CAN_IT_WKU:
mbed_official 126:549ba18ddd81 1350 /* Clear CAN_MSR_WKUI (rc_w1)*/
mbed_official 126:549ba18ddd81 1351 CANx->MSR = CAN_MSR_WKUI;
mbed_official 126:549ba18ddd81 1352 break;
mbed_official 126:549ba18ddd81 1353 case CAN_IT_SLK:
mbed_official 126:549ba18ddd81 1354 /* Clear CAN_MSR_SLAKI (rc_w1)*/
mbed_official 126:549ba18ddd81 1355 CANx->MSR = CAN_MSR_SLAKI;
mbed_official 126:549ba18ddd81 1356 break;
mbed_official 126:549ba18ddd81 1357 case CAN_IT_EWG:
mbed_official 126:549ba18ddd81 1358 /* Clear CAN_MSR_ERRI (rc_w1) */
mbed_official 126:549ba18ddd81 1359 CANx->MSR = CAN_MSR_ERRI;
mbed_official 126:549ba18ddd81 1360 /* Note : the corresponding Flag is cleared by hardware depending
mbed_official 126:549ba18ddd81 1361 of the CAN Bus status*/
mbed_official 126:549ba18ddd81 1362 break;
mbed_official 126:549ba18ddd81 1363 case CAN_IT_EPV:
mbed_official 126:549ba18ddd81 1364 /* Clear CAN_MSR_ERRI (rc_w1) */
mbed_official 126:549ba18ddd81 1365 CANx->MSR = CAN_MSR_ERRI;
mbed_official 126:549ba18ddd81 1366 /* Note : the corresponding Flag is cleared by hardware depending
mbed_official 126:549ba18ddd81 1367 of the CAN Bus status*/
mbed_official 126:549ba18ddd81 1368 break;
mbed_official 126:549ba18ddd81 1369 case CAN_IT_BOF:
mbed_official 126:549ba18ddd81 1370 /* Clear CAN_MSR_ERRI (rc_w1) */
mbed_official 126:549ba18ddd81 1371 CANx->MSR = CAN_MSR_ERRI;
mbed_official 126:549ba18ddd81 1372 /* Note : the corresponding Flag is cleared by hardware depending
mbed_official 126:549ba18ddd81 1373 of the CAN Bus status*/
mbed_official 126:549ba18ddd81 1374 break;
mbed_official 126:549ba18ddd81 1375 case CAN_IT_LEC:
mbed_official 126:549ba18ddd81 1376 /* Clear LEC bits */
mbed_official 126:549ba18ddd81 1377 CANx->ESR = RESET;
mbed_official 126:549ba18ddd81 1378 /* Clear CAN_MSR_ERRI (rc_w1) */
mbed_official 126:549ba18ddd81 1379 CANx->MSR = CAN_MSR_ERRI;
mbed_official 126:549ba18ddd81 1380 break;
mbed_official 126:549ba18ddd81 1381 case CAN_IT_ERR:
mbed_official 126:549ba18ddd81 1382 /*Clear LEC bits */
mbed_official 126:549ba18ddd81 1383 CANx->ESR = RESET;
mbed_official 126:549ba18ddd81 1384 /* Clear CAN_MSR_ERRI (rc_w1) */
mbed_official 126:549ba18ddd81 1385 CANx->MSR = CAN_MSR_ERRI;
mbed_official 126:549ba18ddd81 1386 /* Note : BOFF, EPVF and EWGF Flags are cleared by hardware depending
mbed_official 126:549ba18ddd81 1387 of the CAN Bus status*/
mbed_official 126:549ba18ddd81 1388 break;
mbed_official 126:549ba18ddd81 1389 default :
mbed_official 126:549ba18ddd81 1390 break;
mbed_official 126:549ba18ddd81 1391 }
mbed_official 126:549ba18ddd81 1392 }
mbed_official 126:549ba18ddd81 1393
mbed_official 126:549ba18ddd81 1394 /**
mbed_official 126:549ba18ddd81 1395 * @brief Checks whether the CAN interrupt has occurred or not.
mbed_official 126:549ba18ddd81 1396 * @param CAN_Reg: specifies the CAN interrupt register to check.
mbed_official 126:549ba18ddd81 1397 * @param It_Bit: specifies the interrupt source bit to check.
mbed_official 126:549ba18ddd81 1398 * @retval The new state of the CAN Interrupt (SET or RESET).
mbed_official 126:549ba18ddd81 1399 */
mbed_official 126:549ba18ddd81 1400 static ITStatus CheckITStatus(uint32_t CAN_Reg, uint32_t It_Bit)
mbed_official 126:549ba18ddd81 1401 {
mbed_official 126:549ba18ddd81 1402 ITStatus pendingbitstatus = RESET;
mbed_official 126:549ba18ddd81 1403
mbed_official 126:549ba18ddd81 1404 if ((CAN_Reg & It_Bit) != (uint32_t)RESET)
mbed_official 126:549ba18ddd81 1405 {
mbed_official 126:549ba18ddd81 1406 /* CAN_IT is set */
mbed_official 126:549ba18ddd81 1407 pendingbitstatus = SET;
mbed_official 126:549ba18ddd81 1408 }
mbed_official 126:549ba18ddd81 1409 else
mbed_official 126:549ba18ddd81 1410 {
mbed_official 126:549ba18ddd81 1411 /* CAN_IT is reset */
mbed_official 126:549ba18ddd81 1412 pendingbitstatus = RESET;
mbed_official 126:549ba18ddd81 1413 }
mbed_official 126:549ba18ddd81 1414 return pendingbitstatus;
mbed_official 126:549ba18ddd81 1415 }
mbed_official 126:549ba18ddd81 1416
mbed_official 126:549ba18ddd81 1417
mbed_official 126:549ba18ddd81 1418 /**
mbed_official 126:549ba18ddd81 1419 * @}
mbed_official 126:549ba18ddd81 1420 */
mbed_official 126:549ba18ddd81 1421
mbed_official 126:549ba18ddd81 1422 /**
mbed_official 126:549ba18ddd81 1423 * @}
mbed_official 126:549ba18ddd81 1424 */
mbed_official 126:549ba18ddd81 1425
mbed_official 126:549ba18ddd81 1426 /**
mbed_official 126:549ba18ddd81 1427 * @}
mbed_official 126:549ba18ddd81 1428 */
mbed_official 126:549ba18ddd81 1429
mbed_official 126:549ba18ddd81 1430 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/