IWR6843AOP: D3 RS-6843AOP CAN-FD RX ISSUE

Hello,

I wanted to provide an update on my progress since yesterday.

I have confirmed that the RX is functioning correctly on ball F2, and I successfully verified reception using the D3's prebuilt example binary. It has become evident that when I incorrectly set the RX ball in the pinmux, the TX does not operate properly.

Additionally, I was able to receive a CAN-FD message using my custom firmware; however, this was only successful when the CAN bit timings were configured for low speeds (5 Kbps for both the nominal and data phases).

When I adjusted the bit timings to 1 Mbps and 5 Mbps for the nominal and data phases, respectively, I encountered a CANFD_Reason_PROTOCOL_ERR_DATA_PHASE. I am currently investigating this issue.

I suspect there may be a mismatch in the bit timing parameters between the two nodes. The current setup includes one radar node and another node, the Nvidia Jetson TX2. In the Jetson, I am using the mttcan driver, which seems to use BRP=1, while in the radar, the BRP is set to 2. I also attempted to run the radar with the same parameters configured by the TX2, but as mentioned, I received the

CANFD_Reason_PROTOCOL_ERR_DATA_PHASE.

Hello Josh,

Thank you for your prompt response.

Since my last update, I have made some progress by following the MCAN user manual from BOSCH. I successfully configured my setup for both transmission (TX) and reception (RX) across two nodes, achieving bit timings of 500 Kbps for nominal and 2 Mbps for data.

For anyone who may find themselves in a similar situation in the future, I would like to share some guidelines that I wish I had when I began integrating CAN into the existing SDK project:

1. Start with the lowest CAN bit timings: Set both nominal and data rates to 500 Kbps, using a low frame periodicity (around 500 ms) to prevent the TX buffer from overflowing. This configuration is the most tolerant, allowing you to test TX and RX setups with minimal noise. If you do not receive RX messages with this setup, it is likely that the RX configuration, such as rxMsgHandle and filters, has not been set up correctly.
   
   

2. Gradually increase the DATA bit timing: Ensure you understand the parameters involved. Here are some rules of thumb to follow:

   • Prefer a Baud Rate Prescaler (BRP) of 1 to maintain a high resolution of time quantum.

   • Calculate the Divisor using the formula: Divisor = CAN_CLK / Desired-bit-rate. For example, Divisor = 40 MHz / 5 Mbps = 8.

   • Set Pseg2 =~ 0.2 * Divisor, resulting in a sampling point of around 80%.

   • PropSeg and Pseg1 = Divisor - Pseg2 - 1.

   • Depending on the bus length and physical constraints, choose either PropSeg > Pseg1 or Pseg1 > PropSeg.

   • Ensure that SJW <= Pseg2.
     
     

3. Once everything is functioning correctly, increase the nominal bit timings to 1 Mbps.
   
   

For your reference, here is my CAN initialization and parameters. Note that I'm using a D3 engineering custom board based on IWR6843AOP, so your pinmux might be different:

/**************************************************************************
******************** CAN Parameters initialize Function *****************
**************************************************************************/
static void MCANAppInitParams(CANFD_MCANInitParams* mcanCfgParams)
{
    /*Intialize MCAN Config Params*/
    memset (mcanCfgParams, sizeof (CANFD_MCANInitParams), 0);

    mcanCfgParams->fdMode = 0x1U;
    mcanCfgParams->brsEnable = 0x1U;
    mcanCfgParams->txpEnable = 0x0U;
    mcanCfgParams->efbi = 0x0U;
    mcanCfgParams->pxhddisable = 0x0U;

    // Disable auto-retransmission
    mcanCfgParams->darEnable = 0x1U;

    mcanCfgParams->wkupReqEnable = 0x1U;
    mcanCfgParams->autoWkupEnable = 0x1U;
    mcanCfgParams->emulationEnable = 0x0U;
    mcanCfgParams->emulationFAck = 0x0U;
    mcanCfgParams->clkStopFAck = 0x0U;
    mcanCfgParams->wdcPreload = 0x0U;
    mcanCfgParams->tdcEnable = 0x1U;
    mcanCfgParams->tdcConfig.tdcf = 2U;
    mcanCfgParams->tdcConfig.tdco = 4U;
    mcanCfgParams->monEnable = 0x0U;
    mcanCfgParams->asmEnable = 0x0U;
    mcanCfgParams->tsPrescalar = 0x0U;
    mcanCfgParams->tsSelect = 0x0U;
    mcanCfgParams->timeoutSelect = CANFD_MCANTimeOutSelect_CONT;
    mcanCfgParams->timeoutPreload = 0x0U;
    mcanCfgParams->timeoutCntEnable= 0x0U;

    // Reject all remote frames:
    // A remote frame is a frame that does not carry data,
    // but instead requests data from another node
    // CAN-FD does not support remote frames
    mcanCfgParams->filterConfig.rrfe = 0x1U;
    mcanCfgParams->filterConfig.rrfs = 0x1U;

    // Reject Non-matching frames
    // Non-matching frames are frames that do not match the
    // filter configuration of the receiver
    mcanCfgParams->filterConfig.anfe = 0x3U;
    mcanCfgParams->filterConfig.anfs = 0x3U;

    mcanCfgParams->msgRAMConfig.lss = 127U;
    mcanCfgParams->msgRAMConfig.lse = 64U;
    mcanCfgParams->msgRAMConfig.txBufNum = 32U;
    mcanCfgParams->msgRAMConfig.txFIFOSize = 0U;
    mcanCfgParams->msgRAMConfig.txBufMode = 0U;
    mcanCfgParams->msgRAMConfig.txEventFIFOSize = 0U;
    mcanCfgParams->msgRAMConfig.txEventFIFOWaterMark = 0U;

    // FIFO0 and FIFO1 are not used
    mcanCfgParams->msgRAMConfig.rxFIFO0size = 0U;
    mcanCfgParams->msgRAMConfig.rxFIFO0OpMode = 0U;
    mcanCfgParams->msgRAMConfig.rxFIFO0waterMark = 0U;

    mcanCfgParams->msgRAMConfig.rxFIFO1size = 64U;
    mcanCfgParams->msgRAMConfig.rxFIFO1waterMark = 64U;
    mcanCfgParams->msgRAMConfig.rxFIFO1OpMode = 64U;

    mcanCfgParams->eccConfig.enable = 1;
    mcanCfgParams->eccConfig.enableChk = 1;
    mcanCfgParams->eccConfig.enableRdModWr = 1;

    /*
    Simplify Interrupts for Debug:
    Temporarily set mcanCfgParams->errInterruptEnable = 0U; while debugging reception.
    Re-enable it later and ensure MCANAppErrStatusCallback handles errors correctly (clears flags).*/
    mcanCfgParams->errInterruptEnable = 1U;

    mcanCfgParams->dataInterruptEnable = 1U;
    mcanCfgParams->appErrCallBack = MCANAppErrStatusCallback;
    mcanCfgParams->appDataCallBack = MCANAppCallback;
}

/**************************************************************************
*************************** CAN Driver Initialize Function ***********************
**************************************************************************/
void Can_Initialize(void)
{
    int32_t errCode = 0;
    int32_t retVal = 0;
    CANFD_MCANInitParams mcanCfgParams;
    CANFD_MCANBitTimingParams mcanBitTimingParams;
    gTxDoneFlag = 0;
    gRxDoneFlag = 0;

    /* Setup the PINMUX to bring out the XWR68xx CANFD pins. */

    //Enable CAN transciever AOP
    // D3 RS-6843AOPC: There is an enable signal on the CAN transceiver that is connected to ball C2 on the IWR6843AOP.
    // *  PINE15_PADAG functionality
    // *  Equivalent to PINC2_PADAG on XWR68XXAOP Device
    Pinmux_Set_Pull(SOC_XWR68XX_PINE15_PADAG, PINMUX_PULLDOWN_EN);

    // Set TX pin
    // D3 RS-6843AOPC: CAN TX is on ball D1 of the IWR6843AOP.
    // *  PINE14_PADAE functionality
    // *  Equivalent to PIND1_PADAE on XWR68XXAOP Device
    Pinmux_Set_OverrideCtrl(SOC_XWR68XX_PINE14_PADAE, PINMUX_OUTEN_RETAIN_HW_CTRL, PINMUX_INPEN_RETAIN_HW_CTRL);
    Pinmux_Set_FuncSel(SOC_XWR68XX_PINE14_PADAE, SOC_XWR68XX_PINE14_PADAE_CANFD_TX);

    // Set RX pin
    // D3 RS-6843AOPC: RX is on F2.
    // *  PIND13_PADAD functionality
    // *  Equivalent to PINF2_PADAD on XWR68XXAOP Device
    Pinmux_Set_OverrideCtrl(SOC_XWR68XX_PIND13_PADAD,PINMUX_OUTEN_RETAIN_HW_CTRL, PINMUX_INPEN_RETAIN_HW_CTRL);
    Pinmux_Set_FuncSel(SOC_XWR68XX_PIND13_PADAD,SOC_XWR68XX_PIND13_PADAD_CANFD_RX);

     /* Configure the divide value for MCAN source clock */
    SOC_setPeripheralClock(gMmwMCB.socHandle, SOC_MODULE_MCAN, SOC_CLKSOURCE_VCLK, 4U, &errCode);

    /* Initialize peripheral memory */
    SOC_initPeripheralRam(gMmwMCB.socHandle, SOC_MODULE_MCAN, &errCode);

    CSL_FINSR(0x43201450, 22, 22, 0x1U);
    CSL_FINSR(0x4320140C, 26, 16, 0x23U);

    MCANAppInitParams (&mcanCfgParams);

    /* Initialize the CANFD 0 driver */
    canHandle = CANFD_init(0, &mcanCfgParams, &errCode);
    if (canHandle == NULL)
    {
        //init_print("Error: CANFD Module Initialization failed [Error code %d]\n", errCode);
        return;
    }

    /* Configuring 1Mbps and 1Mbps as nominal and data bit-rate respectively
     * Bit Rate = CAN_CLK / (k(PHSEG1 + PROPSEG + PHSEG2 + 1) * BRP)
        Prop seg: 8
        Ph seg 1: 6
        Ph Seg2 : 5
        Sync jump: 1
        BRP(Baud rate Prescaler): 2
        Nominal Bit rate = (40)/(((8+6+5)+1)*BRP) = 1Mhz
        Timing Params for Data Bit rate:
        Prop seg: 1
        Ph seg 1: 1
        Ph Seg2 : 1
        Sync jump: 1
        BRP(Baud rate Prescaler): 2
        Data Bit rate = (40)/(((1+1+1)+1)*BRP) = 5Mhz
    */
    // NOMINAL bit timings:
    // 500Kbps
    // mcanBitTimingParams.nomBrp      = 0x5U;
    // mcanBitTimingParams.nomPropSeg  = 0x6U;
    // mcanBitTimingParams.nomPseg1    = 0x5U;
    // mcanBitTimingParams.nomPseg2    = 0x4U;
    // mcanBitTimingParams.nomSjw      = 0x1U;

    // 1Mbps
    mcanBitTimingParams.nomBrp      = 0x2U;
    mcanBitTimingParams.nomPropSeg  = 0x8U;
    mcanBitTimingParams.nomPseg1    = 0x6U;
    mcanBitTimingParams.nomPseg2    = 0x5U;
    mcanBitTimingParams.nomSjw      = 0x3U;

    // DATA bit timings:
    // 2Mbps
    mcanBitTimingParams.dataBrp     = 0x1U;
    mcanBitTimingParams.dataPropSeg = 0x8U;
    mcanBitTimingParams.dataPseg1   = 0x9U;
    mcanBitTimingParams.dataPseg2   = 0x2U;
    mcanBitTimingParams.dataSjw     = 0x2U;


    /* Configure the CAN driver */
    retVal = CANFD_configBitTime (canHandle, &mcanBitTimingParams, &errCode);
    if (retVal < 0)
    {
        //init_print("Error: CANFD Module configure bit time failed [Error code %d]\n", errCode);
        return ;
    }

    /* Setup the transmit message object */
    txMsgObjectParams.direction = CANFD_Direction_TX;
    txMsgObjectParams.msgIdType = CANFD_MCANXidType_29_BIT;
    txMsgObjectParams.msgIdentifier = 0xD1;
    txMsgObjHandle = CANFD_createMsgObject (canHandle, &txMsgObjectParams, &errCode);
    if (txMsgObjHandle == NULL)
    {
        //init_print("Error: CANFD create Tx message object failed [Error code %d]\n", errCode);
        return ;
    }

    /* Setup the receive message object */
    rxMsgObjectParams.direction = CANFD_Direction_RX;
    rxMsgObjectParams.msgIdType = CANFD_MCANXidType_29_BIT;
    rxMsgObjectParams.msgIdentifier = 0xA0;
    rxMsgObjHandle = CANFD_createMsgObject (canHandle, &rxMsgObjectParams, &errCode);
    if (rxMsgObjHandle == NULL)
    {
        //init_print("Error: CANFD create Rx message object failed [Error code %d]\n", errCode);
        return ;
    }

    //init_print("Debug: CANFD Instance 0 Initialization was successful\n");
}

Hi, 

Thank you for sharing this valuable detailed information on the forum! Let me know if you are still facing any issues or if you have unrelated questions please feel free to create a new post. 

Best regards,

Josh