LPC54616的CAN通信，断线之后重连数据发送不出去

zmh169

使用LPC54616的CAN外设，无阻断的中断发送模式，用连接电脑的一个CAN-USB适配器做接收节点。当我把连接线断了之后再重新连接，CAN就不能发送数据了。必须重启MCU才能再次发送。程序参考了NXP的 SDK 2.7 官方例程。类似的代码，用SDK 2.6没有问题。请问是什么原因。新版本BUG？附上代码。

最佳答案

提供一个猜测，做参考。是否是因为等待CAN设备的ACK？如果只有两个CAN节点，脱开一个之后，发送的报文没有ACK会发送失败，在错误过多的情况下，会主动关闭CAN收发器。 ...

• stm1024
• 发表于2020-05-20
• 详细答案>>

阅读全文

小恩GG

当连接线断了后，调试过程中有发现代码进入loop或者中断吗？

stm1024

提供一个猜测，做参考。是否是因为等待CAN设备的ACK？如果只有两个CAN节点，脱开一个之后，发送的报文没有ACK会发送失败，在错误过多的情况下，会主动关闭CAN收发器。

zmh169

小恩GG 发表于 2020-5-20 09:04
当连接线断了后，调试过程中有发现代码进入loop或者中断吗？

断线重连，就一直卡死在“while (!txComplete){}”循环等待中了，SDK2.6没这问题。不改SDK的情况下，可能在循环中加个超时退出是个办法。

zmh169

stm1024 发表于 2020-5-20 19:57
提供一个猜测，做参考。是否是因为等待CAN设备的ACK？如果只有两个CAN节点，脱开一个之后，发送的报文没有A ...

打断点然后对比SDK2.6和SDK2.7的CAN寄存器值，发现寄存器值都一样，不是CAN配置的问题。最后通过替换两个版本的函数，发现问题在中断处理函数上，SDK2.7的CAN中断处理函数比SDK2.6复杂了不少，还没想好如何修改。
void MCAN_TransferHandleIRQ(CAN_Type *base, mcan_handle_t *handle)
SDK2.6的代码如下：

1.     /* Assertion. */
   
2.     assert(handle);
   
3. 
   
4.     status_t status = kStatus_MCAN_UnHandled;
   
5.     uint32_t result;
   
6. 
   
7.     /* Store Current MCAN Module Error and Status. */
   
8.     result = base->IR;
   
9. 
   
10.     do
    
11.     {
    
12.         /* Solve Rx FIFO, Tx interrupt. */
    
13.         if (result & kMCAN_TxTransmitCompleteFlag)
    
14.         {
    
15.             status = kStatus_MCAN_TxIdle;
    
16.             MCAN_TransferAbortSend(base, handle, handle->txbufferIdx);
    
17.         }
    
18.         else if (result & kMCAN_RxFifo0NewFlag)
    
19.         {
    
20.             MCAN_ReadRxFifo(base, 0, handle->rxFifoFrameBuf);
    
21.             status = kStatus_MCAN_RxFifo0Idle;
    
22.             MCAN_TransferAbortReceiveFifo(base, 0, handle);
    
23.         }
    
24.         else if (result & kMCAN_RxFifo0LostFlag)
    
25.         {
    
26.             status = kStatus_MCAN_RxFifo0Lost;
    
27.         }
    
28.         else if (result & kMCAN_RxFifo1NewFlag)
    
29.         {
    
30.             MCAN_ReadRxFifo(base, 1, handle->rxFifoFrameBuf);
    
31.             status = kStatus_MCAN_RxFifo1Idle;
    
32.             MCAN_TransferAbortReceiveFifo(base, 1, handle);
    
33.         }
    
34.         else if (result & kMCAN_RxFifo1LostFlag)
    
35.         {
    
36.             status = kStatus_MCAN_RxFifo0Lost;
    
37.         }
    
38.         else
    
39.         {
    
40.             ;
    
41.         }
    
42. 
    
43.         /* Clear resolved Rx FIFO, Tx Buffer IRQ. */
    
44.         MCAN_ClearStatusFlag(base, result);
    
45. 
    
46.         /* Calling Callback Function if has one. */
    
47.         if (handle->callback != NULL)
    
48.         {
    
49.             handle->callback(base, handle, status, result, handle->userData);
    
50.         }
    
51. 
    
52.         /* Reset return status */
    
53.         status = kStatus_MCAN_UnHandled;
    
54. 
    
55.         /* Store Current MCAN Module Error and Status. */
    
56.         result = base->IR;
    
57.     } while ((0 != MCAN_GetStatusFlag(base, 0xFFFFFFFFU)) ||
    
58.              (0 != (result & (kMCAN_ErrorWarningIntFlag | kMCAN_BusOffIntFlag | kMCAN_ErrorPassiveIntFlag))));
    

复制代码

SDK2.7的代码如下：

1.     /* Assertion. */
   
2.     assert(NULL != handle);
   
3. 
   
4.     status_t status = kStatus_MCAN_UnHandled;
   
5.     uint32_t valueIR;
   
6.     uint32_t result;
   
7. 
   
8.     /* Store Current MCAN Module Error and Status. */
   
9.     valueIR = base->IR;
   
10. 
    
11.     do
    
12.     {
    
13.         if (0U != (valueIR & ((uint32_t)kMCAN_ErrorWarningIntFlag | (uint32_t)kMCAN_ErrorPassiveIntFlag |
    
14.                               (uint32_t)kMCAN_BusOffIntFlag)))
    
15.         {
    
16.             /* Solve error. */
    
17.             result = (uint32_t)kMCAN_ErrorWarningIntFlag | (uint32_t)kMCAN_ErrorPassiveIntFlag |
    
18.                      (uint32_t)kMCAN_BusOffIntFlag;
    
19.             status = kStatus_MCAN_ErrorStatus;
    
20.         }
    
21.         else if (0U != (valueIR & (uint32_t)kMCAN_TxTransmitCompleteFlag))
    
22.         {
    
23.             /* Solve Tx interrupt. */
    
24.             result = (uint32_t)kMCAN_TxTransmitCompleteFlag;
    
25.             status = kStatus_MCAN_TxIdle;
    
26.             MCAN_TransferAbortSend(base, handle, handle->txbufferIdx);
    
27.         }
    
28.         else if (0U != (valueIR & (uint32_t)kMCAN_RxFifo0NewFlag))
    
29.         {
    
30.             (void)MCAN_ReadRxFifo(base, 0U, handle->rxFifoFrameBuf);
    
31.             result = (uint32_t)kMCAN_RxFifo0NewFlag;
    
32.             status = kStatus_MCAN_RxFifo0Idle;
    
33.             MCAN_TransferAbortReceiveFifo(base, 0U, handle);
    
34.         }
    
35.         else if (0U != (valueIR & (uint32_t)kMCAN_RxFifo0LostFlag))
    
36.         {
    
37.             result = (uint32_t)kMCAN_RxFifo0LostFlag;
    
38.             status = kStatus_MCAN_RxFifo0Lost;
    
39.         }
    
40.         else if (0U != (valueIR & (uint32_t)kMCAN_RxFifo1NewFlag))
    
41.         {
    
42.             (void)MCAN_ReadRxFifo(base, 1U, handle->rxFifoFrameBuf);
    
43.             result = (uint32_t)kMCAN_RxFifo1NewFlag;
    
44.             status = kStatus_MCAN_RxFifo1Idle;
    
45.             MCAN_TransferAbortReceiveFifo(base, 1U, handle);
    
46.         }
    
47.         else if (0U != (valueIR & (uint32_t)kMCAN_RxFifo1LostFlag))
    
48.         {
    
49.             result = (uint32_t)kMCAN_RxFifo1LostFlag;
    
50.             status = kStatus_MCAN_RxFifo0Lost;
    
51.         }
    
52.         else
    
53.         {
    
54.             /* Handle the interrupt flag unsupported in current version of MCAN driver.
    
55.              * User can get these unsupported interrupt flags by callback function,
    
56.              * we can clear directly in the handler to prevent endless loop.
    
57.              */
    
58.             result = valueIR;
    
59.             result &= ~((uint32_t)kMCAN_ErrorWarningIntFlag | (uint32_t)kMCAN_ErrorPassiveIntFlag |
    
60.                         (uint32_t)kMCAN_BusOffIntFlag | (uint32_t)kMCAN_TxTransmitCompleteFlag |
    
61.                         (uint32_t)kMCAN_RxFifo0NewFlag | (uint32_t)kMCAN_RxFifo0LostFlag |
    
62.                         (uint32_t)kMCAN_RxFifo1NewFlag | (uint32_t)kMCAN_RxFifo1LostFlag);
    
63.         }
    
64. 
    
65.         /* Clear Error interrupt, resolved Rx FIFO, Tx Buffer IRQ and other unsupported interrupt flags. */
    
66.         MCAN_ClearStatusFlag(base, result);
    
67. 
    
68.         /* Calling Callback Function if has one. */
    
69.         if (handle->callback != NULL)
    
70.         {
    
71.             handle->callback(base, handle, status, result, handle->userData);
    
72.         }
    
73. 
    
74.         /* Reset return status */
    
75.         status = kStatus_MCAN_UnHandled;
    
76. 
    
77.         /* Store Current MCAN Module Error and Status. */
    
78.         valueIR = base->IR;
    
79.     } while (0U != valueIR);

复制代码

zmh169

问题已解决：
错误标志的处理要放在最后一个else if中，否则断线后就反复处理错误，重连也从错误状态跳不出来。修改后的void MCAN_TransferHandleIRQ(CAN_Type *base, mcan_handle_t *handle)函数代码如下：

1.     /* Assertion. */
   
2.     assert(NULL != handle);
   
3. 
   
4.     status_t status = kStatus_MCAN_UnHandled;
   
5.     uint32_t valueIR;
   
6.     uint32_t result;
   
7. 
   
8.     /* Store Current MCAN Module Error and Status. */
   
9.     valueIR = base->IR;
   
10. 
    
11.     do
    
12.     {
    
13.         if (0U != (valueIR & (uint32_t)kMCAN_TxTransmitCompleteFlag))
    
14.         {
    
15.             /* Solve Tx interrupt. */
    
16.             result = (uint32_t)kMCAN_TxTransmitCompleteFlag;
    
17.             status = kStatus_MCAN_TxIdle;
    
18.             MCAN_TransferAbortSend(base, handle, handle->txbufferIdx);
    
19.         }
    
20.         else if (0U != (valueIR & (uint32_t)kMCAN_RxFifo0NewFlag))
    
21.         {
    
22.             (void)MCAN_ReadRxFifo(base, 0U, handle->rxFifoFrameBuf);
    
23.             result = (uint32_t)kMCAN_RxFifo0NewFlag;
    
24.             status = kStatus_MCAN_RxFifo0Idle;
    
25.             MCAN_TransferAbortReceiveFifo(base, 0U, handle);
    
26.         }
    
27.         else if (0U != (valueIR & (uint32_t)kMCAN_RxFifo0LostFlag))
    
28.         {
    
29.             result = (uint32_t)kMCAN_RxFifo0LostFlag;
    
30.             status = kStatus_MCAN_RxFifo0Lost;
    
31.         }
    
32.         else if (0U != (valueIR & (uint32_t)kMCAN_RxFifo1NewFlag))
    
33.         {
    
34.             (void)MCAN_ReadRxFifo(base, 1U, handle->rxFifoFrameBuf);
    
35.             result = (uint32_t)kMCAN_RxFifo1NewFlag;
    
36.             status = kStatus_MCAN_RxFifo1Idle;
    
37.             MCAN_TransferAbortReceiveFifo(base, 1U, handle);
    
38.         }
    
39.         else if (0U != (valueIR & (uint32_t)kMCAN_RxFifo1LostFlag))
    
40.         {
    
41.             result = (uint32_t)kMCAN_RxFifo1LostFlag;
    
42.             status = kStatus_MCAN_RxFifo0Lost;
    
43.         }
    
44.         // 出错标志需在最后一个else if 中后处理，否则断线后重连CAN不能自动恢复
    
45.         else if (0U != (valueIR & ((uint32_t)kMCAN_ErrorWarningIntFlag |
    
46.                         (uint32_t)kMCAN_ErrorPassiveIntFlag |(uint32_t)kMCAN_BusOffIntFlag)))
    
47.         {
    
48.                 /* Solve error. */
    
49.                 result = (uint32_t)kMCAN_ErrorWarningIntFlag | (uint32_t)kMCAN_ErrorPassiveIntFlag |
    
50.                                 (uint32_t)kMCAN_BusOffIntFlag;
    
51.                 status = kStatus_MCAN_ErrorStatus;
    
52.         }
    
53.         else
    
54.         {
    
55.             /* Handle the interrupt flag unsupported in current version of MCAN driver.
    
56.              * User can get these unsupported interrupt flags by callback function,
    
57.              * we can clear directly in the handler to prevent endless loop.
    
58.              */
    
59.             result = valueIR;
    
60.             result &= ~((uint32_t)kMCAN_ErrorWarningIntFlag | (uint32_t)kMCAN_ErrorPassiveIntFlag |
    
61.                         (uint32_t)kMCAN_BusOffIntFlag | (uint32_t)kMCAN_TxTransmitCompleteFlag |
    
62.                         (uint32_t)kMCAN_RxFifo0NewFlag | (uint32_t)kMCAN_RxFifo0LostFlag |
    
63.                         (uint32_t)kMCAN_RxFifo1NewFlag | (uint32_t)kMCAN_RxFifo1LostFlag);
    
64.         }
    
65. 
    
66.         /* Clear Error interrupt, resolved Rx FIFO, Tx Buffer IRQ and other unsupported interrupt flags. */
    
67.         MCAN_ClearStatusFlag(base, result);
    
68. 
    
69.         /* Calling Callback Function if has one. */
    
70.         if (handle->callback != NULL)
    
71.         {
    
72.             handle->callback(base, handle, status, result, handle->userData);
    
73.         }
    
74. 
    
75.         /* Reset return status */
    
76.         status = kStatus_MCAN_UnHandled;
    
77. 
    
78.         /* Store Current MCAN Module Error and Status. */
    
79.         valueIR = base->IR;
    
80.     } while (0U != valueIR);

复制代码