AnsweredAssumed Answered

CAN4 register Access

Question asked by Rehan Khan on Jun 20, 2016
Latest reply on Jun 22, 2016 by Martin Kovar

Hi,

 

I am using sample CAN example to test FlexCAN. I have modified the code for CAN4 instead of CAN0. When I try to configure CAN4 registers It doesn't allow me to do that whereas CAN0 and CAN1 can be configured. Below is my code

 

/* main.c: FlexCAN program */

/* Description: Transmit one message from FlexCAN 0 buf. 0 to FlexCAN C buf. 1 */

/* Rev 0.1 Jan 16, 2006 S.Mihalik, Copyright Freescale, 2006. All Rights Reserved */

/* Rev 0.2 Jun 6 2006 SM - changed Flexcan A to C & enabled 64 msg buffers */

/* Rev 0.3 Jun 15 2006 SM - 1. Made globals uninitialized */

/*         2. RecieveMsg function:  read CANx_TIMER, removed setting buffer's CODE*/

/*         3. added idle loop code for smoother Nexus trace */

/*         4. modified for newer Freescale header files (r 16) */

/* Rev 0.4 Aug 11 2006 SM - Removed redundant CAN_A.MCR init */

/* Rev 0.5 Jan 31 2007 SM - Removed other redundant CAN_C.MCR init */

/* Rev 0.6 Mar 08 2007 SM - Corrected init of MBs- cleared 64 MBs, instead of 63 */

/* Rev 0.7 Jul 20 2007 SM - Changes for MPC5510 */

/* Rev 0.8 May 15 2008 SM - Changes for new header file symbols */

/* Rev 0.9 May 22 2009 SM - Changes for MPC56xxB/P/S */

/* Rev 1.0 Jul 10 2009 SM - Simplified, cleared CAN Msg Buf flag by writing to reg */

/*   not bit, increased Tx pads slew rate, changed RxCODE, RxLENGTH, dummy data types*/

/*   & init receiving CAN first to allow CAN bus sync time before receiving 1st msg*/

/* Rev 1.1 Mar 14 2010 SM - modified initModesAndClock, updated header file */

/*  NOTE!! structure canbuf_t in header file modified to allow byte addressing*/

 

 

#include "MPC5607B.h" /* Use proper include file */

 

 

uint32_t RxCODE;              /* Received message buffer code */

uint32_t RxID;                 /* Received message ID */

uint32_t RxLENGTH;            /* Recieved message number of data bytes */

uint8_t  RxDATA[8];            /* Received message data string*/

uint32_t RxTIMESTAMP;          /* Received message time */                        

 

 

void initModesAndClks(void) {

  ME.MER.R = 0x0000001D;          /* Enable DRUN, RUN0, SAFE, RESET modes */

                                  /* Initialize PLL before turning it on: */

/* Use 1 of the next 2 lines depending on crystal frequency: */

  CGM.FMPLL_CR.R = 0x02400100;    /* 8 MHz xtal: Set PLL0 to 64 MHz */  

/*CGM.FMPLL_CR.R = 0x12400100;*/  /* 40 MHz xtal: Set PLL0 to 64 MHz */  

  ME.RUN[0].R = 0x001F0074;       /* RUN0 cfg: 16MHzIRCON,OSC0ON,PLL0ON,syclk=PLL */

  ME.RUNPC[1].R = 0x00000010;  /* Peri. Cfg. 1 settings: only run in RUN0 mode */

  ME.PCTL[34].R = 0x01;           /* MPC56xxB/P/S FlexCAN4: select ME.RUNPC[1] */

  //ME.PCTL[17].R = 0x01;         /* MPC56xxB/S FlexCAN1:  select ME.RUNPC[1] */

  ME.PCTL[68].R = 0x01;           /* MPC56xxB/S SIUL:  select ME.RUNPC[1] */

                                  /* Mode Transition to enter RUN0 mode: */

  ME.MCTL.R = 0x40005AF0;         /* Enter RUN0 Mode & Key */

  ME.MCTL.R = 0x4000A50F;         /* Enter RUN0 Mode & Inverted Key */ 

  while (ME.GS.B.S_MTRANS) {}     /* Wait for mode transition to complete */   

                                  /* Note: could wait here using timer and/or I_TC IRQ */

  while(ME.GS.B.S_CURRENTMODE != 4) {} /* Verify RUN0 is the current mode */

}

 

 

void initPeriClkGen(void) {

  CGM.SC_DC0.R = 0x80;     /* MPC56xxB/S: Enable peri set 2 sysclk divided by 1 */

}

 

 

void disableWatchdog(void) {

  SWT.SR.R = 0x0000c520;     /* Write keys to clear soft lock bit */

  SWT.SR.R = 0x0000d928;

  SWT.CR.R = 0x8000010A;     /* Clear watchdog enable (WEN) */

}       

 

 

void initCAN_1 (void) {

  uint8_t   i;

 

  CAN_1.MCR.R = 0x5000003F;       /* Put in Freeze Mode & enable all 64 msg bufs */

  CAN_1.CR.R = 0x04DB0006;        /* Configure for 8MHz OSC, 100KHz bit time */

  for (i=0; i<64; i++) {

    CAN_1.BUF[i].CS.B.CODE = 0;   /* Inactivate all message buffers */

  }

  CAN_1.BUF[4].CS.B.IDE = 0;      /* MB 4 will look for a standard ID */

  CAN_1.BUF[4].ID.B.STD_ID = 555; /* MB 4 will look for ID = 555 */

  CAN_1.BUF[4].CS.B.CODE = 4;     /* MB 4 set to RX EMPTY */

  CAN_1.RXGMASK.R = 0x1FFFFFFF;   /* Global acceptance mask */

  SIU.PCR[42].R = 0x0624;         /* MPC56xxB: Config port C10 as CAN1TX, open drain */

  SIU.PCR[35].R = 0x0100;         /* MPC56xxB: Configure port C3 as CAN1RX */

  SIU.PSMI[0].R = 0x00;           /* MPC56xxB: Select PCR 35 for CAN1RX Input */

  CAN_1.MCR.R = 0x0000003F;       /* Negate FlexCAN 1 halt state for  64 MB */

}

 

 

void initCAN_4(void) {

  uint8_t   i;

 

  CAN_4.MCR.R = 0x5000003F;       /* Put in Freeze Mode & enable all 64 msg bufs */

  CAN_4.CR.R = 0x04DB0006;        /* Configure for 8MHz OSC, 100KHz bit time */

  for (i=0; i<64; i++) {

   CAN_4.BUF[i].CS.B.CODE = 0;   /* Inactivate all message buffers */

  }

  CAN_4.BUF[0].CS.B.CODE = 8;     /* Message Buffer 0 set to TX INACTIVE */

  SIU.PCR[37].R = 0x0A24;         /* MPC56xxB: Config port B0 as CAN0TX, open drain */

  //SIU.PCR[17].R = 0x0100;         /* MPC56xxB: Configure port B1 as CAN0RX */

  CAN_4.MCR.R = 0x0000003F;       /* Negate FlexCAN 0 halt state for 64 MB */

}

 

 

void TransmitMsg (void) {

  uint8_t i;

                                   /* Assumption:  Message buffer CODE is INACTIVE */

  const uint8_t TxData[] = {"Hello"};  /* Transmit string*/

  CAN_4.BUF[0].CS.B.IDE = 0;           /* Use standard ID length */

  CAN_4.BUF[0].ID.B.STD_ID = 555;      /* Transmit ID is 555 */

  CAN_4.BUF[0].CS.B.RTR = 0;           /* Data frame, not remote Tx request frame */

  CAN_4.BUF[0].CS.B.LENGTH = sizeof(TxData) -1 ; /* # bytes to transmit w/o null */

  for (i=0; i<sizeof(TxData); i++) {

    CAN_4.BUF[0].DATA.B[i] = TxData[i];      /* Data to be transmitted */

  }

  CAN_4.BUF[0].CS.B.SRR = 1;           /* Tx frame (not req'd for standard frame)*/

  CAN_4.BUF[0].CS.B.CODE =0xC;         /* Activate msg. buf. to transmit data frame */

}

 

 

void RecieveMsg (void) {

  uint8_t j;

  uint32_t dummy;

 

 

  while (CAN_1.IFRL.B.BUF04I == 0) {};  /* Wait for CAN 1 MB 4 flag */

  RxCODE   = CAN_1.BUF[4].CS.B.CODE;    /* Read CODE, ID, LENGTH, DATA, TIMESTAMP */

  RxID     = CAN_1.BUF[4].ID.B.STD_ID;

  RxLENGTH = CAN_1.BUF[4].CS.B.LENGTH;

  for (j=0; j<RxLENGTH; j++) {

    RxDATA[j] = CAN_1.BUF[4].DATA.B[j];

  }

  RxTIMESTAMP = CAN_1.BUF[4].CS.B.TIMESTAMP;

  dummy = CAN_1.TIMER.R;                /* Read TIMER to unlock message buffers */   

  CAN_1.IFRL.R = 0x00000010;            /* Clear CAN 1 MB 4 flag */

}

 

 

void main(void) {

  volatile uint32_t IdleCtr = 0;

 

  initModesAndClks();      /* Initialize mode entries */

  initPeriClkGen();        /* Initialize peripheral clock generation for DSPIs */

  disableWatchdog();       /* Disable watchdog */

//initCAN_1();             /* Initialize FLEXCAN 1 & one of its buffers for receive*/

  initCAN_4();             /* Initialize FlexCAN 4 & one of its buffers for transmit*/

  TransmitMsg();           /* Transmit one message from a FlexCAN 0 buffer */

  //RecieveMsg();            /* Wait for the message to be recieved at FlexCAN 1 */

  while (1) {              /* Idle loop: increment counter */

    IdleCtr++;              

  }

}

Outcomes