Hello everyone,

I got a strange communication issue between a master (XMC 4500) and more than one slave (XMC1201 + port expander card which communicates via SPI).
On my board it's possible to plug in 2 different cards on the same SPI-port (every card gets an chip select and the master toggles between them).

When the master communicates with one slave (MCP23S17 -> port expander card), the waveform of the MISO looks like expected (image below).


The problem starts when the master communicates with both cards -> port expander card and an additional XMC1201 in slave mode (SPI003-app was used).
This looks like the slave is pulling up the MISO-line very strong and the MCP23S17 can't pull the line to ground when it gets the /CS. So the master thinks, due to the wrong voltage level, that the slave sends 0xFF instead of 0x00.



I'm not sure what I can do to prevent this behaviour. In a workaround I could configure the MISO-line to tristate when the end-of-message interrupt occures and reconfigure it at the start of the message (not really smart imho). This could prevent data corruption for other cards.

Thanks in advance for any help !

best regards
Sebastian Show Less

Hello.

Just wanted to check if anyone else is seeing this problem.

We have set up a Gateway node connecting 2 CANnets.
Since the HW Gateway has it quirks http://see https://www.infineonforums.com/threads/5360-Problems-with-FIFO-Gateway-on-XMCs-4400-Multican?, we opted for setting up 4 RX FIFOs and let the irq routines do the data shuffling.

This scheme works almost OK, but we are experiencing MSGLST from a MO in the RXFIFO even though the FIFO is not full.
The CAN_RXOF irq is enabled (and tested OK), but is not asserted in these MSGLST cases.
Fault rate is about 1-2 messages in about 40 millions, so the FIFOs wrapps around numerous times. We also have a FIFO highwater-mark monitor, and it shows that the FIFO is filled with max 2 unread messages at the time MSGLST is set.
FIFO sizes vary from 8 to 20 MOs.
Have also implemented a test command where the RX irq routine can skip n readouts, hence filling the FIFO, and that also works fine. Next irq that reads, empties the FIFO.

We are using the MSIMASK/MSID HW registers to find out which FIFO to read from.

In all the multiCAN examples we have come across, there is no examples on how to empty multiple RXFIFO using the MSIMASK/MSID HW registers.

Hoping someone can chime in on this one.

Here is our irq routine:

    bool receive(CanMessage* msg)
    {
        uint32_t pendingIndex;
        int i;
//        printf("%s:\n", m_owner);
//        printf("MSPND:   %08x %08x\n", CAN->MSPND[1], CAN->MSPND[0]);
//        printf("MSIMASK: %08x %08x\n", m_msimask[1], m_msimask[0]);

        if (m_irqOwner != (uint32_t)(PPB->ICSR & PPB_ICSR_VECTACTIVE_Msk) - 16) {
            Can *can = Can::getInstance();
            can->s_wrongIRQ++;
            return false;
        }

        for (i=0; i<2; i++) {
            CAN->MSIMASK = m_msimask;
            pendingIndex = CAN->MSID;
//            printf("%-15s[%d] %d\n", "pendingIndex", i, pendingIndex);

            if (pendingIndex == CAN_MSI_NO_PENDING) {
                if (i == 1) {
                    return false;
                }
                else {
                    continue;
                }
            }
            CLR_BIT(CAN->MSPND, pendingIndex);
            pendingIndex += 32*i;
            break;
        }
//        printf("%-15s %d\n", "pendingIndex", pendingIndex);
        uint8_t baseIndex = m_messageObjects.front().getNumber();
        XMC_CAN_MO_t* baseMoPtr = m_messageObjects.front().getMoPtr();
        XMC_CAN_FIFO_SetSELMO(baseMoPtr, pendingIndex);
        //printf("%-15s %d\n", "baseIndex", baseIndex);        
        return m_messageObjects[pendingIndex - baseIndex].receive(msg);
    }

    bool receive(CanMessage* msg)
    {
        uint32_t mo_message_lost = (uint32_t)((m_xmcCanMo.can_mo_ptr->MOSTAT) & CAN_MO_MOSTAT_MSGLST_Msk) >> CAN_MO_MOSTAT_MSGLST_Pos;
checkAgain:
        m_xmcCanMo.can_mo_ptr->MOCTR = CAN_MO_MOCTR_RESNEWDAT_Msk | CAN_MO_MOCTR_RESRXPND_Msk; // reset NEWDAT & RXPND

        if ((((m_xmcCanMo.can_mo_ptr->MOAR) & CAN_MO_MOAR_IDE_Msk) >> CAN_MO_MOAR_IDE_Pos) == 1U) { // 29-bit ID
            uint32_t identifier = (m_xmcCanMo.can_mo_ptr->MOAR & CAN_MO_MOAR_ID_Msk);
            newCanMessage(msg, identifier & 0x000000ff);
            msg->size       = (uint8_t)((uint32_t)((m_xmcCanMo.can_mo_ptr->MOFCR) & CAN_MO_MOFCR_DLC_Msk) >> CAN_MO_MOFCR_DLC_Pos);
            msg->identifier = identifier;
            msg->nodeNum    = (identifier & 0x0000ff00) >> 8;
            uint32_t* dataPtr = reinterpret_cast(msg->data);
            if (msg->size > 0) {
                dataPtr[0] = m_xmcCanMo.can_mo_ptr->MODATAL;
            }
            if (msg->size > 4) {
                dataPtr[1] = m_xmcCanMo.can_mo_ptr->MODATAH;
            }
        }

        uint32_t mo_new_data_available = (uint32_t)((m_xmcCanMo.can_mo_ptr->MOSTAT) & CAN_MO_MOSTAT_NEWDAT_Msk) >> CAN_MO_MOSTAT_NEWDAT_Pos;
        uint32_t mo_recepcion_ongoing = (uint32_t)((m_xmcCanMo.can_mo_ptr->MOSTAT) & CAN_MO_MOSTAT_RXUPD_Msk) >> CAN_MO_MOSTAT_RXUPD_Pos;

        if ((mo_new_data_available) || (mo_recepcion_ongoing)) {
            Can::s_checkedAgain++;
            goto checkAgain;
        }

        if (mo_message_lost) {
            m_xmcCanMo.can_mo_ptr->MOCTR = CAN_MO_MOCTR_RESMSGLST_Msk; // reset lost bit
            if (Can::s_gatewayEnabled) {
                if ((m_number>=CAN_RX12_MOSTART) && (m_number<=CAN_RX12_MOEND)) {
                    Can::s_lostCntr1++;
                } else {
                    if ((m_number>=CAN_RX2_MOSTART) && (m_number<=CAN_RX2_MOEND)) {
                        Can::s_lostCntr2++;
                    }
                }
            } else {
                if ((m_number>=CAN_RX_MOSTART) && (m_number<=CAN_RX_MOEND)) {
                    Can::s_lostCntr1++;
                }
            }
            //            panic_printf(PANIC_USER, "CAN MSG LOST, MO%02d, idle %d%%", m_number, getIdlePercent());
            ////            panic_printf(PANIC_USER, "LOST MO%02d %08x %08x", m_number, CAN->MSPND[1], CAN->MSPND[0]);
            ////            printf("\n\nLOST MO%02d %08x %08x\n\n", m_number, CAN->MSPND[1], CAN->MSPND[0]);
            //            return false;
        }


        //        if (mo_recepcion_ongoing) {
        //            panic_printf(PANIC_USER, "CAN MSG RX BUSY, MO%02d", m_number);
        //        }

        return true;
    }

(Also opened a support case: Case:3740999) Show Less