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

user1944858

Prodigy 110 points

问题：配置CAN后，发送过一帧CAN数据后，检测CANTX引脚持续不断发送该数据间隔时间240us左右

仿真器查看：ECanaRegs.CANES.bit.Tm=1

ECanaRegs.CANTEC.all =128

,请问可能什么配置原因造成的？

7 年多前

0 Seven Han 7 年多前

TI__Mastermind 43911 points

从描述看不出有啥问题，建议您贴上代码。

0 user1944858 7 年多前回复 Seven Han

Prodigy 110 points

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;
    }
}

0 user1944858 7 年多前回复 user1944858

Prodigy 110 points

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

0 Alvin Chen 7 年多前回复 user1944858

TI__Guru 56646 points

//==========================================================================
//
// 文件名称:    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;
}


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

0 Seven Han 7 年多前回复 user1944858

TI__Mastermind 43911 points

发送后CANTA位有置位么，应该是数据没有发送成功，您板子上的can有用transfer吗？

0 user1944858 7 年多前回复 Seven Han

Prodigy 110 points

发送后CANTA位没有置位，通过示波器看TX引脚波形已经发送出去了。就是间隔400us左右重复发送、板子上用的NCV7351收发器。
ECanaRegs.CANES.bit.Tm=1;ECanaRegs.CANTEC .all=128了

0 Seven Han 7 年多前回复 user1944858

TI__Mastermind 43911 points

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

发送

0 user1944858 7 年多前回复 Seven Han

Prodigy 110 points

可以参考此链接 e2echina.ti.com/.../438798
我用ti ecan_back2back测试了一下，寄存器正常，自测模式。

0 Seven Han 7 年多前回复 user1944858

TI__Mastermind 43911 points

不在自测模式下可以正常收发数据不，建议用can盒来测。

0 user1944858 7 年多前回复 Seven Han

Prodigy 110 points

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

0 user1944858 7 年多前回复 Seven Han

Prodigy 110 points

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

0 Seven Han 7 年多前回复 user1944858

TI__Mastermind 43911 points

使用ti ecan_back2back测试的话，需要检查下波特率设置，gpio的配置。

0 user1944858 7 年多前回复 Seven Han

Prodigy 110 points

这是ti 工程师回复内容：
When a node transmits a frame on the CAN bus, it expects an ACKnowledgement from at least one other node on the network. The receiving node that provides the ACK does not need to be the intended recipient of the frame, although it could very well be. When the transmitting node does not receive an ACK, it results in ACKnowledge error and it keeps re-transmitting the frame forever. In this situation, the TA bit for the transmitting mailbox does not get set at all and code will be looping there forever. For proper operation, the CAN_H pins of all CAN nodes must be connected together and likewise the CAN_L pins. The bus also should be terminated correctly on either ends (only).

对此软件如何进行设置可以避免这类现象发生

Hercules 安全微控制器

Hercules™︎ 安全微控制器论坛

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