jspc29.x-matter.uni-frankfurt.de Git - mvd_firmware.git/blob

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