NXP

在调试flexcan,看来有点难(已解决)

2020-02-20 20:32发布

站内问答 / 51单片机
3293 16 16
本帖最后由 richyhuang 于 2014-12-9 16:44 编辑

位时间定义看的有点晕啊.
友情提示: 此问题已得到解决，问题已经关闭,关闭后问题禁止继续编辑，回答。
16条回答
richyhuang
2020-02-22 20:15
FSL_TICS_Robin 发表于 2014-12-9 16:25
PE就可以实现自动计算，楼主可以尝试配置一个带PE的工程调用CAN的那个LDD试一下。 ...

搞定了,根据网友提供的例子,改了一下就可以了.
这里就改了一个定义分频系数的地方就可以了,我现在用的是60M的外设时钟,500K通信
  1. void CAN1_ORed_Message_buffer_IRQHandler(void)
  2. {
  3.         printf("CAN1->IFLAG1 = %08x ", CAN1->IFLAG1);
  4.         CAN1->IFLAG1 |= 0xFFFFFFFF;
  5. }
  6. void CAN1_Bus_Off_IRQHandler(void)
  7. {
  8.         printf("CAN1_Bus_Off_IRQHandler ");       
  9. }
  10. void CAN1_Error_IRQHandler(void)
  11. {
  12.         printf("CAN1_Error_IRQHandler ");
  13. }
  14. void CAN1_Tx_Warning_IRQHandler(void)
  15. {
  16.         printf("CAN1_Tx_Warning_IRQHandler ");
  17. }
  18. void CAN1_Rx_Warning_IRQHandler(void)
  19. {
  20.         printf("CAN1_Tx_Warning_IRQHandler ");
  21. }
  22. void CAN1_Wake_Up_IRQHandler(void)
  23. {
  24.         printf("CAN1_Tx_Warning_IRQHandler ");
  25. }

  27. //tower上面使用can1
  28. int CANx_init(uint8_t CANChannel,uint32_t baudrateKHz,uint8_t selfLoop,uint8_t idMask)
  29. {
  30.     int i;
  31.     CAN_Type *CANx;

  33.     if (CANChannel == 0)
  34.         CANx = CAN0;
  35.     else if (CANChannel == 1)
  36.         CANx = CAN1;
  37.        
  38.     //使能FlexCAN外部时钟
  39. //    OSC1->CR |= OSC_CR_ERCLKEN_MASK | OSC_CR_EREFSTEN_MASK;
  40.     SIM->SCGC3 |= SIM_SCGC3_FLEXCAN1_MASK;//使能CAN1的时钟模块

  42.     NVIC_EnableIRQ(CAN1_ORed_Message_buffer_IRQn);
  43.         NVIC_EnableIRQ(CAN1_Bus_Off_IRQn);
  44.         NVIC_EnableIRQ(CAN1_Error_IRQn);
  45.         NVIC_EnableIRQ(CAN1_Tx_Warning_IRQn);
  46.         NVIC_EnableIRQ(CAN1_Rx_Warning_IRQn);
  47.         NVIC_EnableIRQ(CAN1_Wake_Up_IRQn);
  48.     //(p281.pin out)
  49.         if((uint32_t)CANx == (uint32_t)CAN1_BASE)
  50.         {
  51.                 PORTC->PCR[16] = PORT_PCR_MUX(2) | PORT_PCR_PE_MASK | PORT_PCR_PS_MASK; //上拉
  52.                 PORTC->PCR[17] = PORT_PCR_MUX(2) | PORT_PCR_PE_MASK | PORT_PCR_PS_MASK; //上拉
  53.         }else if((uint32_t)CANx == (uint32_t)CAN0_BASE)
  54.         {
  55.                
  56.         }else{
  57.                 return 2;
  58.         }
  59.     //选择时钟源，外设时钟60MHz，振荡器时钟：50MHz
  60.     CANx->CTRL1 |= CAN_CTRL1_CLKSRC_MASK;//选择内部时钟

  62.     CANx->MCR |= CAN_MCR_FRZ_MASK;  //使能冻结模式
  63.     CANx->MCR &= ~CAN_MCR_MDIS_MASK;//使能CAN模块
  64.     //确认已退出冻结模式
  65.     while ((CAN_MCR_LPMACK_MASK & CANx->MCR));

  67.     //软件复位
  68.     CANx->MCR ^= CAN_MCR_SOFTRST_MASK;
  69.     //等待复位完成
  70.     while (CAN_MCR_SOFTRST_MASK & CANx->MCR);
  71.     //等待进入冻结模式
  72.     while (!(CAN_MCR_FRZACK_MASK & CANx->MCR));

  74.     //将16个邮箱缓冲区内容清0
  75.     for (i=0;i<16;i++)
  76.     {
  77.         CANx->MB[i].CS = 0x00000000;
  78.         CANx->MB[i].ID = 0x00000000;
  79.         CANx->MB[i].WORD0 = 0x00000000;
  80.         CANx->MB[i].WORD1 = 0x00000000;
  81.     }

  83.     //接收邮箱过滤IDE比较，RTR不比较
  84.     CANx->CTRL2 &= ~CAN_CTRL2_EACEN_MASK;
  85.     //远程请求帧产生
  86.     CANx->CTRL2 &= ~CAN_CTRL2_RRS_MASK;
  87.     //邮箱首先从接收FIFO队列匹配然后再在邮箱中匹配
  88.     CANx->CTRL2 &= ~CAN_CTRL2_MRP_MASK;

  90.     //使用一个32位过滤器
  91.     CANx->MCR |= (CANx->MCR & ~CAN_MCR_IDAM_MASK) | CAN_MCR_IDAM(0);
  92.     //设置波特率
  93.     if (SetCANBand(CANChannel,baudrateKHz) == 1)//若设置错误
  94.         return 1;

  96.     //模式选择：回环模式或正常模式
  97.     if (1==selfLoop)
  98.         CANx->CTRL1 |= CAN_CTRL1_LPB_MASK;        //使用回环模式
  99. //        CANx->CTRL1 |= CAN_CTRL1_LOM_MASK;                 //使用监听模式
  100.     //初始化掩码寄存器
  101.     if (1==idMask)//屏蔽ID
  102.     {
  103.         CANx->RXMGMASK = 0x1FFFFFFF;
  104.         CANx->RX14MASK = 0x1FFFFFFF;
  105.         CANx->RX15MASK = 0x1FFFFFFF;
  106.     }
  107.     else//不屏蔽ID
  108.     {
  109.         CANx->RXMGMASK = 0x0;
  110.         CANx->RX14MASK = 0x0;
  111.         CANx->RX15MASK = 0x0;
  112.     }

  114.     //如果单独掩码功能使能，为每个队列初始化单独的掩码寄存器
  115.     if (CANx->MCR & CAN_MCR_IRMQ_MASK)
  116.         for (i = 0; i < NUMBER_OF_MB ; i++)
  117.             CANx->RXIMR[i] = 0x1FFFFFFFL;

  119.     //只有在冻结模式下才能配置，配置完推出冻结模式
  120.     CANx->MCR &= ~(CAN_MCR_HALT_MASK);
  121.     //等待直到退出冻结模式
  122.     while ( CANx->MCR & CAN_MCR_FRZACK_MASK);
  123.     //等到不在冻结模式，休眠模式或者停止模式
  124.     while ((CANx->MCR & CAN_MCR_NOTRDY_MASK));
  125.        
  126.         CANEnableRXBuff(1,//uint8_t CANChannel,
  127.                                         0,//uint16_t iMB,
  128.                                         1//uint32_t id)
  129.         );
  130.         CAN1->IMASK1 |= CAN_IMASK1_BUFLM(0x1ul);
  131.         return 0;
  132. }

  134. //============================================================================
  135. //函数名称：CANSendData
  136. //函数返回：0：成功，1：失败
  137. //参数说明：
  138. //         CANChannel：模块号
  139. //                iMB：缓冲区号
  140. //                               id: ID号
  141. //                           length：数据长度
  142. //                           Data[8]:发送数据缓冲区
  143. //功能概要：发送数据
  144. //============================================================================
  145. int CANSendData(uint8_t CANChannel,uint16_t iMB, uint32_t id,uint8_t length,uint8_t Data[])
  146. {
  147.     int16_t  i,wno,bno;
  148.     uint32_t word[2] = {0};
  149.     CAN_Type *CANx;

  151.     if (CANChannel == 0)
  152.         CANx = CAN0;
  153.     else if (CANChannel == 1)
  154.         CANx = CAN1;

  156.     //缓冲区和数据长度设置错误
  157.     if (iMB >= NUMBER_OF_MB || length >8)
  158.         return 1; //超出范围

  160.     //转换8个字节转换成32位的word存储
  161.     wno = (length-1)>>2;//是否超过4字节
  162.     bno = (length-1)%4; //
  163.     if (wno > 0)        //长度大于4(即发送数据超过4字节)
  164.     {
  165.         word[0] = (
  166.                       (Data[0]<<24)
  167.                       | (Data[1]<<16)
  168.                       | (Data[2]<< 8)
  169.                       |  Data[3]
  170.                   );
  171.     }
  172.     for (i=0;i<=bno;i++)
  173.         word[wno] |= Data[(wno<<2)+i] << (24-(i<<3));

  175.     ///////////////////////////////////////////////////////
  176.     // ID 格式
  177.     // B31 30 29 28 27 26 ... 11 10 9 8 7 6 5 4 3 2 1 0
  178.     // |        |         |                                                                          |
  179.     // |    |    |------------------------------------|
  180.     // |        |                                        |--> 29 位 ID
  181.     // |        |
  182.     // |    |--> RTR  1: 远程帧, 0: 数据帧
  183.     // |
  184.     // |-------> IDE 1 : 扩展ID, 0: 标准ID
  185.     ///////////////////////////////////////////////////////

  187.     //通过id判断帧类型——扩展帧
  188.     wno = (id &  CAN_MSG_IDE_MASK)>>CAN_MSG_IDE_BIT_NO;  //IDE
  189.     //通过id判断帧类型——远程帧
  190.     bno = (id &  CAN_MSG_TYPE_MASK)>>CAN_MSG_TYPE_BIT_NO;//RTR

  192.     //获得ID位数
  193.     i =  wno? 0: FLEXCAN_MB_ID_STD_BIT_NO;

  195.     //以下四步骤为发送过程
  196.     CANx->MB[iMB].CS = FLEXCAN_MB_CS_CODE(FLEXCAN_MB_CODE_TX_INACTIVE)//缓冲区写激活代码
  197.                        | (wno<<FLEXCAN_MB_CS_IDE_BIT_NO)//缓冲区写IDE位
  198.                        | (bno<<FLEXCAN_MB_CS_RTR_BIT_NO)//缓冲区写RTR位
  199.                        | FLEXCAN_MB_CS_LENGTH(length);  //缓冲区写数据长度

  201.     //缓冲区写ID
  202.     CANx->MB[iMB].ID = (1 << FLEXCAN_MB_ID_PRIO_BIT_NO)
  203.                        | ((id & ~(CAN_MSG_IDE_MASK|CAN_MSG_TYPE_MASK))<<i);

  205.     //缓冲区写内容
  206.     CANx->MB[iMB].WORD0 = word[0];
  207.     CANx->MB[iMB].WORD1 = word[1];

  209.     //延迟
  210.     for (i = 0;i < 100;i++);

  212.     //通过制定的发送代码开始发送
  213.     CANx->MB[iMB].CS = (CANx->MB[iMB].CS & ~(FLEXCAN_MB_CS_CODE_MASK))
  214.                        | FLEXCAN_MB_CS_CODE(FLEXCAN_MB_CODE_TX_ONCE)//写激活代码
  215.                        | FLEXCAN_MB_CS_LENGTH(length);//缓冲区写数据长度

  217.     //限时等待发送完成（如果使用中断则限时等待语句可删除）
  218.     i=0;
  219.     while (!(CANx->IFLAG1 & (1<<iMB)))
  220.     {
  221.         if ((i++)>0x1000)
  222.             return 1;
  223.     }
  224.     //清报文缓冲区中断标志
  225.     CANx->IFLAG1 = (1<<iMB);
  226.     return 0;
  227. }

  229. //============================================================================
  230. //函数名称：CANEnableRXBuff
  231. //函数返回：无
  232. //参数说明： CANChannel：CAN模块号
  233. //                 iMB：缓冲区号
  234. //                  id：id号
  235. //功能概要：使能接收缓冲区
  236. //============================================================================
  237. void CANEnableRXBuff(uint8_t CANChannel,uint16_t iMB, uint32_t id)
  238. {
  239.     uint32_t id2;
  240.     uint32_t cs = FLEXCAN_MB_CS_CODE(FLEXCAN_MB_CODE_RX_EMPTY);
  241.     CAN_Type *CANx;

  243.     if (CANChannel == 0)
  244.         CANx = CAN0;
  245.     else if (CANChannel == 1)
  246.         CANx = CAN1;

  248.     //将MB配置为非激活状态
  249.     CANx->MB[iMB].CS = FLEXCAN_MB_CS_CODE(FLEXCAN_MB_CODE_RX_INACTIVE);

  251.     //取出29位单独的ID
  252.     id2 = id & ~(CAN_MSG_IDE_MASK | CAN_MSG_TYPE_MASK);
  253.     if (id & CAN_MSG_IDE_MASK)//扩展帧
  254.     {
  255.         CANx->MB[iMB].ID = id2;
  256.         cs |= FLEXCAN_MB_CS_IDE;//置位IDE位
  257.     }
  258.     else//标准帧
  259.     {
  260.         CANx->MB[iMB].ID = id2<<FLEXCAN_MB_ID_STD_BIT_NO;
  261.     }

  263.     //激活接收缓冲区，code写0100
  264.     CANx->MB[iMB].CS = cs;
  265. }

  267. //============================================================================
  268. //函数名称：CANRecData
  269. //函数返回：0：成功，1：失败
  270. //参数说明：CANChannel：CAN模块号
  271. //                iMB：缓冲区号
  272. //                               id: ID号
  273. //                           lenght：数据长度
  274. //                          Data[8]: 和接收数据缓冲区
  275. //功能概要：接收数据
  276. //============================================================================
  277. uint8_t CANRecData(uint8_t CANChannel,uint16_t iMB, uint32_t *id,uint8_t *Datalenght,uint8_t Data[])
  278. {
  279.     int8_t   i,wno,bno;
  280.     uint16_t code;
  281.     uint8_t  *pMBData;
  282.     int16_t  length;
  283.     int8_t   format;
  284.     uint8_t *pBytes = Data;
  285.     CAN_Type *CANx;

  287.     if (CANChannel == 0)
  288.         CANx = CAN0;
  289.     else if (CANChannel == 1)
  290.         CANx = CAN1;

  292.     // 锁定MB
  293.     code = FLEXCAN_get_code(CANx->MB[iMB].CS);

  295.     if (code != 0x02)//缓冲区没有接收到数据，返回错误
  296.     {
  297.         *Datalenght = 0;
  298.         return 1;
  299.     }
  300.     length = FLEXCAN_get_length(CANx->MB[iMB].CS);

  302.     if (length <1)//接收到的数据长度小于1，返回错误
  303.     {
  304.         *Datalenght = 0;
  305.         return 1;
  306.     }

  308.     //判断是标准帧还是扩展帧
  309.     format = (CANx->MB[iMB].CS & FLEXCAN_MB_CS_IDE)? 1:0;
  310.     *id = (CANx->MB[iMB].ID & FLEXCAN_MB_ID_EXT_MASK);

  312.     if (!format)
  313.     {
  314.         *id >>= FLEXCAN_MB_ID_STD_BIT_NO; // 获得标准帧号
  315.     }
  316.     else
  317.     {
  318.         *id |= CAN_MSG_IDE_MASK; //标记扩展的ID
  319.     }

  321.     format = (CANx->MB[iMB].CS & FLEXCAN_MB_CS_RTR)? 1:0;
  322.     if (format)
  323.     {
  324.         *id |= CAN_MSG_TYPE_MASK; //标记为远程帧类型
  325.     }
  326.     //读取报文数据
  327.     wno = (length-1)>>2;
  328.     bno = length-1;
  329.     if (wno>0)
  330.     {
  331.         (*(uint32_t*)pBytes) = CANx->MB[iMB].WORD0;
  332.         swap_4bytes(pBytes);
  333.         bno -= 4;
  334.         pMBData = (uint8_t*)&CANx->MB[iMB].WORD1+3;
  335.     }
  336.     else
  337.     {
  338.         pMBData = (uint8_t*)&CANx->MB[iMB].WORD0+3;
  339.     }

  341.     for (i=0; i <= bno; i++)
  342.         pBytes[i+(wno<<2)] = *pMBData--;

  344.     *Datalenght = length;
  345.     return 0;
  346. }

  348. //============================================================================
  349. //函数名称：EnableCANInterrupt
  350. //函数返回：无
  351. //参数说明：
  352. //          CANChannel:CAN模块号
  353. //                 iMB:缓冲区号
  354. //功能概要：使能缓冲区接收和发送中断
  355. //============================================================================
  356. void EnableCANInterrupt(uint8_t CANChannel,uint16_t iMB)
  357. {
  358.     CAN_Type *CANx;

  360.     if (CANChannel == 0)
  361.         CANx = CAN0;
  362.     else if (CANChannel == 1)
  363.         CANx = CAN1;

  365.     CANx->IMASK1 = (1<<iMB);
  366. }

  368. //============================================================================
  369. //函数名称：DisableCANInterrupt
  370. //函数返回：无
  371. //参数说明：
  372. //         CANChannel:CAN模块号
  373. //                iMB:缓冲区号
  374. //功能概要：禁止缓冲区接收和发送中断
  375. //============================================================================
  376. void DisableCANInterrupt(uint8_t CANChannel,uint16_t iMB)
  377. {
  378.     CAN_Type *CANx;

  380.     if (CANChannel == 0)
  381.         CANx = CAN0;
  382.     else if (CANChannel == 1)
  383.         CANx = CAN1;

  385.     CANx->IMASK1 &= ~CAN_IMASK1_BUFLM(iMB);
  386. }

  388. //============================================================================
  389. //函数名称：CANClearFlag
  390. //函数返回：无
  391. //参数说明：
  392. //        CANChannel:CAN模块号
  393. //               iMB:缓冲区号
  394. //功能概要：清缓冲区中断标志
  395. //============================================================================
  396. void CANClearFlag(uint8_t CANChannel,uint16_t iMB)
  397. {
  398.     CAN_Type *CANx;

  400.     if (CANChannel == 0)
  401.         CANx = CAN0;
  402.     else if (CANChannel == 1)
  403.         CANx = CAN1;

  405.     CANx->IFLAG1 = (1<<iMB);
  406. }
  407. //============================================================================
  408. //函数名称：CANGetFlag
  409. //函数返回：无
  410. //参数说明：
  411. //         CANChannel:CAN模块号
  412. //                iMB:缓冲区号
  413. //功能概要：获得缓冲区中断标志
  414. //============================================================================
  415. uint32_t CANGetFlag(uint8_t CANChannel,uint16_t iMB)
  416. {
  417.     CAN_Type *CANx;

  419.     if (CANChannel == 0)
  420.         CANx = CAN0;
  421.     else if (CANChannel == 1)
  422.         CANx = CAN1;

  424.     return (CANx->IFLAG1 & (1<<iMB));
  425. }
  426. //===========================内部函数=========================================
  427. //============================================================================
  428. //函数名称：SetCANBand
  429. //函数返回：0:配置成功 1：配置成功
  430. //参数说明：无
  431. //功能概要：设置CAN的波特率
  432. //============================================================================
  433. int SetCANBand(uint8_t CANChannel,uint32_t baudrateKHz)
  434. {
  435.     CAN_Type *CANx;

  437.     if (CANChannel == 0)
  438.         CANx = CAN0;
  439.     else if (CANChannel == 1)
  440.         CANx = CAN1;
  441.     switch (baudrateKHz)
  442.     {
  443.     case (33):        // 33.33K
  444.         if (CANx->CTRL1 & CAN_CTRL1_CLKSRC_MASK)
  445.         {
  446.             // 48M/120= 400k sclock, 12Tq
  447.             // PROPSEG = 3, LOM = 0x0, LBUF = 0x0, TSYNC = 0x0, SAMP = 1
  448.             // RJW = 3, PSEG1 = 4, PSEG2 = 4,PRESDIV = 120
  449.             CANx->CTRL1 = (0 | CAN_CTRL1_PROPSEG(2)
  450.                            | CAN_CTRL1_RJW(2)
  451.                            | CAN_CTRL1_PSEG1(3)
  452.                            | CAN_CTRL1_PSEG2(3)
  453.                            | CAN_CTRL1_PRESDIV(119));
  454.         }
  455.         else
  456.         {
  457.             // 12M/20= 600k sclock, 18Tq
  458.             // PROPSEG = 1, LOM = 0x0, LBUF = 0x0, TSYNC = 0x0, SAMP = 1
  459.             // RJW = 4, PSEG1 = 8, PSEG2 = 8,PRESDIV = 20
  460.             CANx->CTRL1 = (0  | CAN_CTRL1_PROPSEG(0)
  461.                            | CAN_CTRL1_PROPSEG(3)
  462.                            | CAN_CTRL1_PSEG1(7)
  463.                            | CAN_CTRL1_PSEG2(7)
  464.                            | CAN_CTRL1_PRESDIV(19));
  465.         }
  466.         break;
  467.     case (83):        // 83.33K
  468.         if (CANx->CTRL1 & CAN_CTRL1_CLKSRC_MASK)
  469.         {
  470.             // 48M/48= 1M sclock, 12Tq
  471.             // PROPSEG = 3, LOM = 0x0, LBUF = 0x0, TSYNC = 0x0, SAMP = 1
  472.             // RJW = 3, PSEG1 = 4, PSEG2 = 4,PRESDIV = 48
  473.             CANx->CTRL1 = (0 | CAN_CTRL1_PROPSEG(2)
  474.                            | CAN_CTRL1_RJW(2)
  475.                            | CAN_CTRL1_PSEG1(3)
  476.                            | CAN_CTRL1_PSEG2(3)
  477.                            | CAN_CTRL1_PRESDIV(47));
  478.         }
  479.         else
  480.         {
  481.             // 12M/12= 1M sclock, 12Tq
  482.             // PROPSEG = 3, LOM = 0x0, LBUF = 0x0, TSYNC = 0x0, SAMP = 1
  483.             // RJW = 3, PSEG1 = 4, PSEG2 = 4,PRESDIV = 12
  484.             CANx->CTRL1 = (0 | CAN_CTRL1_PROPSEG(2)
  485.                            | CAN_CTRL1_RJW(2)
  486.                            | CAN_CTRL1_PSEG1(3)
  487.                            | CAN_CTRL1_PSEG2(3)
  488.                            | CAN_CTRL1_PRESDIV(11));
  489.         }
  490.         break;
  491.     case (50):
  492.         if (CANx->CTRL1 & CAN_CTRL1_CLKSRC_MASK)
  493.         {
  494.             // 48M/80= 0.6M sclock, 12Tq
  495.             // PROPSEG = 3, LOM = 0x0, LBUF = 0x0, TSYNC = 0x0, SAMP = 1
  496.             // RJW = 3, PSEG1 = 4, PSEG2 = 4, PRESDIV = 40
  497.             CANx->CTRL1 = (0 | CAN_CTRL1_PROPSEG(2)
  498.                            | CAN_CTRL1_RJW(1)
  499.                            | CAN_CTRL1_PSEG1(3)
  500.                            | CAN_CTRL1_PSEG2(3)
  501.                            | CAN_CTRL1_PRESDIV(79));
  502.         }
  503.         else
  504.         {
  505.             // 12M/20= 0.6M sclock, 12Tq
  506.             // PROPSEG = 3, LOM = 0x0, LBUF = 0x0, TSYNC = 0x0, SAMP = 1
  507.             // RJW = 3, PSEG1 = 4, PSEG2 = 4, PRESDIV = 20
  508.             CANx->CTRL1 = (0 | CAN_CTRL1_PROPSEG(2)
  509.                            | CAN_CTRL1_RJW(2)
  510.                            | CAN_CTRL1_PSEG1(3)
  511.                            | CAN_CTRL1_PSEG2(3)
  512.                            | CAN_CTRL1_PRESDIV(19));
  513.         }
  514.         break;
  515.     case (100):
  516.         if (CANx->CTRL1 & CAN_CTRL1_CLKSRC_MASK)
  517.         {
  518.             // 48M/40= 1.2M sclock, 12Tq
  519.             // PROPSEG = 3, LOM = 0x0, LBUF = 0x0, TSYNC = 0x0, SAMP = 1
  520.             // RJW = 3, PSEG1 = 4, PSEG2 = 4, PRESDIV = 40
  521.             CANx->CTRL1 = (0 | CAN_CTRL1_PROPSEG(2)
  522.                            | CAN_CTRL1_RJW(2)
  523.                            | CAN_CTRL1_PSEG1(3)
  524.                            | CAN_CTRL1_PSEG2(3)
  525.                            | CAN_CTRL1_PRESDIV(39));
  526.         }
  527.         else
  528.         {
  529.             // 12M/10= 1.2M sclock, 12Tq
  530.             // PROPSEG = 3, LOM = 0x0, LBUF = 0x0, TSYNC = 0x0, SAMP = 1
  531.             // RJW = 3, PSEG1 = 4, PSEG2 = 4, PRESDIV = 10
  532.             CANx->CTRL1 = (0 | CAN_CTRL1_PROPSEG(2)
  533.                            | CAN_CTRL1_RJW(2)
  534.                            | CAN_CTRL1_PSEG1(3)
  535.                            | CAN_CTRL1_PSEG2(3)
  536.                            | CAN_CTRL1_PRESDIV(9));
  537.         }
  538.         break;
  539.     case (125):
  540.         if (CANx->CTRL1 & CAN_CTRL1_CLKSRC_MASK)
  541.         {
  542.             // 48M/32= 1.5M sclock, 12Tq
  543.             // PROPSEG = 3, LOM = 0x0, LBUF = 0x0, TSYNC = 0x0, SAMP = 1
  544.             // RJW = 3, PSEG1 = 4, PSEG2 = 4, PRESDIV = 32
  545.             CANx->CTRL1 = (0 | CAN_CTRL1_PROPSEG(2)
  546.                            | CAN_CTRL1_RJW(2)
  547.                            | CAN_CTRL1_PSEG1(3)
  548.                            | CAN_CTRL1_PSEG2(3)
  549.                            | CAN_CTRL1_PRESDIV(31));
  550.         }
  551.         else
  552.         {
  553.             // 12M/8= 1.5M sclock, 12Tq
  554.             // PROPSEG = 3, LOM = 0x0, LBUF = 0x0, TSYNC = 0x0, SAMP = 1
  555.             // RJW = 3, PSEG1 = 4, PSEG2 = 4, PRESDIV = 8
  556.             CANx->CTRL1 = (0 | CAN_CTRL1_PROPSEG(2)
  557.                            | CAN_CTRL1_RJW(2)
  558.                            | CAN_CTRL1_PSEG1(3)
  559.                            | CAN_CTRL1_PSEG2(3)
  560.                            | CAN_CTRL1_PRESDIV(7));
  561.         }
  562.         break;
  563.     case (250):
  564.         if (CANx->CTRL1 & CAN_CTRL1_CLKSRC_MASK)
  565.         {
  566.             // 48M/16= 3M sclock, 12Tq
  567.             // PROPSEG = 3, LOM = 0x0, LBUF = 0x0, TSYNC = 0x0, SAMP = 1
  568.             // RJW = 2, PSEG1 = 4, PSEG2 = 4, PRESDIV = 16
  569.             CANx->CTRL1 = (0 | CAN_CTRL1_PROPSEG(2)
  570.                            | CAN_CTRL1_RJW(1)
  571.                            | CAN_CTRL1_PSEG1(3)
  572.                            | CAN_CTRL1_PSEG2(3)
  573.                            | CAN_CTRL1_PRESDIV(15));
  574.         }
  575.         else
  576.         {
  577.             // 12M/4= 3M sclock, 12Tq
  578.             // PROPSEG = 3, LOM = 0x0, LBUF = 0x0, TSYNC = 0x0, SAMP = 1
  579.             // RJW = 2, PSEG1 = 4, PSEG2 = 4, PRESDIV = 4
  580.             CANx->CTRL1 = (0 | CAN_CTRL1_PROPSEG(2)
  581.                            | CAN_CTRL1_RJW(1)
  582.                            | CAN_CTRL1_PSEG1(3)
  583.                            | CAN_CTRL1_PSEG2(3)
  584.                            | CAN_CTRL1_PRESDIV(3));
  585.         }
  586.         break;
  587.     case (500):
  588.         if (CANx->CTRL1 & CAN_CTRL1_CLKSRC_MASK)
  589.         {
  590.             // 60M/10=6M sclock, 12Tq
  591.             // PROPSEG = 3, LOM = 0x0, LBUF = 0x0, TSYNC = 0x0, SAMP = 1
  592.             // RJW = 2, PSEG1 = 4, PSEG2 = 4, PRESDIV = 6
  593.             CANx->CTRL1 = (0 | CAN_CTRL1_PROPSEG(2)
  594.                            | CAN_CTRL1_RJW(1)
  595.                            | CAN_CTRL1_PSEG1(3)
  596.                            | CAN_CTRL1_PSEG2(3)
  597.                            | CAN_CTRL1_PRESDIV(9));
  598.         }
  599.         else
  600.         {
  601.             // 12M/2=6M sclock, 12Tq
  602.             // PROPSEG = 3, LOM = 0x0, LBUF = 0x0, TSYNC = 0x0, SAMP = 1
  603.             // RJW = 2, PSEG1 = 4, PSEG2 = 4, PRESDIV = 2
  604.             CANx->CTRL1 = (0 | CAN_CTRL1_PROPSEG(2)
  605.                            | CAN_CTRL1_RJW(1)
  606.                            | CAN_CTRL1_PSEG1(3)
  607.                            | CAN_CTRL1_PSEG2(3)
  608.                            | CAN_CTRL1_PRESDIV(1));
  609.         }
  610.         break;
  611.     case (1000):
  612.         if (CANx->CTRL1 & CAN_CTRL1_CLKSRC_MASK)
  613.         {
  614.             // 48M/6=8M sclock
  615.             // PROPSEG = 4, LOM = 0x0, LBUF = 0x0, TSYNC = 0x0, SAMP = 1
  616.             // RJW = 1, PSEG1 = 1, PSEG2 = 2, PRESCALER = 6
  617.             CANx->CTRL1 = (0 | CAN_CTRL1_PROPSEG(3)
  618.                            | CAN_CTRL1_RJW(0)
  619.                            | CAN_CTRL1_PSEG1(0)
  620.                            | CAN_CTRL1_PSEG2(1)
  621.                            | CAN_CTRL1_PRESDIV(5));
  622.         }
  623.         else
  624.         {
  625.             // 12M/1=12M sclock,12Tq
  626.             // PROPSEG = 3, LOM = 0x0, LBUF = 0x0, TSYNC = 0x0, SAMP = 1
  627.             // RJW = 4, PSEG1 = 4, PSEG2 = 4, PRESCALER = 1
  628.             CANx->CTRL1 = (0 | CAN_CTRL1_PROPSEG(2)
  629.                            | CAN_CTRL1_RJW(3)
  630.                            | CAN_CTRL1_PSEG1(3)
  631.                            | CAN_CTRL1_PSEG2(3)
  632.                            | CAN_CTRL1_PRESDIV(0));
  633.         }
  634.         break;
  635.     default:
  636.         return 1;
  637.     }
  638.     return 0;
  639. }
复制代码

一周热门 更多>