YTM32MC03 MCAL LIN Slave 发送回环测试异常

lxhxss

现象：MCU 作为 LIN Slave，接收上位机报文正常（RX 通路完好），回复报文时底层回环测试失败——UART TX 引脚已通过示波器确认发出了正确的波形（19200bps，帧格式正确），但 MCU 内部 RX 未对该回环信号产生 RXIF 中断，导致 TX 状态机无法推进，TxConfirmation 回调永不触发。

已确认：

同一块硬件使用 SDK 工程可正常收发
示波器实测 TX 引脚波形符合预期，排除 TX 未发出或比特率错误
UART0_IRQHandler 在回环期间完全不触发，说明问题在 UART 硬件层面——RX 未识别到 RXD 引脚上的回环信号

RuiXu

在错误回调函数LinIf_LinErrorIndication中观察LIN是否报错

RuiXu

用的MCAL哪个版本？

lxhxss

没有报错

lxhxss

RuiXu RuiXu RuiXu 2_3_0版本回退了 1.0.0也一样

RuiXu

我没有理解那两张图片的意思，可否详细说一下？

lxhxss

这个是函数 Lin_Lld_Uart_LocSlaveRxOk 每个状态进入的次数进入一次就累计一次，累计发送了 27次 SLAVE 回复 MASTER 的相关报文

lxhxss

RuiXu 这样说不知道有没有表达清楚您有理解吗

RuiXu

还是不是很清楚，收发流程是怎么样的，可以给我看看LIN收发的代码吗？

lxhxss

RuiXu 主函数就是demo的

这是历程中的底层函数

uint8 temp2[22];

LIN_FUNC void Lin_Lld_Uart_LocSlaveRxOk(const uint8 Channel, volatile UART_Type Base, uint8 ResData)
{
#if (LIN_SLAVE_API_SUPPORT == STD_ON)
Lin_PduType TmpPduInfo;
#endif
if (LIN_DRV_HW_SYNC_FIELD == Lin_LocUartHwStatus[Channel])
{
/ check whether 0x55 /
if (LIN_CONST_SYNC_FIELD_DATA == ResData)
{
temp2[0]++; / SYNC match → ID_FIELD /
/ start receive pid /
Lin_LocUartHwStatus[Channel] = LIN_DRV_HW_ID_FIELD;
}
else
{
temp2[1]++; / SYNC mismatch → error + IDLE /
#if (LIN_SLAVE_API_SUPPORT == STD_ON)
LinIf_LinErrorIndication(Channel, LIN_ERR_HEADER);
#endif
/ enable break detect /
Lin_Lld_Uart_LocEnableLbkDtc(Base);
/ state idle /
Lin_LocUartHwStatus[Channel] = LIN_DRV_HW_IDLE_MODE;
}
}
else if (LIN_DRV_HW_ID_FIELD == Lin_LocUartHwStatus[Channel])
{
/ stop header res timeout tick /
Lin_Lld_Uart_LocStopToTicks(Channel);
#if (LIN_SLAVE_API_SUPPORT == STD_ON)
TmpPduInfo.Pid = ResData;
TmpPduInfo.SduPtr = &Lin_DrvUartFrameSdu[Channel][0];
TmpPduInfo.Dl = LIN_CONST_MAX_FRAME_BYTES_NUM;
TmpPduInfo.Drc = LIN_FRAMERESPONSE_IGNORE;
TmpPduInfo.Cs = LIN_ENHANCED_CS;
if (E_OK == LinIf_HeaderIndication(Channel, &TmpPduInfo))
{
temp2[2]++; / ID_FIELD + HeaderIndication OK /
Lin_LocCurrentPdu[Channel].Pid = TmpPduInfo.Pid;
Lin_LocCurrentPdu[Channel].Drc = TmpPduInfo.Drc;
Lin_LocCurrentPdu[Channel].Cs = TmpPduInfo.Cs;
Lin_LocCurrentPdu[Channel].Dl = TmpPduInfo.Dl;
if ((0U == TmpPduInfo.Dl) || (8U < TmpPduInfo.Dl))
{
temp2[3]++; / ID_FIELD + OK + invalid Dl /
Base->INTF = Base->INTF;
Lin_Lld_Uart_LocEnableLbkDtc(Base);
Lin_LocUartHwStatus[Channel] = LIN_DRV_HW_IDLE_MODE;
return;
}
if (LIN_FRAMERESPONSE_RX == TmpPduInfo.Drc)
{
temp2[4]++; / ID_FIELD + OK + RX → DATA_FIELD /
/ start slave res timeout tick /
Lin_Lld_Uart_LocStartToTicks(Channel, LIN_DRV_TO_S_RECEIVE);
Lin_LocUartTimeoutType[Channel] = LIN_DRV_TO_S_RECEIVE;
Lin_DrvUartDataCount[Channel] = 0U;
Lin_LocUartHwStatus[Channel] = LIN_DRV_HW_DATA_FIELD;
}
else if (LIN_FRAMERESPONSE_TX == TmpPduInfo.Drc)
{
temp2[5]++; / ID_FIELD + OK + TX → DATA_FIELD /
Base->CTRL0 = UART_CTRL0_RXEN_MASK | UART_CTRL0_TXEN_MASK;
Base->RXFIFO = UART_RXFIFO_RESET_MASK | UART_RXFIFO_EN_MASK;
Base->DATA = TmpPduInfo.SduPtr[0];
Lin_DrvUartSentData[Channel] = TmpPduInfo.SduPtr[0];
Lin_DrvUartDataCount[Channel] = 1U;
for (uint8 Index = 0u; Index < TmpPduInfo.Dl; ++Index)
{
Lin_DrvUartFrameSdu[Channel][Index] = TmpPduInfo.SduPtr[Index];
}
Lin_DrvUartFrameChecksum[Channel] = Lin_Lld_Uart_LocGetChecksumByte(&Lin_LocCurrentPdu[Channel]);
Lin_LocUartHwStatus[Channel] = LIN_DRV_HW_DATA_FIELD;
}
else / slave to slave /
{
temp2[6]++; / ID_FIELD + OK + IGNORE → IDLE /
Base->INTF = Base->INTF;
Lin_Lld_Uart_LocEnableLbkDtc(Base);
Lin_LocUartHwStatus[Channel] = LIN_DRV_HW_IDLE_MODE;
}
}
else
#endif
{
temp2[7]++; / ID_FIELD + HeaderIndication NOT_OK → IDLE /
Base->INTF = Base->INTF;
Lin_Lld_Uart_LocEnableLbkDtc(Base);
Lin_LocUartHwStatus[Channel] = LIN_DRV_HW_IDLE_MODE;
}
}
else if (LIN_DRV_HW_DATA_FIELD == Lin_LocUartHwStatus[Channel])
{
if (LIN_FRAMERESPONSE_RX == Lin_LocCurrentPdu[Channel].Drc)
{
Lin_DrvUartFrameSdu[Channel][Lin_DrvUartDataCount[Channel]] = ResData;
++Lin_DrvUartDataCount[Channel];
if (Lin_DrvUartDataCount[Channel] >= Lin_LocCurrentPdu[Channel].Dl)
{
temp2[8]++; / DATA_FIELD + RX + last byte → CHECKSUM /
Lin_LocUartHwStatus[Channel] = LIN_DRV_HW_CHECKSUM_FIELD;
}
else
{
temp2[9]++; / DATA_FIELD + RX + continue /
}
}
else if (LIN_FRAMERESPONSE_TX == Lin_LocCurrentPdu[Channel].Drc)
{
if (ResData == Lin_DrvUartSentData[Channel])
{
/ last data send success, start next*/
if (Lin_DrvUartDataCount[Channel] < Lin_LocCurrentPdu[Channel].Dl)
{
temp2[10]++; /* DATA_FIELD + TX + echo OK + continue send /
/ response not finish /
Base->DATA = Lin_DrvUartFrameSdu[Channel][Lin_DrvUartDataCount[Channel]];
Lin_DrvUartSentData[Channel] = Lin_DrvUartFrameSdu[Channel][Lin_DrvUartDataCount[Channel]];
++Lin_DrvUartDataCount[Channel];
}
else / response finish /
{
temp2[11]++; / DATA_FIELD + TX + echo OK + last byte → CHECKSUM /
Lin_LocUartHwStatus[Channel] = LIN_DRV_HW_CHECKSUM_FIELD;
Base->DATA = Lin_DrvUartFrameChecksum[Channel];
Lin_DrvUartSentData[Channel] = Lin_DrvUartFrameChecksum[Channel];
}
}
else / last data send fail*/
{
temp2[12]++; /* DATA_FIELD + TX + echo MISMATCH → BIT_ERROR /
Lin_LocChFrameErrorStates[Channel] = LIN_DRV_BIT_ERROR;
Lin_LocUartHwStatus[Channel] = LIN_DRV_HW_IDLE_MODE;
#if (LIN_SLAVE_API_SUPPORT == STD_ON)
LinIf_LinErrorIndication(Channel, LIN_ERR_RESP_DATABIT);
#endif
Base->INTF = Base->INTF;
/ enable break detect /
Lin_Lld_Uart_LocEnableLbkDtc(Base);
}
}
else
{
temp2[13]++; / DATA_FIELD + else (can not be here) /
}
}
else if (LIN_DRV_HW_CHECKSUM_FIELD == Lin_LocUartHwStatus[Channel])
{
if (LIN_FRAMERESPONSE_RX == Lin_LocCurrentPdu[Channel].Drc)
{
if (ResData == Lin_Lld_Uart_LocGetChecksumByte(&Lin_LocCurrentPdu[Channel]))
{
temp2[14]++; / CHECKSUM + RX + checksum OK /
#if (LIN_SLAVE_API_SUPPORT == STD_ON)
LinIf_RxIndication(Channel, &Lin_DrvUartFrameSdu[Channel][0]);
#endif
}
else
{
temp2[15]++; / CHECKSUM + RX + checksum FAIL /
#if (LIN_SLAVE_API_SUPPORT == STD_ON)
LinIf_LinErrorIndication(Channel, LIN_ERR_RESP_CHKSUM);
#endif
}
}
else if (LIN_FRAMERESPONSE_TX == Lin_LocCurrentPdu[Channel].Drc)
{
if (ResData == Lin_DrvUartFrameChecksum[Channel])
{
temp2[16]++; / CHECKSUM + TX + checksum OK → TxConfirmation /
/ send checksum success /
Lin_LocUartHwStatus[Channel] = LIN_DRV_HW_IDLE_MODE;
LinIf_TxConfirmation(Channel);
}
else
{
temp2[17]++; / CHECKSUM + TX + checksum FAIL → BIT_ERROR /
/ send checksum fail /
Lin_LocChFrameErrorStates[Channel] = LIN_DRV_BIT_ERROR;
Lin_LocUartHwStatus[Channel] = LIN_DRV_HW_IDLE_MODE;
#if (LIN_SLAVE_API_SUPPORT == STD_ON)
LinIf_LinErrorIndication(Channel, LIN_ERR_RESP_DATABIT);
#endif
Base->INTF = Base->INTF;
Lin_Lld_Uart_LocEnableLbkDtc(Base);
}
}
else
{
temp2[18]++; / CHECKSUM + else (can not be here) /
}
/ stop slave res timeout tick /
Lin_Lld_Uart_LocStopToTicks(Channel);
/ enable break detect /
Lin_Lld_Uart_LocEnableLbkDtc(Base);
}
else if (LIN_DRV_HW_WAKEUP_FIELD == Lin_LocUartHwStatus[Channel])
{
/ check wakeup signal /
if (ResData == Lin_LocUartWakeupByte[Channel])
{
temp2[19]++; / WAKEUP + match → CH_READY /
/ Update LIN channel frame operation status /
Lin_LocChFrameStates[Channel] = LIN_DRV_CH_READY;
/ Reset frame error status /
Lin_LocChFrameErrorStates[Channel] = LIN_DRV_NO_ERROR;
Lin_ChStates[Channel] = LIN_DRV_CH_OPERATIONAL;
Lin_LocUartHwStatus[Channel] = LIN_DRV_HW_IDLE_MODE;
}
else
{
temp2[20]++; / WAKEUP + mismatch → BIT_ERROR /
/ wakeup signal send fail /
Lin_LocChFrameErrorStates[Channel] = LIN_DRV_BIT_ERROR;
Lin_LocUartHwStatus[Channel] = LIN_DRV_HW_IDLE_MODE;
#if (LIN_SLAVE_API_SUPPORT == STD_ON)
LinIf_LinErrorIndication(Channel, LIN_ERR_RESP_DATABIT);
#endif
Base->INTF = Base->INTF;
Lin_Lld_Uart_LocEnableLbkDtc(Base);
}
}
else
{
temp2[21]++; / no matching state */
}
}

lxhxss

都是demo的代码应该是没改动到什么东西不过 demo 是 64PIN 我是 48PIN就是

RuiXu

主程序是我们的demo?是Demo这样通信有问题？

RuiXu

确定LinIf_HeaderIndication已经进入了吗？

RuiXu

TX 引脚发出数据段的第一个字节是图中示波器上的数据是吧？

lxhxss

对的 TX 引脚发出数据段的第一个字节是图中示波器上的数据

关于硬件这块我这里使用SDK 的版本是可以进行LIN的正常收发的

RuiXu

抓一个完整波形看看，第一个数据是0xE9,示波器上面的似乎是PID段的波形。

RuiXu

还有demo里面没用LinIf_LinErrorIndication，加上这个函数，一定要保证没用报错。

lxhxss

RuiXu 您好我想问一个问题 MCAL 和 SDK 中 LIN 的协议栈是一样的吗？

RuiXu

实现逻辑是不一样的

lxhxss

RuiXu 只是实现逻辑不一样吗，从实现结果上来说是相同的吗

YunTu Forum

YTM32MC03 MCAL LIN Slave 发送回环测试异常

Online Users