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.