can_ex1.c

can bus 源代码

/*----------------------------------------------------------------------------
 *      A R T X   C A N   D r i v e r   E x a m p l e   1
 *----------------------------------------------------------------------------
 *      Name:    CAN_Ex1.c
 *      Purpose: ARTX CAN Driver usage example
 *      Rev.:    V0.20 / october-14-2005
 *----------------------------------------------------------------------------
 *      This code is part of the ARTX-ARM kernel package of Keil Software.
 *      Copyright (c) 2004-2005 Keil Software. All rights reserved.
 *---------------------------------------------------------------------------*/

#include <ARTX.h>                     /* ARTX kernel functions & defines     */
#include <LPC21xx.h>                  /* LPC21xx definitions                 */
#include "ARTX_CAN.h"                 /* CAN Generic functions & defines     */ 


#include		"..\Source\RTOS.h"


#define			ONLY_CAN_PROG			0

#if(ONLY_CAN_PROG)

#define     NOP()      __asm{NOP}
#define		RESET_WATCH_DOG		{ IODIR0 |= (1<<11); NOP();   NOP();\
											  IOCLR0 |= (1<<11); NOP();	NOP();\
											  IOSET0 |= (1<<11); NOP();	NOP();\
											  IOCLR0 |= (1<<11); NOP();	NOP();\
											  IOSET0 |= (1<<11); NOP();	NOP();\
											} ;

#endif


OS_TID tsk1;                          /* Assigned identification for task 1  */
OS_TID tsk2;                          /* Assigned identification for task 1  */

void task_send_CAN (void) __task;     /* Task that sends CAN message         */
void task_rece_CAN (void) __task;     /* Task that receives CAN message      */


unsigned short	Can2RxOK;

unsigned char	PutBuffer(unsigned char,unsigned short,unsigned char*);


unsigned char get_AD (void);          /* A/D potentiometer value readout     */

/*----------------------------------------------------------------------------
 *  LED Functions
 *---------------------------------------------------------------------------*/

void LED_Init (void) {
  
}

void LED_Byte (unsigned char LED_state) 
{
	LED_state = 0;
  
}

/*
01 00 00 00 	01 00 00 00 
3C 00 00 00    3C 00 00 00 
00 00 00 00    00 00 00 00 
00 00 00 00    00 00 00 00 
00 00 1C 00    00 00 1C 00 
60 00 00 00    60 00 00 00 
3C 3C 3C 00    3C 3C 3C 00 
00 00 00 00    00 00 00 00 
00 00 00 00    00 00 00 00 
00 00 0D 0A    00 00 0D 0A 
 16:20:12★     16:26:58★ 
 	*/

unsigned long		CanRegStatus[10];

void			GetCanRegValue(void)
{
	unsigned long  i;
	#if(CAN_TEST_REG_VALUE_TO_UART0)
   os_dly_wait(3);
   i = 0;  
   CanRegStatus[i++] = C1MOD;
   CanRegStatus[i++] = C1GSR;
   CanRegStatus[i++] = C1ICR;
   CanRegStatus[i++] = C1IER;
   CanRegStatus[i++] = C1BTR;
   CanRegStatus[i++] = C1EWL;
   CanRegStatus[i++] = C1SR;
   CanRegStatus[i++] = C1RFS;
   CanRegStatus[i++] = C1RID;
   
   
   /*
   CanRegStatus[i++] = C2MOD;
   CanRegStatus[i++] = C2GSR;
   CanRegStatus[i++] = C2ICR;
   CanRegStatus[i++] = C2IER;
   */
   
   CanRegStatus[i++] = 0x0a0d0000;
   
   PutBuffer(1,(i<<2),(unsigned char *)CanRegStatus);
   
   #endif
}


#if(0)

void			CanInit(void)
{
	PINSEL1 &= 0xFFEBFFFF;            /* Reset CAN1 bits                     */
   PINSEL1 |= 0x00040000;            /* Set CAN1 bits to 01                 */

   /* Set interrupt vector for Tx1                                          */
   *(&VICVectAddr0 + VIC_NUM_CTRL1_TX) = (unsigned long) CAN_TX1_ISR;
   *(&VICVectCntl0 + VIC_NUM_CTRL1_TX) = 0x20 | 20;
   /* Set interrupt vector for Rx1                                          */
   *(&VICVectAddr0 + VIC_NUM_CTRL1_RX) = (unsigned long) CAN_RX1_ISR;       
   *(&VICVectCntl0 + VIC_NUM_CTRL1_RX) = 0x20 | 26;
   VICIntEnable |= 0x04100000;      
   /////////////////////////////////////////
   C1MOD = 0x01;		// 复位
   C1EWL = 0x60;		// 错误报警界限
   C1BTR = CAN_calc_baudrate(500000);
   C1IER = 0x0603;	// 中断使能
   AFMReg = 0x02;
   C1MOD = 0x80;
   
}

#endif

unsigned char        PutString(unsigned char  *p);

/*
typedef struct  {
  U32 id;                 
  U8  data[8];            
  U8  len;                
  U8  ch;                 
  U8  format;             
  U8  type;               
}  CAN_msg;
*/

unsigned long		Can2TxInt;




CAN_ERROR CAN_hw_init (U32 ctrl, U32 baudrate);

/*----------------------------------------------------------------------------
 *  Task 1:  Sends message with AD value in data[0] over CAN periodically
 *---------------------------------------------------------------------------*/
unsigned short		CanID = 0;
void task_send_CAN (void) __task  
{
	unsigned char		CanStatus;
	
	
  /* Initialize message  = { ID, {data[0] .. data[7]}, LEN, CHANNEL, FORMAT, TYPE } */
  CAN_msg msg_send       = { 33, {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'},   
                              1, 2, STANDARD_FORMAT, DATA_FRAME };
  os_dly_wait(1);
  CAN_init (1, 500000);               /* CAN controller 1 init, 500 kbit/s   */
  CAN_init (2, 500000);               /* CAN controller 2 init, 500 kbit/s   */

	//CanInit();


	


	CAN_hw_init(1,500000);
	CAN_hw_init(2,500000);

  /* Transmit object does not have to be enabled but channel has to be 
     reserved for tansmitting, in this example channel 1 is reserved for 
     transmission                                                            */

  CAN_rx_object (1, 2,  33, STANDARD_FORMAT); /* Enable reception of         */
                                      /* message on controller 1, channel is */
                                      /* not used for LPC (can be set to     */
                                      /* whatever value), with standard id 33*/
  CAN_start (1);                      /* Start controller 1                  */
  CAN_start (2);                      /* Start controller 2                  */

  //tsk1 = os_tsk_self ();              /* Get own task identification number  */
  tsk2 = os_tsk_create (task_rece_CAN, TASK_CAN_REC);  /* Start receive task            */

  for (;;)  
  {
    msg_send.data[0] = get_AD ();     /* Data[0] field = analog value from   */
    
	#if(ONLY_CAN_PROG) 
	 RESET_WATCH_DOG;                                 /* potentiometer                       */
	 #endif
		CanID++;
	msg_send.id = CanID;
	
	#if(1)
	os_dly_wait(1);
	Can2TxInt = 0;
	CanStatus = CAN_send (2, &msg_send, 0x0f00);
	os_dly_wait(1);	
	
	#if(0)//CAN_TEST_STATUS_TO_UART0)
    if((CanStatus == CAN_OK))//&&(Can2TxInt == 0x55aa))	  /* Send msg_send on controller 2       */   
  		PutString("Can send OK!\r\n\0"); 
    else
    	PutString("Can send task running!\r\n\0");
   #endif 	
    #endif
    
   GetCanRegValue();
   
    
    os_dly_wait (100);                /* Wait 1 second                       */    
  }
}


/*----------------------------------------------------------------------------
 *  Task 2:  Turns on the LEDs according to data[0] of received CAN message
 *---------------------------------------------------------------------------*/

void task_rece_CAN (void) __task  
{
  CAN_msg 		msg_rece;

  for (;;)  
  {
    /* When message arrives activate LED for value in data[0] of              
       arrived message                                                       */
    #if(CAN_TEST_STATUS_TO_UART0)
    
    
    if(Can2RxOK == 0x55aa)    
    {
    	Can2RxOK = 0;
    	PutString("Can2RxOK==0x55aa!\r\n\0");
    }
    os_dly_wait(2);
    if (CAN_receive (2, &msg_rece, 0x00FF) == CAN_OK)  
    {
      	LED_Byte (msg_rece.data[0]);
      	PutString("Can receive OK!\r\n\0");
    }
    else
    {
    	PutString("Can receive task running!\r\n\0");
   }
   #else
   CAN_receive (1, &msg_rece, 0x00FF);
   #endif
    
  }
}




/*----------------------------------------------------------------------------
 *  Function for getting the AD conversion
 *---------------------------------------------------------------------------*/

unsigned char get_AD (void) 
{
	#if(0)
  unsigned int val;

  ADCR |= 0x01000000;                 /* Start A/D Conversion                */

  do  {
    val = ADDR;                       /* Read A/D Data Register              */
  } 
  while ((val & 0x80000000) == 0);    /* Wait for end of A/D Conversion      */

  ADCR &= ~0x01000000;                /* Stop A/D Conversion                 */
  val = (val >> 8) & 0xFF;            /* Extract AIN0 Value                  */
	#endif
  return 100;
}

#if(ONLY_CAN_PROG)
/*----------------------------------------------------------------------------
 *        Main: Initialize and start ARTX Kernel
 *---------------------------------------------------------------------------*/

void main (void)  {                   /* Program execution starts here       */
  ADCR   = 0x00270401;                /* Setup A/D: 10-bit AIN0 @ 3MHz       */

  LED_Init ();                        /* Initialize LED                      */
  LED_Byte (0);                       /* Turn the LED off                    */

  os_sys_init (task_send_CAN);        /* Initialize and start task 1         */
}

#else





#endif


/*----------------------------------------------------------------------------
 * end of file
 *---------------------------------------------------------------------------*/