M480 BSP V3.05.006
The Board Support Package for M480 Series
can.c
Go to the documentation of this file.
1/**************************************************************************/
9#include "NuMicro.h"
10
25#if defined(CAN2)
26static uint8_t gu8LockCanIf[3ul][2ul] = {0ul}; /* The chip has three CANs. */
27#elif defined(CAN1)
28static uint8_t gu8LockCanIf[2ul][2ul] = {0ul}; /* The chip has two CANs. */
29#elif defined(CAN0) || defined(CAN)
30static uint8_t gu8LockCanIf[1ul][2ul] = {0ul}; /* The chip only has one CAN. */
31#endif
32
33#define RETRY_COUNTS (0x10000000ul)
34
35#define TSEG1_MIN 2ul
36#define TSEG1_MAX 16ul
37#define TSEG2_MIN 1ul
38#define TSEG2_MAX 8ul
39#define BRP_MIN 1ul
40#define BRP_MAX 1024ul /* 6-bit BRP field + 4-bit BRPE field*/
41#define SJW_MAX 4ul
42#define BRP_INC 1ul
43
44/* #define DEBUG_PRINTF printf */
45#define DEBUG_PRINTF(...)
46
47static uint32_t LockIF(CAN_T *tCAN);
48static uint32_t LockIF_TL(CAN_T *tCAN);
49static void ReleaseIF(CAN_T *tCAN, uint32_t u32IfNo);
50static int can_update_spt(int sampl_pt, int tseg, int *tseg1, int *tseg2);
51
61static uint32_t LockIF(CAN_T *tCAN)
62{
63 uint32_t u32CanNo;
64 uint32_t u32FreeIfNo;
65 uint32_t u32IntMask;
66
67#if defined(CAN1)
68 if(tCAN == CAN0)
69 u32CanNo = 0ul;
70 else if(tCAN == CAN1)
71 u32CanNo = 1ul;
72 #if defined(CAN2)
73 else if(tCAN == CAN2)
74 u32CanNo = 2ul;
75 #endif
76#else /* defined(CAN0) || defined(CAN) */
77 u32CanNo = 0ul;
78#endif
79
80 u32FreeIfNo = 2ul;
81
82 /* Disable CAN interrupt */
83 u32IntMask = tCAN->CON & (CAN_CON_IE_Msk | CAN_CON_SIE_Msk | CAN_CON_EIE_Msk);
85
86 /* Check interface 1 is available or not */
87 if((tCAN->IF[0ul].CREQ & CAN_IF_CREQ_BUSY_Msk) == 0ul)
88 {
89 if(gu8LockCanIf[u32CanNo][0ul] == 0ul)
90 {
91 gu8LockCanIf[u32CanNo][0ul] = 1u;
92 u32FreeIfNo = 0ul;
93 }
94 else
95 {
96 }
97 }
98 else
99 {
100 }
101
102 /* Or check interface 2 is available or not */
103 if(u32FreeIfNo == 2ul)
104 {
105 if((tCAN->IF[1ul].CREQ & CAN_IF_CREQ_BUSY_Msk) == 0ul)
106 {
107 if(gu8LockCanIf[u32CanNo][1ul] == 0ul)
108 {
109 gu8LockCanIf[u32CanNo][1ul] = 1u;
110 u32FreeIfNo = 1ul;
111 }
112 else
113 {
114 }
115 }
116 else
117 {
118 }
119 }
120 else
121 {
122 }
123
124 /* Enable CAN interrupt */
125 tCAN->CON |= u32IntMask;
126
127 return u32FreeIfNo;
128}
129
140static uint32_t LockIF_TL(CAN_T *tCAN)
141{
142 uint32_t u32Count;
143 uint32_t u32FreeIfNo;
144
145 for(u32Count = 0ul; u32Count < RETRY_COUNTS; u32Count++)
146 {
147 if((u32FreeIfNo = LockIF(tCAN)) != 2ul)
148 {
149 break;
150 }
151 else
152 {
153 }
154 }
155
156 return u32FreeIfNo;
157}
158
166static void ReleaseIF(CAN_T *tCAN, uint32_t u32IfNo)
167{
168 uint32_t u32IntMask;
169 uint32_t u32CanNo;
170
171 if(u32IfNo >= 2ul)
172 {
173 }
174 else
175 {
176#if defined(CAN1)
177 if(tCAN == CAN0)
178 u32CanNo = 0ul;
179 else if(tCAN == CAN1)
180 u32CanNo = 1ul;
181 #if defined(CAN2)
182 else if(tCAN == CAN2)
183 u32CanNo = 2ul;
184 #endif
185#else /* defined(CAN0) || defined(CAN) */
186 u32CanNo = 0ul;
187#endif
188
189 /* Disable CAN interrupt */
190 u32IntMask = tCAN->CON & (CAN_CON_IE_Msk | CAN_CON_SIE_Msk | CAN_CON_EIE_Msk);
192
193 gu8LockCanIf[u32CanNo][u32IfNo] = 0u;
194
195 /* Enable CAN interrupt */
196 tCAN->CON |= u32IntMask;
197 }
198}
199
200static int can_update_spt(int sampl_pt, int tseg, int *tseg1, int *tseg2)
201{
202 *tseg2 = tseg + 1 - (sampl_pt * (tseg + 1)) / 1000;
203 if (*tseg2 < TSEG2_MIN)
204 {
205 *tseg2 = TSEG2_MIN;
206 }
207 else
208 {
209 }
210
211 if (*tseg2 > TSEG2_MAX)
212 {
213 *tseg2 = TSEG2_MAX;
214 }
215 else
216 {
217 }
218
219 *tseg1 = tseg - *tseg2;
220 if (*tseg1 > TSEG1_MAX)
221 {
222 *tseg1 = TSEG1_MAX;
223 *tseg2 = tseg - *tseg1;
224 }
225 else
226 {
227 }
228
229 return 1000 * (tseg + 1 - *tseg2) / (tseg + 1);
230}
231
248void CAN_EnterInitMode(CAN_T *tCAN, uint8_t u8Mask)
249{
250 tCAN->CON = u8Mask | (CAN_CON_INIT_Msk | CAN_CON_CCE_Msk);
251}
252
253
262{
263 uint32_t u32TimeOutCount = SystemCoreClock; // 1 second timeout
264 tCAN->CON &= (~(CAN_CON_INIT_Msk | CAN_CON_CCE_Msk));
265 while(tCAN->CON & CAN_CON_INIT_Msk) /* Check INIT bit is released */
266 {
267 if(u32TimeOutCount == 0) break;
268 u32TimeOutCount--;
269 }
270}
271
280{
281 tCAN->STATUS = 0x0ul; /* clr status */
282
283 while(1)
284 {
285 if(tCAN->IF[1].MCON & CAN_IF_MCON_NEWDAT_Msk) /* check new data */
286 {
287 /* New Data IN */
288 break;
289 }
290 else
291 {
292 }
293
294 if(tCAN->STATUS & CAN_STATUS_RXOK_Msk)
295 {
296 /* Rx OK */
297 }
298 else
299 {
300 }
301
302 if(tCAN->STATUS & CAN_STATUS_LEC_Msk)
303 {
304 /* Error */
305 }
306 else
307 {
308 }
309 }
310}
311
319{
320 uint32_t u32Tseg1, u32Tseg2;
321 uint32_t u32Bpr;
322 uint32_t u32Clock = (uint32_t)0;
323
325 if((tCAN == CAN0) || (tCAN == CAN2))
326 {
327 u32Clock = CLK_GetPCLK0Freq();
328 }
329 else if(tCAN == CAN1)
330 {
331 u32Clock = CLK_GetPCLK1Freq();
332 }
333
334 u32Tseg1 = (tCAN->BTIME & CAN_BTIME_TSEG1_Msk) >> CAN_BTIME_TSEG1_Pos;
335 u32Tseg2 = (tCAN->BTIME & CAN_BTIME_TSEG2_Msk) >> CAN_BTIME_TSEG2_Pos;
336 u32Bpr = (tCAN->BTIME & CAN_BTIME_BRP_Msk) | (tCAN->BRPE << 6ul);
337
338 return (u32Clock / (u32Bpr + 1ul) / (u32Tseg1 + u32Tseg2 + 3ul));
339}
340
354void CAN_EnterTestMode(CAN_T *tCAN, uint8_t u8TestMask)
355{
356 tCAN->CON |= CAN_CON_TEST_Msk;
357 tCAN->TEST = u8TestMask;
358}
359
360
368{
369 tCAN->CON |= CAN_CON_TEST_Msk;
371 tCAN->CON &= (~CAN_CON_TEST_Msk);
372}
373
382uint32_t CAN_IsNewDataReceived(CAN_T *tCAN, uint8_t u8MsgObj)
383{
384 return (u8MsgObj < 16ul ? tCAN->NDAT1 & (1ul << u8MsgObj) : tCAN->NDAT2 & (1ul << (u8MsgObj - 16ul)));
385}
386
387
399int32_t CAN_BasicSendMsg(CAN_T *tCAN, STR_CANMSG_T* pCanMsg)
400{
401 uint32_t i = 0ul;
402 int32_t rev = 1l;
403 uint32_t u32TimeOutCount = SystemCoreClock; // 1 second timeout
404
405 while(tCAN->IF[0].CREQ & CAN_IF_CREQ_BUSY_Msk)
406 {
407 i++;
408 if(i > u32TimeOutCount) return -1;
409 }
410
411 tCAN->STATUS &= (~CAN_STATUS_TXOK_Msk);
412
413 if(pCanMsg->IdType == CAN_STD_ID)
414 {
415 /* standard ID*/
416 tCAN->IF[0].ARB1 = 0ul;
417 tCAN->IF[0].ARB2 = (((pCanMsg->Id) & 0x7FFul) << 2ul) ;
418 }
419 else
420 {
421 /* extended ID*/
422 tCAN->IF[0].ARB1 = (pCanMsg->Id) & 0xFFFFul;
423 tCAN->IF[0].ARB2 = ((pCanMsg->Id) & 0x1FFF0000ul) >> 16ul | CAN_IF_ARB2_XTD_Msk;
424
425 }
426
427 if(pCanMsg->FrameType)
428 {
429 tCAN->IF[0].ARB2 |= CAN_IF_ARB2_DIR_Msk;
430 }
431 else
432 {
433 tCAN->IF[0].ARB2 &= (~CAN_IF_ARB2_DIR_Msk);
434 }
435
436 tCAN->IF[0].MCON = (tCAN->IF[0].MCON & (~CAN_IF_MCON_DLC_Msk)) | pCanMsg->DLC;
437 tCAN->IF[0].DAT_A1 = (uint16_t)((uint16_t)((uint16_t)pCanMsg->Data[1] << 8) | pCanMsg->Data[0]);
438 tCAN->IF[0].DAT_A2 = (uint16_t)((uint16_t)((uint16_t)pCanMsg->Data[3] << 8) | pCanMsg->Data[2]);
439 tCAN->IF[0].DAT_B1 = (uint16_t)((uint16_t)((uint16_t)pCanMsg->Data[5] << 8) | pCanMsg->Data[4]);
440 tCAN->IF[0].DAT_B2 = (uint16_t)((uint16_t)((uint16_t)pCanMsg->Data[7] << 8) | pCanMsg->Data[6]);
441
442 /* request transmission*/
443 tCAN->IF[0].CREQ &= (~CAN_IF_CREQ_BUSY_Msk);
444 if(tCAN->IF[0].CREQ & CAN_IF_CREQ_BUSY_Msk)
445 {
446 /* Cannot clear busy for sending ...*/
447 rev = 0l; /* return FALSE */
448 }
449 else
450 {
451 tCAN->IF[0].CREQ |= CAN_IF_CREQ_BUSY_Msk; /* sending */
452
453 for(i = 0ul; i < 0xFFFFFul; i++)
454 {
455 if((tCAN->IF[0].CREQ & CAN_IF_CREQ_BUSY_Msk) == 0ul)
456 {
457 break;
458 }
459 else
460 {
461 }
462 }
463
464 if(i >= 0xFFFFFul)
465 {
466 /* Cannot send out... */
467 rev = 0l; /* return FALSE */
468 }
469 else
470 {
471 }
472 }
473
474 return rev;
475}
476
487int32_t CAN_BasicReceiveMsg(CAN_T *tCAN, STR_CANMSG_T* pCanMsg)
488{
489 int32_t rev = 1l;
490
491 if((tCAN->IF[1].MCON & CAN_IF_MCON_NEWDAT_Msk) == 0ul)
492 {
493 /* In basic mode, receive data always save in IF2 */
494 rev = 0; /* return FALSE */
495 }
496 else
497 {
498
499 tCAN->STATUS &= (~CAN_STATUS_RXOK_Msk);
500
501 tCAN->IF[1].CMASK = CAN_IF_CMASK_ARB_Msk
505
506 if((tCAN->IF[1].ARB2 & CAN_IF_ARB2_XTD_Msk) == 0ul)
507 {
508 /* standard ID*/
509 pCanMsg->IdType = CAN_STD_ID;
510 pCanMsg->Id = (tCAN->IF[1].ARB2 >> 2) & 0x07FFul;
511
512 }
513 else
514 {
515 /* extended ID*/
516 pCanMsg->IdType = CAN_EXT_ID;
517 pCanMsg->Id = (tCAN->IF[1].ARB2 & 0x1FFFul) << 16;
518 pCanMsg->Id |= (uint32_t)tCAN->IF[1].ARB1;
519 }
520
521 pCanMsg->FrameType = (((tCAN->IF[1].ARB2 & CAN_IF_ARB2_DIR_Msk) >> CAN_IF_ARB2_DIR_Pos)) ? 0ul : 1ul;
522
523 pCanMsg->DLC = (uint8_t)(tCAN->IF[1].MCON & CAN_IF_MCON_DLC_Msk);
524 pCanMsg->Data[0] = (uint8_t)(tCAN->IF[1].DAT_A1 & CAN_IF_DAT_A1_DATA0_Msk);
525 pCanMsg->Data[1] = (uint8_t)((tCAN->IF[1].DAT_A1 & CAN_IF_DAT_A1_DATA1_Msk) >> CAN_IF_DAT_A1_DATA1_Pos);
526 pCanMsg->Data[2] = (uint8_t)(tCAN->IF[1].DAT_A2 & CAN_IF_DAT_A2_DATA2_Msk);
527 pCanMsg->Data[3] = (uint8_t)((tCAN->IF[1].DAT_A2 & CAN_IF_DAT_A2_DATA3_Msk) >> CAN_IF_DAT_A2_DATA3_Pos);
528 pCanMsg->Data[4] = (uint8_t)(tCAN->IF[1].DAT_B1 & CAN_IF_DAT_B1_DATA4_Msk);
529 pCanMsg->Data[5] = (uint8_t)((tCAN->IF[1].DAT_B1 & CAN_IF_DAT_B1_DATA5_Msk) >> CAN_IF_DAT_B1_DATA5_Pos);
530 pCanMsg->Data[6] = (uint8_t)(tCAN->IF[1].DAT_B2 & CAN_IF_DAT_B2_DATA6_Msk);
531 pCanMsg->Data[7] = (uint8_t)((tCAN->IF[1].DAT_B2 & CAN_IF_DAT_B2_DATA7_Msk) >> CAN_IF_DAT_B2_DATA7_Pos);
532 }
533
534 return rev;
535}
536
559int32_t CAN_SetRxMsgObjAndMsk(CAN_T *tCAN, uint8_t u8MsgObj, uint8_t u8idType, uint32_t u32id, uint32_t u32idmask, uint8_t u8singleOrFifoLast)
560{
561 int32_t rev = 1l;
562 uint32_t u32MsgIfNum;
563
564 /* Get and lock a free interface */
565 if((u32MsgIfNum = LockIF_TL(tCAN)) == 2ul)
566 {
567 rev = 0; /* return FALSE */
568 }
569 else
570 {
571 /* Command Setting */
574
575 if(u8idType == CAN_STD_ID) /* According STD/EXT ID format,Configure Mask and Arbitration register */
576 {
577 tCAN->IF[u32MsgIfNum].ARB1 = 0ul;
578 tCAN->IF[u32MsgIfNum].ARB2 = CAN_IF_ARB2_MSGVAL_Msk | (u32id & 0x7FFul) << 2;
579 }
580 else
581 {
582 tCAN->IF[u32MsgIfNum].ARB1 = u32id & 0xFFFFul;
583 tCAN->IF[u32MsgIfNum].ARB2 = CAN_IF_ARB2_MSGVAL_Msk | CAN_IF_ARB2_XTD_Msk | (u32id & 0x1FFF0000ul) >> 16;
584 }
585
586 tCAN->IF[u32MsgIfNum].MASK1 = (u32idmask & 0xFFFFul);
587 tCAN->IF[u32MsgIfNum].MASK2 = (u32idmask >> 16) & 0xFFFFul;
588
589 /* tCAN->IF[u32MsgIfNum].MCON |= CAN_IF_MCON_UMASK_Msk | CAN_IF_MCON_RXIE_Msk; */
590 tCAN->IF[u32MsgIfNum].MCON = CAN_IF_MCON_UMASK_Msk | CAN_IF_MCON_RXIE_Msk;
591 if(u8singleOrFifoLast)
592 {
593 tCAN->IF[u32MsgIfNum].MCON |= CAN_IF_MCON_EOB_Msk;
594 }
595 else
596 {
597 tCAN->IF[u32MsgIfNum].MCON &= (~CAN_IF_MCON_EOB_Msk);
598 }
599
600 tCAN->IF[u32MsgIfNum].DAT_A1 = 0ul;
601 tCAN->IF[u32MsgIfNum].DAT_A2 = 0ul;
602 tCAN->IF[u32MsgIfNum].DAT_B1 = 0ul;
603 tCAN->IF[u32MsgIfNum].DAT_B2 = 0ul;
604
605 tCAN->IF[u32MsgIfNum].CREQ = 1ul + u8MsgObj;
606 ReleaseIF(tCAN, u32MsgIfNum);
607 }
608
609 return rev;
610}
611
629int32_t CAN_SetRxMsgObj(CAN_T *tCAN, uint8_t u8MsgObj, uint8_t u8idType, uint32_t u32id, uint8_t u8singleOrFifoLast)
630{
631 int32_t rev = 1l;
632 uint32_t u32MsgIfNum;
633
634 /* Get and lock a free interface */
635 if((u32MsgIfNum = LockIF_TL(tCAN)) == 2ul)
636 {
637 rev = 0; /* return FALSE */
638 }
639 else
640 {
641 /* Command Setting */
644
645 if(u8idType == CAN_STD_ID) /* According STD/EXT ID format,Configure Mask and Arbitration register */
646 {
647 tCAN->IF[u32MsgIfNum].ARB1 = 0ul;
648 tCAN->IF[u32MsgIfNum].ARB2 = CAN_IF_ARB2_MSGVAL_Msk | (u32id & 0x7FFul) << 2;
649 }
650 else
651 {
652 tCAN->IF[u32MsgIfNum].ARB1 = u32id & 0xFFFFul;
653 tCAN->IF[u32MsgIfNum].ARB2 = CAN_IF_ARB2_MSGVAL_Msk | CAN_IF_ARB2_XTD_Msk | (u32id & 0x1FFF0000ul) >> 16;
654 }
655
656 /* tCAN->IF[u8MsgIfNum].MCON |= CAN_IF_MCON_UMASK_Msk | CAN_IF_MCON_RXIE_Msk; */
657 tCAN->IF[u32MsgIfNum].MCON = CAN_IF_MCON_UMASK_Msk | CAN_IF_MCON_RXIE_Msk;
658 if(u8singleOrFifoLast)
659 {
660 tCAN->IF[u32MsgIfNum].MCON |= CAN_IF_MCON_EOB_Msk;
661 }
662 else
663 {
664 tCAN->IF[u32MsgIfNum].MCON &= (~CAN_IF_MCON_EOB_Msk);
665 }
666
667 tCAN->IF[u32MsgIfNum].DAT_A1 = 0ul;
668 tCAN->IF[u32MsgIfNum].DAT_A2 = 0ul;
669 tCAN->IF[u32MsgIfNum].DAT_B1 = 0ul;
670 tCAN->IF[u32MsgIfNum].DAT_B2 = 0ul;
671
672 tCAN->IF[u32MsgIfNum].CREQ = 1ul + u8MsgObj;
673 ReleaseIF(tCAN, u32MsgIfNum);
674 }
675
676 return rev;
677}
678
693int32_t CAN_ReadMsgObj(CAN_T *tCAN, uint8_t u8MsgObj, uint8_t u8Release, STR_CANMSG_T* pCanMsg)
694{
695 int32_t rev = 1l;
696 uint32_t u32MsgIfNum;
697 uint32_t u32TimeOutCount = SystemCoreClock * 2; // 2 second timeout
698
699 if(!CAN_IsNewDataReceived(tCAN, u8MsgObj))
700 {
701 rev = 0; /* return FALSE */
702 }
703 else
704 {
705 /* Get and lock a free interface */
706 if((u32MsgIfNum = LockIF_TL(tCAN)) == 2ul)
707 {
708 rev = 0; /* return FALSE */
709 }
710 else
711 {
712 tCAN->STATUS &= (~CAN_STATUS_RXOK_Msk);
713
714 /* read the message contents*/
715 tCAN->IF[u32MsgIfNum].CMASK = CAN_IF_CMASK_MASK_Msk
719 | (u8Release ? CAN_IF_CMASK_TXRQSTNEWDAT_Msk : 0ul)
722
723 tCAN->IF[u32MsgIfNum].CREQ = 1ul + u8MsgObj;
724
725 while(tCAN->IF[u32MsgIfNum].CREQ & CAN_IF_CREQ_BUSY_Msk) /*Wait*/
726 {
727 if(u32TimeOutCount == 0)
728 {
729 ReleaseIF(tCAN, u32MsgIfNum);
730 return -1;
731 }
732 u32TimeOutCount--;
733 }
734
735 if((tCAN->IF[u32MsgIfNum].ARB2 & CAN_IF_ARB2_XTD_Msk) == 0ul)
736 {
737 /* standard ID*/
738 pCanMsg->IdType = CAN_STD_ID;
739 pCanMsg->Id = (tCAN->IF[u32MsgIfNum].ARB2 & CAN_IF_ARB2_ID_Msk) >> 2ul;
740 }
741 else
742 {
743 /* extended ID*/
744 pCanMsg->IdType = CAN_EXT_ID;
745 pCanMsg->Id = (((tCAN->IF[u32MsgIfNum].ARB2) & 0x1FFFul) << 16) | tCAN->IF[u32MsgIfNum].ARB1;
746 }
747
748 pCanMsg->DLC = (uint8_t)(tCAN->IF[u32MsgIfNum].MCON & CAN_IF_MCON_DLC_Msk);
749 pCanMsg->Data[0] = (uint8_t)(tCAN->IF[u32MsgIfNum].DAT_A1 & CAN_IF_DAT_A1_DATA0_Msk);
750 pCanMsg->Data[1] = (uint8_t)((tCAN->IF[u32MsgIfNum].DAT_A1 & CAN_IF_DAT_A1_DATA1_Msk) >> CAN_IF_DAT_A1_DATA1_Pos);
751 pCanMsg->Data[2] = (uint8_t)(tCAN->IF[u32MsgIfNum].DAT_A2 & CAN_IF_DAT_A2_DATA2_Msk);
752 pCanMsg->Data[3] = (uint8_t)((tCAN->IF[u32MsgIfNum].DAT_A2 & CAN_IF_DAT_A2_DATA3_Msk) >> CAN_IF_DAT_A2_DATA3_Pos);
753 pCanMsg->Data[4] = (uint8_t)(tCAN->IF[u32MsgIfNum].DAT_B1 & CAN_IF_DAT_B1_DATA4_Msk);
754 pCanMsg->Data[5] = (uint8_t)((tCAN->IF[u32MsgIfNum].DAT_B1 & CAN_IF_DAT_B1_DATA5_Msk) >> CAN_IF_DAT_B1_DATA5_Pos);
755 pCanMsg->Data[6] = (uint8_t)(tCAN->IF[u32MsgIfNum].DAT_B2 & CAN_IF_DAT_B2_DATA6_Msk);
756 pCanMsg->Data[7] = (uint8_t)((tCAN->IF[u32MsgIfNum].DAT_B2 & CAN_IF_DAT_B2_DATA7_Msk) >> CAN_IF_DAT_B2_DATA7_Pos);
757
758 ReleaseIF(tCAN, u32MsgIfNum);
759 }
760 }
761
762 return rev;
763}
764
765
776uint32_t CAN_SetBaudRate(CAN_T *tCAN, uint32_t u32BaudRate)
777{
778 long rate;
779 long best_error = 1000000000, error = 0;
780 int best_tseg = 0, best_brp = 0, brp = 0;
781 int tsegall, tseg = 0, tseg1 = 0, tseg2 = 0;
782 int spt_error = 1000, spt = 0, sampl_pt;
783 uint64_t clock_freq = (uint64_t)0, u64PCLK_DIV = (uint64_t)1;
784 uint32_t sjw = (uint32_t)SJW_MAX;
785
786 CAN_EnterInitMode(tCAN, (uint8_t)0);
787
789 if((tCAN == CAN0) || (tCAN == CAN2))
790 {
791 u64PCLK_DIV = (uint64_t)(CLK->PCLKDIV & CLK_PCLKDIV_APB0DIV_Msk);
792 u64PCLK_DIV = (uint64_t)(1 << u64PCLK_DIV);
793 }
794 else if(tCAN == CAN1)
795 {
796 u64PCLK_DIV = (uint64_t)((CLK->PCLKDIV & CLK_PCLKDIV_APB1DIV_Msk) >> CLK_PCLKDIV_APB1DIV_Pos);
797 u64PCLK_DIV = (uint64_t)(1 << u64PCLK_DIV);
798 }
799
800 clock_freq = SystemCoreClock / u64PCLK_DIV;
801
802 if(u32BaudRate >= (uint32_t)1000000)
803 {
804 u32BaudRate = (uint32_t)1000000;
805 }
806
807 /* Use CIA recommended sample points */
808 if (u32BaudRate > (uint32_t)800000)
809 {
810 sampl_pt = (int)750;
811 }
812 else if (u32BaudRate > (uint32_t)500000)
813 {
814 sampl_pt = (int)800;
815 }
816 else
817 {
818 sampl_pt = (int)875;
819 }
820
821 /* tseg even = round down, odd = round up */
822 for (tseg = (TSEG1_MAX + TSEG2_MAX) * 2ul + 1ul; tseg >= (TSEG1_MIN + TSEG2_MIN) * 2ul; tseg--)
823 {
824 tsegall = 1ul + tseg / 2ul;
825 /* Compute all possible tseg choices (tseg=tseg1+tseg2) */
826 brp = clock_freq / (tsegall * u32BaudRate) + tseg % 2;
827 /* chose brp step which is possible in system */
828 brp = (brp / BRP_INC) * BRP_INC;
829
830 if ((brp < BRP_MIN) || (brp > BRP_MAX))
831 {
832 continue;
833 }
834 rate = clock_freq / (brp * tsegall);
835
836 error = u32BaudRate - rate;
837
838 /* tseg brp biterror */
839 if (error < 0)
840 {
841 error = -error;
842 }
843 if (error > best_error)
844 {
845 continue;
846 }
847 best_error = error;
848 if (error == 0)
849 {
850 spt = can_update_spt(sampl_pt, tseg / 2, &tseg1, &tseg2);
851 error = sampl_pt - spt;
852 if (error < 0)
853 {
854 error = -error;
855 }
856 if (error > spt_error)
857 {
858 continue;
859 }
860 spt_error = error;
861 }
862 best_tseg = tseg / 2;
863 best_brp = brp;
864
865 if (error == 0)
866 {
867 break;
868 }
869 }
870
871 spt = can_update_spt(sampl_pt, best_tseg, &tseg1, &tseg2);
872
873 /* check for sjw user settings */
874 /* bt->sjw is at least 1 -> sanitize upper bound to sjw_max */
875 if (sjw > SJW_MAX)
876 {
877 sjw = SJW_MAX;
878 }
879 /* bt->sjw must not be higher than tseg2 */
880 if (tseg2 < sjw)
881 {
882 sjw = tseg2;
883 }
884
885 /* real bit-rate */
886 u32BaudRate = clock_freq / (best_brp * (tseg1 + tseg2 + 1));
887
888 tCAN->BTIME = ((uint32_t)(tseg2 - 1ul) << CAN_BTIME_TSEG2_Pos) | ((uint32_t)(tseg1 - 1ul) << CAN_BTIME_TSEG1_Pos) |
889 ((uint32_t)(best_brp - 1ul) & CAN_BTIME_BRP_Msk) | (sjw << CAN_BTIME_SJW_Pos);
890 tCAN->BRPE = ((uint32_t)(best_brp - 1ul) >> 6) & 0x0Ful;
891
892 /* printf("\n bitrate = %d \n", CAN_GetCANBitRate(tCAN)); */
893
894 CAN_LeaveInitMode(tCAN);
895
896 return u32BaudRate;
897}
898
908void CAN_Close(CAN_T *tCAN)
909{
911}
912
926uint32_t CAN_Open(CAN_T *tCAN, uint32_t u32BaudRate, uint32_t u32Mode)
927{
928 uint32_t u32CurrentBitRate;
929
930 u32CurrentBitRate = CAN_SetBaudRate(tCAN, u32BaudRate);
931
932 if(u32Mode == CAN_BASIC_MODE)
933 {
935 }
936 else
937 {
938 }
939
940 return u32CurrentBitRate;
941}
942
956int32_t CAN_SetTxMsg(CAN_T *tCAN, uint32_t u32MsgNum, STR_CANMSG_T* pCanMsg)
957{
958 int32_t rev = 1l;
959 uint32_t u32MsgIfNum;
960
961 if((u32MsgIfNum = LockIF_TL(tCAN)) == 2ul)
962 {
963 rev = 0; /* return FALSE */
964 }
965 else
966 {
967 /* update the contents needed for transmission*/
970
971 if(pCanMsg->IdType == CAN_STD_ID)
972 {
973 /* standard ID*/
974 tCAN->IF[u32MsgIfNum].ARB1 = 0ul;
975 tCAN->IF[u32MsgIfNum].ARB2 = (((pCanMsg->Id) & 0x7FFul) << 2) | CAN_IF_ARB2_DIR_Msk | CAN_IF_ARB2_MSGVAL_Msk;
976 }
977 else
978 {
979 /* extended ID*/
980 tCAN->IF[u32MsgIfNum].ARB1 = (pCanMsg->Id) & 0xFFFFul;
981 tCAN->IF[u32MsgIfNum].ARB2 = ((pCanMsg->Id) & 0x1FFF0000ul) >> 16 |
983 }
984
985 if(pCanMsg->FrameType)
986 {
987 tCAN->IF[u32MsgIfNum].ARB2 |= CAN_IF_ARB2_DIR_Msk;
988 }
989 else
990 {
991 tCAN->IF[u32MsgIfNum].ARB2 &= (~CAN_IF_ARB2_DIR_Msk);
992 }
993
994 tCAN->IF[u32MsgIfNum].DAT_A1 = (uint16_t)((uint16_t)(((uint16_t)pCanMsg->Data[1] << 8)) | pCanMsg->Data[0]);
995 tCAN->IF[u32MsgIfNum].DAT_A2 = (uint16_t)((uint16_t)(((uint16_t)pCanMsg->Data[3] << 8)) | pCanMsg->Data[2]);
996 tCAN->IF[u32MsgIfNum].DAT_B1 = (uint16_t)((uint16_t)(((uint16_t)pCanMsg->Data[5] << 8)) | pCanMsg->Data[4]);
997 tCAN->IF[u32MsgIfNum].DAT_B2 = (uint16_t)((uint16_t)(((uint16_t)pCanMsg->Data[7] << 8)) | pCanMsg->Data[6]);
998
999 tCAN->IF[u32MsgIfNum].MCON = CAN_IF_MCON_NEWDAT_Msk | pCanMsg->DLC | CAN_IF_MCON_TXIE_Msk | CAN_IF_MCON_EOB_Msk;
1000 tCAN->IF[u32MsgIfNum].CREQ = 1ul + u32MsgNum;
1001
1002 ReleaseIF(tCAN, u32MsgIfNum);
1003 }
1004
1005 return rev;
1006}
1007
1020int32_t CAN_TriggerTxMsg(CAN_T *tCAN, uint32_t u32MsgNum)
1021{
1022 int32_t rev = 1l;
1023 uint32_t u32MsgIfNum;
1024 uint32_t u32TimeOutCount = SystemCoreClock; // 1 second timeout
1025
1026 if((u32MsgIfNum = LockIF_TL(tCAN)) == 2ul)
1027 {
1028 rev = 0; /* return FALSE */
1029 }
1030 else
1031 {
1032 tCAN->STATUS &= (~CAN_STATUS_TXOK_Msk);
1033
1034 /* read the message contents*/
1035 tCAN->IF[u32MsgIfNum].CMASK = CAN_IF_CMASK_CLRINTPND_Msk
1037
1038 tCAN->IF[u32MsgIfNum].CREQ = 1ul + u32MsgNum;
1039
1040 while(tCAN->IF[u32MsgIfNum].CREQ & CAN_IF_CREQ_BUSY_Msk) /*Wait*/
1041 {
1042 if(u32TimeOutCount == 0)
1043 {
1044 ReleaseIF(tCAN, u32MsgIfNum);
1045 return -1;
1046 }
1047 u32TimeOutCount--;
1048 }
1050 tCAN->IF[u32MsgIfNum].CREQ = 1ul + u32MsgNum;
1051
1052 ReleaseIF(tCAN, u32MsgIfNum);
1053 }
1054
1055 return rev;
1056}
1057
1072void CAN_EnableInt(CAN_T *tCAN, uint32_t u32Mask)
1073{
1074 tCAN->CON = (tCAN->CON & ~(CAN_CON_IE_Msk | CAN_CON_SIE_Msk | CAN_CON_EIE_Msk)) |
1076}
1077
1088void CAN_DisableInt(CAN_T *tCAN, uint32_t u32Mask)
1089{
1090 tCAN->CON = tCAN->CON & ~((u32Mask & (CAN_CON_IE_Msk | CAN_CON_SIE_Msk | CAN_CON_EIE_Msk)));
1091}
1092
1093
1110int32_t CAN_SetRxMsg(CAN_T *tCAN, uint32_t u32MsgNum, uint32_t u32IDType, uint32_t u32ID)
1111{
1112 int32_t rev = (int32_t)TRUE;
1113 uint32_t u32TimeOutCount = 0ul;
1114
1115 while(CAN_SetRxMsgObj(tCAN, (uint8_t)u32MsgNum, (uint8_t)u32IDType, u32ID, (uint8_t)TRUE) == (int32_t)FALSE)
1116 {
1117 if(++u32TimeOutCount >= RETRY_COUNTS)
1118 {
1119 rev = (int32_t)(FALSE); /* return FALSE */
1120 break;
1121 }
1122 else
1123 {
1124 }
1125 }
1126
1127 return rev;
1128}
1129
1147int32_t CAN_SetRxMsgAndMsk(CAN_T *tCAN, uint32_t u32MsgNum, uint32_t u32IDType, uint32_t u32ID, uint32_t u32IDMask)
1148{
1149 int32_t rev = (int32_t)TRUE;
1150 uint32_t u32TimeOutCount = 0ul;
1151
1152 while(CAN_SetRxMsgObjAndMsk(tCAN, (uint8_t)u32MsgNum, (uint8_t)u32IDType, u32ID, u32IDMask, (uint8_t)TRUE) == (int32_t)FALSE)
1153 {
1154 if(++u32TimeOutCount >= RETRY_COUNTS)
1155 {
1156 rev = (int32_t)FALSE;
1157 break;
1158 }
1159 else
1160 {
1161 }
1162 }
1163
1164 return rev;
1165}
1166
1184int32_t CAN_SetMultiRxMsg(CAN_T *tCAN, uint32_t u32MsgNum, uint32_t u32MsgCount, uint32_t u32IDType, uint32_t u32ID)
1185{
1186 int32_t rev = (int32_t)TRUE;
1187 uint32_t i = 0ul;
1188 uint32_t u32TimeOutCount;
1189 uint32_t u32EOB_Flag = 0ul;
1190
1191 for(i = 1ul; i <= u32MsgCount; i++)
1192 {
1193 u32TimeOutCount = 0ul;
1194
1195 if(i == u32MsgCount)
1196 {
1197 u32EOB_Flag = 1ul;
1198 }
1199 else
1200 {
1201 }
1202
1203 while(CAN_SetRxMsgObj(tCAN, (uint8_t)u32MsgNum, (uint8_t)u32IDType, u32ID, (uint8_t)u32EOB_Flag) == (int32_t)FALSE)
1204 {
1205 if(++u32TimeOutCount >= RETRY_COUNTS)
1206 {
1207 rev = (int32_t)FALSE;
1208 return rev;
1209 }
1210 else
1211 {
1212 }
1213 }
1214
1215 u32MsgNum++;
1216 }
1217
1218 return rev;
1219}
1220
1221
1235int32_t CAN_Transmit(CAN_T *tCAN, uint32_t u32MsgNum, STR_CANMSG_T* pCanMsg)
1236{
1237 int32_t rev = (int32_t)TRUE;
1238 uint32_t u32Tmp;
1239
1240 u32Tmp = (tCAN->TEST & CAN_TEST_BASIC_Msk);
1241
1242 if((tCAN->CON & CAN_CON_TEST_Msk) && u32Tmp)
1243 {
1244 rev = CAN_BasicSendMsg(tCAN, pCanMsg);
1245 if(rev < 0) rev = 0;
1246 }
1247 else
1248 {
1249 if(CAN_SetTxMsg(tCAN, u32MsgNum, pCanMsg) == FALSE)
1250 {
1251 rev = (int32_t)FALSE;
1252 }
1253 else
1254 {
1255 CAN_TriggerTxMsg(tCAN, u32MsgNum);
1256 }
1257 }
1258
1259 return rev;
1260}
1261
1262
1275int32_t CAN_Receive(CAN_T *tCAN, uint32_t u32MsgNum, STR_CANMSG_T* pCanMsg)
1276{
1277 int32_t rev = (int32_t)TRUE;
1278 uint32_t u32Tmp;
1279
1280 u32Tmp = (tCAN->TEST & CAN_TEST_BASIC_Msk);
1281
1282 if((tCAN->CON & CAN_CON_TEST_Msk) && u32Tmp)
1283 {
1284 rev = CAN_BasicReceiveMsg(tCAN, pCanMsg);
1285 }
1286 else
1287 {
1288 rev = CAN_ReadMsgObj(tCAN, (uint8_t)u32MsgNum, (uint8_t)TRUE, pCanMsg);
1289 }
1290
1291 return rev;
1292}
1293
1303void CAN_CLR_INT_PENDING_BIT(CAN_T *tCAN, uint8_t u32MsgNum)
1304{
1305 uint32_t u32MsgIfNum;
1306
1307 if((u32MsgIfNum = LockIF_TL(tCAN)) == 2ul)
1308 {
1309 u32MsgIfNum = 0ul;
1310 }
1311 else
1312 {
1313 }
1314
1316 tCAN->IF[u32MsgIfNum].CREQ = 1ul + u32MsgNum;
1317
1318 ReleaseIF(tCAN, u32MsgIfNum);
1319}
1320
1321 /* end of group CAN_EXPORTED_FUNCTIONS */
1323 /* end of group CAN_Driver */
1325 /* end of group Standard_Driver */
1327
1328/*** (C) COPYRIGHT 2016 Nuvoton Technology Corp. ***/
1329
NuMicro peripheral access layer header file.
#define CAN_EXT_ID
Definition: can.h:39
#define CAN_BASIC_MODE
Definition: can.h:33
#define CAN_STD_ID
Definition: can.h:38
void CAN_EnterTestMode(CAN_T *tCAN, uint8_t u8TestMask)
Switch the CAN into test mode.
Definition: can.c:354
void CAN_Close(CAN_T *tCAN)
The function is used to disable all CAN interrupt.
Definition: can.c:908
int32_t CAN_BasicSendMsg(CAN_T *tCAN, STR_CANMSG_T *pCanMsg)
Send CAN message in BASIC mode of test mode.
Definition: can.c:399
void CAN_LeaveInitMode(CAN_T *tCAN)
Leave initialization mode.
Definition: can.c:261
int32_t CAN_SetRxMsg(CAN_T *tCAN, uint32_t u32MsgNum, uint32_t u32IDType, uint32_t u32ID)
The function is used to configure a receive message object.
Definition: can.c:1110
void CAN_LeaveTestMode(CAN_T *tCAN)
Leave the test mode.
Definition: can.c:367
uint8_t Data[8]
Definition: can.h:68
void CAN_WaitMsg(CAN_T *tCAN)
Wait message into message buffer in basic mode.
Definition: can.c:279
int32_t CAN_SetTxMsg(CAN_T *tCAN, uint32_t u32MsgNum, STR_CANMSG_T *pCanMsg)
The function is used to configure a transmit object.
Definition: can.c:956
int32_t CAN_TriggerTxMsg(CAN_T *tCAN, uint32_t u32MsgNum)
Set transmit request bit.
Definition: can.c:1020
int32_t CAN_Receive(CAN_T *tCAN, uint32_t u32MsgNum, STR_CANMSG_T *pCanMsg)
Gets the message, if received.
Definition: can.c:1275
int32_t CAN_ReadMsgObj(CAN_T *tCAN, uint8_t u8MsgObj, uint8_t u8Release, STR_CANMSG_T *pCanMsg)
Gets the message.
Definition: can.c:693
int32_t CAN_BasicReceiveMsg(CAN_T *tCAN, STR_CANMSG_T *pCanMsg)
Get a message information in BASIC mode.
Definition: can.c:487
uint8_t DLC
Definition: can.h:67
int32_t CAN_SetRxMsgObj(CAN_T *tCAN, uint8_t u8MsgObj, uint8_t u8idType, uint32_t u32id, uint8_t u8singleOrFifoLast)
Set Rx message object.
Definition: can.c:629
uint32_t FrameType
Definition: can.h:65
uint32_t CAN_GetCANBitRate(CAN_T *tCAN)
Get current bit rate.
Definition: can.c:318
int32_t CAN_SetRxMsgAndMsk(CAN_T *tCAN, uint32_t u32MsgNum, uint32_t u32IDType, uint32_t u32ID, uint32_t u32IDMask)
The function is used to configure a receive message object.
Definition: can.c:1147
uint32_t CAN_IsNewDataReceived(CAN_T *tCAN, uint8_t u8MsgObj)
Get the waiting status of a received message.
Definition: can.c:382
uint32_t CAN_SetBaudRate(CAN_T *tCAN, uint32_t u32BaudRate)
Set bus baud-rate.
Definition: can.c:776
void CAN_DisableInt(CAN_T *tCAN, uint32_t u32Mask)
Disable CAN interrupt.
Definition: can.c:1088
void CAN_EnableInt(CAN_T *tCAN, uint32_t u32Mask)
Enable CAN interrupt.
Definition: can.c:1072
void CAN_CLR_INT_PENDING_BIT(CAN_T *tCAN, uint8_t u32MsgNum)
Clear interrupt pending bit.
Definition: can.c:1303
uint32_t CAN_Open(CAN_T *tCAN, uint32_t u32BaudRate, uint32_t u32Mode)
Set CAN operation mode and target baud-rate.
Definition: can.c:926
int32_t CAN_SetRxMsgObjAndMsk(CAN_T *tCAN, uint8_t u8MsgObj, uint8_t u8idType, uint32_t u32id, uint32_t u32idmask, uint8_t u8singleOrFifoLast)
Set Rx message object, include ID mask.
Definition: can.c:559
int32_t CAN_SetMultiRxMsg(CAN_T *tCAN, uint32_t u32MsgNum, uint32_t u32MsgCount, uint32_t u32IDType, uint32_t u32ID)
The function is used to configure several receive message objects.
Definition: can.c:1184
void CAN_EnterInitMode(CAN_T *tCAN, uint8_t u8Mask)
Enter initialization mode.
Definition: can.c:248
uint32_t Id
Definition: can.h:66
uint32_t IdType
Definition: can.h:64
int32_t CAN_Transmit(CAN_T *tCAN, uint32_t u32MsgNum, STR_CANMSG_T *pCanMsg)
Send CAN message.
Definition: can.c:1235
uint32_t CLK_GetPCLK1Freq(void)
Get PCLK1 frequency.
Definition: clk.c:206
uint32_t CLK_GetPCLK0Freq(void)
Get PCLK0 frequency.
Definition: clk.c:166
#define TRUE
Boolean true, define to use in API parameters or return value.
Definition: M480.h:608
#define FALSE
Boolean false, define to use in API parameters or return value.
Definition: M480.h:609
#define CAN1
Definition: M480.h:444
#define CLK
Definition: M480.h:368
#define CAN0
Definition: M480.h:443
#define CAN2
Definition: M480.h:445
#define CAN_CON_CCE_Msk
Definition: can_reg.h:1138
#define CAN_CON_IE_Msk
Definition: can_reg.h:1126
#define CAN_IF_CMASK_DATAB_Msk
Definition: can_reg.h:1210
#define CAN_IF_DAT_B2_DATA7_Msk
Definition: can_reg.h:1312
#define CAN_TEST_SILENT_Msk
Definition: can_reg.h:1189
#define CAN_IF_CREQ_BUSY_Msk
Definition: can_reg.h:1207
#define CAN_IF_MCON_EOB_Msk
Definition: can_reg.h:1264
#define CAN_CON_SIE_Msk
Definition: can_reg.h:1129
#define CAN_IF_DAT_B2_DATA6_Msk
Definition: can_reg.h:1309
#define CAN_BTIME_TSEG1_Msk
Definition: can_reg.h:1177
#define CAN_CON_EIE_Msk
Definition: can_reg.h:1132
#define CAN_IF_MCON_NEWDAT_Msk
Definition: can_reg.h:1288
#define CLK_PCLKDIV_APB1DIV_Msk
Definition: clk_reg.h:2682
#define CAN_IF_DAT_A1_DATA1_Pos
Definition: can_reg.h:1293
#define CAN_IF_MCON_DLC_Msk
Definition: can_reg.h:1261
#define CAN_IF_ARB2_DIR_Msk
Definition: can_reg.h:1252
#define CAN_IF_CMASK_CLRINTPND_Msk
Definition: can_reg.h:1219
#define CAN_IF_MCON_TXIE_Msk
Definition: can_reg.h:1276
#define CAN_TEST_LBACK_Msk
Definition: can_reg.h:1192
#define CAN_BTIME_BRP_Msk
Definition: can_reg.h:1171
#define CAN_IF_MCON_UMASK_Msk
Definition: can_reg.h:1279
#define CAN_BTIME_SJW_Pos
Definition: can_reg.h:1173
#define CAN_STATUS_LEC_Msk
Definition: can_reg.h:1144
#define CAN_IF_ARB2_XTD_Msk
Definition: can_reg.h:1255
#define CAN_IF_CMASK_CONTROL_Msk
Definition: can_reg.h:1222
#define CAN_IF_CMASK_ARB_Msk
Definition: can_reg.h:1225
#define CAN_IF_DAT_B1_DATA4_Msk
Definition: can_reg.h:1303
#define CAN_IF_DAT_B2_DATA7_Pos
Definition: can_reg.h:1311
#define CLK_PCLKDIV_APB1DIV_Pos
Definition: clk_reg.h:2681
#define CLK_PCLKDIV_APB0DIV_Msk
Definition: clk_reg.h:2679
#define CAN_CON_INIT_Msk
Definition: can_reg.h:1123
#define CAN_IF_ARB2_ID_Msk
Definition: can_reg.h:1249
#define CAN_STATUS_RXOK_Msk
Definition: can_reg.h:1150
#define CAN_IF_DAT_A1_DATA1_Msk
Definition: can_reg.h:1294
#define CAN_TEST_BASIC_Msk
Definition: can_reg.h:1186
#define CAN_IF_DAT_B1_DATA5_Pos
Definition: can_reg.h:1305
#define CAN_IF_DAT_A1_DATA0_Msk
Definition: can_reg.h:1291
#define CAN_IF_ARB2_DIR_Pos
Definition: can_reg.h:1251
#define CAN_IF_DAT_A2_DATA3_Pos
Definition: can_reg.h:1299
#define CAN_IF_CMASK_TXRQSTNEWDAT_Msk
Definition: can_reg.h:1216
#define CAN_BTIME_TSEG2_Pos
Definition: can_reg.h:1179
#define CAN_IF_DAT_A2_DATA3_Msk
Definition: can_reg.h:1300
#define CAN_BTIME_TSEG1_Pos
Definition: can_reg.h:1176
#define CAN_CON_TEST_Msk
Definition: can_reg.h:1141
#define CAN_IF_MCON_RXIE_Msk
Definition: can_reg.h:1273
#define CAN_IF_DAT_B1_DATA5_Msk
Definition: can_reg.h:1306
#define CAN_BTIME_TSEG2_Msk
Definition: can_reg.h:1180
#define CAN_IF_ARB2_MSGVAL_Msk
Definition: can_reg.h:1258
#define CAN_IF_CMASK_WRRD_Msk
Definition: can_reg.h:1231
#define CAN_IF_CMASK_MASK_Msk
Definition: can_reg.h:1228
#define CAN_IF_DAT_A2_DATA2_Msk
Definition: can_reg.h:1297
#define CAN_IF_CMASK_DATAA_Msk
Definition: can_reg.h:1213
__IO uint32_t CREQ
Definition: can_reg.h:533
__IO uint32_t MCON
Definition: can_reg.h:539
__IO uint32_t MASK2
Definition: can_reg.h:536
__IO uint32_t DAT_A1
Definition: can_reg.h:540
__IO uint32_t DAT_A2
Definition: can_reg.h:541
__IO uint32_t ARB2
Definition: can_reg.h:538
__IO uint32_t DAT_B1
Definition: can_reg.h:542
__IO uint32_t MASK1
Definition: can_reg.h:535
__IO uint32_t DAT_B2
Definition: can_reg.h:543
__IO uint32_t CMASK
Definition: can_reg.h:534
__IO uint32_t ARB1
Definition: can_reg.h:537
Definition: can_reg.h:551
__IO uint32_t STATUS
Definition: can_reg.h:1082
__IO uint32_t CON
Definition: can_reg.h:1081
__IO CAN_IF_T IF[2]
Definition: can_reg.h:1091
__IO uint32_t BTIME
Definition: can_reg.h:1084
__IO uint32_t TEST
Definition: can_reg.h:1086
__I uint32_t NDAT2
Definition: can_reg.h:1101
__IO uint32_t BRPE
Definition: can_reg.h:1087
uint32_t SystemCoreClock
Definition: system_M480.c:21
void SystemCoreClockUpdate(void)
Updates the SystemCoreClock with current core Clock retrieved from cpu registers.
Definition: system_M480.c:29