OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [freertos-6.1.1/] [Demo/] [ARM7_STR75x_GCC/] [STLibrary/] [src/] [75x_can.c] - Blame information for rev 577

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 577 jeremybenn 
/******************** (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****/

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.