TMS320F28062 CAN模块查询发送，中断接收

void CO_SetupCAN(void)  //初始化
{
 struct ECAN_REGS ECanaShadow;
 ECanaShadow.CANME.all = ECanaRegs.CANME.all;
 ECanaShadow.CANME.all = 0;  //不使能邮箱
 ECanaRegs.CANME.all = ECanaShadow.CANME.all;
 /* Setup CAN bus */
 EALLOW;  // EALLOW enables access to protected bits
 /* Configure eCAN RX and TX pins for eCAN transmissions using eCAN regs*/
 ECanaShadow.CANTIOC.all = ECanaRegs.CANTIOC.all;
    ECanaShadow.CANTIOC.bit.TXFUNC = 1;
 ECanaRegs.CANTIOC.all = ECanaShadow.CANTIOC.all;

 ECanaShadow.CANRIOC.all = ECanaRegs.CANRIOC.all;
 ECanaShadow.CANRIOC.bit.RXFUNC = 1;
 ECanaRegs.CANRIOC.all = ECanaShadow.CANRIOC.all;
    /* Configure eCAN for HECC mode - (reqd to access mailboxes 16 thru 31) */
 // HECC mode also enables time-stamping feature
 ECanaShadow.CANMC.all = ECanaRegs.CANMC.all;
 ECanaShadow.CANMC.bit.SCB = 1;  //
 ECanaRegs.CANMC.all = ECanaShadow.CANMC.all;
 /* Initialize all bits of 'Master Control Field' to zero */
 ECanaMboxes.MBOX0.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX1.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX2.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX3.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX4.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX5.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX6.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX7.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX8.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX9.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX10.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX11.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX12.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX13.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX14.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX15.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX16.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX17.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX18.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX19.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX20.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX21.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX22.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX23.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX24.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX25.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX26.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX27.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX28.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX29.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX30.MSGCTRL.all = 0x00000000;
    ECanaMboxes.MBOX31.MSGCTRL.all = 0x00000000;
    // TAn, RMPn, GIFn bits are all zero upon reset and are cleared again
    // as a matter of precaution.
 ECanaRegs.CANTA.all = 0xFFFFFFFF; /* Clear all TAn bits 清除所有邮箱的发送成功标志*/
 ECanaRegs.CANRMP.all = 0xFFFFFFFF; /* Clear all RMPn bits 清除所有邮箱的接收成功标志*/
 ECanaRegs.CANGIF0.all = 0xFFFFFFFF; /* Clear all interrupt flag bits 清除所有中断标志*/
 ECanaRegs.CANGIF1.all = 0xFFFFFFFF; /* Clear all interrupt flag bits 清除所有中断标志*/
 /* Configure bit timing parameters for ECana*/
 ECanaShadow.CANMC.all = ECanaRegs.CANMC.all;
 ECanaShadow.CANMC.bit.CCR = 1 ;  // Set CCR = 1 waiting CCE bit to be set
    ECanaRegs.CANMC.all = ECanaShadow.CANMC.all;

    while(ECanaRegs.CANES.bit.CCE != 1 ) {}   // Wait for CCE bit to be set..

    ECanaShadow.CANBTC.all = 0;

    ECanaShadow.CANBTC.bit.BRPREG = CO_BitRateData[Rompara_A08->CANBaud].BRP;
    ECanaShadow.CANBTC.bit.TSEG1REG = CO_BitRateData[Rompara_A08->CANBaud].TSeg1;
    ECanaShadow.CANBTC.bit.TSEG2REG = CO_BitRateData[Rompara_A08->CANBaud].TSeg2;
    if(((Rompara_A08->CANBaud)&0x000F) >= 2)
    {
     ECanaShadow.CANBTC.bit.SAM = 0;///////
  ECanaShadow.CANBTC.bit.SJWREG = 3;
 }
 else
 {
  ECanaShadow.CANBTC.bit.SAM = 1;///////
  ECanaShadow.CANBTC.bit.SJWREG = 3;
 }
    ECanaRegs.CANBTC.all = ECanaShadow.CANBTC.all;

 ECanaShadow.CANGAM.all = ECanaRegs.CANGAM.all;
 ECanaShadow.CANGAM.bit.AMI = 1;  //标准帧和扩展帧，扩展帧29bit全部存放在MSGID作为标识
 ECanaRegs.CANGAM.all = ECanaShadow.CANGAM.all;

    ECanaShadow.CANMC.all = ECanaRegs.CANMC.all;
 ECanaShadow.CANMC.bit.CCR = 0 ;            // Set CCR = 0
 ECanaShadow.CANMC.bit.ABO = 1 ;            // bus open
 ECanaShadow.CANMC.bit.DBO = 1 ;            // CAN先发送低字节，在发送高字节
    ECanaRegs.CANMC.all = ECanaShadow.CANMC.all;

    while(ECanaRegs.CANES.bit.CCE == !0 ) {}   // Wait for CCE bit to be cleared..
    /* Disable all Mailboxes  */
//  ECanaRegs.CANME.all = 0;  // Required before writing the MSGIDs
    EDIS;
 //init rx mail  接收邮箱配置16~31为接收邮箱
 EALLOW;
/***********************************************************************/
/* NMT: mailbox  16; */
/* SYNC: mailbox  17; */
/* RPDO0: mailbox  18; */
/* RPDO1: mailbox  19; */
/* RPDO2: mailbox  20; */
/* RPDO3: mailbox  21; */
/* SDO: mailbox  22; */
/* LIFE: mailbox  23; */
/***********************************************************************/
 ECanaShadow.CANMD.all = ECanaRegs.CANMD.all;
 ECanaShadow.CANMD.all |= 0xFFFF0000; // MBOX16~31 is recieve_box
    ECanaRegs.CANMD.all = ECanaShadow.CANMD.all;
 ECanaShadow.CANME.all = ECanaRegs.CANME.all;
    ECanaShadow.CANME.all = 0x00000000; // MBOX16~31 is disabled
    ECanaRegs.CANME.all = ECanaShadow.CANME.all;
 //接收字节数据判断
 if(Rompara_A08->CANRx1ADDR4!=0)
 {
  CO_RXCAN[16].NoOfBytes=8;
 }
 else if(Rompara_A08->CANRx1ADDR3!=0)
 {
  CO_RXCAN[16].NoOfBytes=6;
 }
 else if(Rompara_A08->CANRx1ADDR2!=0)
 {
  CO_RXCAN[16].NoOfBytes=4;
 }
 else if(Rompara_A08->CANRx1ADDR1!=0)
 {
  CO_RXCAN[16].NoOfBytes=2;
 }
 else
 {
  CO_RXCAN[16].NoOfBytes=0;
 }

 if(Rompara_A08->CANRx2ADDR4!=0)
 {
  CO_RXCAN[17].NoOfBytes=8;
 }
 else if(Rompara_A08->CANRx2ADDR3!=0)
 {
  CO_RXCAN[17].NoOfBytes=6;
 }
 else if(Rompara_A08->CANRx2ADDR2!=0)
 {
  CO_RXCAN[17].NoOfBytes=4;
 }
 else if(Rompara_A08->CANRx2ADDR1!=0)
 {
  CO_RXCAN[17].NoOfBytes=2;
 }
 else
 {
  CO_RXCAN[17].NoOfBytes=0;
 }
 //接收字节数据判断
 if(Rompara_A08->CANRx3ADDR4!=0)
 {
  CO_RXCAN[18].NoOfBytes=8;
 }
 else if(Rompara_A08->CANRx3ADDR3!=0)
 {
  CO_RXCAN[18].NoOfBytes=6;
 }
 else if(Rompara_A08->CANRx3ADDR2!=0)
 {
  CO_RXCAN[18].NoOfBytes=4;
 }
 else if(Rompara_A08->CANRx3ADDR1!=0)
 {
  CO_RXCAN[18].NoOfBytes=2;
 }
 else
 {
  CO_RXCAN[18].NoOfBytes=0;
 }
 //接收字节数据判断
 if(Rompara_A08->CANRx4ADDR4!=0)
 {
  CO_RXCAN[19].NoOfBytes=8;
 }
 else if(Rompara_A08->CANRx4ADDR3!=0)
 {
  CO_RXCAN[19].NoOfBytes=6;
 }
 else if(Rompara_A08->CANRx4ADDR2!=0)
 {
  CO_RXCAN[19].NoOfBytes=4;
 }
 else if(Rompara_A08->CANRx4ADDR1!=0)
 {
  CO_RXCAN[19].NoOfBytes=2;
 }
 else
 {
  CO_RXCAN[19].NoOfBytes=0;
 }
 //发送配置
 if(Rompara_A08->CANTx1ADDR4!=0)
 {
  CO_TXCAN[0].NoOfBytes=8;
 }
 else if(Rompara_A08->CANTx1ADDR3!=0)
 {
  CO_TXCAN[0].NoOfBytes=6;
 }
 else if(Rompara_A08->CANTx1ADDR2!=0)
 {
  CO_TXCAN[0].NoOfBytes=4;
 }
 else if(Rompara_A08->CANTx1ADDR1!=0)
 {
  CO_TXCAN[0].NoOfBytes=2;
 }
 else
 {
  CO_TXCAN[0].NoOfBytes=0;
 }

 if(Rompara_A08->CANTx2ADDR4!=0)
 {
  CO_TXCAN[1].NoOfBytes=8;
 }
 else if(Rompara_A08->CANTx2ADDR3!=0)
 {
  CO_TXCAN[1].NoOfBytes=6;
 }
 else if(Rompara_A08->CANTx2ADDR2!=0)
 {
  CO_TXCAN[1].NoOfBytes=4;
 }
 else if(Rompara_A08->CANTx2ADDR1!=0)
 {
  CO_TXCAN[1].NoOfBytes=2;
 }
 else
 {
  CO_TXCAN[1].NoOfBytes=0;
 }

 if(Rompara_A08->CANTx3ADDR4!=0)
 {
  CO_TXCAN[2].NoOfBytes=8;
 }
 else if(Rompara_A08->CANTx3ADDR3!=0)
 {
  CO_TXCAN[2].NoOfBytes=6;
 }
 else if(Rompara_A08->CANTx3ADDR2!=0)
 {
  CO_TXCAN[2].NoOfBytes=4;
 }
 else if(Rompara_A08->CANTx3ADDR1!=0)
 {
  CO_TXCAN[2].NoOfBytes=2;
 }
 else
 {
  CO_TXCAN[2].NoOfBytes=0;
 }

 if(Rompara_A08->CANTx4ADDR4!=0)
 {
  CO_TXCAN[3].NoOfBytes=8;
 }
 else if(Rompara_A08->CANTx4ADDR3!=0)
 {
  CO_TXCAN[3].NoOfBytes=6;
 }
 else if(Rompara_A08->CANTx4ADDR2!=0)
 {
  CO_TXCAN[3].NoOfBytes=4;
 }
 else if(Rompara_A08->CANTx4ADDR1!=0)
 {
  CO_TXCAN[3].NoOfBytes=2;
 }
 else
 {
  CO_TXCAN[3].NoOfBytes=0;
 }
 ECanaRegs.CANME.all = 0;  // Required before writing the MSGIDs
    if(Rompara_A08->CANRx1IdL!=0 ||Rompara_A08->CANRx1IdH!=0)
    {
     ECanaMboxes.MBOX16.MSGID.bit.IDE = 1;  //  0标准帧  1：扩展帧
     ECanaMboxes.MBOX16.MSGID.bit.AME = 1;
     ECanaMboxes.MBOX16.MSGID.bit.AAM = 0;
     ECanaMboxes.MBOX16.MSGID.bit.EXTMSGID_L =Rompara_A08->CANRx1IdL; //bit0~bit15; A08.06~A08.07
     ECanaMboxes.MBOX16.MSGID.bit.EXTMSGID_H =(Rompara_A08->CANRx1IdH & 0x0003);  //bit16~bit17;
     ECanaMboxes.MBOX16.MSGID.bit.STDMSGID =((Rompara_A08->CANRx1IdH>>2) & 0x3F);//bit18 ~bit28;
    }
    if(Rompara_A08->CANRx2IdL!=0 ||Rompara_A08->CANRx2IdH!=0)
    {
     ECanaMboxes.MBOX17.MSGID.bit.IDE = 1;  //  0标准帧  1：扩展帧
     ECanaMboxes.MBOX17.MSGID.bit.AME = 1;
     ECanaMboxes.MBOX17.MSGID.bit.AAM = 0;
        ECanaMboxes.MBOX17.MSGID.bit.EXTMSGID_L =Rompara_A08->CANRx2IdL; //bit0~bit15; A08.12~A08.13
        ECanaMboxes.MBOX17.MSGID.bit.EXTMSGID_H =(Rompara_A08->CANRx2IdH & 0x0003);  //bit16~bit17;
        ECanaMboxes.MBOX17.MSGID.bit.STDMSGID =((Rompara_A08->CANRx2IdH>>2) & 0x3F);//bit18 ~bit28;
    }
    if(Rompara_A08->CANRx3IdL!=0 ||Rompara_A08->CANRx3IdH!=0)
    {
     ECanaMboxes.MBOX18.MSGID.bit.IDE = 1;  //  0标准帧  1：扩展帧
     ECanaMboxes.MBOX18.MSGID.bit.AME = 1;
     ECanaMboxes.MBOX18.MSGID.bit.AAM = 0;
        ECanaMboxes.MBOX18.MSGID.bit.EXTMSGID_L =Rompara_A08->CANRx3IdL; //bit0~bit15; A08.18~A08.19
        ECanaMboxes.MBOX18.MSGID.bit.EXTMSGID_H =(Rompara_A08->CANRx3IdH & 0x0003);  //bit16~bit17;
        ECanaMboxes.MBOX18.MSGID.bit.STDMSGID =((Rompara_A08->CANRx3IdH>>2) & 0x3F);//bit18 ~bit28;
    }
 if(Rompara_A08->CANRx4IdL!=0 ||Rompara_A08->CANRx4IdH!=0)
 {
     ECanaMboxes.MBOX19.MSGID.bit.IDE = 1;  //  0标准帧  1：扩展帧
     ECanaMboxes.MBOX19.MSGID.bit.AME = 1;
     ECanaMboxes.MBOX19.MSGID.bit.AAM = 0;
     ECanaMboxes.MBOX19.MSGID.bit.EXTMSGID_L =Rompara_A08->CANRx4IdL; //bit0~bit15; A08.24~A08.25
     ECanaMboxes.MBOX19.MSGID.bit.EXTMSGID_H =(Rompara_A08->CANRx4IdH & 0x0003);  //bit16~bit17;
     ECanaMboxes.MBOX19.MSGID.bit.STDMSGID =((Rompara_A08->CANRx4IdH>>2) & 0x3F);//bit18 ~bit28;
 }


 //发送邮箱配置
    if(Rompara_A08->CANTx1IdL!=0 ||Rompara_A08->CANTx1IdH!=0)
    {
       ECanaMboxes.MBOX0.MSGCTRL.bit.DLC =CO_TXCAN[0].NoOfBytes;
       ECanaMboxes.MBOX0.MSGID.bit.EXTMSGID_L=Rompara_A08->CANTx1IdL; //bit0~bit15 A08.30~A08.31
       ECanaMboxes.MBOX0.MSGID.bit.EXTMSGID_H =(Rompara_A08->CANTx1IdH & 0x0003);  //bit16~bit17
       ECanaMboxes.MBOX0.MSGID.bit.STDMSGID =((Rompara_A08->CANTx1IdH>>2) & 0x3F);//bit18 ~bit28
    }
    if(Rompara_A08->CANTx2IdL!=0 ||Rompara_A08->CANTx2IdH!=0)
    {
     ECanaMboxes.MBOX1.MSGCTRL.bit.DLC =CO_TXCAN[1].NoOfBytes;
        ECanaMboxes.MBOX1.MSGID.bit.EXTMSGID_L=Rompara_A08->CANTx2IdL; //bit0~bit15 A08.36~A08.37
        ECanaMboxes.MBOX1.MSGID.bit.EXTMSGID_H =(Rompara_A08->CANTx2IdH & 0x0003);  //bit16~bit17
        ECanaMboxes.MBOX1.MSGID.bit.STDMSGID =((Rompara_A08->CANTx2IdH>>2) & 0x3F);//bit18 ~bit28
    }
 if(Rompara_A08->CANTx3IdL!=0 ||Rompara_A08->CANTx3IdH!=0)
 {
  ECanaMboxes.MBOX2.MSGCTRL.bit.DLC =CO_TXCAN[2].NoOfBytes;
     ECanaMboxes.MBOX2.MSGID.bit.EXTMSGID_L=Rompara_A08->CANTx3IdL; //bit0~bit15 A08.42~A08.43
     ECanaMboxes.MBOX2.MSGID.bit.EXTMSGID_H =(Rompara_A08->CANTx3IdH & 0x0003);  //bit16~bit17
     ECanaMboxes.MBOX2.MSGID.bit.STDMSGID =((Rompara_A08->CANTx3IdH>>2) & 0x3F);//bit18 ~bit28
 }
 if(Rompara_A08->CANTx4IdL!=0 ||Rompara_A08->CANTx4IdH!=0)
 {
  ECanaMboxes.MBOX3.MSGCTRL.bit.DLC =CO_TXCAN[3].NoOfBytes;
     ECanaMboxes.MBOX3.MSGID.bit.EXTMSGID_L=Rompara_A08->CANTx4IdL; //bit0~bit15 A08.48~A08.49
     ECanaMboxes.MBOX3.MSGID.bit.EXTMSGID_H =(Rompara_A08->CANTx4IdH & 0x0003);  //bit16~bit17
     ECanaMboxes.MBOX3.MSGID.bit.STDMSGID =((Rompara_A08->CANTx4IdH>>2) & 0x3F);//bit18 ~bit28
 }
 ECanaShadow.CANME.all = ECanaRegs.CANME.all;
    ECanaShadow.CANME.all = 0xFFFFFFFF; //
    ECanaRegs.CANME.all = ECanaShadow.CANME.all;

 // Configure CAN interrupts  在中断线1上产生邮箱邢
 ECanaShadow.CANMIL.all = 0xFFFFFFFF ; // Interrupts asserted on eCAN1INT
 ECanaRegs.CANMIL.all = ECanaShadow.CANMIL.all;
 ECanaRegs.CANOPC.all=0;//0xFFFFFFFF; 2008-9-23
 //邮箱中断屏蔽位
 ECanaShadow.CANMIM.all  = 0;//发送中断不打开

 ECanaShadow.CANMIM.bit.MIM19 = 1;  // RPDO1
 ECanaShadow.CANMIM.bit.MIM18 = 1;  // RPDO0
 ECanaShadow.CANMIM.bit.MIM17 = 1;  // RX
 ECanaShadow.CANMIM.bit.MIM16 = 1;  // RX
    ECanaRegs.CANMIM.all = ECanaShadow.CANMIM.all;

    //全局中断屏蔽寄存器
    ECanaShadow.CANGIM.all=0;
    ECanaShadow.CANGIM.bit.I0EN = 0;    // Enable eCAN1INT
    ECanaShadow.CANGIM.bit.I1EN = 1; // Disable eCAN0INT
 ECanaShadow.CANGIM.bit.GIL = 1;  //所有全局中断都映射到INT1中断线上
    ECanaRegs.CANGIM.all = ECanaShadow.CANGIM.all;
 EDIS;
 //set filters
}

Uint16 CAN_BufTx(Uint16 MBXnbr, Uint8 *pData, Uint8 Size)  //启动发送
{
    volatile struct MBOX *Mailbox;
    Mailbox = &ECanaMboxes.MBOX0 + MBXnbr;
    if(Size<=8 && MBXnbr<=9)
    {
     if(Size==1)
     {
      Mailbox->MDL.byte.BYTE0 = pData[0];
     }
     else if(Size==2)
     {
         Mailbox->MDL.byte.BYTE1 = pData[1];
         Mailbox->MDL.byte.BYTE2 = pData[2];
     }
     else if(Size==3)
     {
         Mailbox->MDL.byte.BYTE1 = pData[1];
         Mailbox->MDL.byte.BYTE2 = pData[2];
         Mailbox->MDL.byte.BYTE3 = pData[3];
     }
     else if(Size==4)
     {
         Mailbox->MDL.byte.BYTE1 = pData[1];
         Mailbox->MDL.byte.BYTE2 = pData[2];
         Mailbox->MDL.byte.BYTE3 = pData[3];
         Mailbox->MDH.byte.BYTE4 = pData[4];
     }
     else if(Size==5)
     {
         Mailbox->MDL.byte.BYTE1 = pData[1];
         Mailbox->MDL.byte.BYTE2 = pData[2];
         Mailbox->MDL.byte.BYTE3 = pData[3];
         Mailbox->MDH.byte.BYTE4 = pData[4];
         Mailbox->MDH.byte.BYTE5 = pData[5];
     }
     else if(Size==6)
     {
         Mailbox->MDL.byte.BYTE1 = pData[1];
         Mailbox->MDL.byte.BYTE2 = pData[2];
         Mailbox->MDL.byte.BYTE3 = pData[3];
         Mailbox->MDH.byte.BYTE4 = pData[4];
         Mailbox->MDH.byte.BYTE5 = pData[5];
         Mailbox->MDH.byte.BYTE6 = pData[6];
     }
     else if(Size==7)
     {
         Mailbox->MDL.byte.BYTE1 = pData[1];
         Mailbox->MDL.byte.BYTE2 = pData[2];
         Mailbox->MDL.byte.BYTE3 = pData[3];
         Mailbox->MDH.byte.BYTE4 = pData[4];
         Mailbox->MDH.byte.BYTE5 = pData[5];
         Mailbox->MDH.byte.BYTE6 = pData[6];
         Mailbox->MDH.byte.BYTE7 = pData[7];
     }
     EALLOW;
     ECanaRegs.CANTRS.all = ((Uint32)0x00000001)<<MBXnbr; //启动发送
     while((ECanaRegs.CANTA.all>>MBXnbr)&0x01==0x00)
     {
      ;
     }
     ECanaRegs.CANTA.all=(Uint32)(0x01<<MBXnbr);
     EDIS;
     return 1;
    }
    else
    {
     return 0;
    }
}

代码如上，问题是我发送一帧数据后，芯片TX引脚发送，可以检测到Tx引脚间隔400us重复发送该数据，TRS0一直为1

//==========================================================================
//
// 文件名称:    F2812_CANTX.c
//
// 功能描述:    DSP28 CAN 传输测试
//              CPU Timer0 ISR周期 50 ms
//              看门狗使能，在主循环中处理
//              CAN 消息 : 发送一个字节的数据
//              CAN通信速率： 100KBPS
//              扩展标识符 :  0x1000 0000
//              使用的邮箱 ：Mailbox #5 #1
//
//==========================================================================

#include "DSP281x_Device.h"
#include "DSP281x_Examples.h"   // DSP281x Examples Include File
// 函数原型声明

void Gpio_select(void);

void InitCan();
int RXcounter = 0;
int TXcounter = 0;
char CAN0RXDATA[8];
struct  ECAN_REGS ECanaShadow;
interrupt void CAN0INTA_ISR(void);
void Mboxesinit(void);
void TX_send(void);
interrupt void cpu_timer0_isr(void);
void main(void)
{


    InitSysCtrl();

   // Step 2. Initalize GPIO:
   // This example function is found in the DSP281x_Gpio.c file and
   // illustrates how to set the GPIO to it's default state.
   // InitGpio();  // Skipped for this example

   // Step 3. Clear all interrupts and initialize PIE vector table:
   // Disable CPU interrupts
      DINT;

   // Initialize PIE control registers to their default state.
   // The default state is all PIE interrupts disabled and flags
   // are cleared.
   // This function is found in the DSP281x_PieCtrl.c file.
   //   InitPieCtrl(); // Skipped for this example

   // Disable CPU interrupts and clear all CPU interrupt flags:
      IER = 0x0000;
      IFR = 0x0000;

    Gpio_select();      // 配置GPIO复用功能寄存器

    InitPieCtrl();      // 调用外设中断扩展初始化单元 PIE-unit ( 代码 : DSP281x_PieCtrl.c)

    InitPieVectTable(); // 初始化 PIE vector向量表  ( 代码 : DSP281x_PieVect.c )
    EALLOW;  // This is needed to write to EALLOW protected registers
    PieVectTable.TINT0 = &cpu_timer0_isr;
    EDIS;    // This is needed to disable write to EALLOW protected registers

    // Step 4. Initialize all the Device Peripherals:
    // This function is found in DSP281x_InitPeripherals.c
    // InitPeripherals(); // Not required for this example
    InitCpuTimers();   // For this example, only initialize the Cpu Timers

    // Configure CPU-Timer 0 to interrupt every second:
    // 100MHz CPU Freq, 1 second Period (in uSeconds)
    ConfigCpuTimer(&CpuTimer0, 100, 1000000);
    StartCpuTimer0();
    IER |= M_INT1;

    // Enable TINT0 in the PIE: Group 1 interrupt 7
    PieCtrlRegs.PIEIER1.bit.INTx7 = 1;

    PieCtrlRegs.PIEIER9.bit.INTx5=1;
    IER|=M_INT9;
    EINT;
    ERTM;




    InitCan();  // 初始化CAN模块
    Mboxesinit();

    while(1)
    {
        ;
    }
}
void TX_send(void)
{


      ECanaMboxes.MBOX5.MDL.all = 0x55555555;
      ECanaMboxes.MBOX5.MDH.all = 0x55555555;
      ECanaShadow.CANTRS.all = 0;
      ECanaShadow.CANTRS.bit.TRS5 = 1;     // 设置 TRS for mailbox under test
      ECanaRegs.CANTRS.all = ECanaShadow.CANTRS.all;

      while(ECanaRegs.CANTA.bit.TA5 == 0 ) {}  // 等待 TA5 bit 置位..
      TXcounter++;
      ECanaShadow.CANTA.all = 0;
      ECanaShadow.CANTA.bit.TA5 = 1;       // 清除 TA5
      ECanaRegs.CANTA.all = ECanaShadow.CANTA.all;

}
void Mboxesinit(void)
{

    /* 写消息标识符 MSGID  */

       ECanaMboxes.MBOX5.MSGID.all     = 0x10000000;
       ECanaMboxes.MBOX5.MSGID.bit.IDE = 1;  // 扩展标识符

       /* 配置 Mailbox 5 作为发送邮箱 */

       ECanaShadow.CANMD.all = ECanaRegs.CANMD.all;
       ECanaShadow.CANMD.bit.MD5 = 0;
       ECanaRegs.CANMD.all = ECanaShadow.CANMD.all;


       /* 使能邮箱 */

       ECanaShadow.CANME.all = ECanaRegs.CANME.all;
       ECanaShadow.CANME.bit.ME5 = 1;
       ECanaRegs.CANME.all = ECanaShadow.CANME.all;
       ECanaMboxes.MBOX5.MSGCTRL.bit.DLC = 1;
   /********************** 4/11/2018 **********************/
       /* 写消息标识符 MSGID 区  */
       ECanaMboxes.MBOX1.MSGID.all  = 0x10000000;  // 扩展标识符
       ECanaMboxes.MBOX1.MSGID.bit.IDE = 1;

       /* 配置邮箱1作为接收器邮箱 */
       ECanaShadow.CANMD.all = ECanaRegs.CANMD.all;
       ECanaShadow.CANMD.bit.MD1 = 1;
       ECanaRegs.CANMD.all = ECanaShadow.CANMD.all;

       /* 使能邮箱mailbox 1  */

       ECanaShadow.CANME.all = ECanaRegs.CANME.all;
       ECanaShadow.CANME.bit.ME1 = 1;
       ECanaRegs.CANME.all = ECanaShadow.CANME.all;

       ECanaMboxes.MBOX1.MSGCTRL.bit.DLC = 8;
       ECanaMboxes.MBOX1.MSGCTRL.bit.RTR = 0;
       /* 在消息控制寄存器中写 DLC 区 */

       ECanaMboxes.MBOX5.MSGCTRL.bit.DLC = 8;
       /***************使能中断******************/
       EALLOW;
       ECanaRegs.CANMIM.bit.MIM1=1;
       ECanaRegs.CANMIL.bit.MIL1=0;
       ECanaRegs.CANGIF0.all=0xFFFFFFFF;
       ECanaRegs.CANGIM.bit.I0EN=1;
       PieVectTable.ECAN0INTA= &CAN0INTA_ISR;
       EDIS;


}
void Gpio_select(void)
{
    EALLOW;
    GpioMuxRegs.GPAMUX.all = 0x0;   // 所有GPIO引脚配置为I/O
    GpioMuxRegs.GPBMUX.all = 0x0;
    GpioMuxRegs.GPDMUX.all = 0x0;
    GpioMuxRegs.GPFMUX.all = 0x0;
    GpioMuxRegs.GPFMUX.bit.CANTXA_GPIOF6 = 1;  //CAN引脚配置
    GpioMuxRegs.GPFMUX.bit.CANRXA_GPIOF7 = 1;
    GpioMuxRegs.GPEMUX.all = 0x0;
    GpioMuxRegs.GPGMUX.all = 0x0;

    GpioMuxRegs.GPADIR.all = 0x0;     // GPIO PORT 配置为输入
    GpioMuxRegs.GPBDIR.all = 0x0;  // GPIO Port B15-B8  配置为输入 , B7-B0  配置为输出
    GpioMuxRegs.GPDDIR.all = 0x0;     // GPIO PORT   配置为输入
    GpioMuxRegs.GPEDIR.all = 0x0;     // GPIO PORT   配置为输入
    GpioMuxRegs.GPFDIR.all = 0x0;     // GPIO PORT   配置为输入
    GpioMuxRegs.GPGDIR.all = 0x0;     // GPIO PORT   配置为输入

    GpioMuxRegs.GPAQUAL.all = 0x0;    // 设置所有 GPIO 输入的量化值等于0
    GpioMuxRegs.GPBQUAL.all = 0x0;
    GpioMuxRegs.GPDQUAL.all = 0x0;
    GpioMuxRegs.GPEQUAL.all = 0x0;
    EDIS;
}


void InitCan(void)
{
    EALLOW;
/* 通过eCAN寄存器配置RX和TX引脚作为发送接收*/

    ECanaRegs.CANTIOC.bit.TXFUNC = 1;
    ECanaRegs.CANRIOC.bit.RXFUNC = 1;

/* 配置 eCAN 工作在 HECC模式 - (请求访问邮箱16 到 31) */
// HECC模式还是能时间标签功能
   ECanaRegs.CANMC.bit.SCB = 1;
   // ECanaRegs.CANMC.bit.STM= 1;
/* 配置位的时间参数 */

    ECanaRegs.CANMC.bit.CCR = 1 ;            // 设置 CCR = 1

    while(ECanaRegs.CANES.bit.CCE != 1 ) {}   //等待 CCE bit置位..

    ECanaRegs.CANBTC.bit.BRPREG = 19;
    ECanaRegs.CANBTC.bit.TSEG2REG = 2;
    ECanaRegs.CANBTC.bit.TSEG1REG = 10;

    ECanaRegs.CANMC.bit.CCR = 0 ;             // 设置 CCR = 0
    while(ECanaRegs.CANES.bit.CCE == !0 ) {}   // 等待 CCE bit清0..

/* Disable all Mailboxes  */

    ECanaRegs.CANME.all = 0;        // 写 MSGIDs之前发出请求
    EDIS;
}
interrupt void CAN0INTA_ISR(void)
{
    RXcounter++;
    while(ECanaShadow.CANRMP.bit.RMP1 != 1 );       // 等待 RMP1置位..

    //     GpioDataRegs.GPBDAT.all = ECanaMboxes.MBOX1.MDL.byte.BYTE0;





    ECanaShadow.CANRMP.bit.RMP1 = 1;

    ECanaRegs.CANRMP.all = ECanaShadow.CANRMP.all;
    CAN0RXDATA[0]= ECanaMboxes.MBOX1.MDL.byte.BYTE0;
    CAN0RXDATA[1]= ECanaMboxes.MBOX1.MDL.byte.BYTE1;
    CAN0RXDATA[2]= ECanaMboxes.MBOX1.MDL.byte.BYTE2;
    CAN0RXDATA[3]= ECanaMboxes.MBOX1.MDL.byte.BYTE3;
    CAN0RXDATA[4]= ECanaMboxes.MBOX1.MDH.byte.BYTE4;
    CAN0RXDATA[5]= ECanaMboxes.MBOX1.MDH.byte.BYTE5;
    CAN0RXDATA[6]= ECanaMboxes.MBOX1.MDH.byte.BYTE6;
    CAN0RXDATA[7]= ECanaMboxes.MBOX1.MDH.byte.BYTE7;
    PieCtrlRegs.PIEACK.bit.ACK9=1;
    EINT;



}

interrupt void cpu_timer0_isr(void)
{
   CpuTimer0.InterruptCount++;
   TX_send();

   // Acknowledge this interrupt to receive more interrupts from group 1
   PieCtrlRegs.PIEACK.all = PIEACK_GROUP1;
}


这个是我之前自己写的一个，您可以参考一下，如果发现错误也欢迎指出。以后您贴程序尽量贴成这种格式看起来方便一些。

邮箱数据发送成功后相应的TA会置位，您用can盒抓下数据看看。也可以用TI的ecan_back2back例程测试下，是不是硬件的问题。

发送

发数据不行，示波器可以看到CANTXA一直处于发送状态。TA不能置位

发现一个现象  CANTIOC和CANRIOC值9和8跳变，初始化配置为8了，这是什么原因？？