TM4C129单片机CAN发送标准帧数据帧之后无法再接收标准帧远程帧

您好：

我在使用TM4C129芯片的CAN外设的过程中出现一个问题

“发送标准帧数据帧之后无法再接收标准帧远程帧“

使用流程：

1、初始化CAN

2、接收数据，可以接收所有类型的数据

3、发送一个标准帧数据帧的CAN帧

4、再次接收数据，发现标准帧远程帧收不到，其他类型的CAN帧可以正常接收

5、仿真发现问题：

       1、接收正常的数据是进入两次CAN接收中断，第一次表明有数据接收完成，第二次表明某一个消息对象接收完成可以读取数据

       2、接收标准帧远程帧的时候只进入一次接收中断，表明有数据接收完成，不进入第二次中断，其他类型的帧正常

6、猜想，在查找问题的过程中发现，发送数据的时候使用CANMessageSet（）函数，会写过滤寄存器，不知道是不是发数据的时候将标准帧远程帧过滤掉了

7、发数据与接收不到的数据对应关系：

          发送标准帧数据帧之后无法接受标准帧远程帧

        发送标准帧远程帧之后无法接受标准帧数据帧

        发送扩展帧数据帧之后无法接受扩展帧远程帧

        发送扩展帧远程帧之后无法接受扩展帧数据帧

8、 重启之后可以再次接收所有数据

9、产品已经入测试阶段，请尽快回复一下看看是什么地方的问题

附程序：

1、CAN初始化：

int InitCAN0(void)
{

    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

    GPIOPinConfigure(GPIO_PA0_CAN0RX);
    GPIOPinConfigure(GPIO_PA1_CAN0TX);

    GPIOPinTypeCAN(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);

    SysCtlPeripheralEnable(SYSCTL_PERIPH_CAN0);

    CANInit(CAN0_BASE);


    if(g_sParameters.CANpara[0].CANmode == 1)
    {
		HWREG(CAN0_BASE + CAN_O_CTL) = HWREG(CAN0_BASE + CAN_O_CTL) | CAN_CTL_TEST;
		HWREG(CAN0_BASE + CAN_O_TST) = HWREG(CAN0_BASE + CAN_O_TST) | CAN_TST_LBACK;
    }

    CANBitRateSet(CAN0_BASE, g_ui32SysClock, g_sParameters.CANpara[0].CANbandrates);

    CANIntEnable(CAN0_BASE, CAN_INT_MASTER | CAN_INT_ERROR | CAN_INT_STATUS);

    IntEnable(INT_CAN0);

    CANEnable(CAN0_BASE);
//    使用os不需要在此处配置中断函数
//    IntRegister(INT_CAN1,CAN1IntHandler);

    g_sCAN0RxMessage.ui32MsgID = 0;
    g_sCAN0RxMessage.ui32MsgIDMask = 0;
    g_sCAN0RxMessage.ui32Flags = MSG_OBJ_RX_INT_ENABLE | MSG_OBJ_USE_ID_FILTER;
    g_sCAN0RxMessage.ui32MsgLen = 8;

    CANMessageSet(CAN0_BASE, 10, &g_sCAN0RxMessage, MSG_OBJ_TYPE_RX);



    return 0;
}

2、发送函数

void Can0_Send(int objectID)
{
	tCANMsgObject	CAN0_t;
	CANMessageBuff	TxMsg;


	if(!Can_Ring_out(&Can0TxRingBuff,&TxMsg))
	{
		return;
	}


	CAN0_t.ui32MsgID = TxMsg.MSG_ID;
	CAN0_t.ui32MsgIDMask = 0;
	CAN0_t.ui32Flags = 0;
	CAN0_t.ui32Flags = MSG_OBJ_TX_INT_ENABLE;

	if((TxMsg.msg_len & 0x40) == 0x40)
		CAN0_t.ui32Flags |= MSG_OBJ_REMOTE_FRAME;

	if((TxMsg.msg_len & 0x80) == 0x80)
		CAN0_t.ui32Flags |= MSG_OBJ_EXTENDED_ID;

	CAN0_t.ui32MsgLen = TxMsg.msg_len & 0x0f;
	CAN0_t.pui8MsgData = (uint8_t *)&(TxMsg.data);

	if((TxMsg.msg_len & 0x40) == 0x40)
	{
		CANMessageSet(CAN0_BASE, objectID, &CAN0_t, MSG_OBJ_TYPE_TX_REMOTE);
		CAN0_send_LED_set();
	}
	else
	{
		CANMessageSet(CAN0_BASE, objectID, &CAN0_t, MSG_OBJ_TYPE_TX);
		CAN0_send_LED_set();
	}
}

3、中断处理函数

void CAN0IntHandler(void)
{
    uint32_t ui32Status;
    uint8_t port = 0;
    ui32Status = CANIntStatus(CAN0_BASE, CAN_INT_STS_CAUSE);

    if(ui32Status == CAN_INT_INTID_STATUS)
    {
        ui32Status = CANStatusGet(CAN0_BASE, CAN_STS_CONTROL);
        g_ui32ErrFlag[port] |= ui32Status;
    }
    else if(ui32Status == RXOBJECT)
    {
    	CANIntClear(CAN0_BASE, RXOBJECT);
    	Can0_Recv(RXOBJECT);
        g_ui32ErrFlag[port] = 0;
    }
    else if(ui32Status == 10)
    {
    	CANIntClear(CAN0_BASE, 10);
    	Can0_Recv(10);
        g_ui32ErrFlag[port] = 0;
    }
    else if(ui32Status == 11)
    {
    	CANIntClear(CAN0_BASE, 11);
    	Can0_Recv(11);
        g_ui32ErrFlag[port] = 0;
    }
    else if(ui32Status == 12)
    {
    	CANIntClear(CAN0_BASE, 12);
    	Can0_Recv(12);
        g_ui32ErrFlag[port] = 0;
    }
    else if(ui32Status == 2)
    {
        CANIntClear(CAN0_BASE, 2);
        g_cont_num.CAN0_tx_byte_cnt++;
        Can0_Send(2);
        g_ui32ErrFlag[port] = 0;
    }
    else if(ui32Status == 3)
	{
		CANIntClear(CAN0_BASE, 3);
		g_cont_num.CAN0_tx_byte_cnt++;
		Can0_Send(3);
		g_ui32ErrFlag[port] = 0;
	}
    else if(ui32Status == 4)
	{
		CANIntClear(CAN0_BASE, 4);
		g_cont_num.CAN0_tx_byte_cnt++;
		Can0_Send(4);
		g_ui32ErrFlag[port] = 0;
	}
    else if(ui32Status == 5)
	{
		CANIntClear(CAN0_BASE, 5);
		g_cont_num.CAN0_tx_byte_cnt++;
		Can0_Send(5);
		g_ui32ErrFlag[port] = 0;
	}
	else if(ui32Status == 6)
	{
		CANIntClear(CAN0_BASE, 6);
		g_cont_num.CAN0_tx_byte_cnt++;
		Can0_Send(6);
		g_ui32ErrFlag[port] = 0;
	}
	else if(ui32Status == 7)
	{
		CANIntClear(CAN0_BASE, 7);
		g_cont_num.CAN0_tx_byte_cnt++;
		Can0_Send(7);
		g_ui32ErrFlag[port] = 0;
	}
    else
    {
    	CANIntClear(CAN0_BASE, ui32Status);
    }

    return;
}