mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

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

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

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

Import librarymbed

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

Last commit 20 Feb 2019 by mbed official

targets/cmsis/TARGET_STM/TARGET_NUCLEO_F302R8/stm32f30x_can.c@125:23cc3068a9e4, 2014-03-19 (annotated)

Committer:
mbed_official
Date:
Wed Mar 19 10:15:22 2014 +0000
Revision:
125:23cc3068a9e4
Synchronized with git revision ace35dfba3748c7cdc102eb38ec6b9e1067c3252



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



[NUCLEO_F302R8] Add cmsis and hal files + change F401RE clock to 84MHz

Who changed what in which revision?

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