begriffs open source - cmsis-freertos/blob - Demo/ARM7_STR75x_GCC/STLibrary/src/75x_can.c

   1 /******************** (C) COPYRIGHT 2006 STMicroelectronics ********************
   2 * File Name          : 75x_can.c
   3 * Author             : MCD Application Team
   4 * Date First Issued  : 03/10/2006
   5 * Description        : This file provides all the CAN software functions.
   6 ********************************************************************************
   7 * History:
   8 * 07/17/2006 : V1.0
   9 * 03/10/2006 : V0.1
  10 ********************************************************************************
  11 * THE PRESENT SOFTWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
  12 * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
  13 * AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
  14 * INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
  15 * CONTENT OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
  16 * INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
  17 *******************************************************************************/
  18
  19 /* Includes ------------------------------------------------------------------*/
  20 #include "75x_can.h"
  21 #include "75x_mrcc.h"
  22
  23 /* Private typedef -----------------------------------------------------------*/
  24 /* Private define ------------------------------------------------------------*/
  25 /* Private macro -------------------------------------------------------------*/
  26 /*----------------------------------------------------------------------------*/
  27 /* Macro Name     : xxx_ID_MSK, xxx_ID_ARB                                    */
  28 /* Description    : Form the Mask and Arbitration registers value to filter   */
  29 /*                  a range of identifiers or a fixed identifier, for standard*/
  30 /*                  and extended IDs                                          */
  31 /*----------------------------------------------------------------------------*/
  32 #define RANGE_ID_MSK(range_start, range_end)    (~((range_end) - (range_start)))
  33 #define RANGE_ID_ARB(range_start, range_end)    ((range_start) & (range_end))
  34
  35 #define FIXED_ID_MSK(id)        RANGE_ID_MSK((id), (id))
  36 #define FIXED_ID_ARB(id)        RANGE_ID_ARB((id), (id))
  37
  38 #define STD_RANGE_ID_MSK(range_start, range_end)        ((u16)((RANGE_ID_MSK((range_start), (range_end)) & 0x7FF) << 2))
  39 #define STD_RANGE_ID_ARB(range_start, range_end)        ((u16)(RANGE_ID_ARB((range_start), (range_end)) << 2))
  40
  41 #define STD_FIXED_ID_MSK(id)    ((u16)((FIXED_ID_MSK(id) & 0x7FF) << 2))
  42 #define STD_FIXED_ID_ARB(id)    ((u16)(FIXED_ID_ARB(id) << 2))
  43
  44 #define EXT_RANGE_ID_MSK_L(range_start, range_end)      ((u16)(RANGE_ID_MSK((range_start), (range_end)) >> 11))
  45 #define EXT_RANGE_ID_MSK_H(range_start, range_end)      ((u16)(STD_RANGE_ID_MSK((range_start), (range_end)) | ((RANGE_ID_MSK((range_start), (range_end)) >> 27) & 0x03)))
  46 #define EXT_RANGE_ID_ARB_L(range_start, range_end)      ((u16)(RANGE_ID_ARB((range_start), (range_end)) >> 11))
  47 #define EXT_RANGE_ID_ARB_H(range_start, range_end)      ((u16)(STD_RANGE_ID_ARB((range_start), (range_end)) | ((RANGE_ID_ARB((range_start), (range_end)) >> 27) & 0x03)))
  48
  49 #define EXT_FIXED_ID_MSK_L(id)  ((u16)(FIXED_ID_MSK(id) >> 11))
  50 #define EXT_FIXED_ID_MSK_H(id)  ((u16)(STD_FIXED_ID_MSK(id) | ((FIXED_ID_MSK(id) >> 27) & 0x03)))
  51 #define EXT_FIXED_ID_ARB_L(id)  ((u16)(FIXED_ID_ARB(id) >> 11))
  52 #define EXT_FIXED_ID_ARB_H(id)  ((u16)(STD_FIXED_ID_ARB(id) | ((FIXED_ID_ARB(id) >> 27) & 0x03)))
  53
  54 /* macro to format the timing register value from the timing parameters*/
  55 #define CAN_TIMING(tseg1, tseg2, sjw, brp)      ((((tseg2-1) & 0x07) << 12) | (((tseg1-1) & 0x0F) << 8) | (((sjw-1) & 0x03) << 6) | ((brp-1) & 0x3F))
  56
  57 /* Private variables ---------------------------------------------------------*/
  58 /* array of pre-defined timing parameters for standard bitrates*/
  59 u16 CanTimings[] = {       /* value   bitrate     NTQ  TSEG1  TSEG2  SJW  BRP */
  60   CAN_TIMING(11, 4, 4, 5), /* 0x3AC4  100 kbit/s  16   11     4      4    5   */
  61   CAN_TIMING(11, 4, 4, 4), /* 0x3AC3  125 kbit/s  16   11     4      4    4   */
  62   CAN_TIMING( 4, 3, 3, 4), /* 0x2383  250 kbit/s   8    4     3      3    4   */
  63   CAN_TIMING(13, 2, 1, 1), /* 0x1C00  500 kbit/s  16   13     2      1    1   */
  64   CAN_TIMING( 4, 3, 1, 1), /* 0x2300  1 Mbit/s     8    4     3      1    1   */
  65 };
  66
  67 /* Private function prototypes -----------------------------------------------*/
  68 static u32 GetFreeIF(void);
  69 /* Private functions ---------------------------------------------------------*/
  70
  71 /*******************************************************************************
  72 * Function Name  : CAN_DeInit
  73 * Description    : Deinitializes the CAN peripheral registers to their default
  74 *                  reset values.
  75 * Input          : None
  76 * Output         : None
  77 * Return         : None
  78 *******************************************************************************/
  79 void CAN_DeInit (void)
  80 {
  81   /* Reset the CAN registers values*/
  82   MRCC_PeripheralSWResetConfig(MRCC_Peripheral_CAN,ENABLE);
  83   MRCC_PeripheralSWResetConfig(MRCC_Peripheral_CAN,DISABLE);
  84 }
  85
  86 /*******************************************************************************
  87 * Function Name  : CAN_Init
  88 * Description    : Initializes the CAN peripheral according to the specified
  89 *                  parameters in the CAN_InitStruct.
  90 * Input          : CAN_InitStruct: pointer to a CAN_InitTypeDef structure that
  91 *                  contains the configuration information for the CAN peripheral.
  92 * Output         : None
  93 * Return         : None
  94 *******************************************************************************/
  95 void CAN_Init(CAN_InitTypeDef* CAN_InitStruct)
  96 {
  97   CAN_EnterInitMode(CAN_CR_CCE | CAN_InitStruct->CAN_ConfigParameters);
  98   CAN_SetBitrate(CAN_InitStruct->CAN_Bitrate);
  99   CAN_LeaveInitMode();
 100   CAN_LeaveTestMode();
 101 }
 102
 103 /*******************************************************************************
 104 * Function Name  : CAN_StructInit
 105 * Description    : Fills each CAN_InitStruct member with its reset value.
 106 * Input          : CAN_InitStruct : pointer to a CAN_InitTypeDef structure which
 107 *                  will be initialized.
 108 * Output         : None
 109 * Return         : None.
 110 *******************************************************************************/
 111 void CAN_StructInit(CAN_InitTypeDef* CAN_InitStruct)
 112 {
 113 /* Reset CAN init structure parameters values */
 114   CAN_InitStruct->CAN_ConfigParameters = 0x0;
 115   CAN_InitStruct->CAN_Bitrate = 0x2301;
 116 }
 117
 118 /*******************************************************************************
 119 * Function Name  : CAN_SetBitrate
 120 * Description    : Setups a standard CAN bitrate.
 121 * Input          : bitrate: specifies the bit rate.
 122 * Output         : None
 123 * Return         : None
 124 *******************************************************************************/
 125 void CAN_SetBitrate(u32 bitrate)
 126 {
 127   CAN->BTR = CanTimings[bitrate];  /* write the predefined timing value */
 128   CAN->BRPR = 0;                     /* clear the Extended Baud Rate Prescaler */
 129 }
 130
 131 /*******************************************************************************
 132 * Function Name  : CAN_SetTiming
 133 * Description    : Setups the CAN timing with specific parameters
 134 * Input          : - tseg1: specifies Time Segment before the sample point.
 135 *                    This parameter must be a number between 1 and 16.
 136 *                  - tseg2: Time Segment after the sample point. This parameter
 137 *                    must be a number between 1 and 8.
 138 *                  - sjw: Synchronisation Jump Width. This parameter must be
 139 *                     a number between 1 and 4.
 140 *                  - brp: Baud Rate Prescaler. This parameter must be a number
 141 *                    between 1 and 1024.
 142 * Output         : None
 143 * Return         : None
 144 *******************************************************************************/
 145 void CAN_SetTiming(u32 tseg1, u32 tseg2, u32 sjw, u32 brp)
 146 {
 147   CAN->BTR = CAN_TIMING(tseg1, tseg2, sjw, brp);
 148   CAN->BRPR = ((brp-1) >> 6) & 0x0F;
 149 }
 150
 151 /*******************************************************************************
 152 * Function Name  : GetFreeIF
 153 * Description    : Searchs the first free message interface, starting from 0.
 154 * Input          : None
 155 * Output         : None
 156 * Return         : A free message interface number (0 or 1) if found, else 2
 157 *******************************************************************************/
 158 static u32 GetFreeIF(void)
 159 {
 160   if ((CAN->sMsgObj[0].CRR & CAN_CRR_BUSY) == 0)
 161     return 0;
 162   else if ((CAN->sMsgObj[1].CRR & CAN_CRR_BUSY) == 0)
 163     return 1;
 164   else
 165    return 2;
 166 }
 167
 168 /*******************************************************************************
 169 * Function Name  : CAN_SetUnusedMsgObj
 170 * Description    : Configures the message object as unused
 171 * Input          : msgobj: specifies the Message object number, from 0 to 31.
 172 * Output         : None
 173 * Return         : An ErrorStatus enumuration value:
 174 *                         - SUCCESS: Interface to treat the message
 175 *                         - ERROR: No interface found to treat the message
 176 *******************************************************************************/
 177 ErrorStatus CAN_SetUnusedMsgObj(u32 msgobj)
 178 {
 179   u32 msg_if=0;
 180
 181   if ((msg_if = GetFreeIF()) == 2)
 182   {
 183     return ERROR;
 184   }
 185
 186   CAN->sMsgObj[msg_if].CMR = CAN_CMR_WRRD
 187                            | CAN_CMR_MASK
 188                            | CAN_CMR_ARB
 189                            | CAN_CMR_CONTROL
 190                            | CAN_CMR_DATAA
 191                            | CAN_CMR_DATAB;
 192
 193   CAN->sMsgObj[msg_if].M1R = 0;
 194   CAN->sMsgObj[msg_if].M2R = 0;
 195
 196   CAN->sMsgObj[msg_if].A1R = 0;
 197   CAN->sMsgObj[msg_if].A2R = 0;
 198
 199   CAN->sMsgObj[msg_if].MCR = 0;
 200
 201   CAN->sMsgObj[msg_if].DA1R = 0;
 202   CAN->sMsgObj[msg_if].DA2R = 0;
 203   CAN->sMsgObj[msg_if].DB1R = 0;
 204   CAN->sMsgObj[msg_if].DB2R = 0;
 205
 206  CAN->sMsgObj[msg_if].CRR = 1 + msgobj;
 207
 208  return SUCCESS;
 209 }
 210
 211 /*******************************************************************************
 212 * Function Name  : CAN_SetTxMsgObj
 213 * Description    : Configures the message object as TX.
 214 * Input          : - msgobj: specifies the Message object number, from 0 to 31.
 215 *                  - idType: specifies the identifier type of the frames that
 216 *                    will be transmitted using this message object.
 217 *                    This parameter can be one of the following values:
 218 *                          - CAN_STD_ID (standard ID, 11-bit)
 219 *                          - CAN_EXT_ID (extended ID, 29-bit)
 220 * Output         : None
 221 * Return         : An ErrorStatus enumuration value:
 222 *                         - SUCCESS: Interface to treat the message
 223 *                         - ERROR: No interface found to treat the message
 224 *******************************************************************************/
 225 ErrorStatus CAN_SetTxMsgObj(u32 msgobj, u32 idType)
 226 {
 227   u32 msg_if=0;
 228
 229   if ((msg_if = GetFreeIF()) == 2)
 230   {
 231     return ERROR;
 232   }
 233
 234   CAN->sMsgObj[msg_if].CMR = CAN_CMR_WRRD
 235                            | CAN_CMR_MASK
 236                            | CAN_CMR_ARB
 237                            | CAN_CMR_CONTROL
 238                            | CAN_CMR_DATAA
 239                            | CAN_CMR_DATAB;
 240
 241   CAN->sMsgObj[msg_if].M1R = 0;
 242   CAN->sMsgObj[msg_if].A1R = 0;
 243
 244   if (idType == CAN_STD_ID)
 245   {
 246     CAN->sMsgObj[msg_if].M2R = CAN_M2R_MDIR;
 247     CAN->sMsgObj[msg_if].A2R = CAN_A2R_MSGVAL | CAN_A2R_DIR;
 248   }
 249   else
 250   {
 251     CAN->sMsgObj[msg_if].M2R = CAN_M2R_MDIR | CAN_M2R_MXTD;
 252     CAN->sMsgObj[msg_if].A2R = CAN_A2R_MSGVAL | CAN_A2R_DIR | CAN_A2R_XTD;
 253   }
 254
 255   CAN->sMsgObj[msg_if].MCR = CAN_MCR_TXIE | CAN_MCR_EOB;
 256
 257   CAN->sMsgObj[msg_if].DA1R = 0;
 258   CAN->sMsgObj[msg_if].DA2R = 0;
 259   CAN->sMsgObj[msg_if].DB1R = 0;
 260   CAN->sMsgObj[msg_if].DB2R = 0;
 261
 262   CAN->sMsgObj[msg_if].CRR = 1 + msgobj;
 263
 264   return SUCCESS;
 265 }
 266
 267 /*******************************************************************************
 268 * Function Name  : CAN_SetRxMsgObj
 269 * Description    : Configures the message object as RX.
 270 * Input          : - msgobj: specifies the Message object number, from 0 to 31.
 271 *                  - idType: specifies the identifier type of the frames that
 272 *                    will be transmitted using this message object.
 273 *                    This parameter can be one of the following values:
 274 *                          - CAN_STD_ID (standard ID, 11-bit)
 275 *                          - CAN_EXT_ID (extended ID, 29-bit)
 276 *                  - idLow: specifies the low part of the identifier range used
 277 *                    for acceptance filtering.
 278 *                  - idHigh: specifies the high part of the identifier range
 279 *                    used for acceptance filtering.
 280 *                  - singleOrFifoLast: specifies the end-of-buffer indicator.
 281 *                    This parameter can be one of the following values:
 282 *                          - TRUE: for a single receive object or a FIFO receive
 283 *                            object that is the last one of the FIFO.
 284 *                          - FALSE: for a FIFO receive object that is not the
 285 *                            last one.
 286 * Output         : None
 287 * Return         : An ErrorStatus enumuration value:
 288 *                         - SUCCESS: Interface to treat the message
 289 *                         - ERROR: No interface found to treat the message
 290 *******************************************************************************/
 291 ErrorStatus CAN_SetRxMsgObj(u32 msgobj, u32 idType, u32 idLow, u32 idHigh, bool singleOrFifoLast)
 292 {
 293   u32 msg_if=0;
 294
 295   if ((msg_if = GetFreeIF()) == 2)
 296   {
 297     return ERROR;
 298   }
 299
 300   CAN->sMsgObj[msg_if].CMR = CAN_CMR_WRRD
 301                            | CAN_CMR_MASK
 302                            | CAN_CMR_ARB
 303                            | CAN_CMR_CONTROL
 304                            | CAN_CMR_DATAA
 305                            | CAN_CMR_DATAB;
 306
 307   if (idType == CAN_STD_ID)
 308   {
 309     CAN->sMsgObj[msg_if].M1R = 0;
 310     CAN->sMsgObj[msg_if].M2R = STD_RANGE_ID_MSK(idLow, idHigh);
 311
 312     CAN->sMsgObj[msg_if].A1R = 0;
 313     CAN->sMsgObj[msg_if].A2R = CAN_A2R_MSGVAL | STD_RANGE_ID_ARB(idLow, idHigh);
 314   }
 315   else
 316   {
 317     CAN->sMsgObj[msg_if].M1R = EXT_RANGE_ID_MSK_L(idLow, idHigh);
 318     CAN->sMsgObj[msg_if].M2R = CAN_M2R_MXTD | EXT_RANGE_ID_MSK_H(idLow, idHigh);
 319
 320     CAN->sMsgObj[msg_if].A1R = EXT_RANGE_ID_ARB_L(idLow, idHigh);
 321     CAN->sMsgObj[msg_if].A2R = CAN_A2R_MSGVAL | CAN_A2R_XTD | EXT_RANGE_ID_ARB_H(idLow, idHigh);
 322   }
 323
 324   CAN->sMsgObj[msg_if].MCR = CAN_MCR_RXIE | CAN_MCR_UMASK | (singleOrFifoLast ? CAN_MCR_EOB : 0);
 325
 326   CAN->sMsgObj[msg_if].DA1R = 0;
 327   CAN->sMsgObj[msg_if].DA2R = 0;
 328   CAN->sMsgObj[msg_if].DB1R = 0;
 329   CAN->sMsgObj[msg_if].DB2R = 0;
 330
 331   CAN->sMsgObj[msg_if].CRR = 1 + msgobj;
 332
 333   return SUCCESS;
 334 }
 335
 336 /*******************************************************************************
 337 * Function Name  : CAN_InvalidateAllMsgObj
 338 * Description    : Configures all the message objects as unused.
 339 * Input          : None
 340 * Output         : None
 341 * Return         : None
 342 *******************************************************************************/
 343 void CAN_InvalidateAllMsgObj(void)
 344 {
 345   u32 i=0;
 346   for (i = 0; i < 32; i++)
 347     CAN_SetUnusedMsgObj(i);
 348 }
 349
 350
 351 /*******************************************************************************
 352 * Function Name  : CAN_ReleaseMessage
 353 * Description    : Releases the message object
 354 * Input          : - msgobj: specifies the Message object number, from 0 to 31.
 355 * Output         : None
 356 * Return         : An ErrorStatus enumuration value:
 357 *                         - SUCCESS: Interface to treat the message
 358 *                         - ERROR: No interface found to treat the message
 359 *******************************************************************************/
 360 ErrorStatus CAN_ReleaseMessage(u32 msgobj)
 361 {
 362   u32 msg_if=0;
 363
 364   if ((msg_if = GetFreeIF()) == 2)
 365   {
 366     return ERROR;
 367   }
 368
 369   CAN->sMsgObj[msg_if].CMR = CAN_CMR_CLRINTPND | CAN_CMR_TXRQSTNEWDAT;
 370   CAN->sMsgObj[msg_if].CRR = 1 + msgobj;
 371
 372   return SUCCESS;
 373 }
 374
 375 /*******************************************************************************
 376 * Function Name  : CAN_SendMessage
 377 * Description    : Start transmission of a message
 378 * Input          : - msgobj: specifies the Message object number, from 0 to 31.
 379 *                : - pCanMsg: pointer to the message structure containing data
 380 *                    to transmit.
 381 * Output         : None
 382 * Return         : An ErrorStatus enumuration value:
 383 *                         - SUCCESS: Transmission OK
 384 *                         - ERROR: No transmission
 385 *******************************************************************************/
 386 ErrorStatus CAN_SendMessage(u32 msgobj, canmsg* pCanMsg)
 387 {
 388   if (CAN->sMsgObj[0].CRR & CAN_CRR_BUSY)
 389   {
 390     return ERROR;
 391   }
 392
 393   CAN->SR &= ~CAN_SR_TXOK;
 394
 395   /* read the Arbitration and Message Control*/
 396   CAN->sMsgObj[0].CMR = CAN_CMR_ARB | CAN_CMR_CONTROL;
 397
 398   CAN->sMsgObj[0].CRR = 1 + msgobj;
 399
 400   if (CAN->sMsgObj[0].CRR & CAN_CRR_BUSY)
 401   {
 402     return ERROR;
 403   }
 404
 405   /* update the contents needed for transmission*/
 406   CAN->sMsgObj[0].CMR = CAN_CMR_WRRD
 407                       | CAN_CMR_ARB
 408                       | CAN_CMR_CONTROL
 409                       | CAN_CMR_DATAA
 410                       | CAN_CMR_DATAB;
 411
 412   if ((CAN->sMsgObj[0].A2R & CAN_A2R_XTD) == 0)
 413   {
 414     /* standard ID*/
 415     CAN->sMsgObj[0].A1R = 0;
 416     CAN->sMsgObj[0].A2R = (CAN->sMsgObj[0].A2R & 0xE000) | STD_FIXED_ID_ARB(pCanMsg->Id);
 417   }
 418   else
 419   {
 420     /* extended ID*/
 421     CAN->sMsgObj[0].A1R = EXT_FIXED_ID_ARB_L(pCanMsg->Id);
 422     CAN->sMsgObj[0].A2R = (CAN->sMsgObj[0].A2R & 0xE000) | EXT_FIXED_ID_ARB_H(pCanMsg->Id);
 423   }
 424
 425   CAN->sMsgObj[0].MCR = (CAN->sMsgObj[0].MCR & 0xFEF0) | CAN_MCR_NEWDAT | CAN_MCR_TXRQST | pCanMsg->Dlc;
 426
 427   CAN->sMsgObj[0].DA1R = ((u16)pCanMsg->Data[1]<<8) | pCanMsg->Data[0];
 428   CAN->sMsgObj[0].DA2R = ((u16)pCanMsg->Data[3]<<8) | pCanMsg->Data[2];
 429   CAN->sMsgObj[0].DB1R = ((u16)pCanMsg->Data[5]<<8) | pCanMsg->Data[4];
 430   CAN->sMsgObj[0].DB2R = ((u16)pCanMsg->Data[7]<<8) | pCanMsg->Data[6];
 431
 432   CAN->sMsgObj[0].CRR = 1 + msgobj;
 433
 434   return SUCCESS;
 435 }
 436
 437 /*******************************************************************************
 438 * Function Name  : CAN_ReceiveMessage
 439 * Description    : Gets the message, if received.
 440 * Input          : - msgobj: specifies the Message object number, from 0 to 31.
 441 *                  - release: specifies the message release indicator.
 442 *                    This parameter can be one of the following values:
 443 *                          - TRUE: the message object is released when getting
 444 *                            the data.
 445 *                          - FALSE: the message object is not released.
 446 *                  - pCanMsg: pointer to the message structure where received
 447 *                    data is copied.
 448 * Output         : None
 449 * Return         : An ErrorStatus enumuration value:
 450 *                         - SUCCESS: Reception OK
 451 *                         - ERROR: No message pending
 452 *******************************************************************************/
 453 ErrorStatus CAN_ReceiveMessage(u32 msgobj, bool release, canmsg* pCanMsg)
 454 {
 455   if (!CAN_IsMessageWaiting(msgobj))
 456   {
 457     return ERROR;
 458   }
 459
 460   CAN->SR &= ~CAN_SR_RXOK;
 461
 462   /* read the message contents*/
 463   CAN->sMsgObj[1].CMR = CAN_CMR_MASK
 464                       | CAN_CMR_ARB
 465                       | CAN_CMR_CONTROL
 466                       | CAN_CMR_CLRINTPND
 467                       | (release ? CAN_CMR_TXRQSTNEWDAT : 0)
 468                       | CAN_CMR_DATAA
 469                       | CAN_CMR_DATAB;
 470
 471   CAN->sMsgObj[1].CRR = 1 + msgobj;
 472
 473   if (CAN->sMsgObj[1].CRR & CAN_CRR_BUSY)
 474   {
 475     return ERROR;
 476   }
 477
 478   if ((CAN->sMsgObj[1].A2R & CAN_A2R_XTD) == 0)
 479   {
 480     /* standard ID*/
 481     pCanMsg->IdType = CAN_STD_ID;
 482     pCanMsg->Id = (CAN->sMsgObj[1].A2R >> 2) & 0x07FF;
 483   }
 484   else
 485   {
 486     /* extended ID*/
 487     pCanMsg->IdType = CAN_EXT_ID;
 488     pCanMsg->Id  = ((CAN->sMsgObj[1].A2R >> 2) & 0x07FF);
 489     pCanMsg->Id |= ((u32)CAN->sMsgObj[1].A1R << 11);
 490     pCanMsg->Id |= (((u32)CAN->sMsgObj[1].A2R & 0x0003) << 27);
 491   }
 492
 493   pCanMsg->Dlc = CAN->sMsgObj[1].MCR & 0x0F;
 494
 495   pCanMsg->Data[0] = (u8) CAN->sMsgObj[1].DA1R;
 496   pCanMsg->Data[1] = (u8)(CAN->sMsgObj[1].DA1R >> 8);
 497   pCanMsg->Data[2] = (u8) CAN->sMsgObj[1].DA2R;
 498   pCanMsg->Data[3] = (u8)(CAN->sMsgObj[1].DA2R >> 8);
 499   pCanMsg->Data[4] = (u8) CAN->sMsgObj[1].DB1R;
 500   pCanMsg->Data[5] = (u8)(CAN->sMsgObj[1].DB1R >> 8);
 501   pCanMsg->Data[6] = (u8) CAN->sMsgObj[1].DB2R;
 502   pCanMsg->Data[7] = (u8)(CAN->sMsgObj[1].DB2R >> 8);
 503
 504   return SUCCESS;
 505 }
 506
 507 /*******************************************************************************
 508 * Function Name  : CAN_WaitEndOfTx
 509 * Description    : Waits until current transmission is finished.
 510 * Input          : None
 511 * Output         : None
 512 * Return         : An ErrorStatus enumuration value:
 513 *                         - SUCCESS: Transmission ended
 514 *                         - ERROR: Transmission did not occur yet
 515 *******************************************************************************/
 516 ErrorStatus CAN_WaitEndOfTx(void)
 517 {
 518   if ((CAN->SR & CAN_SR_TXOK) == 0)
 519   {
 520     return ERROR;
 521   }
 522   CAN->SR &= ~CAN_SR_TXOK;
 523
 524   return SUCCESS;
 525 }
 526
 527 /*******************************************************************************
 528 * Function Name  : CAN_BasicSendMessage
 529 * Description    : Starts transmission of a message in BASIC mode. This mode
 530 *                  does not use the message RAM.
 531 * Input          : pCanMsg: Pointer to the message structure containing data to
 532 *                  transmit.
 533 * Output         : None
 534 * Return         : An ErrorStatus enumuration value:
 535 *                         - SUCCESS: Transmission OK
 536 *                         - ERROR: No transmission
 537 *******************************************************************************/
 538 ErrorStatus CAN_BasicSendMessage(canmsg* pCanMsg)
 539 {
 540   /* clear NewDat bit in IF2 to detect next reception*/
 541   CAN->sMsgObj[1].MCR &= ~CAN_MCR_NEWDAT;
 542
 543   CAN->SR &= ~CAN_SR_TXOK;
 544   CAN->sMsgObj[0].CMR = CAN_CMR_WRRD
 545                       | CAN_CMR_ARB
 546                       | CAN_CMR_CONTROL
 547                       | CAN_CMR_DATAA
 548                       | CAN_CMR_DATAB;
 549
 550   if (pCanMsg->IdType == CAN_STD_ID)
 551   {
 552     /* standard ID*/
 553     CAN->sMsgObj[0].A1R = 0;
 554     CAN->sMsgObj[0].A2R = (CAN->sMsgObj[0].A2R & 0xE000) | STD_FIXED_ID_ARB(pCanMsg->Id);
 555   }
 556   else
 557   {
 558     /* extended ID*/
 559     CAN->sMsgObj[0].A1R = EXT_FIXED_ID_ARB_L(pCanMsg->Id);
 560     CAN->sMsgObj[0].A2R = ((CAN->sMsgObj[0].A2R) & 0xE000) | EXT_FIXED_ID_ARB_H(pCanMsg->Id);
 561   }
 562
 563   CAN->sMsgObj[0].MCR = (CAN->sMsgObj[0].MCR & 0xFCF0) | pCanMsg->Dlc;
 564
 565   CAN->sMsgObj[0].DA1R = ((u16)pCanMsg->Data[1]<<8) | pCanMsg->Data[0];
 566   CAN->sMsgObj[0].DA2R = ((u16)pCanMsg->Data[3]<<8) | pCanMsg->Data[2];
 567   CAN->sMsgObj[0].DB1R = ((u16)pCanMsg->Data[5]<<8) | pCanMsg->Data[4];
 568   CAN->sMsgObj[0].DB2R = ((u16)pCanMsg->Data[7]<<8) | pCanMsg->Data[6];
 569
 570   /* request transmission*/
 571   if (CAN->sMsgObj[0].CRR == CAN_CRR_BUSY )
 572   {
 573     return ERROR;
 574   }
 575
 576   return SUCCESS;
 577 }
 578
 579 /*******************************************************************************
 580 * Function Name  : CAN_BasicReceiveMessage
 581 * Description    : Gets the message in BASIC mode, if received. This mode does
 582 *                  not use the message RAM.
 583 * Input          : pCanMsg: pointer to the message structure where message is copied.
 584 * Output         : None
 585 * Return         : An ErrorStatus enumuration value:
 586 *                         - SUCCESS: Reception OK
 587 *                         - ERROR: No message pending
 588 *******************************************************************************/
 589 ErrorStatus CAN_BasicReceiveMessage(canmsg* pCanMsg)
 590 {
 591   if ((CAN->sMsgObj[1].MCR & CAN_MCR_NEWDAT) == 0)
 592   {
 593     return ERROR;
 594   }
 595
 596   CAN->SR &= ~CAN_SR_RXOK;
 597
 598   CAN->sMsgObj[1].CMR = CAN_CMR_ARB
 599                       | CAN_CMR_CONTROL
 600                       | CAN_CMR_DATAA
 601                       | CAN_CMR_DATAB;
 602
 603   if ((CAN->sMsgObj[1].A2R & CAN_A2R_XTD) == 0)
 604   {
 605     /* standard ID*/
 606     pCanMsg->IdType = CAN_STD_ID;
 607     pCanMsg->Id = (CAN->sMsgObj[1].A2R >> 2) & 0x07FF;
 608   }
 609   else
 610   {
 611     /* extended ID*/
 612     pCanMsg->IdType = CAN_EXT_ID;
 613     pCanMsg->Id  = ((CAN->sMsgObj[1].A2R >> 2) & 0x07FF);
 614     pCanMsg->Id |= ((u32)CAN->sMsgObj[1].A1R << 11);
 615     pCanMsg->Id |= (((u32)CAN->sMsgObj[1].A2R & 0x0003) << 27);
 616   }
 617
 618   pCanMsg->Dlc = CAN->sMsgObj[1].MCR & 0x0F;
 619
 620   pCanMsg->Data[0] = (u8) CAN->sMsgObj[1].DA1R;
 621   pCanMsg->Data[1] = (u8)(CAN->sMsgObj[1].DA1R >> 8);
 622   pCanMsg->Data[2] = (u8) CAN->sMsgObj[1].DA2R;
 623   pCanMsg->Data[3] = (u8)(CAN->sMsgObj[1].DA2R >> 8);
 624   pCanMsg->Data[4] = (u8) CAN->sMsgObj[1].DB1R;
 625   pCanMsg->Data[5] = (u8)(CAN->sMsgObj[1].DB1R >> 8);
 626   pCanMsg->Data[6] = (u8) CAN->sMsgObj[1].DB2R;
 627   pCanMsg->Data[7] = (u8)(CAN->sMsgObj[1].DB2R >> 8);
 628
 629   return SUCCESS;
 630 }
 631
 632 /*******************************************************************************
 633 * Function Name  : CAN_EnterInitMode
 634 * Description    : Switchs the CAN into initialization mode. This function must
 635 *                  be used in conjunction with CAN_LeaveInitMode().
 636 * Input          : InitMask: specifies the CAN configuration in normal mode.
 637 * Output         : None
 638 * Return         : None
 639 *******************************************************************************/
 640 void CAN_EnterInitMode(u8 InitMask)
 641 {
 642   CAN->CR = InitMask | CAN_CR_INIT;
 643   CAN->SR = 0;                                  /* reset the status*/
 644 }
 645
 646 /*******************************************************************************
 647 * Function Name  : CAN_LeaveInitMode
 648 * Description    : Leaves the initialization mode (switch into normal mode).
 649 *                  This function must be used in conjunction with CAN_EnterInitMode().
 650 * Input          : None
 651 * Output         : None
 652 * Return         : None
 653 *******************************************************************************/
 654 void CAN_LeaveInitMode(void)
 655 {
 656   CAN->CR &= ~(CAN_CR_INIT | CAN_CR_CCE);
 657 }
 658
 659 /*******************************************************************************
 660 * Function Name  : CAN_EnterTestMode
 661 * Description    : Switchs the CAN into test mode. This function must be used in
 662 *                  conjunction with CAN_LeaveTestMode().
 663 * Input          : TestMask: specifies the configuration in test modes.
 664 * Output         : None
 665 * Return         : None
 666 *******************************************************************************/
 667 void CAN_EnterTestMode(u8 TestMask)
 668 {
 669   CAN->CR |= CAN_CR_TEST;
 670   CAN->TESTR |= TestMask;
 671 }
 672
 673 /*******************************************************************************
 674 * Function Name  : CAN_LeaveTestMode
 675 * Description    : Leaves the current test mode (switch into normal mode).
 676 *                  This function must be used in conjunction with CAN_EnterTestMode().
 677 * Input          : None
 678 * Output         : None
 679 * Return         : None
 680 *******************************************************************************/
 681 void CAN_LeaveTestMode(void)
 682 {
 683   CAN->CR |= CAN_CR_TEST;
 684   CAN->TESTR &= ~(CAN_TESTR_LBACK | CAN_TESTR_SILENT | CAN_TESTR_BASIC);
 685   CAN->CR &= ~CAN_CR_TEST;
 686 }
 687
 688 /*******************************************************************************
 689 * Function Name  : CAN_ReleaseTxMessage
 690 * Description    : Releases the transmit message object.
 691 * Input          : - msgobj: specifies the Message object number, from 0 to 31.
 692 * Output         : None
 693 * Return         : None
 694 *******************************************************************************/
 695 void CAN_ReleaseTxMessage(u32 msgobj)
 696 {
 697   CAN->sMsgObj[0].CMR = CAN_CMR_CLRINTPND | CAN_CMR_TXRQSTNEWDAT;
 698   CAN->sMsgObj[0].CRR = 1 + msgobj;
 699 }
 700
 701 /*******************************************************************************
 702 * Function Name  : CAN_ReleaseRxMessage
 703 * Description    : Releases the receive message object.
 704 * Input          : - msgobj: specifies the Message object number, from 0 to 31.
 705 * Output         : None
 706 * Return         : None
 707 *******************************************************************************/
 708 void CAN_ReleaseRxMessage(u32 msgobj)
 709 {
 710   CAN->sMsgObj[1].CMR = CAN_CMR_CLRINTPND | CAN_CMR_TXRQSTNEWDAT;
 711   CAN->sMsgObj[1].CRR = 1 + msgobj;
 712 }
 713
 714 /*******************************************************************************
 715 * Function Name  : CAN_IsMessageWaiting
 716 * Description    : Tests the waiting status of a received message.
 717 * Input          : - msgobj: specifies the Message object number, from 0 to 31.
 718 * Output         : None
 719 * Return         : A non-zero value if the corresponding message object has
 720 *                  received a message waiting to be copied, else 0.
 721 *******************************************************************************/
 722 u32 CAN_IsMessageWaiting(u32 msgobj)
 723 {
 724   return (msgobj < 16 ? CAN->ND1R & (1 << msgobj) : CAN->ND2R & (1 << (msgobj-16)));
 725 }
 726
 727 /*******************************************************************************
 728 * Function Name  : CAN_IsTransmitRequested
 729 * Description    : Tests the request status of a transmitted message.
 730 * Input          : - msgobj: specifies the Message object number, from 0 to 31.
 731 * Output         : None
 732 * Return         : A non-zero value if the corresponding message is requested
 733 *                  to transmit, else 0.
 734 *******************************************************************************/
 735 u32 CAN_IsTransmitRequested(u32 msgobj)
 736 {
 737   return (msgobj < 16 ? CAN->TXR1R & (1 << msgobj) : CAN->TXR2R & (1 << (msgobj-16)));
 738 }
 739
 740 /*******************************************************************************
 741 * Function Name  : CAN_IsInterruptPending
 742 * Description    : Tests the interrupt status of a message object.
 743 * Input          : - msgobj: specifies the Message object number, from 0 to 31.
 744 * Output         : None
 745 * Return         : A non-zero value if the corresponding message has an
 746 *                  interrupt pending, else 0.
 747 *******************************************************************************/
 748 u32 CAN_IsInterruptPending(u32 msgobj)
 749 {
 750   return (msgobj < 16 ? CAN->IP1R & (1 << msgobj) : CAN->IP2R & (1 << (msgobj-16)));
 751 }
 752
 753 /*******************************************************************************
 754 * Function Name  : CAN_IsObjectValid
 755 * Description    : Tests the validity of a message object (ready to use).
 756 * Input          : - msgobj: specifies the Message object number, from 0 to 31.
 757 * Output         : None
 758 * Return         : A non-zero value if the corresponding message object is
 759 *                  valid, else 0.
 760 *******************************************************************************/
 761 u32 CAN_IsObjectValid(u32 msgobj)
 762 {
 763   return (msgobj < 16 ? CAN->MV1R & (1 << msgobj) : CAN->MV2R & (1 << (msgobj-16)));
 764 }
 765 /******************* (C) COPYRIGHT 2006 STMicroelectronics *****END OF FILE****/