main.c

基于芯片MC9S12DG128 开发的CAN测试程序

#include <hidef.h>      /* common defines and macros */
#include <mc9s12dg128.h>     /* derivative information */
#pragma LINK_INFO DERIVATIVE "mc9s12dg128b"

#define NO_ERR 0x00
#define ERR_BUFFER_FULL 0x80
unsigned char IntFlag,Tick,CanTxTrmCnt; 
void CAN0Init(void) 
{
    CAN0CTL0 = 0x01;                                                                
    while (!(CAN0CTL1&0x01)){};
    CAN0CTL1 = 0x80;               
    CAN0BTR0 = 0xC3;           
    CAN0BTR1 = 0x3A;	         
    CAN0IDAC = 0x20;

    CAN0CTL0 = 0x00;                    /* Exit Initialization Mode Request */
    while ((CAN0CTL1&0x00) != 0){};   	/* Wait for Normal Mode */    
    while(!(CAN0CTL0&0x10));            /* Wait for Synchronization */   
    CAN0RFLG = 0xC3;
    CAN0RIER = 0x01;
}

void CAN4Init(void) 
{
    CAN4CTL0 = 0x01;                                                                
    while (!(CAN4CTL1&0x01)){};
    CAN4CTL1 = 0x80;               
    CAN4BTR0 = 0xC3;           
    CAN4BTR1 = 0x3A;	         
    CAN4IDAC = 0x20;
    CAN4CTL0 = 0x00;                    /* Exit Initialization Mode Request */
    while ((CAN4CTL1&0x00) != 0){};   	/* Wait for Normal Mode */    
    while(!(CAN4CTL0&0x10));            /* Wait for Synchronization */   
    CAN4RFLG = 0xC3;
    CAN4RIER = 0x01;
}
byte  CAN0SendFrame(word id, byte priority,byte length, byte *txdata )
{     
    byte index;
    byte CanTxBufer;

    if (!CAN0TFLG)                                /* Is Transmit Buffer full??  */
    {      
        return ERR_BUFFER_FULL;
    }
    CAN0TBSEL = CAN0TFLG;                         /* Select lowest empty buffer */
    CanTxBufer = CAN0TBSEL;		                    /* Backup selected buffer     */
    
    /* Load Id to IDR Registers */
    *((word *) ((word)(&CAN0TXIDR0)))= id;
        
    for (index=0;index<length;index++) 
    {
        *(&CAN0TXDSR0 + index) = txdata[index];   /* Load data to Tx buffer 
                                                   * Data Segment Registers     */
    } 
    CAN0TXDLR = length;                           /* Set Data Length Code       */
    CAN0TXTBPR = priority;                        /* Set Priority               */

    CAN0TFLG = CanTxBufer;	                      /* Start transmission         */                                                
    while ( (CAN0TFLG & CanTxBufer) != CanTxBufer)/* Wait for Transmission 
                                                   * completion                 */
    {
      if(CanTxTrmCnt==0)  break;
    }
    return NO_ERR;
}
byte  CAN4SendFrame(word id, byte priority,byte length, byte *txdata )
{     
    byte index;
    byte CanTxBufer;

    if (!CAN4TFLG)                                /* Is Transmit Buffer full??  */
    {      
        return ERR_BUFFER_FULL;
    }
    CAN4TBSEL = CAN4TFLG;                         /* Select lowest empty buffer */
    CanTxBufer = CAN4TBSEL;		                    /* Backup selected buffer     */
    
    /* Load Id to IDR Registers */
    *((word *) ((word)(&CAN4TXIDR0)))= id;
        
    for (index=0;index<length;index++) 
    {
        *(&CAN4TXDSR0 + index) = txdata[index];   /* Load data to Tx buffer 
                                                   * Data Segment Registers     */
    } 
    CAN4TXDLR = length;                           /* Set Data Length Code       */
    CAN4TXTBPR = priority;                        /* Set Priority               */

    CAN4TFLG = CanTxBufer;	                      /* Start transmission         */                                                
    while ( (CAN4TFLG & CanTxBufer) != CanTxBufer)/* Wait for Transmission 
                                                   * completion                 */
    {
      if(CanTxTrmCnt==0)  break;
    } 
    return NO_ERR;
}
#pragma CODE_SEG NON_BANKED
void interrupt MDC_ISR(void)
{
  MCFLG_MCZF=1;
  IntFlag=1; 
  if(CanTxTrmCnt!=0) CanTxTrmCnt--; 
}
void interrupt CAN0RxISR(void) 
{
  byte  length, i;
  byte  RxData[8];
  union {
      unsigned char Bytes[2];
      unsigned int  Word;
  } CanIDR;
  /*数据接收  */
  length = (CAN0RXDLR & 0x0F);
	for (i=0; i<length; i++)
  	 RxData[i] = *(&CAN0RXDSR0 + i);          
  CanIDR.Bytes[0]=CAN0RXIDR0;                 
  CanIDR.Bytes[1]=CAN0RXIDR1 & 0xE0;
  CAN0RFLG = 0x01;
}
void interrupt CAN4RxISR(void) 
{
  byte  length, i;
  byte  RxData[8];
  union {
      unsigned char Bytes[2];
      unsigned int  Word;
  } CanIDR;
  /*数据接收  */
  length = (CAN4RXDLR & 0x0F);
	for (i=0; i<length; i++)
  	 RxData[i] = *(&CAN4RXDSR0 + i);          
  CanIDR.Bytes[0]=CAN4RXIDR0;                 
  CanIDR.Bytes[1]=CAN4RXIDR1 & 0xE0;
  CAN4RFLG = 0x01;
}
#pragma CODE_SEG DEFAULT
void main(void) {
  byte  errorflag,i,bytes[8];
  DDRM_DDRM2=1;
  CAN0Init();
  CAN4Init();
  TIOS = 0x00;   //通道0-7为输入捕捉
  TCTL4 = 0x02;  //通道0下降沿捕捉
  TFLG1 = 0xFF;  //中断标志位清零  
  TIE = 0x00;    //使能捕捉中断
  TSCR2=0x4;
  TSCR1_TEN=1;
  MCCTL=0xC5;
  MCCNT=5000; //5ms 
  /* put your own code here */
  EnableInterrupts;
  for(i=0;i<8;i++)    bytes[i]=0x55;
  for(;;) {
    
    /* please make sure that you never leave this function */
    if(IntFlag==1){                         
          IntFlag=0;
          if(Tick!=0) Tick--;
          else{
            Tick=40;
            PTM_PTM2=!PTM_PTM2;       
            errorflag = CAN0SendFrame(0x0A00, 0, 8, bytes);
            errorflag = CAN4SendFrame(0x0C00, 0, 8, bytes);
          }
     }
  }
}