• 状态 Resolved
  • 已锁定 已锁定
  • 回复 7 回复
  • 订户 0 订户
  • 视图 384 视图
  • 用户 0 会员在此处
选项
选项
相关

This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

[参考译文] CCS/RM48L952：CAN 发送中的待处理消息(__LW_AT__trREQX）

admin
Guru**** 2614265 points
Other Parts Discussed in Thread: HALCOGEN

请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

https://e2e.ti.com/support/microcontrollers/arm-based-microcontrollers-group/arm-based-microcontrollers/f/arm-based-microcontrollers-forum/777025/ccs-rm48l952-how-the-pending-message-trreqx-in-can-transmitting

器件型号：RM48L952
主题中讨论的其他器件：HALCOGEN

工具/软件：Code Composer Studio

 所用的 IDE 为 CCS 6.2 for Hercules，CAN 通信驱动程序由 HALcogen。生成

我发送128个10字节的数据包，，并在主程序，中调用 canTransmit()，在 CAN 中断通知。中调用其他127个数据包 trampnit，我使用 messagebox1进行 trasmit。

  canTransmit()函数中的 somtimes 返回值为0，请参阅下图：

但是 勘误表中的 TxOK 位是1、并且没有其他 CAN 总线错误。 cantrampit ()位于主程序中。 当出现这种情况时，我尝试在  while 循环中调用 canTransmit()，但不起作用。

我的问题是为什么有待处理的消息？  我应该检查哪些标志以 确保无错误 CAN 转换？

  • 0
    TI__Guru**** 2614265 points
    请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。
    您好！
    您是否尝试一次发送10个字节？ CAN (不是 CAN FD)的最大有效载荷为8字节。
    您能否分享您代码的某些部分？

    此致、
    米罗
  • 0
    TI__Guru**** 2614265 points
    请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

    我使用 can2.0A，十个字节包括8字节数据和2字节 ID

  • 0
    TI__Guru**** 2614265 points
    请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。
    您好！
    您能否共享一些代码或 CCS 和 HALCoGen 项目？

    此致、
    米罗
  • 0
    TI__Guru**** 2614265 points
    请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

    appmain (空)
    ｛
    uint32_t MainTime = 0U；
    uint32_t RunFlag = 0U；
    uint8_t FeedDogFlag = 6U；

    RtiInit()；
    CanInit()；
    while (1)
    ｛
    unsigned int temp122；
    temp122=cansendfinish (canREG1)；//读取错误和状态寄存器 ES

    ClearIObuf()；
    ｛
    if ((temp122&0x80)！=0x80)// CAN 不是脱机的
    CommIORcv ()；//CAN 接收
    其他
    ｛
    ；
    // cout11[0]= 0x11；
    // cout11[1]=0x11；
    // cout11[2]=0x11；
    // cout11[3]=0x11；
    ｝
    ｝
    if ((TX_DATA_FULL=0U)&&(temp122&0x80)！=0x80)//发送包号正常，ES 寄存器为 TXOK
    ｛
    if ((((temp122 & 0xE0)！=0x00)||(((temp122&0x07)！=0x07)&&((temp122&0x07)！=0x00))&&(fistcout=0))
    ｛
    // cout11[0]= temp122和0xFF；
    // cout11[1]=temp122&0xFF；
    // cout11[2]=temp122&0xFF；
    // cout11[3]=temp122&0xFF；
    fistcout=1；
    //返回；
    ｝
    if (((temp122&0x08)=0x08)||(temp122&0x07)==0x07)//无 CAN 错误，然后发送数据
    CommIOSnd()；
    ｝

    ｝

    /*运行运行灯*/
    if (RunFlag=1U)
    ｛
    RunFlag = 0U；
    ｝
    其他
    ｛
    RunFlag = 1U；
    ｝
    点运行灯(22U、RunFlag)；/*Δ ti*/

    /*A-MS/B-MS 主从*/
    if (CPU1== OwnStatus.CPU1orCPU2)
    ｛
    HETIO (24U、1U)；/*点主从指示灯*/
    ｝
    其他
    ｛
    HETIO (24U、0U)；
    ｝

    HETIO (9U、1U)；
    HETIO (9U、0U)；
    ｝
    ｝

    void CommIORcv (void)
    ｛
    rpaks = RecvCan()；/*收数>>rcvCan[i]*/
    ｝

    钟 uint16_t RecvCan (void)//13370164196 μ s
    ｛
    const uint8_t rcvcanbuf[10*MAX_MODE]=｛0U｝；/*接收缓冲区*/
    uint16_t rcvlen = 0U；/*接收长度*/
    uint16_t I = 0U；
    uint16_t j = 0U；
    uint16_t k = 0U；
    uint16_t TotalLen = 0U；
    静态 uint32_t rerr_cnt = 0U；/*用于通信中断的计时器计数器*/
    静态 uint8_t canrcverr = 0U；/*可以接收 err*/
    G_RcvCanlen = 0U；/*0*/

    if (rerr_cnt=0U)
    ｛
    rerr_cnt = tickGet ()；
    ｝
    操作
    ｛
    rcvlen =(uint16_t) CanRecive (rcvcanbuf、10U*((uint32_t) MAX_MODES)；/*接收CAN数据包*
    if (rcvlen =0u)/*20160518 g*/
    ｛
    if (GetElapse (rer_cnt)>3000U)/*3s，判断是否3秒未收到数，若是则判通信中断*/
    ｛
    OcuErr=ERR_CANRCV；
    canrcvr=1U；
    ｝
    ｝
    其他
    ｛
    rerr_cnt = tickGet ()；/*记录收收的时间*/
    ｝

    k = 0U；
    while (((k*10U)<rcvlen) && (i<(uint16_t)MAX_MODUS)) /*逐包处理接收的数据*/
    ｛
    rcvCan[i].id=0U；
    rcvCan[i].id |=(uint32_t)(((uint32_t) rcvcanbuf[k*10U+0U])<3)；/*提取CAN ID*/
    rcvCan[i].id |=(uint32_t)(((uint32_t) rcvcanbuf[k*10U+1U]>>5)；/*提取CAN ID*/
    rcvCan[i].dataLen = rcvcanbuf[k*10U+1U]和0x0FU；/*提取CAN 数据包长度*/
    对于(j = 0U；j <(uint16_t) rcvCan[i].dataLen；j++)/*提取CAN 数据*
    ｛
    rcvCan[i].data[j]= rcvcanbuf[k*10U+j+2U]；
    ｝
    //////////////////////////////////////////////////////////////////// 判断序号连续 μ A
    uint16_t CRC = 0U；/* CAN 数据crc *
    CRC = CRC16 ((uint8_t *)(&rcvcanbuf[k*10U+0U])、8U)；/*计算crc *
    if ((((CRC>>>8)&0xFF)=rcvcanbuf[k*10U+8U])&&(((CRC 和0xFF)=rcvcanbuf[k *10U+9U]))
    ｛
    if (((rcvcanbuf[k*10U+3U]=0))
    ｛
    COUT[0]++；
    if (cout[1]>0)
    ｛
    if ((cout[1]！=128))//判断 cout【2】
    ｛
    crc错误点红灯(21U、1U)；//μ s
    HETIO (9U、1U)；
    HETIO (9U、0U)；
    cout11[1]=(unsigned char) cout[1]；
    ｝
    COUT[1]=0；
    ｝
    ｝
    if ((rcvcanbuf[k*10U+3U]=2))
    ｛
    COUT[2]++；
    if (cout[3]>0)
    ｛
    if ((cout[3]！=128))//判断 cout【2】
    ｛
    crc错误点红灯(21U、1U)；//μ s
    HETIO (9U、1U)；
    HETIO (9U、0U)；
    cout11[3]=(unsigned char) cout[3]；
    ｝
    COUT[3]=0；
    ｝
    ｝
    if ((rcvcanbuf[k*10U+3U]=1))
    ｛
    COUT[1]++；
    if (cout[2]>0)
    ｛
    if ((cout[2]！=128))//判断 cout【2】
    ｛
    crc错误点红灯(21U、1U)；//μ s
    HETIO (9U、1U)；
    HETIO (9U、0U)；
    cout11[2]=(unsigned char) cout[2]；
    ｝
    COUT[2]= 0；
    ｝
    ｝
    if ((rcvcanbuf[k*10U+3U]=3))
    ｛
    COUT[3]++；
    if (cout[0])
    ｛
    if ((cout[0]！=128))//判断 cout【3】
    ｛
    crc错误点红灯(21U、1U)；//μ s
    HETIO (9U、1U)；
    HETIO (9U、0U)；
    cout11[0]=(unsigned char) cout[0]；
    ｝
    COUT[0]= 0；
    ｝
    ｝
    ｝
    其他
    ｛
    CANRevNum=CANRevNum；
    crc错误点红灯(21U、1U)；//μ s
    HETIO (9U、1U)；
    HETIO (9U、0U)；
    COout11[0]= 0xFD；
    COout11[1]=0xFD；
    COout11[2]=0xFD；
    COout11[3]=0xFD；
    ｝

    if (CANRevFirst=0)
    ｛
    if (CANRevNum=0xFF)
    ｛
    if (rcvCan[i].data[0]！=0)
    ｛

    CANRevNum=CANRevNum；
    crc错误点红灯(21U、1U)；//μ s
    HETIO (9U、1U)；
    HETIO (9U、0U)；
    COout11[0]= 0xFC；
    COout11[1]=0xFC；
    COout11[2]=0xFC；
    COout11[3]=0xFC；
    ｝
    其他
    ｛

    CANRevNum=CANRevNum；
    ｝
    ｝
    其他
    ｛
    if (rcvCan[i].data[0]！=CANRevNum+1)
    ｛
    CANRevNum=CANRevNum；
    crc错误点红灯(21U、1U)；//μ s
    HETIO (9U、1U)；
    HETIO (9U、0U)；
    COout11[0]= 0xFB；
    COout11[1]=0xFB；
    COout11[2]=0xFB；
    COout11[3]=0xFB；
    ｝
    其他
    ｛

    CANRevNum=CANRevNum；
    ｝

    ｝
    ｝

    if (CANRevFirst==1)
    CANRevFirst=0；
    CANRevNum = rcvCan[i]。data[0]；


    ////////////////////////////////////////////////////////////////////////////
    MEM_CPY (&g_RcvCanbuf[g_RcvCanlen]、&rcvcanbuf[k*10U]、10U)；/*拷贝要发送给从CPU的数据*
    G_RcvCanlen = g_RcvCanlen+10U；/*要发送给从CPU的数据长度赋值*/

    I = I+1U；
    k = k+1U；
    ｝
    TotalLen = TotalLen+rcvlen；
    if (TotalLen>MAX_MODE*10U*2U)/*超过最大数量的2倍认为接收异常*/
    ｛
    fatalErr=ferr_CanRcv；
    MyExit()；
    中断；
    ｝
    }while (rcvlen>0U)；

    if ((canrcverr=1U)&&(i>0U))/* CAN数据有错误时，清空接收长度*/
    ｛
    I=0U；
    G_RcvCanlen = 0U；
    CANRcvr=0U；
    ｝
    /*测试后添加，临时*/
    返回 i；
    ｝

    静态空 SendCAN (uint16_t paks)
    ｛
    uint8_t sndcanbuf[10*MAX_MODE]={0U}；/* CAN收到的数据包数*/
    uint16_t j = 0U；
    uint16_t I = 0U；
    静态 uint32_t SERR_cnt=0U；/*最后一次发送成功的时间，用于发送失败的判断*/

    if (SERR_cnt=0U)
    ｛
    serr_cnt = tickGet ()；
    ｝

    while ((<paks) && (i<(uint16_t)MAX_MODUS)) /*逐包发送CAN数据包*/
    ｛
    sndcanbuf[10U*i+0U]=(uint8_t)(sndCan[i].id>3)；
    sndcanbuf[10U*i+1U]=(uint8_t)(sndCan[i].id<5)+ 8U；
    for (j=0U;j ｛
    sndcanbuf[10U*i+j+2U]=sndCan[i].data[j]；
    ｝
    I = I+1U；
    ｝
    if (CANSend (sndcanbuf、(uint32_t) paks)！=(uint32_t) paks)/*判断是否都发送完成*
    ｛
    if (GetElapse (SERR_cnt)>3000U)/* 3s 均发送失败则报错*/
    ｛
    OcuErr=ERR_CANSEND；/*20160518 g*/
    ｝
    ｝
    其他
    ｛
    serr_cnt=tickGet ()；
    ｝

    MEM_SET (sndCan、0U、sizeof (sndCan))；/*清空发送缓冲区*
    ｝


    uint32_t 导联(空)
    ｛
    /*在 Cortex R4中启用 IRQ 中断*/
    _enable_interrupt_()；

    /**-在 RAM 中写入随机数据-传输*/
    //dumpSomeData()；

    /**-将 CAN1 MB1、Msg ID-1配置为发送、将 CAN2 MB1配置为接收*/
    canInit()；

    // canEnableStatusChangeNotification (canREG1)；
    /**-启用错误中断*/
    canEnableErrorNotification (canREG1)；
    // canEnableErrorNotification (canREG2)；

    返回1；
    ｝

    /*用户代码开始(2)*/
    void canUpdateTRID (canBASE-t *节点、uint32 MessageBox、uint32 msgBoxArbitVal)
    ｛

    /**-等待 IF1准备就绪可供使用*/
    while ((node->IF1STAT & 0x80U)=0x80U)
    ｛
    }/*等待*/
    NOLE->IF1MSK = 0xC0000000U |(UINT32)((UINT32)((UINT32) 0x000007FFU &(UINT32) 0x000007FFU)<<(UINT32) 18U)；
    NOLE->IF1ARB =(uint32) 0x800000U |(uint32) 0x00000000U |(uint32) 0x20000000U |(uint32)((uint32)(msgBoxArbitVal &(uint32) 0x000007FFU)<<(uint32) 18U)；
    NOLE->IF1MCTL = 0x00001080U |(UINT32) 0x00000800U |(UINT32) 0x00000000U |(UINT32) 8U；
    NOD->IF1CMD =(uint8) 0xF8U；
    节点->IF1NO = 1U；
    /**-等待数据被复制到 IF1中*/
    while ((node->IF1STAT & 0x80U)=0x80U)
    ｛
    }/*等待*/
    ｝
    /*用户代码结束*/
    extern unsigned char cout11[4]；
    uint32_t CANSend (uint8 * ptx、uint32 cnt)
    ｛
    uint32 rtn = 0U；
    uint32成功= 0U；
    静态 uint8_t 标志= 0U；
    uint32 TimeCount=0；

    //成功=cansendok (canREG1)；

    /* while (TX_DATA_FULL=1)；//该句话放在此处时，部分信号闪烁*/
    if ((TX_DATA_FULL=0U)/*&&(cansendok (canREG1)*/)
    ｛
    TX_DATA_COUNT = 0；
    MEM_CPY (TX_DATA、ptx、cnt*10)；
    uint32 msgBoxArbitVal =((( uint32) TX_DATA[TX_DATA_COUNT][0])<<8)|((uint32) TX_DATA[TX_DATA_COUNT][1])>>5；
    canUpdateTRID (canREG1、canMESSAGE_BOX1、msgBoxArbitVal)；//0x81 101
    Success = canTransmit (canREG1、canMESSAGE_BOX1、&TX_DATA[TX_DATA_COUNT][2])；//传输8个不同的块1 x 1 */

    // RitDelay (1U)；

    if (成功！= 1)
    ｛
    //(5U)；


    //=tickGet ()；
    while ((canTransmit (canREG1、canMESSAGE_BOX1、&TX_DATA[TX_DATA_COUNT][2])！=1)&&(TimeCount<3))
    ｛
    if (计时计数<8)
    TimeCount++；
    RitDelay (1)；

    }//传输8个不同的块1 x 1
    TimeCount=0；
    // canUpdateTRID (canREG1、canMESSAGE_BOX9、msgBoxArbitVal)；// 0x81 101
    //成功= canTransmit (canREG1、canMESSAGE_BOX9、&TX_DATA[TX_DATA_COUNT][2])；//传输8个不同的块1 x 1 */
    ｝

    if (成功！= 1)
    ｛
    Success = 0；
    crc错误点红灯(21U、1U)；//μ s
    HETIO (9U、1U)；
    HETIO (9U、0U)；
    COout11[0]= 0xFE；
    COout11[1]=0xFE；
    COout11[2]=0xFE；
    COout11[3]=0xFE；
    ｝

    // while (cansendfinish (canREG1)！=1)
    ；

    rtn = cnt；
    spakcnt = cnt；
    TX_DATA_FULL=1U；
    TX_DATA_COUNT++；

    if (flag==0U)
    ｛
    标志= 1U；
    ｝
    其他
    ｛
    FLAG = 0U；
    ｝
    hetio(26, flag)；
    heitio (9、1)；
    Heitio (9、0)；

    SetDebugSndData_CanSnd (ptx、cnt*10)；
    ｝
    #ifdef DEBUG_ETHMOD
    // SetModData_CanSnd (ptx、cnt*10U)；
    #endif

    /*while (TX_DATA_FULL=1 && Success！=0)；*/

    返回 RTN；
    ｝
    /*数据队列存储*/
    空 PushStack1 (uint8_t buf[])
    ｛
    if ((stackHead1 == stackTail1)&&(stackLen1！= 0U))/*队列满之后一直走该分支*
    ｛
    MEM_CPY (&stackBuf1[stackTail1][0]、buf、10U)；
    stackTail1 = stackTail1 + 1U；
    if (stackTail1==MAX_MODE*2)
    ｛
    stackTail1 = 0U；
    ｝
    stackHead1 = stackTail1；
    ｝
    else /*队列未满走该分支*/
    ｛
    MEM_CPY (&stackBuf1[stackTail1][0]、buf、10U)；
    stackLen1 = stackLen1 + 1U；
    stackTail1 = stackTail1 + 1U；
    if (stackTail1==MAX_MODE*2)
    ｛
    stackTail1 = 0U；
    ｝
    ｝
    TMP_RxCount++；
    ｝
    /*数据队列提取*/
    uint32_t PopStack1 (uint8_t buf[])
    ｛
    uint32_t rtnlen = 0U；
    if (stackLen1==0U)
    ｛
    /*无数据*/
    rtnlen = 0U；
    ｝
    其他
    ｛
    MEM_CPY (buf、&stackBuf1[stackHead1][0]、10U)；
    MEM_SET (&stackBuf1[stackHead1][0]、0U、10U)；
    stackHead1 = stackHead1 + 1U；
    if (stackHead1==MAX_MODE*2)
    ｛
    stackHead1 = 0U；
    ｝
    stackLen1 = stackLen1 - 1U；

    rtnlen = 10u；
    ｝

    返回 rtnlen；
    ｝
    uint32_t CanRecive (uint8 * ptr、uint32 buflen)
    ｛
    静态 uint8_t 标志= 0U；
    uint32_t cnt = 0U；
    uint8_t buf[10]=｛0U｝；

    while (注意事项<buflen)
    ｛
    if (PopStack1 (buf)>0U)
    ｛
    MEM_CPY (&PTR[cnt]、buf、10U)；
    CNT = cnt + 10U；
    ｝
    其他
    ｛
    中断；
    ｝
    ｝

    if (cnt >0U)
    ｛
    if (flag==0U)
    ｛
    标志= 1U；
    ｝
    其他
    ｛
    FLAG = 0U；
    ｝
    hetio(27, flag);
    heitio (9、1)；
    Heitio (9、0)；
    ｝


    #ifdef DEBUG_COM
    if (((tmp_RxCount！=MAX_MODET)&&(cnt！=0))
    ｛
    SetDebugSndData_CanRcv (ptr、cnt)；
    ｝
    if (tmp_RxCount>MAX_MOSTI)
    ｛
    TMP_RxCount = 0；
    ｝
    TMP_RxCount = 0；
    #endif

    返回 cnt；/*返回接收成功的字节数*/

    if (rpakcnt>0U)
    ｛
    if (buflen>=rpakcnt*10)
    ｛
    不能烧的()；
    MEM_CPY (ptr、rx_ptr、rpakcnt*10)；
    RX_DATA_COUNT = 0U；
    CNT = rpakcnt*10；
    rpakcnt = 0U；
    enableecanint()；
    ｝
    其他
    ｛
    不能烧的()；
    MEM_CPY (ptr、rx_ptr、buflen)；
    MEM_CPY (Rx_PTR、&Rx_PTR[buflen]、rpakcnt * 10-buflen)；
    RX_DATA_COUNT = rpakcnT-buflen/10U；
    CNT = buflen；
    rpakcnt = rpakcnt - buflen/10U；
    enableecanint()；
    ｝

    if (flag==0U)
    ｛
    标志= 1U；
    ｝
    其他
    ｛
    FLAG = 0U；
    ｝
    hetio(27, flag);
    heitio (9、1)；
    Heitio (9、0)；
    ｝
    其他
    ｛
    CNT = 0U；
    ｝

    //SetDebugSndData_CanRcv (rx_ptr、cnt)；

    返回 cnt；
    ｝

    /*用户代码开始(4)*/
    空延迟(uint32 cout)
    ｛
    uint32 i;
    for (i=0；<cout;i++))
    ｛
    i++；
    一----；
    ｝

    ｝

    /*可以中断通知*/
    /*注意-您需要从 notification.c 中删除 canMessageNotification 以避免重新定义*/
    extern unsigned char sendok；
    void canMessageNotification (canbase_t *节点、uint32 MessageBox)
    ｛
    uint32成功= 0；
    /*节点1 -传输请求*/
    if (node=canREG1 && MessageBox =canMESSAGE_BOX1)
    ｛
    /**-开始传输*/
    if (<spakcnt))
    ｛
    uint32 msgBoxArbitVal =((( uint32) TX_DATA[TX_DATA_COUNT][0])<<8)|((uint32) TX_DATA[TX_DATA_COUNT][1])>>5；
    canUpdateTRID (canREG1、canMESSAGE_BOX1、msgBoxArbitVal)；/*0x81 101*/
    if (canTransmit (canREG1、canMESSAGE_BOX1、&TX_DATA[TX_DATA_COUNT][2])=1)//*传输8个不同的块1 x 1 */
    TX_DATA_COUNT = TX_DATA_COUNT+1U；

    if (<spakcnt))
    ｛
    if (TX_DATA_COUNT%45=0)
    ｛
    // RitDelay (1U)；
    延迟(0x2FFF)；
    ｝
    ｝
    ｝
    其他
    ｛
    TX_DATA_COUNT=0U；
    TX_DATA_FULL = 0U；
    ｝
    ｝
    /*
    if (node=canREG1 && MessageBox =canMESSAGE_BOX9)
    ｛
    if (<spakcnt))
    ｛
    uint32 msgBoxArbitVal =((( uint32) TX_DATA[TX_DATA_COUNT][0])<<8)|((uint32) TX_DATA[TX_DATA_COUNT][1])>>5；
    canUpdateTRID (canREG1、canMESSAGE_BOX9、msgBoxArbitVal)；
    canTransmit (canREG1、canMESSAGE_BOX9、&TX_DATA[TX_DATA_COUNT][2])；
    TX_DATA_COUNT = TX_DATA_COUNT+1U；

    if (<spakcnt))
    ｛
    if (TX_DATA_COUNT%45=0)
    ｛
    // RitDelay (1U)；
    延迟(0x2FFF)；
    ｝
    ｝
    ｝
    其他
    ｛
    TX_DATA_COUNT=0U；
    TX_DATA_FULL = 0U；
    ｝
    ｝
    *
    /*节点2 -接收完成*/
    if (node=canREG1 && MessageBox =canMESSAGE_BOX2)
    ｛
    if (canIsRxMessageArtrived (canREG1、canMESSAGE_BOX2))
    ｛
    Success= canGetData (canREG1、canMESSAGE_BOX2、&Rx_PTR[RX_DATA_COUNT*10])；/*复制到 RAM */
    if (成功= 1)
    ｛
    if (CANRevIntten= 1)
    PushStack1 (Rx_PTR)；
    ｝
    ｝
    ｝
    /*节点2 -接收完成*/
    if (node=canREG1 && MessageBox =canMESSAGE_box3)
    ｛
    if (canIsRxMessageArrived (canREG1、canMESSAGE_box3))
    ｛
    Success= canGetData (canREG1、canMESSAGE_box3、&Rx_PTR[RX_DATA_COUNT*10])；//复制到 RAM */
    if (成功= 1)
    ｛
    if (CANRevIntten= 1)
    PushStack1 (Rx_PTR)；
    ｝
    ｝
    ｝
    /*节点2 -接收完成*/
    if (node=canREG1 && MessageBox =canMESSAGE_BOX4)
    ｛
    if (canIsRxMessageArrived (canREG1、canMESSAGE_BOX4))
    ｛
    Success= canGetData (canREG1、canMESSAGE_BOX4、&Rx_PTR[RX_DATA_COUNT*10])；/*复制到 RAM */
    if (成功= 1)
    ｛
    if (CANRevIntten= 1)
    PushStack1 (Rx_PTR)；
    ｝
    ｝
    ｝
    /*节点2 -接收完成*/
    if (node=canREG1 && MessageBox =canMESSAGE_BOX5)
    ｛
    if (canIsRxMessageArtrived (canREG1、canMESSAGE_BOX5))
    ｛
    Success= canGetData (canREG1、canMESSAGE_BOX5、&Rx_PTR[RX_DATA_COUNT*10])；/*复制到 RAM */
    if (成功= 1)
    ｛
    if (CANRevIntten= 1)
    PushStack1 (Rx_PTR)；
    ｝
    ｝
    ｝
    /*节点2 -接收完成*/
    if (node=canREG1 && MessageBox =canMESSAGE_BOX6)
    ｛
    if (canIsRxMessageArrived (canREG1、canMESSAGE_BOX6))
    ｛
    Success= canGetData (canREG1、canMESSAGE_BOX6、&Rx_PTR[RX_DATA_COUNT*10])；/*复制到 RAM */
    if (成功= 1)
    ｛
    if (CANRevIntten= 1)
    PushStack1 (Rx_PTR)；
    ｝
    ｝
    ｝
    /*节点2 -接收完成*/
    if (node=canREG1 && MessageBox =canMESSAGE_BOX7)
    ｛
    if (canIsRxMessageArrived (canREG1、canMESSAGE_BOX7))
    ｛
    Success= canGetData (canREG1、canMESSAGE_BOX7、&Rx_PTR[RX_DATA_COUNT*10])；//复制到 RAM */
    if (成功= 1)
    ｛
    if (CANRevIntten= 1)
    PushStack1 (Rx_PTR)；
    ｝

    ｝
    ｝
    /*节点2 -接收完成*/
    if (node=canREG1 && MessageBox =canMESSAGE_BOX8)
    ｛
    if (canIsRxMessageArrived (canREG1、canMESSAGE_BOX8))
    ｛
    Success= canGetData (canREG1、canMESSAGE_BOX8、&Rx_PTR[RX_DATA_COUNT*10])；/*复制到 RAM */
    if (成功= 1)
    ｛
    if (CANRevIntten= 1)
    PushStack1 (Rx_PTR)；
    ｝
    ｝
    ｝
    /*节点2 -接收完成*/
    if (node=canREG1 && MessageBox =canMESSAGE_BOX10)
    ｛
    if (canIsRxMessageArrived (canREG1、canMESSAGE_BOX10))
    ｛
    Success= canGetData (canREG1、canMESSAGE_BOX10、&Rx_PTR[RX_DATA_COUNT*10])；/*复制到 RAM */
    if (成功= 1)
    ｛
    if (CANRevIntten= 1)
    PushStack1 (Rx_PTR)；
    ｝

    ｝
    ｝
    /*注意：由于两个节点上都只使用了消息框1，因此我们不在此进行检查。*/


    ｝

    空 canInit (空)
    ｛
    /*用户代码开始(4)*/
    /*用户代码结束*/
    /**@b 初始化@b CAN1：*/

    /**-设置控制寄存器
    *-禁用总线活动时的自动唤醒
    *-禁用本地断电模式
    *-禁用 DMA 请求线路
    *-启用全局中断线路0和1
    *-禁用调试模式
    *-从软件复位中释放
    *-启用/禁用奇偶校验或 ECC
    *-启用/禁用计时器上的自动总线
    *-进入调试状态之前设置消息完成
    *-设置正常操作模式
    *-请求对配置寄存器的写入访问
    *-设置消息的自动重新传输
    *-禁用错误中断
    *-禁用状态中断
    *-进入初始化模式
    *
    CANREG1->CTL =(uint32) 0x00000200U
    |(UINT32) 0x00000000U
    |(UINT32)((UINT32) 0x0000000AU << 10U)
    |(UINT32) 0x00020043U；

    /**-清除所有挂起的错误标志并重置当前状态*/
    canREG1->ES |= 0xFFFFFFU；

    /**-为消息分配中断级别*/
    CANREG1->INTMUXx[0U]=(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U；

    CANREG1->INTMUXx[1U]=(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U
    |(UINT32) 0x00000000U；

    /**-在定时器周期上设置自动总线*/
    canREG1->ABOTR =(uint32) 0U；

    /**-初始化消息1.
    *-等待 IF1就绪可供使用
    *-设置消息掩码
    *-设置消息控制字
    *-设置消息仲裁
    *-设置 IF1控制字节
    *-设置 IF1消息编号
    *
    /*SAFETYMCUSW 28 D MR：NA "找到可能无限的循环-执行序列的硬件状态检查"*/
    while ((canREG1->IF1STAT & 0x80U)=0x80U)
    ｛
    }/*等待*/


    CANREG1->IF1MSK = 0xC0000000U |(UINT32)((UINT32)((UINT32) 0x000007FFU &(UINT32) 0x000007FFU)<<(UINT32) 18U)；
    CANREG1->IF1ARB =(uint32) 0x8000000000U |(uint32) 0x000000000000 U |(uint32) 0x20000000U |(uint32)(((uint32) 1U &(uint32) 0x000007FFU)<<(uint32) 18U)；
    CANREG1->IF1MCTL = 0x00001080U |(UINT32) 0x00000800U |(UINT32) 0x00000000U |(UINT32) 8U；
    CANREG1->IF1CMD =(uint8) 0xF8U；
    canREG1->IF1NO = 1U；

    /**-初始化消息2.
    *-等待 IF2就绪可供使用
    *-设置消息掩码
    *-设置消息控制字
    *-设置消息仲裁
    *-设置 IF2控制字节
    *-设置 IF2消息编号
    *
    /*SAFETYMCUSW 28 D MR：NA "找到可能无限的循环-执行序列的硬件状态检查"*/
    while ((canREG1->IF2STAT & 0x80U)=0x80U)
    ｛
    }/*等待*/

    // canREG1->IF2MSK = 0xC0000000U |(uint32)(((uint32) 0x00000000U &(uint32) 0x000007FFU)<<(uint32) 18U)；
    CANREG1->IF2MSK = 0xC0000000U |(UINT32)((UINT32)((UINT32) 0x00000000U 和(UINT32) 0x000007FFU)<<(UINT32) 18U)；
    // canREG1->IF2ARB =(uint32) 0x8000000000U |(uint32) 0x000000000000 U |(uint32) 0x000000000000 U |(uint32)(((uint32) 2U 和(uint32) 0x000007FFU)<<(uint32) 18U)；
    CANREG1->IF2ARB =(uint32) 0x8000000000U |(uint32) 0x000000000000 U |(uint32) 0x000000000000 U |(uint32)(((uint32) 0U 和(uint32) 0x000007FFU)<<(uint32) 18U)；
    CANREG1->IF2MCTL = 0x00001000U |(UINT32) 0x00000400U |(UINT32) 0x00000000U |(UINT32) 8U；
    CANREG1->IF2CMD =(uint8) 0xF8U；
    canREG1->IF2NO = 2U；

    /**-初始化消息2.
    *-等待 IF2就绪可供使用
    *-设置消息掩码
    *-设置消息控制字
    *-设置消息仲裁
    *-设置 IF2控制字节
    *-设置 IF2消息编号
    *
    /*SAFETYMCUSW 28 D MR：NA "找到可能无限的循环-执行序列的硬件状态检查"*/
    while ((canREG1->IF2STAT & 0x80U)=0x80U)
    ｛
    }/*等待*/

    // canREG1->IF2MSK = 0xC0000000U |(uint32)(((uint32) 0x00000000U &(uint32) 0x000007FFU)<<(uint32) 18U)；
    CANREG1->IF2MSK = 0xC0000000U |(UINT32)((UINT32)((UINT32) 0x00000000U 和(UINT32) 0x000007FFU)<<(UINT32) 18U)；
    // canREG1->IF2ARB =(uint32) 0x8000000000U |(uint32) 0x000000000000 U |(uint32) 0x000000000000 U |(uint32)(((uint32) 2U 和(uint32) 0x000007FFU)<<(uint32) 18U)；
    CANREG1->IF2ARB =(uint32) 0x8000000000U |(uint32) 0x000000000000 U |(uint32) 0x000000000000 U |(uint32)(((uint32) 0x8U 和(uint32) 0x000007FFU)<<(uint32) 18U)；
    CANREG1->IF2MCTL = 0x00001000U |(UINT32) 0x00000400U |(UINT32) 0x00000000U |(UINT32) 8U；
    CANREG1->IF2CMD =(uint8) 0xF8U；
    canREG1->IF2NO = 3U；

    /**-初始化消息2.
    *-等待 IF2就绪可供使用
    *-设置消息掩码
    *-设置消息控制字
    *-设置消息仲裁
    *-设置 IF2控制字节
    *-设置 IF2消息编号
    *
    /*SAFETYMCUSW 28 D MR：NA "找到可能无限的循环-执行序列的硬件状态检查"*/
    while ((canREG1->IF2STAT & 0x80U)=0x80U)
    ｛
    }/*等待*/

    // canREG1->IF2MSK = 0xC0000000U |(uint32)(((uint32) 0x00000000U &(uint32) 0x000007FFU)<<(uint32) 18U)；
    CANREG1->IF2MSK = 0xC0000000U |(UINT32)((UINT32)((UINT32) 0x00000000U 和(UINT32) 0x000007FFU)<<(UINT32) 18U)；
    // canREG1->IF2ARB =(uint32) 0x8000000000U |(uint32) 0x000000000000 U |(uint32) 0x000000000000 U |(uint32)(((uint32) 2U 和(uint32) 0x000007FFU)<<(uint32) 18U)；
    CANREG1->IF2ARB =(uint32) 0x8000000000U |(uint32) 0x000000000000 U |(uint32) 0x000000000000 U |(uint32)(((uint32) 0x10U &(uint32) 0x000007FFU)<<(uint32) 18U)；
    CANREG1->IF2MCTL = 0x00001000U |(UINT32) 0x00000400U |(UINT32) 0x00000000U |(UINT32) 8U；
    CANREG1->IF2CMD =(uint8) 0xF8U；
    canREG1->IF2NO = 4U；
    /**-初始化消息2.
    *-等待 IF2就绪可供使用
    *-设置消息掩码
    *-设置消息控制字
    *-设置消息仲裁
    *-设置 IF2控制字节
    *-设置 IF2消息编号
    *
    /*SAFETYMCUSW 28 D MR：NA "找到可能无限的循环-执行序列的硬件状态检查"*/
    while ((canREG1->IF2STAT & 0x80U)=0x80U)
    ｛
    }/*等待*/

    // canREG1->IF2MSK = 0xC0000000U |(uint32)(((uint32) 0x00000000U &(uint32) 0x000007FFU)<<(uint32) 18U)；
    CANREG1->IF2MSK = 0xC0000000U |(UINT32)((UINT32)((UINT32) 0x00000000U 和(UINT32) 0x000007FFU)<<(UINT32) 18U)；
    // canREG1->IF2ARB =(uint32) 0x8000000000U |(uint32) 0x000000000000 U |(uint32) 0x000000000000 U |(uint32)(((uint32) 2U 和(uint32) 0x000007FFU)<<(uint32) 18U)；
    CANREG1->IF2ARB =(uint32) 0x8000000000U |(uint32) 0x000000000000 U |(uint32) 0x000000000000 U |(uint32)(((uint32) 0x18U &(uint32) 0x000007FFU)<<(uint32) 18U)；
    CANREG1->IF2MCTL = 0x00001000U |(UINT32) 0x00000400U |(UINT32) 0x00000000U |(UINT32) 8U；
    CANREG1->IF2CMD =(uint8) 0xF8U；
    canREG1->IF2NO = 5U；
    /**-初始化消息2.
    *-等待 IF2就绪可供使用
    *-设置消息掩码
    *-设置消息控制字
    *-设置消息仲裁
    *-设置 IF2控制字节
    *-设置 IF2消息编号
    *
    /*SAFETYMCUSW 28 D MR：NA "找到可能无限的循环-执行序列的硬件状态检查"*/
    while ((canREG1->IF2STAT & 0x80U)=0x80U)
    ｛
    }/*等待*/

    // canREG1->IF2MSK = 0xC0000000U |(uint32)(((uint32) 0x00000000U &(uint32) 0x000007FFU)<<(uint32) 18U)；
    CANREG1->IF2MSK = 0xC0000000U |(UINT32)((UINT32)((UINT32) 0x00000000U 和(UINT32) 0x000007FFU)<<(UINT32) 18U)；
    // canREG1->IF2ARB =(uint32) 0x8000000000U |(uint32) 0x000000000000 U |(uint32) 0x000000000000 U |(uint32)(((uint32) 2U 和(uint32) 0x000007FFU)<<(uint32) 18U)；
    CANREG1->IF2ARB =(uint32) 0x8000000000U |(uint32) 0x000000000000 U |(uint32) 0x000000000000 U |(uint32)(((uint32) 0x20U 和(uint32) 0x000007FFU)<<(uint32) 18U)；
    CANREG1->IF2MCTL = 0x00001000U |(UINT32) 0x00000400U |(UINT32) 0x00000000U |(UINT32) 8U；
    CANREG1->IF2CMD =(uint8) 0xF8U；
    canREG1->IF2NO = 6U；
    /**-初始化消息2.
    *-等待 IF2就绪可供使用
    *-设置消息掩码
    *-设置消息控制字
    *-设置消息仲裁
    *-设置 IF2控制字节
    *-设置 IF2消息编号
    *
    /*SAFETYMCUSW 28 D MR：NA "找到可能无限的循环-执行序列的硬件状态检查"*/
    while ((canREG1->IF2STAT & 0x80U)=0x80U)
    ｛
    }/*等待*/

    // canREG1->IF2MSK = 0xC0000000U |(uint32)(((uint32) 0x00000000U &(uint32) 0x000007FFU)<<(uint32) 18U)；
    CANREG1->IF2MSK = 0xC0000000U |(UINT32)((UINT32)((UINT32) 0x00000000U 和(UINT32) 0x000007FFU)<<(UINT32) 18U)；
    // canREG1->IF2ARB =(uint32) 0x8000000000U |(uint32) 0x000000000000 U |(uint32) 0x000000000000 U |(uint32)(((uint32) 2U 和(uint32) 0x000007FFU)<<(uint32) 18U)；
    CANREG1->IF2ARB =(uint32) 0x8000000000U |(uint32) 0x000000000000 U |(uint32) 0x000000000000 U |(uint32)(((uint32) 0x28U 和(uint32) 0x000007FFU)<<(uint32) 18U)；
    CANREG1->IF2MCTL = 0x00001000U |(UINT32) 0x00000400U |(UINT32) 0x00000000U |(UINT32) 8U；
    CANREG1->IF2CMD =(uint8) 0xF8U；
    canREG1->IF2NO = 7U；
    /**-初始化消息2.
    *-等待 IF2就绪可供使用
    *-设置消息掩码
    *-设置消息控制字
    *-设置消息仲裁
    *-设置 IF2控制字节
    *-设置 IF2消息编号
    *
    /*SAFETYMCUSW 28 D MR：NA "找到可能无限的循环-执行序列的硬件状态检查"*/
    while ((canREG1->IF2STAT & 0x80U)=0x80U)
    ｛
    }/*等待*/

    // canREG1->IF2MSK = 0xC0000000U |(uint32)(((uint32) 0x00000000U &(uint32) 0x000007FFU)<<(uint32) 18U)；
    CANREG1->IF2MSK = 0xC0000000U |(UINT32)((UINT32)((UINT32) 0x00000000U 和(UINT32) 0x000007FFU)<<(UINT32) 18U)；
    // canREG1->IF2ARB =(uint32) 0x8000000000U |(uint32) 0x000000000000 U |(uint32) 0x000000000000 U |(uint32)(((uint32) 2U 和(uint32) 0x000007FFU)<<(uint32) 18U)；
    CANREG1->IF2ARB =(uint32) 0x8000000000U |(uint32) 0x000000000000 U |(uint32) 0x000000000000 U |(uint32)(((uint32) 0x30U 和(uint32) 0x000007FFU)<<(uint32) 18U)；
    CANREG1->IF2MCTL = 0x00001000U |(UINT32) 0x00000400U |(UINT32) 0x00000000U |(UINT32) 8U；
    CANREG1->IF2CMD =(uint8) 0xF8U；
    canREG1->IF2NO = 8U；
    /**-初始化消息9.
    *-等待 IF1就绪可供使用
    *-设置消息掩码
    *-设置消息控制字
    *-设置消息仲裁
    *-设置 IF1控制字节
    *-设置 IF1消息编号
    *
    /*SAFETYMCUSW 28 D MR：NA "找到可能无限的循环-执行序列的硬件状态检查"*/
    while ((canREG1->IF1STAT & 0x80U)=0x80U)
    ｛
    }/*等待*/
    /*
    CANREG1->IF1MSK = 0xC0000000U |(UINT32)((UINT32)((UINT32) 0x000007FFU &(UINT32) 0x000007FFU)<<(UINT32) 18U)；
    CANREG1->IF1ARB =(uint32) 0x8000000000U |(uint32) 0x000000000000 U |(uint32) 0x20000000U |(uint32)(((uint32) 1U &(uint32) 0x000007FFU)<<(uint32) 18U)；
    CANREG1->IF1MCTL = 0x00001080U |(UINT32) 0x00000800U |(UINT32) 0x00000000U |(UINT32) 8U；
    CANREG1->IF1CMD =(uint8) 0xF8U；
    canREG1->IF1NO = 1U；
    *

    CANREG1->IF1MSK = 0xC0000000U |(UINT32)((UINT32)((UINT32) 0x000007FFU &(UINT32) 0x000007FFU)<<(UINT32) 18U)；
    CANREG1->IF1ARB =(uint32) 0x8000000000U |(uint32) 0x000000000000 U |(uint32) 0x20000000U |(uint32)(((uint32) 0x1U &(uint32) 0x000007FFU)<<(uint32) 18U)；
    CANREG1->IF1MCTL = 0x00001080U |(UINT32) 0x00000800U |(UINT32) 0x00000000U |(UINT32) 8U；
    CANREG1->IF1CMD =(uint8) 0xF8U；
    canREG1->IF1NO = 9U；

    /**-初始化消息10.
    *-等待 IF2就绪可供使用
    *-设置消息掩码
    *-设置消息控制字
    *-设置消息仲裁
    *-设置 IF2控制字节
    *-设置 IF2消息编号
    *
    /*SAFETYMCUSW 28 D MR：NA "找到可能无限的循环-执行序列的硬件状态检查"*/
    while ((canREG1->IF2STAT & 0x80U)=0x80U)
    ｛
    }/*等待*/

    // canREG1->IF2MSK = 0xC0000000U |(uint32)(((uint32)((uint32) 0x000007FFU &(uint32) 0x000007FFU)<<(uint32) 18U)；
    CANREG1->IF2MSK = 0xC0000000U |(UINT32)((UINT32)((UINT32) 0x00000000U 和(UINT32) 0x000007FFU)<<(UINT32) 18U)；
    // canREG1->IF2ARB =(uint32) 0x8000000000U |(uint32) 0x000000000000 U |(uint32) 0x20000000U |(uint32)(((uint32) 0x85U &(uint32) 0x000007FFU)<<(uint32) 18U；
    CANREG1->IF2ARB =(uint32) 0x8000000000U |(uint32) 0x000000000000 U |(uint32) 0x000000000000 U |(uint32)(((uint32) 0x38U &(uint32) 0x000007FFU)<<(uint32) 18U)；
    CANREG1->IF2MCTL = 0x00001080U |(UINT32) 0x00000400U |(UINT32) 0x00000000U |(UINT32) 8U；
    CANREG1->IF2CMD =(uint8) 0xF8U；
    canREG1->IF2NO = 10U；

    /**-设置 IF1以进行数据传输
    *-等待 IF1就绪可供使用
    *-设置 IF1控制字节
    *
    /*SAFETYMCUSW 28 D MR：NA "找到可能无限的循环-执行序列的硬件状态检查"*/
    while ((canREG1->IF1STAT & 0x80U)=0x80U)
    ｛
    }/*等待*/
    CANREG1->IF1CMD = 0x87U；

    /**-设置 IF2以读取数据
    *-等待 IF1就绪可供使用
    *-设置 IF1控制字节
    *
    /*SAFETYMCUSW 28 D MR：NA "找到可能无限的循环-执行序列的硬件状态检查"*/
    while ((canREG1->IF2STAT & 0x80U)=0x80U)
    ｛
    }/*等待*/
    CANREG1->IF2CMD = 0x17U；

    /**-设置位时序
    *-设置波特率预分频器扩展
    *-设置 TSeg2
    *-设置 TSeg1
    *-设置样本跳转宽度
    *-设置波特率预分频器
    *
    canREG1->BTR =(uint32)((uint32) 0U << 16U)|
    (uint32)((uint32)(4U - 1U)<<12U)|
    (uint32)((uint32)((2U + 4U)- 1U)<<8U)|
    (uint32)((uint32)(4U - 1U)<<6U)|
    (uint32) 39U；


    /**- CAN1端口输出值*/
    canREG1->TIOC =(UINT32)((UINT32) 1U <<18U)
    |(uint32)((uint32) 0U <<17U)
    |(uint32)((uint32) 0U <<16U)
    |(uint32)((uint32) 1U <<3U)
    |(uint32)((uint32) 1U <<2U)
    |(uint32)((uint32) 1U <<1U)；

    canREG1->RIOC =(UINT32)((UINT32) 1U <<18U)
    |(uint32)((uint32) 0U <<17U)
    |(uint32)((uint32) 0U <<16U)
    |(uint32)((uint32) 1U <<3U)
    |(uint32)((uint32) 0U <<2U)
    |(uint32)((uint32) 0U <<1U)；

    /**-离开配置和初始化模式*/
    canREG1->CTL &=~(uint32)(0x00000041U)；


    /**@注意，必须先调用此函数，然后才能使用驱动程序。\n
    *此函数必须在特权模式下执行。\n
    *

    /*用户代码开始(5)*/
    /*用户代码结束*/
    ｝

    uint32 canTransmit (canBASE-t *节点、uint32 MessageBox、const uint8 *数据)
    ｛
    uint32 i;
    uint32成功= 0U；
    uint32 regIndex =(MessageBox - 1U)>> 5U；
    uint32 bitIndex = 1U <<(MessageBox - 1U)和0x1FU)；

    /*用户代码开始(7)*/
    /*用户代码结束*/


    /**-检查待处理消息：
    *-待处理消息、返回0
    *-无待处理消息、开始新传输
    *

    if ((node->TXRQx[regIndex]& bitIndex)！= 0U)
    ｛
    成功= 0U；
    ｝

    其他
    ｛
    /**-等待 IF1准备就绪可供使用*/
    /*SAFETYMCUSW 28 D MR：NA "找到可能无限的循环-执行序列的硬件状态检查"*/
    while ((node->IF1STAT & 0x80U)=0x80U)
    ｛
    }/*等待*/

    /**-为配置 IF1
    *-消息方向-写入
    *-数据更新
    *-开始传输
    *
    NOD->IF1CMD = 0x87U；

    /**-将 TX 数据复制到 IF1中*/
    对于(I = 0U；I < 8U；I++)
    ｛
    #if ((__little_endian__= 1)||(__little_ENDIAN__= 1)
    /*SAFETYMCUSW 45 D MR：21.1 "仅此驱动程序允许有效的非 NULL 输入参数"*/
    NODE->IF1DATx[i]=*数据；
    /*SAFETYMCUSW 45 D MR：21.1 "仅此驱动程序允许有效的非 NULL 输入参数"*/
    /*SAFETYMCUSW 567 S MR:17.1,17.4 "需要指针增量"*/
    Data++；
    其他
    /*SAFETYMCUSW 45 D MR：21.1 "仅此驱动程序允许有效的非 NULL 输入参数"*/
    NODE->IF1DATx[s_canByteOrder[i]=*数据；
    /*SAFETYMCUSW 45 D MR：21.1 "仅此驱动程序允许有效的非 NULL 输入参数"*/
    /*SAFETYMCUSW 567 S MR:17.1,17.4 "需要指针增量"*/
    Data++；
    #endif
    ｝

    /**-将 TX 数据复制到消息框中*/
    /*SAFETYMCUSW 93 S MR：6.1、6.2、10.1、10.2、10.3、10.4 "LDRA 工具问题"*/
    NOode->IF1NO =(uint8) MessageBox；

    成功= 1U；
    ｝
    /**@请注意，必须先调用函数 canInit，然后才能使用此函数。\n
    *用户负责初始化消息框。
    *

    /*用户代码开始(8)*/
    /*用户代码结束*/

    返回成功；
    ｝

    void canUpdateID (canBASE-t *节点、uint32 MessageBox、uint32 msgBoxArbitVal)
    ｛

    /**-等待 IF2就绪可供使用*/
    while ((node->IF2STAT & 0x80U)=0x80U)
    ｛
    }/*等待*/

    /**-为配置 IF2
    *-消息方向-读取
    *-数据读取
    *-清除报文对象中的 NewDat 位。
    *
    NOD->IF2CMD = 0xA0U；
    /*将传递的值复制到仲裁寄存器中。 *
    NODe->IF2ARB &= 0x80000000U；
    NODe->IF2ARB |=(msgBoxArbitVal & 0x7FFFFFFFU)；

    /**-更新消息框编号。 *
    /*SAFETYMCUSW 93 S MR：6.1、6.2、10.1、10.2、10.3、10.4 "LDRA 工具问题"*/
    节点->IF2NO =(uint8) MessageBox；

    /**-等待数据被复制到 IF2中*/
    while ((node->IF2STAT & 0x80U)=0x80U)
    ｛
    }/*等待*/

    ｝

    uint32 canIsTxMessagePending (canBASE-t *节点、uint32 MessageBox)
    ｛
    uint32标志；
    uint32 regIndex =(MessageBox - 1U)>> 5U；
    uint32 bitIndex = 1U <<(MessageBox - 1U)和0x1FU)；

    /*用户代码开始(13)*/
    /*用户代码结束*/

    /**-读取 Tx 请求寄存器*/
    flag = node->TXRQx[regIndex]& bitIndex；

    /*用户代码开始(14)*/
    /*用户代码结束*/

    返回标志；
    ｝

    unsigned int cansendfinish (canbase_t *节点)
    ｛
    unsigned int temp=0；
    temp= node->ES & 0xFFFU；
    返回温度；
    ｝


    void enableecanint (void)
    ｛
    /*
    canREG1->CTL = canREG1->CTL | 0x0E；
    canREG1->IF1MCTL=canREG1->IF1MCTL | 0xB00；
    canREG1->IF2MCTL=canREG1->IF2MCTL | 0xB00；
    canREG1->IF3MCTL=canREG1->IF3MCTL | 0xB00；
    *
    CANRevIntene=1；
    ｝

    void disablecanint (void)
    ｛
    /*
    canREG1->CTL = canREG1->CTL & 0xFFFFFFF1；
    canREG1->IF1MCTL=canREG1->IF1MCTL & 0xFFFFF4FF；
    canREG1->IF2MCTL=canREG1->IF2MCTL & 0xFFFFF4FF；
    canREG1->IF3MCTL=canREG1->IF3MCTL & 0xFFFFF4FF；
    *
    CANRevIntene=0；
    ｝

  • 0
    TI__Guru**** 2614265 points
    请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

    如何使用 canIsTxMessagePending（），在使用 uint32 canTransmit (canBASE-t *节点、uint32 MessageBox、const uint8 *数据)之前，是否应检查此标志？如果 canIsTxMessagePending（）为1，那么如果消息处于挂起状态，我该怎么办，请等待一段时间，例如5ms？

  • 0
    TI__Guru**** 2614265 points
    请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。
    如何使用 canIsTxMessagePending（），在使用 uint32 canTransmit (canBASE-t *节点、uint32 MessageBox、const uint8 *数据)之前，是否应检查此标志？如果 canIsTxMessagePending（）为1，那么如果消息处于挂起状态，我该怎么办，请等待一段时间，例如5ms？
  • 0
    TI__Guru**** 2614265 points
    请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

    您好！
    请看一下 HALCoGen - canIntCommunication.c 中的示例
    您可以在 HALCoGen 示例文件夹下找到此示例、并在 HALCoGen 帮助主题中找到说明。

    此致、
    米罗