canbus.c

uccos2的的源码文件

//
// CAN-BUS 应用
// by liaonh 2008/1
//

#include "test.h"
#include "SJA1000.h"

/////////////////////////////////////////////////////
#define ENODEV  1
#define EINVAL  2
#define EFAULT  3
#define ENOTTY  4

#define copy_to_user    memcpy
#define copy_from_user  memcpy
#define ssize_t      int
#define size_t       int
extern  unsigned int VICVectAddr[];
#define printk  myprintf
extern int myprintf(char* format,...);
#define static

//#define INTTERUPT_CANBUS_MODE
/////////////////////////////////////////////////////

/*************************************************************
*  *
**************************************************************/
#include "config.h"

extern stcSJA1000_BufInfo SJA1000_RxBuf;		//used by other file
extern void *sja1000_ale;
extern void *sja1000_dat;


/*
********************************************************************************************************************
**函数原型		:  	int can_open(struct inode *p_inode, struct file *p_file)
**参数说明		:
**返回值		:
**说	明		:	CAN驱动的
********************************************************************************************************************
*/
static int can_open(void)
{

    	//设备初始化
	if(TRUE != SJA1000Init(PELI_CAN,BTR_500K,0x00000000,0xFFFFFFFF)) {
		printk("SJA1000Init Err!!.\n");
		return -ENODEV;
	}

	//MOD_INC_USE_COUNT;

	printk("CanBus Opened!.\n");

	return(0);
}
/*
********************************************************************************************************************
**函数原型		:  	int can_release(struct inode *p_inode, struct file *p_flie)
**参数说明		:
**返回值		:
**说	明		:	CAN驱动的
********************************************************************************************************************
*/
static int can_release(void)
{
	//MOD_DEC_USE_COUNT;

	return(0);
}
/*
********************************************************************************************************************
**函数原型		:  	ssize_t can_read(struct file *p_flie, char *p_buf, size_t count, loff_t *f_pos)
**参数说明		:
**返回值		:
**说	明		:	CAN驱动的
********************************************************************************************************************
*/
static ssize_t can_read(char *p_buf, size_t count)
{
    extern int SJA1000_RxLen;

    if( SJA1000_RxLen <= 0 )
        return 0;
	copy_to_user(p_buf, (void*)(&SJA1000_RxBuf), sizeof(stcSJA1000_BufInfo));
    SJA1000_RxLen = 0;
	return(sizeof(SJA1000_RxBuf));
}
/*
********************************************************************************************************************
**函数原型		:  	ssize_t can_write(struct file *p_flie, const char *p_buf, size_t count, loff_t *f_pos)
**参数说明		:
**返回值		:
**说	明		:	CAN驱动的
********************************************************************************************************************
*/
static ssize_t can_write(const char *p_buf, size_t count)
{
	stcSJA1000_BufInfo TxBuf;
	copy_from_user((void*)&TxBuf,(void*)p_buf,sizeof(stcSJA1000_BufInfo));
	SetTxBuf(&TxBuf);
	SetCommand(CMR_NOM_SD);

	return(sizeof(SJA1000_RxBuf));
}
/*
********************************************************************************************************************
**函数原型		:  	int can_ioctl(struct inode *p_inode, struct file *p_flie, unsigned int cmd, unsigned long param)
**参数说明		:
**返回值		:
**说	明		:	CAN驱动的
********************************************************************************************************************
*/
static int can_ioctl(unsigned int cmd, unsigned long param)
{
	int val = 0;

	switch(cmd) {
		case IOCTL_BAUD:
			SJA_SoftRst(TRUE);
			if(TRUE != SetBaudRate((uint16)param)) {
				val = -ENOTTY;
			}
			SJA_SoftRst(FALSE);
			break;
		case IOCTL_ACR:
			SJA_SoftRst(TRUE);
			if(TRUE != ACRCode(param)) {
				val = -ENOTTY;
			}
			SJA_SoftRst(FALSE);
			break;
		case IOCTL_AMR:
			SJA_SoftRst(TRUE);
			if(TRUE != AMRCode(param)) {
				val = -ENOTTY;
			}
			SJA_SoftRst(FALSE);
			break;
		default:
			val = -ENOTTY;
			break;
	}

	return(val);
}

#define __raw_writel(v,port)    (port) = (v)
#define __raw_readl(port)       (port)

#define S3C2410_GPFCON      rGPFCON
#define S3C2410_EXTINT0     rEXTINT0

/*
********************************************************************************************************************
**函数原型		:  	int can_init(void)
**参数说明		:	NULL
**返回值		:	返回赋值表示调用出错
**说	明		:	CAN驱动的初始化函数函数
********************************************************************************************************************
*/

static int can_init(void)
{
	int  i,result;


    	//测试硬件连接
    	for (i=0 ; i<0x8; i++) {
    		writeb(0x09,sja1000_ale);
		writeb(1<<i,sja1000_dat);
		writeb(0x09,sja1000_ale);

		if(readb(sja1000_dat) != 1<<i) {
			printk("SJA_1000 Hare Ware Connected Err!!");
			return -ENODEV;
		}
    	}

    printk("CAN-BUS INIT OK\r\n");
	//申请中断
	__raw_writel((__raw_readl(S3C2410_GPFCON) & (~(0x03<<10))) | (0x02<<10), S3C2410_GPFCON);  //Pin function
	__raw_writel(__raw_readl(S3C2410_EXTINT0) | (0x02<<20), S3C2410_EXTINT0);	//EINT5--falling edge triger

#ifdef INTTERUPT_CANBUS_MODE
	VICVectAddr[5] = (unsigned int)IntEnty;
    rINTMSK &= ~(1<<5);
#endif
  	return(0);
}
/*
********************************************************************************************************************
**函数原型		:  	void can_cleanup(void)
**参数说明		:	NULL
**返回值		:	NULL
**说	明		:	CAN驱动的清除函数
********************************************************************************************************************
*/
static void can_cleanup(void)
{
#ifdef INTTERUPT_CANBUS_MODE
	rINTMSK |= (1<<5);
#endif
	//关闭CAN设备控制器
	if(TRUE != SJA_SoftRst(TRUE))
    {
		printk("<0>" "SJA_SoftRst False!.\n");
    }
}

#if 0
module_init(can_init);
module_exit(can_cleanup);

EXPORT_SYMBOL(sja1000_ale);
EXPORT_SYMBOL(sja1000_dat);

MODULE_SUPPORTED_DEVICE("Linux 2.6.8 & GEC2410-BOX");
#endif

/*********************************************************************************************************
**                            End Of File
********************************************************************************************************/

static int canbusflag = 0;
stcSJA1000_BufInfo Buf;
int test_canbus_idle(int v)
{
    int count,i;

    SetScrollBox(1);
    ScrollShow(v);
    SetScrollBox(0);
    PollintNet();

    if( canbusflag == 0 )
        return;
#ifndef INTTERUPT_CANBUS_MODE
    IntEnty();
#endif

	count = can_read((void*)(&Buf), sizeof(Buf));
	if(count < 0)
    {
		printf("read err!.\n");
	}
 	else if( count > 0 )
    {
        PrintfFlag = 0x03;
		printf("CAN Recived frame:\n");
		for(i=0; i<(Buf.FrIf.Bits.DLC); i++)
		{
			printf("CAN Data[0x%02X] = 0x%02X.\n",i,Buf.DA[i]);
		}
        PrintfFlag = 0x01;
	}

}

Menu gstr_CANMenu[] =
{
    {"Init CAN BUS",1,test_canbus},
    {"Write CAN BUS",2,test_canbus},
    {"CAN-蜂鸣器",3,test_canbus},
    {"CAN-电机正转",4,test_canbus},
    {"CAN-电机反转",5,test_canbus},
    {"CAN-LED",6,test_canbus},
    {"CAN-数码管",7,test_canbus},
    {"Exit",0xff,0},
    {0,0,0}
};

void CANSend(int id,char* buffer,int len)
{
    int i;
    stcSJA1000_BufInfo Buf;
    Buf.FrID = id;					//设置帧ID 0x12345678
    Buf.FrIf.Byte = 0;
    Buf.FrIf.Bits.DLC = len;					//设置帧数据长度为8字节
    Buf.FrIf.Bits.FF = 1;					//帧为扩展帧

	for(i=0; i<Buf.FrIf.Bits.DLC; i++)  {	//帧数据设定为0x00 0x11 0x22 0x33 0x44										//0x55 0x66 0x77
		Buf.DA[i] = buffer[i];
	}


	printf("CAN Send Frame:\n");
	for(i=0; i<(Buf.FrIf.Bits.DLC); i++) {
		printf("\tCAN Data[0x%02X] = 0x%02X.\n",i,Buf.DA[i]);
	}
	can_write((void*)(&Buf),sizeof(Buf)-8+len);
}

void test_cansend(void)
{
    int i;
    char DA[8];

	for(i=0; i<8; i++)  {	//帧数据设定为0x00 0x11 0x22 0x33 0x44										//0x55 0x66 0x77
		DA[i] = rand()%256;
	}
    CANSend(0x12345678,DA,8);
}

int test_canbus(int v)
{
    char DA[8] = {0,0,0,0,0,0,0,0};
    int len = 0;

    switch(v)
    {
        case 1: // init
            PrintfFlag = 0x03;
            can_open();
            can_init();
            PrintfFlag = 0x01;
            canbusflag = 1;
            break;
        case 2:// write
            PrintfFlag = 0x03;
            test_cansend();
            PrintfFlag = 0x01;
            break;
        case 3:// 蜂鸣器
            DA[0] = 0x01;len=8;break;
        case 4: //电机正转
            DA[0] = 0x02; DA[1] = 0x01; len=8;break;
        case 5: //电机反转
            DA[0] = 0x02; DA[1] = 0x02; len=8;break;
        case 6: //LED
            DA[0] = 0x03; DA[1] = rand()%16; len=8;
            sprintf((char*)buf,"CAN-LED:%x",DA[1]);
            StatusMessage((char*)buf);
            break;
        case 7: //数码管
            len = RunTimeMs % 10;
            #if 1
            len = len+len*10+len*100+len*1000;
            sprintf((char*)buf,"CAN-数码管: %d",len);
            #else
            len = len | (len<<4) | (len<<8) | (len << 12);
            sprintf((char*)buf,"CAN-数码管: %04x",len);
            #endif
            StatusMessage((char*)buf);
            DA[0] = 0x04;
            DA[1] = len;
            DA[2] = len >> 8;
            len=8;
            break;
        default: break;
    }

    if( len > 0 )
    {
#define CAN_ID  0x12345678
        CANSend(CAN_ID,DA,len);
    }

    SetMenuReShow(0);
    return MENU_RETAIN;
}