LPC55S16的CAN_FD初探

maoyanmcu

本人本身不是弄CAN总线通信的，所以日常使用CAN是比较少的。
所以我是这篇就是直接参考了别人的一些资料来的，CAN_FD应该可以说是CAN的升级了，波特率更高，数据帧更长。帧结构也是发生了变化。


本次实验在官方例程下可以找到。loopback是回环测试，外部不需要接CAN芯片就能直接测试。我选择上一个工程测试。

外围电路使用一颗，TJA1050T芯片，作为收发芯片，物理层上不需要改变什么东西，只是协议上的变化。

1.    MCAN_Init(EXAMPLE_MCAN, &mcanConfig, MCAN_CLK_FREQ);
   
2. 
   
3.     /* Create MCAN handle structure and set call back function. */
   
4.     MCAN_TransferCreateHandle(EXAMPLE_MCAN, &mcanHandle, mcan_callback, NULL);
   
5. 
   
6.     /* Set Message RAM base address and clear to avoid BEU/BEC error. */
   
7.     MCAN_SetMsgRAMBase(EXAMPLE_MCAN, MSG_RAM_BASE);
   
8.     uint32_t *p = (uint32_t *)(MSG_RAM_BASE);
   
9.     memset(p, 0, (8U + CAN_DATASIZE) * sizeof(uint8_t));
   
10. 
    
11.     /* STD filter config. */
    
12.     rxFilter.address  = STD_FILTER_OFS;
    
13.     rxFilter.idFormat = kMCAN_FrameIDStandard;
    
14.     rxFilter.listSize = 1U;
    
15.     rxFilter.nmFrame  = kMCAN_reject0;
    
16.     rxFilter.remFrame = kMCAN_rejectFrame;
    
17.     MCAN_SetFilterConfig(EXAMPLE_MCAN, &rxFilter);
    
18. 
    
19.     stdFilter.sfec = kMCAN_storeinFifo0;
    
20.     /* Classic filter mode, only filter matching ID. */
    
21.     stdFilter.sft   = kMCAN_classic;
    
22.     stdFilter.sfid1 = rxIdentifier;
    
23.     stdFilter.sfid2 = 0x7FFU;
    
24.     MCAN_SetSTDFilterElement(EXAMPLE_MCAN, &rxFilter, &stdFilter, 0);
    
25. 
    
26.     /* RX fifo0 config. */
    
27.     rxFifo0.address       = RX_FIFO0_OFS;
    
28.     rxFifo0.elementSize   = 1U;
    
29.     rxFifo0.watermark     = 0;
    
30.     rxFifo0.opmode        = kMCAN_FifoBlocking;
    
31.     rxFifo0.datafieldSize = kMCAN_8ByteDatafield;
    
32. #if (defined(USE_CANFD) && USE_CANFD)
    
33.     rxFifo0.datafieldSize = BYTES_IN_MB;
    
34. #endif
    
35.     MCAN_SetRxFifo0Config(EXAMPLE_MCAN, &rxFifo0);
    
36. 
    
37.     /* TX buffer config. */
    
38.     memset(&txBuffer, 0, sizeof(txBuffer));
    
39.     txBuffer.address       = TX_BUFFER_OFS;
    
40.     txBuffer.dedicatedSize = 1U;
    
41.     txBuffer.fqSize        = 0;
    
42.     txBuffer.datafieldSize = kMCAN_8ByteDatafield;
    
43. #if (defined(USE_CANFD) && USE_CANFD)
    
44.     txBuffer.datafieldSize = BYTES_IN_MB;
    
45. #endif
    
46.     MCAN_SetTxBufferConfig(EXAMPLE_MCAN, &txBuffer);
    
47. 
    
48.     /* Finish software initialization and enter normal mode, synchronizes to
    
49.        CAN bus, ready for communication */
    
50.     MCAN_EnterNormalMode(EXAMPLE_MCAN);
    
51. 
    
52.     if ((node_type == 'A') || (node_type == 'a'))
    
53.     {
    
54.         PRINTF("Press any key to trigger one-shot transmission\r\n\r\n");
    
55.     }
    
56.     else
    
57.     {
    
58.         PRINTF("Start to Wait data from Node A\r\n\r\n");
    
59.     }
    
60. 
    
61.     while (1)
    
62.     {
    
63.         if ((node_type == 'A') || (node_type == 'a'))
    
64.         {
    
65.             GETCHAR();
    
66.             /* Config TX frame data. */
    
67.             memset(tx_data, 0, sizeof(uint8_t) * CAN_DATASIZE);
    
68.             for (cnt = 0; cnt < CAN_DATASIZE; cnt++)
    
69.             {
    
70.                 tx_data[cnt] = cnt;
    
71.             }
    
72.             tx_data[0] += numMessage++;
    
73.             txFrame.xtd  = kMCAN_FrameIDStandard;
    
74.             txFrame.rtr  = kMCAN_FrameTypeData;
    
75.             txFrame.fdf  = 0;
    
76.             txFrame.brs  = 0;
    
77.             txFrame.dlc  = 8U;
    
78.             txFrame.id   = txIdentifier << STDID_OFFSET;
    
79.             txFrame.data = tx_data;
    
80.             txFrame.size = CAN_DATASIZE;
    
81. #if (defined(USE_CANFD) && USE_CANFD)
    
82.             txFrame.fdf = 1;
    
83.             txFrame.brs = 1;
    
84.             txFrame.dlc = DLC;
    
85. #endif
    
86.             txXfer.frame     = &txFrame;
    
87.             txXfer.bufferIdx = 0;
    
88.             MCAN_TransferSendNonBlocking(EXAMPLE_MCAN, &mcanHandle, &txXfer);
    
89. 
    
90.             while (!txComplete)
    
91.             {
    
92.             }
    
93.             txComplete = false;
    
94. 
    
95.             /* Start receive data through Rx FIFO 0. */
    
96.             memset(rx_data, 0, sizeof(uint8_t) * CAN_DATASIZE);
    
97.             /* the MCAN engine can't auto to get rx payload size, we need set it. */
    
98.             rxFrame.size = CAN_DATASIZE;
    
99.             rxXfer.frame = &rxFrame;
    
100.             MCAN_TransferReceiveFifoNonBlocking(EXAMPLE_MCAN, 0, &mcanHandle, &rxXfer);
     
101. 
     
102.             /* Wait until message received. */
     
103.             while (!rxComplete)
     
104.             {
     
105.             }
     
106.             rxComplete = false;
     
107. 
     
108.             /* After call the API of rMCAN_TransferReceiveFifoNonBlocking success, we can
     
109.              * only get a point (rxFrame.data) to the fifo reading entrance.
     
110.              * Copy the received frame data from the FIFO by the pointer(rxFrame.data). */
     
111.             memcpy(rx_data, rxFrame.data, rxFrame.size);
     
112. 
     
113.             PRINTF("Received Frame ID: 0x%x\r\n", rxFrame.id >> STDID_OFFSET);
     
114.             PRINTF("Received Frame DATA: ");
     
115.             cnt = 0;
     
116.             while (cnt < rxFrame.size)
     
117.             {
     
118.                 PRINTF("0x%x ", rx_data[cnt++]);
     
119.             }
     
120.             PRINTF("\r\n");
     
121.             PRINTF("Press any key to trigger the next transmission!\r\n\r\n");
     
122.         }
     
123.         else
     
124.         {
     
125.             memset(rx_data, 0, sizeof(uint8_t) * CAN_DATASIZE);
     
126.             /* the MCAN engine can't auto to get rx payload size, we need set it. */
     
127.             rxFrame.size = CAN_DATASIZE;
     
128.             rxXfer.frame = &rxFrame;
     
129.             MCAN_TransferReceiveFifoNonBlocking(EXAMPLE_MCAN, 0, &mcanHandle, &rxXfer);
     
130. 
     
131.             while (!rxComplete)
     
132.             {
     
133.             }
     
134.             rxComplete = false;
     
135. 
     
136.             /* After call the API of rMCAN_TransferReceiveFifoNonBlocking success, we can
     
137.              * only get a point (rxFrame.data) to the fifo reading entrance.
     
138.              * Copy the received frame data from the FIFO by the pointer(rxFrame.data). */
     
139.             memcpy(rx_data, rxFrame.data, rxFrame.size);
     
140. 
     
141.             PRINTF("Received Frame ID: 0x%x\r\n", rxFrame.id >> STDID_OFFSET);
     
142.             PRINTF("Received Frame DATA: ");
     
143. 
     
144.             cnt = 0;
     
145.             while (cnt < rxFrame.size)
     
146.             {
     
147.                 PRINTF("0x%x ", rx_data[cnt++]);
     
148.             }
     
149.             PRINTF("\r\n");
     
150. 
     
151.             /* Copy received frame data to tx frame. */
     
152.             memcpy(tx_data, rx_data, CAN_DATASIZE);
     
153. 
     
154.             txFrame.xtd      = rxFrame.xtd;
     
155.             txFrame.rtr      = rxFrame.rtr;
     
156.             txFrame.fdf      = rxFrame.fdf;
     
157.             txFrame.brs      = rxFrame.brs;
     
158.             txFrame.dlc      = rxFrame.dlc;
     
159.             txFrame.id       = txIdentifier << STDID_OFFSET;
     
160.             txFrame.data     = tx_data;
     
161.             txFrame.size     = rxFrame.size;
     
162.             txXfer.frame     = &txFrame;
     
163.             txXfer.bufferIdx = 0;
     
164. 
     
165.             MCAN_TransferSendNonBlocking(EXAMPLE_MCAN, &mcanHandle, &txXfer);
     
166. 
     
167.             while (!txComplete)
     
168.             {
     
169.             }
     
170.             txComplete = false;
     
171.             PRINTF("Wait Node A to trigger the next transmission!\r\n\r\n");
     
172.         }
     
173.     }

复制代码

具体代码就是我们通过串口发送“A”或者“a”时其CAN就会开始工作，发送数据并等回传数据。

我是使用了逻辑分析仪测试CAN_H和CAN_L,端口发现是有数据的，不过解码部分就不行了，因为协议对不上。所以数据部分也没有对上。
后期的话就是可以用两块板相互通信，目前就是验证了下可以发送数据，具体也没太深入研究，算初探吧。还要就是我买了新的J-LINK11发现其在KEIL下还是无法进行仿真，下载完程序后依旧是需要手动复位才能运行程序，不过在官方的IDE MCUXpresso工具中是正常的，不知道哪位有办法解决。

阅读全文

jobszheng5

CAN接口 都升级了啊！！ 有些out了
Jlink还停留在v8阶段呢