canbus.c

英贝德ebd9200-I开发板linux下CAN测试程序(MCP2510)

#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>

#include "mcp2510.h"

#define	WRITE_COM		1
#define	READ_COM		2
#define	RESET_COM		3
#define	BWM_COM			4
#define	RTS_COM			5

static struct mcp2510_local mcpFrame;
static int fd0;
static int fd1;

static char k=0;
static char dlc, extF, rtr;	
static unsigned long ID;

void WriteData(char Addr,char* data,int size,int fd)
{
	mcpFrame.len = size;
	mcpFrame.addr = Addr;
	mcpFrame.pData = data;
	ioctl(fd, WRITE_COM, &mcpFrame);
}

void ReadData(char Addr,char* data,int size,int fd)
{	
	mcpFrame.len = size;
	mcpFrame.addr = Addr;
	mcpFrame.pData = data;
	ioctl(fd, READ_COM, &mcpFrame);
}

void WriteBits( char Addr, char mask, char data,int fd)
{
	char command[2];
	command[0]=mask;
	command[1]=data;

	mcpFrame.len = 2;
	mcpFrame.addr = Addr;
	mcpFrame.pData = command;
	ioctl(fd, BWM_COM, &mcpFrame);
}

void WriteRTS(char cmd,int fd)
{
	mcpFrame.addr = cmd;
	ioctl(fd, RTS_COM, &mcpFrame);
}

void MCP2510_Reset(int fd)
{
	mcpFrame.len = 0;
	ioctl(fd, RESET_COM, &mcpFrame);
}
void mcp_read_can_id( char mcp_addr,char* ext,unsigned long* can_id,int fd)
{
    char tbufdata[4];
    *ext = 0;
    *can_id = 0;
	ReadData(mcp_addr,tbufdata,4,fd);
	*can_id = (tbufdata[SIDH]<<3) + (tbufdata[SIDL]>>5);
    if ( (tbufdata[SIDL] & TXB_EXIDE_M) ==  TXB_EXIDE_M ) 
    {
        *can_id = (*can_id<<2) + (tbufdata[SIDL] & 0x03);
        *can_id <<= 16;
        *can_id = *can_id +(tbufdata[EID8]<<8) + tbufdata[EID0];
        *ext = 1;
    }
}

void mcp_write_can_id( char mcp_addr,char ext,unsigned long can_id,int fd)
{
    unsigned int canid;
    char tbufdata[4];
    canid = (unsigned int)(can_id & 0x0FFFF);
    if (ext) {
        tbufdata[EID0] = (char) (canid & 0xFF);
        tbufdata[EID8] = (char) (canid / 0x100);
        canid = (unsigned int)( can_id / 0x10000L );
        tbufdata[SIDL] = (char) (canid & 0x03);
        tbufdata[SIDL] += (char) ((canid & 0x1C)<<3);
        tbufdata[SIDL] |= TXB_EXIDE_M;
        tbufdata[SIDH] = (char) (canid / 32 );
    }
    else {
        tbufdata[SIDH] = (char) (canid / 8 );
        tbufdata[SIDL] = (char) ((canid & 0x07 )<<5);  //*32
        tbufdata[EID0] = 0;
        tbufdata[EID8] = 0;
    }
	WriteData(mcp_addr,tbufdata,4,fd);
}

void MCP2510_Init(int fd)
{
    	char i,j,addr;
	char databuf[2];

	MCP2510_Reset(fd);

	databuf[0]=MODE_CONFIG;
	WriteData(CANCTRL,databuf,1,fd);

	i=20;

	do{
		ReadData(CANSTAT,databuf,1,fd);
	}while( (databuf[0]&0xE0)!=MODE_CONFIG && (i-->0));

	if(i==0)
	{ 
		if(fd==fd0)	printf("\n\rMCP2510 0 Config Mode Failure\n\r");
		else		printf("\n\rMCP2510 1 Config Mode Failure\n\r");
	}

	databuf[0]= SJW1 + BRP3;
	WriteData(CNF1,databuf,1,fd);

	databuf[0]= BTLMODE_CNF3+SEG4<<3+SEG7;
	WriteData(CNF2,databuf,1,fd);

	databuf[0]= SEG4;
	WriteData(CNF3,databuf,1,fd);

	databuf[0]= RX0IE;
	WriteData(CANINTE,databuf,1,fd);

    // Mark all filter bits as don't care:
    mcp_write_can_id(RXM0SIDH, 0, 0,fd);//add,ext,id,cs
    mcp_write_can_id(RXM1SIDH, 0, 0,fd);
    // Anyway, set all filters to 0:
    mcp_write_can_id(RXF0SIDH, 0, 0,fd);
    mcp_write_can_id(RXF1SIDH, 0, 0,fd);
    mcp_write_can_id(RXF2SIDH, 0, 0,fd);
    mcp_write_can_id(RXF3SIDH, 0, 0,fd);
    mcp_write_can_id(RXF4SIDH, 0, 0,fd);
    mcp_write_can_id(RXF5SIDH, 0, 0,fd);

	databuf[0]= MODE_NORMAL +CLKEN+CLK4;
	WriteData(CLKCTRL,databuf,1,fd);

	i=20;

	do{
		ReadData(CANSTAT,databuf,1,fd);
	}while( (databuf[0]&0xE0)!=MODE_NORMAL && (i-->0));

	if(i==0)
	{ 
		if(fd==fd0)	printf("\n\rMCP2510 0 Normal Mode Failure\n\r");
		else		printf("\n\rMCP2510 1 Normal Mode Failure\n\r");
	}

    // Clear, deactivate the three transmit buffers
    addr = TXB0CTRL;
    for (i = 0; i < 3; i++) {
        for (j = 0; j < 14; j++) {
	databuf[0]= 0;
	WriteData(addr,databuf,1,fd);
            addr++;
        }
        addr += 2; // We did not clear CANSTAT or CANCTRL
    }

    // and the two receive buffers.
	databuf[0]= 0;
	WriteData(RXB0CTRL,databuf,1,fd);
	WriteData(RXB1CTRL,databuf,1,fd);
}

void InitPorts(int fd)
{
    // Set RTS pins as inputs (used for the buttons)
    WriteBits( TXRTSCTRL, 0xFF, 0 ,fd);
    // The two pins RX0BF and RX1BF are used to control two LEDs; set them as outputs and
    // set them as 00.
    WriteBits( BFPCTRL, 0xFF , 0x3C,fd);   
}

void SetLED(int v,int fd) 
{
    WriteBits(BFPCTRL, 0x30, ~v << 4,fd);    
}

// Buffer can be 1..2..3
void mcp_write_can( char row, char ext, unsigned long can_id,
                    char dlc, char rtr, char* data,int fd)
{
    char mcp_addr = row*16 + 0x21;
    mcp_write_can_id(mcp_addr,ext,can_id,fd);  	// write CAN id
    WriteData(mcp_addr+5,data,dlc,fd);   	// write n bytes data in the Mcp2510    
    if (rtr == 1) dlc |= RTR_MASK;  		// if RTR set bit in byte
    WriteData((mcp_addr+4),&dlc,1,fd);		// write the RTR and DLC
}
// Buffer can be 4..5
void mcp_read_can( char buffer, char* ext, unsigned long* can_id,
                   char* dlc, char* rtr, char* data,int fd)
{
    
    char mcp_addr = buffer*16 + 0x21, ctrl,size;
    mcp_read_can_id( mcp_addr, ext, can_id,fd);
    ReadData( mcp_addr-1, &ctrl,1,fd);			//read RXBnCTRL
    ReadData( mcp_addr+4, &size,1,fd);      		//read RXBnDLC
    if (ctrl & 0x08) {
        *rtr = 1;
     } 
    else {
        *rtr = 0;
     }
    *dlc =(size & DLC_MASK);
    ReadData( mcp_addr+5, data, *dlc,fd);
}

char canRead(unsigned long* id,char* msg,char* size,char* extF,char* rtr,int fd) 
{
    char byte;
    ReadData(CANINTF, &byte, 1,fd);
    if (byte & RX1INT) 
    { 
       mcp_read_can(5, extF, id, size, rtr, msg,fd);
       WriteBits(CANINTF, RX1INT,(char)~RX1INT,fd); // Clear interrupt
    }
    else if (byte & RX0INT) 
    {   
        mcp_read_can(4, extF, id, size, rtr, msg,fd);
        WriteBits(CANINTF, RX0INT,(char)~RX0INT,fd); // Clear interrupt                       
    }
    if((*size)>8) return 1;
    
    return 0;    
}

void canWrite(unsigned long id,char* msg, char size,
						 char ext,char rtr,int fd) 
{
    mcp_write_can(2,ext,id,size,rtr,msg,fd);
    WriteRTS(0x80|TX1RTS,fd);
}

void CAN_Send(int fd)
{

    	char framedata[6][8]={
					{10,11,12,13,14,15,16,17},
					{200,198,196,194,192,190,188,186},
					{0,2,4,6,8,10,12,14},
					{1,3,5,7,9,11,13,15},
					{219,189,159,129,99,69,39,9},
					{50,100,150,200,250,200,150,100}
					};
	     
   		 canWrite(1026,framedata[k],8,0,0,fd); 
         k++;
         if(k>=6)k=0;
}

int main(int argc, char **argv)
{
	char cm2[8];
	int i;
	char databuf[8];

	printf("CAN-Bus Test Start! \n");
	usleep(100);

	fd0 = open("/dev/can/0", O_RDWR);
	if(fd0 == -1){
		printf("open /dev/can 0 is failed\n");
		exit(1);
	}
	fd1 = open("/dev/can/1", O_RDWR);
	if(fd1 == -1){
		printf("open /dev/can 1 is failed\n");
		exit(1);
	}

	MCP2510_Init(fd0);
	MCP2510_Init(fd1);
	InitPorts(fd0);
	InitPorts(fd1);

	databuf[0]= NO_IE;
	WriteData(CANINTF,databuf,1,fd0);
	WriteData(CANINTF,databuf,1,fd1);

	ID=0;
	dlc=0;

	while(1){
		SetLED(0,fd0);  //all flash
		SetLED(1,fd1);  //all flash
		sleep(1);

		CAN_Send(fd0);
 
		SetLED(0,fd0);  //all flash
		SetLED(2,fd1);  //all flash
		sleep(1);

		if(canRead(&ID,cm2,&dlc,&extF,&rtr,fd1)==0){
 			printf("\nCAN1: receive %d data='",dlc);			
 			for(i=0;i<dlc;i++)  			
 				printf(" %3d",cm2[i]);
			printf("'  ID=%d",ID);
 		}			  			 			 			SetLED(1,fd0);  //all flash
		SetLED(0,fd1);  //all flash
		sleep(1);
			
		CAN_Send(fd1); 

		SetLED(2,fd0);  //all flash
		SetLED(0,fd1);  //all flash
		sleep(1);
		if(canRead(&ID,cm2,&dlc,&extF,&rtr,fd0)==0){
 			printf("\nCAN0: receive %d data='",dlc);			
 			for(i=0;i<dlc;i++)  			
 				printf(" %3d",cm2[i]);
			printf("'  ID=%d",ID);

 		}

	}
	close(fd1);
	close(fd0);
	exit(0);	
}