S32K144 nicht jede CAN Nachricht wird versendet

[Chandler B. (chandler)]

Hallo,
ich habe ein S32K144EVB-Q100. Hier habe ich noch einmal Probleme mit dem 
CAN1.
Prinzipiell funktioniert es. Nur es werden nicht alle Nachrichten 
gesendet.
Nach dem Aufstarten lese ich mir ein Paar Daten aus und möchte diese 
über CAN1 verschicken.

uint8_t canData1_au8[8] = {0};
uint8_t canData2_au8[8] = {0};
uint8_t canData3_au8[8] = {0};
... ... ...
... ... ...
FlexCAN1SendCanData(0x122, canData1_au8, 8);
FlexCAN1SendCanData(0x123, canData2_au8, 8);
FlexCAN1SendCanData(0x124, canData3_au8, 8);

void FLEXCAN1_init(void)
{
#define MSG_BUF_SIZE  4     /* Msg Buffer Size. (CAN 2.0AB: 2 hdr +  2 data= 4 words) */
  uint32_t   i=0;

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

  CAN1->MCR |= CAN_MCR_MDIS_MASK;         /* MDIS=1: Disable module before selecting clock  */
  CAN1->CTRL1 &= ~CAN_CTRL1_CLKSRC_MASK;  /* CLKSRC=0: Clock Source = SOSCDIV2              */
  CAN1->MCR &= ~CAN_MCR_MDIS_MASK;        /* MDIS=0; Enable module config. (Sets FRZ, HALT) */

  while (!((CAN1->MCR & CAN_MCR_FRZACK_MASK) >> CAN_MCR_FRZACK_SHIFT))  {}
  CAN1->CTRL1 = 0
      |CAN_CTRL1_PSEG2(3)       /* Configure for 500 KHz bit time */
          |CAN_CTRL1_PSEG1(3)       /* Time quanta freq = 16 time quanta x 500 KHz bit time= 8MHz   */
          |CAN_CTRL1_PROPSEG(6)     /* PRESDIV+1 = Fclksrc/Ftq=8 MHz/8 MHz*/
          |CAN_CTRL1_RJW(3)         /*    so PRESDIV = 0    */
          |CAN_CTRL1_SMP(1);        /* PSEG2 = Phase_Seg2 - 1 = 4 - 1 = 3 */
                                            /* PSEG1 = PSEG2 = 3 */
                                    /* PROPSEG= Prop_Seg - 1 = 7 - 1 = 6 */
                                    /* RJW: since Phase_Seg2 >=4, RJW+1=4 so RJW=3.                 */
                                    /* SMP = 1: use 3 bits per CAN sample */
                                    /* CLKSRC=0 (unchanged): Fcanclk= Fosc= 8 MHz                   */

  for(i=0; i<64; i++ )
  {                     /* CAN1: clear 16 msg bufs x 4 words/msg buf = 64 words */
    CAN1->RAMn[i] = 0;  /* Clear msg buf word */
  }
  for(i=0; i<16; i++ )
  {                                 /* In FRZ mode, init CAN1 16 msg buf filters */
    //CAN1->RXIMR[i] = 0xFFFFFFFF;      /* Check all ID bits for incoming messages */
    CAN1->RXIMR[i] = 0x00000000;    /* Check No ID bits for incoming messages */
  }
  //CAN1->RXMGMASK = 0x1FFFFFFF;                /* Global acceptance mask: check all ID bits    */
  CAN1->RXMGMASK = 0x00000000;                  /* Global acceptance mask: check no ID bits     */

  CAN1->RAMn[ 4*MSG_BUF_SIZE + 0] = 0x04000000; /* Msg Buf 4, word 0: Enable for reception  */
                                                /* EDL,BRS,ESI=0: */
                                                /* CODE=4: */
                                                /* IDE=0 */
                                                /* SRR, RTR, TIMESTAMP=0*/

   CAN1->RAMn[ 4*MSG_BUF_SIZE + 1] = 0x14440000;
                                                /* Msg Buf 4, word 1*/
                                                /* PRIO=0: CANFD not used */

  CAN1->MCR = 0x0000001F;                       /* Negate FlexCAN 1 halt state for 32 MBs */

  while ((CAN1->MCR && CAN_MCR_FRZACK_MASK) >> CAN_MCR_FRZACK_SHIFT)  {}
  /* Good practice: wait for FRZACK to clear (not in freeze mode) */

  while ((CAN1->MCR && CAN_MCR_NOTRDY_MASK) >> CAN_MCR_NOTRDY_SHIFT)  {}
  /* Good practice: wait for NOTRDY to clear (module ready) */
}


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*/
                                                        /* bit 22: SRR=1 */
                                                        /* bit 21: IDE=0 */
                                                        /* bit 20: RTR=0*/
                                                        /* bit 19-16: DLC=8*/
                                                        /* bit 15-0: TIMESTAMP */
    word1 = ((uint32_t)id_u8 << 18); /* MB0 word 1 */
              /* Tx msg with STD ID  */
                                        /* bit 31-29: PRIO = 0 */
                                        /* bit 28-18: ID (standard) */
                                        /* bit 17-0: ID (extended) */

    word2 = ((uint32_t)data_pu8[0] << 24) 
              | ((uint32_t)data_pu8[1] << 16)
              | ((uint32_t)data_pu8[2] << 8)
              | ((uint32_t)data_pu8[3] << 0); /* MB0 word 2 */
    word3 = ((uint32_t)data_pu8[4] << 24)
              | ((uint32_t)data_pu8[5] << 16)
              | ((uint32_t)data_pu8[6] << 8)
              | ((uint32_t)data_pu8[7] << 0); /* 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; // CODE is written here to activate transmission
}

Die Nachrichten gehen nicht aus dem S32K144 heraus. Ich sehe die 
Nachrichten auch nicht auf der CAN1_TX-Leitung. Dort habe ich einen 
Logikanalyzer dran hängen.

[Alexander (alecxs)]

Beitrag "S32K144 FlexCAN1 probleme"

[Jens G. (jensig)]

Chandler B. schrieb:
> Nach dem Aufstarten lese ich mir ein Paar Daten aus und möchte diese
> über CAN1 verschicken.

Vielleicht klemmt es ja schon an diesem Auslesen der Daten ...

[Luca E. (derlucae98)]

Chandler B. schrieb:
> Nur es werden nicht alle Nachrichten gesendet.

Immer nur die erste?

Du schreibst drei mal hintereinander in den selben message buffer. Der 
MB ist solange blockiert, bis die Nachricht rausgeht.
Wenn am Bus nur ein Logic Analyzer hängt, blockiert der für immer, weil 
die Nachricht nicht mit einem ACK auf dem Bus bestätigt wird.

[Luca E. (derlucae98)]

Ergänzend zu meinem letzten post: Schau dir doch mal das CODE Feld im 
Message buffer an. Das sollte in deinem Fall immer 0b1100 bleiben.

Bevor du die nächste Nachricht sendest, solltest du warten bis CODE = 
0b1000 (Inactive) wird bzw. den entsprechenden Interrupt nutzen.
Alternativ kannst du auch über deine MBs iterieren und den nächsten 
freien benutzen. Dann kümmert sich der CAN-Controller darum, dass alle 
Nachrichten zeitnah rausgehen.
Das alles funktioniert aber wie gesagt nur, wenn mindestens ein weiterer 
Teilnehmer am Bus hängt, der die Nachrichten bestätigt.

Der ganze Prozess ist im Reference Manual unter 55.5.1 Transmit process 
beschrieben.