S32K144 FlexCAN1 probleme

[Chandler B. (chandler)]

Hallo,
ich habe einen S32K144EVB-Q100 -und möchte auf diesen FlexCAN1 
verwenden.
Ich habe dazu das Beispiel von FlexCAN0 genommen und überall CAN0 in 
CAN1 umbenannt.
Da der message Buffer für FlexCAN1 nicht so groß ist, habe ich hier 
weniger buffer mit 0 initialisirt.

Ich habe jetzt zwei Probleme.
1. Wenn ich zyklisch eine CAN-Nachricht schicken möchte, passiert 
nichts. Ich sehe noch nicht einmal etwas auf der CAN1_TX Leitung (dort 
hängt ein Logikanalyzer dran)

2. Laut dem Referenc Manual ist das Register PCC FlexCAN1 bei einem 
Offset von 94h (siehe FlexCAN1_Register.png)

Wenn ich in S32K144.h nachschaue, ist dort ein define

#define PCC_FlexCAN1_INDEX        37

Dies wird in der Initialisierung verwendet

  PCC->PCCn[PCC_FlexCAN1_INDEX] |= PCC_PCCn_CGC_MASK; /* CGC=1: enable clock to FlexCAN1 */

Wie passt das überein?

int main(void)
{
      /*!
       * Initialization:
       * =======================
       */
    WDOG_disable();        /* Disable WDOG */
    SOSC_init_8MHz();        /* Initialize system oscillator for 8 MHz xtal */
    SPLL_init_160MHz();      /* Initialize SPLL to 160 MHz with 8 MHz SOSC */
    NormalRUNmode_80MHz();   /* Init clocks: 80 MHz sysclk & core, 40 MHz bus, 20 MHz flash */
    FLEXCAN1_init();
    PORT_init();             /* Configure ports */
    LPSPI1_init_master();    /* Initialize LPSPI 1 as master */
    LPIT0_init();           /* Initialize PIT0 for 500 ms timeout */
    SBC_Init();
    lightInit_v();

    for(;;)
    {
        while (0 == (LPIT0->MSR & LPIT_MSR_TIF0_MASK)) {} /* Wait for LPIT0 CH0 Flag */
        toggleAnalyzePin_v();
        toggleLightPin_v(color);
        LPIT0->MSR |= LPIT_MSR_TIF0_MASK;               /* Clear Flag */
        FLEXCAN1_transmit_msg();
    }
}

PORT_init():

void PORT_init (void)
{
    /*!
     * Pins definitions
     * ===================================================
     *
     * Pin number        | Function
     * ----------------- |------------------
     * SPI
     * PTB14             | LPSPI1_SCK
     * PTB15             | LPSPI1_SIN
     * PTB16             | LPSPI1_SOUT
     * PTA6              | LPSPI1_PCS1
     *
     * GPIO
     * PTD16             | GPIO output [LED_GREEN]
     * PTD15             | GPIO output [LED_RED]
     *
     * CAN
     * PTA12             | CAN1_RX
     * PTA13             | CAN1_TX
     *
     */
    // SPI
    PCC->PCCn[PCC_PORTB_INDEX ]|=PCC_PCCn_CGC_MASK; /* Enable clock for PORTB */
    PORTB->PCR[14]|=PORT_PCR_MUX(3); /* Port B14: MUX = ALT3, LPSPI1_SCK */
    PORTB->PCR[15]|=PORT_PCR_MUX(3); /* Port B15: MUX = ALT3, LPSPI1_SIN */
    PORTB->PCR[16]|=PORT_PCR_MUX(3); /* Port B16: MUX = ALT3, LPSPI1_SOUT */
    //PORTB->PCR[17]|=PORT_PCR_MUX(3); /* Port B17: MUX = ALT3, LPSPI1_PCS3 */
    PCC->PCCn[PCC_PORTA_INDEX ]|=PCC_PCCn_CGC_MASK; /* Enable clock for PORTA */
    PORTA->PCR[6]|=PORT_PCR_MUX(3); /* Port A06: MUX = ALT3, LPSPI1_PCS3 */

    // GPIO
    PCC->PCCn[PCC_PORTD_INDEX ]|=PCC_PCCn_CGC_MASK; /* Enable clock for PORTD */
    PORTD->PCR[16]|=PORT_PCR_MUX(1); /* Port D16: MUX = ALT1, GPIO */
    PTD->PDDR |= 1<<16;               /* Port D16: Data Direction= output */
    PORTD->PCR[15]|=PORT_PCR_MUX(1); /* Port D16: MUX = ALT1, GPIO */
    PTD->PDDR |= 1<<15;               /* Port D16: Data Direction= output */
    PORTA->PCR[11]|=PORT_PCR_MUX(1); /* Port A11: MUX = ALT1, GPIO */
    PTA->PDDR |= 1<<11;               /* Port A11: Data Direction= output */
    PTA->PSOR |= 1<<11; // low

    // CAN
    PORTA->PCR[12] |= PORT_PCR_MUX(5);  /* Port A12: MUX = ALT5, CAN0_RX */
    PORTA->PCR[13] |= PORT_PCR_MUX(5); /* Port A13: MUX = ALT5, CAN0_TX */

}

[Manuel H. (Firma: Universität Tartu) (xenos1984)]

Chandler B. schrieb:
> Wenn ich in S32K144.h nachschaue, ist dort ein define#define
> PCC_FlexCAN1_INDEX        37
> Dies wird in der Initialisierung verwendet
> PCC->PCCn[PCC_FlexCAN1_INDEX] |= PCC_PCCn_CGC_MASK; /* CGC=1: enable
> clock to FlexCAN1 */
> Wie passt das überein?

Ich denke, die Register sind 4 byte breit. 37 \* 4 = 148 = 94h.

[Luca E. (derlucae98)]

Chandler B. schrieb:
> // CAN
>     PORTA->PCR[12] |= PORT_PCR_MUX(5);  /* Port A12: MUX = ALT5, CAN0_RX
> */
>     PORTA->PCR[13] |= PORT_PCR_MUX(5); /* Port A13: MUX = ALT5, CAN0_TX
> */

Der Port-Mux für CAN1 ist 3, nicht 5.

[Chandler B. (chandler)]

Luca E. schrieb:
> Der Port-Mux für CAN1 ist 3, nicht 5.

Ja, das wars :)
Danke für den Hinweis.

Senden funktioniert jetzt schonmal. Empfangen muss ich noch schauen. Ich 
schicke mir von CANoe die NAchricht direkt. Ich sehe die Nachricht auch 
auf der CAN_RX line, aber im Code kommt die irgendwie noch nicht an. Da 
muss ich nochmal weiterschauen.

[Chandler B. (chandler)]

Ich habe doch noch Probleme (Verständnisprobleme) zum Empfangen von den 
CAN-Nachrichten.

void FlexCAN1SendCanData(uint16_t id_u8, uint8_t* data_pu8, uint8_t lenght_u8)
{
    uint32_t word0 = 0;
    uint32_t word1 = 0;
    uint32_t word2 = 0;
    uint32_t word3 = 0;

    word0 = 0x0C400000 | (8 << CAN_WMBn_CS_DLC_SHIFT);  /* MB0 word 0 */
                                    /* bit 31: EDL=0: */
                                    /* bit 30: BRS=0: */
                                    /* bit 29: ESI=0: */
                                    /* bit 27-24: CODE=0xC: Activate tx */
                                    /* bit 22: SRR=1 Tx frame */
                                    /* bit 21: IDE=0: Standard ID */
                                    /* bit 20: RTR = 0*/
                                    /* bit19-16:DLC=8 */
                                    /* bit 15-0: TIME STAMP = 0 */
    word1 = ((uint32_t)id_u8 << 18); /* MB0 word 1 */
                      /* Tx msg with STD ID 0x555 */
                      /* bit 31-29: PRIO = 0 */
                      /* bit 28-18: ID (standard) = 0x555 */
                      /* bit 17-0: ID (extended) = 0x00 */

    word2 = data_pu8[0] | ((uint32_t)data_pu8[1] << 8) | ((uint32_t)data_pu8[2] << 16) | ((uint32_t)data_pu8[3] << 24); /* MB0 word 2 */
    word3 = data_pu8[4] | ((uint32_t)data_pu8[5] << 8) | ((uint32_t)data_pu8[6] << 16) | ((uint32_t)data_pu8[7] << 24); /* MB0 word 3 */


    CAN1->IFLAG1 = 0x00000001;  /* Clear CAN 1 MB 0 flag without clearing others*/
    CAN1->RAMn[ 0*MSG_BUF_SIZE + 1] = word1;
    CAN1->RAMn[ 0*MSG_BUF_SIZE + 2] = word2;
    CAN1->RAMn[ 0*MSG_BUF_SIZE + 3] = word3;
    CAN1->RAMn[ 0*MSG_BUF_SIZE + 0] = word0;
}

void FLEXCAN1_receive_msg(void)
{
  uint8_t j;
  uint32_t dummy;

  RxCODE   = (CAN1->RAMn[ 4*MSG_BUF_SIZE + 0] & 0x07000000) >> 24;  /* Read CODE field */
  RxID     = (CAN1->RAMn[ 4*MSG_BUF_SIZE + 1] & CAN_WMBn_ID_ID_MASK)  >> CAN_WMBn_ID_ID_SHIFT;  /* Read ID          */
  RxLENGTH = (CAN1->RAMn[ 4*MSG_BUF_SIZE + 0] & CAN_WMBn_CS_DLC_MASK) >> CAN_WMBn_CS_DLC_SHIFT; /* Read Message Length */

  for (j=0; j<2; j++)
  {  /* Read two words of data (8 bytes) */
    RxDATA[j] = CAN1->RAMn[ 4*MSG_BUF_SIZE + 2 + j];
  }
  RxTIMESTAMP = (CAN1->RAMn[ 4*MSG_BUF_SIZE + 0] & 0x000FFFF);
  dummy = CAN1->TIMER;             /* Read TIMER to unlock message buffers */
  CAN1->IFLAG1 = 0x00000010;       /* Clear CAN 1 MB 4 flag without clearing others*/
}

in main.c

    for(;;)
    {
        while (0 == (LPIT0->MSR & LPIT_MSR_TIF0_MASK)) {} /* Wait for LPIT0 CH0 Flag */
        LPIT0->MSR |= LPIT_MSR_TIF0_MASK;               /* Clear Flag */

        FlexCAN1SendCanData(0x123, canData_au8, 8);
        if ((CAN1->IFLAG1 >> 4) & 1)
        //if (CAN_IFLAG1_BUF4TO1I(4))
        {
            FLEXCAN1_receive_msg();
        }
    }

Mein Problem ist, dass das CAN_IFLAG1_BUF4TO1I(4) bit immer gesetzt ist, 
obwohl ich von außen gar keine CAN-Nachrichten sende.
Die Daten die ich dann auslese, sind die Daten aus Mailbox0, also das 
was ich sende.
Wird beim senden von Mailbox 0 das bit für Mailbox 4 gesetzt?
Das Bit lösche ich ja eigentlich wieder in FLEXCAN1_receive_msg();
Wie kann ich verhindern, dass beim Senden von Mailbox 0 das Bit für 
Mailbox 4 gesetzt wird?

[Luca E. (derlucae98)]

Chandler B. schrieb:
> Die Daten die ich dann auslese, sind die Daten aus Mailbox0, also das
> was ich sende.

Das ist wohl ganz normal beim FlexCAN-Modul. Der einzige mir bekannte 
Weg das zu verhindern, ist die eigenen IDs mit dem Empfangsfilter 
wegzufiltern, sodass sie dir die Message Buffer nicht zumüllen.

Chandler B. schrieb:
> Wie kann ich verhindern, dass beim Senden von Mailbox 0 das Bit für
> Mailbox 4 gesetzt wird?

Was spricht dagegen bei einer neuen Nachricht über alle Message Buffer 
zu iterieren und alle eingehenden Nachrichten zu verarbeiten? Mir war 
das zumindest immer egal, welcher Message Buffer zuerst gefüllt wurde.

Zur Inspiration: 
https://github.com/derlucae98/spr-bmu-firmware/blob/ee3239ad22018220fd7fe1fbe2be26231e18262b/driver/can.c#L147