www.pudn.com > CANdrv.rar > CANDrv.c
/* CANDrv.c - MC523x Flexcan communication driver */
/* Copyright 2005 ZHUHAI UNITECH POWER TECHNOLOGY CO.,LTD */
/*
modification history
--------------------
*/
/*
DESCRIPTION
This is the driver for the Flexcan contained in the 523X.
*/
#include "vxWorks.h"
#include "iosLib.h"
#include "intLib.h"
#include "errno.h"
#include "CANDrv.h"
#include "string.h"
int Tx_count;
int Rx_count;
int CanDrvNum = 0;
Tx_count=0;
Rx_count=0;
Can_DEV can_chan_dev[NUM_CAN];
LOCAL STATUS InitCan(Can_DEV *);
LOCAL STATUS WriteByte(Can_DEV *,UCHAR ,int );
LOCAL STATUS CanBaudSet (Can_DEV *, UINT);
LOCAL STATUS CanTxIDSet (Can_DEV *,UINT);
LOCAL STATUS CanRxIDSet (Can_DEV *,UINT);
LOCAL STATUS CheckBusStatus(Can_DEV *);
LOCAL void CanTxInterrupt (Can_DEV *);
LOCAL void CanRxInterrupt (Can_DEV *);
/******************************************************************************
*CanDrv -- CAN驱动安装程序
*返回 - 安装成功返回OK，否则返回ERROR
*参数：无
******************************************************************************/
STATUS CanDrv(void)
{
if(CanDrvNum > 0)
{
printf("Can driver has been installed!\n");
return OK;//已经安装驱动
}
if((CanDrvNum = iosDrvInstall(0,0,CanOpen,CanClose,CanRead,CanWrite,CanIoctl)) == ERROR)
{
printf("Can driver install ERROR!\n");
return ERROR;
}
#if NUM_CAN == 2
intConnect(INUM_TO_IVEC(CAN0_MB0_INTVEC),Can0TxInterrupt,0);
intConnect(INUM_TO_IVEC(CAN0_MB1_INTVEC),Can0RxInterrupt,0);
intConnect(INUM_TO_IVEC(CAN1_MB0_INTVEC),Can1TxInterrupt,0);
intConnect(INUM_TO_IVEC(CAN1_MB1_INTVEC),Can1RxInterrupt,0);
#else
intConnect(INUM_TO_IVEC(CAN0_MB0_INTVEC),Can0TxInterrupt,0);
intConnect(INUM_TO_IVEC(CAN0_MB1_INTVEC),Can0RxInterrupt,0);
#endif
printf("Can driver has been installed successfully !\n");
return OK;
}
/******************************************************************************
*itos -- 将一个整数转换为字符
*返回 - 转换后的字符串指针
*参数：val -- 要转换的整数
******************************************************************************/
static char * itos (int val)
{
static char str [20];
char strtmp [20];
str [0] = '\0';
if (val == 0)
return "0";
while (val != 0)
{
strcpy (strtmp, str);
str[0] = '0' + (val > 10);
str[1] = '\0';
strcat (str, strtmp);
val = val - (val >= 10);
}
return str;
}
/******************************************************************************
*CanDevCreate -- CAN设备创建函数
*返回 - 创建成功返回OK，否则返回ERROR
*参数：无
*
******************************************************************************/
STATUS CanDevCreate()
{
char canName[20];
int i;
if(CanDrvNum == 0)
{
return ERROR;
}
for(i=0;i<NUM_CAN;i++)
{
canName[0] = '\0';
strcat (canName, CAN_NAME_BASE);
strcat (canName, itos (i));
if(iosDevAdd((DEV_HDR *)&amt;can_chan_dev[i],canName,CanDrvNum) == ERROR)
{
printf("Can device add ERROR !\n");
return ERROR;
}
}
return OK;
}
/******************************************************************************
*CanOpen -- 打开CAN设备
*返回 - 返回设备ID号
*参数：pCan_Dev -- 要打开的CAN设备
remainder -- 文件名，在这里为空
flags -- 设备的打开方式，对于can永远以读写方式打开
*
******************************************************************************/
int CanOpen(Can_DEV *pCan_Dev,UCHAR *remainder,int flags)
{
if(flags != 2)
{
printf("Can device open ERROR !\n");
return ERROR;/*只能以读写的方式打开*/
}
if(remainder[0] != 0)
{
printf("Can device open ERROR !\n");
return ERROR;/*can设备没有文件名*/
}
pCan_Dev->Flag_canOpen = CAN_YES; /*打开CAN设备*/
/*使MB0和MB1不参与仲裁与配匹*/
CANDEV_WRITE(pCan_Dev->txcode,
TX_NOTENABLE | DEFAULT_LENGTH);
CANDEV_WRITE(pCan_Dev->rxcode,
RX_NOTENABLE | DEFAULT_LENGTH);
/*清除发送缓冲区数据*/
CANDEV_WRITE(pCan_Dev->txdata0,0x00);
CANDEV_WRITE(pCan_Dev->txdata1,0x00);
CANDEV_WRITE(pCan_Dev->txdata2,0x00);
CANDEV_WRITE(pCan_Dev->txdata3,0x00);
CANDEV_WRITE(pCan_Dev->txdata4,0x00);
CANDEV_WRITE(pCan_Dev->txdata5,0x00);
CANDEV_WRITE(pCan_Dev->txdata6,0x00);
CANDEV_WRITE(pCan_Dev->txdata7,0x00);
/*清除接收缓冲区数据*/
CANDEV_WRITE(pCan_Dev->rxdata0,0x00);
CANDEV_WRITE(pCan_Dev->rxdata1,0x00);
CANDEV_WRITE(pCan_Dev->rxdata2,0x00);
CANDEV_WRITE(pCan_Dev->rxdata3,0x00);
CANDEV_WRITE(pCan_Dev->rxdata4,0x00);
CANDEV_WRITE(pCan_Dev->rxdata5,0x00);
CANDEV_WRITE(pCan_Dev->rxdata6,0x00);
CANDEV_WRITE(pCan_Dev->rxdata7,0x00);
/*接收使能*/
CANDEV_WRITE(pCan_Dev->rxcode,
RX_ENABLE | DEFAULT_LENGTH);
printf("Can device has been opened !\n");
return((int)pCan_Dev);
}
/******************************************************************************
*CanOpen -- 关闭CAN设备
*返回 - 无
*参数：pCan_Dev -- 要关闭的CAN设备
*
******************************************************************************/
int CanClose(Can_DEV *pCan_Dev)
{
if(pCan_Dev->Flag_canOpen == CAN_NO)
{
printf("Can device has been closed !\n");
return OK;
}
pCan_Dev->Flag_canOpen = CAN_NO; /*关闭CAN设备*/
CANDEV_WRITE(pCan_Dev->txcode,
TX_NOTENABLE | DEFAULT_LENGTH);
CANDEV_WRITE(pCan_Dev->rxcode,
RX_NOTENABLE | DEFAULT_LENGTH);
/*初始化发送缓冲区指针及发送计数器*/
pCan_Dev->ptx = pCan_Dev->tx_Buff;
pCan_Dev->tx_number = 0;
pCan_Dev->tx_length =0;
/*初始化接收缓冲区指针及接收计数器*/
pCan_Dev->prx_write = pCan_Dev->rx_Buff;
pCan_Dev->prx_read = pCan_Dev->rx_Buff;
pCan_Dev->rx_number = 0;
pCan_Dev->rx_length = 0;
printf("Can device has been closed !\n");
return OK;
}
/******************************************************************************
*
* CanWrite -- CAN发送函数
* 返回: 成功返回已写入的字节数, 否则返回0
*参数说明：
pChan -- 需要控制的设备
buffer -- 写缓冲区
someArg -- 写字节数
******************************************************************************/
int CanWrite(Can_DEV *pCan_Dev,UCHAR *buffer,UINT16 nBytes)
{
int i;
int j;
UCHAR *txbuf;
txbuf = buffer;
if(pCan_Dev->Flag_canOpen == CAN_NO)
{
printf("Can device hasn't been opened !\n");
return 0;/*如果设备没有打开返回0*/
}
if(nBytes > MAX_TX_BUFFER)
{
printf("要发送的字节数大于发送缓冲区长度 !\n");
return 0; /*要发送的字节数大于发送缓冲区*/
}
/*
if( ERROR == semTake(pCan_Dev->tx_semSync, 50) )
{
printf("Cann't Take The TX Sem.\n\r");
return 0;
}
*/
//semTake(pCan_Dev->tx_semSync,WAIT_FOREVER);/*等待发送中断释放信号量*/
/*如果需发送的字节数小于或等于8，不用复制到设备的发送缓冲区中，直接发送
否则将所有数据复制到设备缓冲区中，先发送前8个字节，剩余的在设备的缓冲区中用中断发送*/
if(nBytes <= 8)
{
j = 0;
while(CheckBusStatus(pCan_Dev) != OK) //检查CAN总线是否在空闲状态
{
j++;
if(j >= 40000) break;
}
if(j >= 40000)
{
printf("Can bus is always busy !\n");
return 0;//总线一直忙
}
CANDEV_WRITE(pCan_Dev->txcode, /*INACTIVE发送*/
TX_NOTENABLE);
for(i=0;i<nBytes;i++)
{
WriteByte(pCan_Dev,*txbuf,i);
txbuf++;
}
pCan_Dev->tx_number = 0;
pCan_Dev->tx_length = nBytes;
pCan_Dev->ptx = pCan_Dev->tx_Buff;
CANDEV_WRITE(pCan_Dev->txcode, /*ACTIVE发送*/
TX_ENABLE | pCan_Dev->tx_length);
printf("Has been transmitted!\n");
}
else
{
/*复制数据到设备的发送缓冲区中*/
for(i = 0;i < nBytes;i++,txbuf++)
{
pCan_Dev->tx_Buff[i] = *txbuf;
}
pCan_Dev->ptx = pCan_Dev->tx_Buff;
pCan_Dev->ptx += 8;/*发送指针往后移8个字节*/
pCan_Dev->tx_number = nBytes -8;
pCan_Dev->tx_length = 8;
j = 0;
while(CheckBusStatus(pCan_Dev) != OK) //检查CAN总线是否在空闲状态
{
j++;
if(j >= 40000) break;
}
if(j >= 40000)
{
pCan_Dev->ptx = pCan_Dev->tx_Buff;
pCan_Dev->tx_number = 0;
pCan_Dev->tx_length = 0;
printf("Can bus is always busy !\n");
return 0;//总线一直忙
}
CANDEV_WRITE(pCan_Dev->txcode, /*INACTIVE发送*/
TX_NOTENABLE);
txbuf = buffer;
for(i=0;i<8;i++)
{
WriteByte(pCan_Dev,*txbuf,i);
txbuf++;
}
CANDEV_WRITE(pCan_Dev->txcode, /*ACTIVE发送*/
TX_ENABLE | pCan_Dev->tx_length);
printf("Has been transmitted!\n");
}
return nBytes;
}
/******************************************************************************
*
* CanRead -- CAN接收函数
* 返回: 成功返回已读的字节数, 否则返回0
*参数说明：
pChan -- 需要控制的设备
buffer -- 读缓冲区
someArg -- 读字节数
******************************************************************************/
int CanRead(Can_DEV *pCan_Dev,UCHAR *buffer,UINT16 nBytes)
{
UINT16 i;
UCHAR *rx_buff;
rx_buff = buffer;
i = 0;
if(pCan_Dev->Flag_canOpen == CAN_NO)
{
printf("Can device is not been opened !\n");
return 0;
}
if( ERROR == semTake(pCan_Dev->rx_semSync, 50) )
{
//printf("Cann't Take The RX Sem.\n");
return 0;
}
//semTake(pCan_Dev->rx_semSync,WAIT_FOREVER);/*等待接收中断释放信号量*/
while((pCan_Dev->prx_read != pCan_Dev->prx_write)&amt;&amt;(i < nBytes))
{
*rx_buff = *pCan_Dev->prx_read;
rx_buff++;
pCan_Dev->prx_read++;
i++;
if((pCan_Dev->prx_read - pCan_Dev->rx_Buff) == MAX_RX_BUFFER )
{
pCan_Dev->prx_read = pCan_Dev->rx_Buff;
}
}
return(i);
}
/******************************************************************************
*
* CAN控制函数
*
* 返回:
* 成功返回OK, 设备错误返回ERROR, 不支持返回ERROR
*
*参数说明：
* pChan -- 需要控制的设备
* request -- 请求的功能
* someArg -- 控制参数
******************************************************************************/
int CanIoctl
(
Can_DEV * pChan, /* device to control */
int request, /* request code */
void * someArg /* some argument */
)
{
STATUS result = OK;
int arg = (int)someArg;
if(pChan->Flag_canOpen != CAN_YES) return ERROR;/*如果设备没有打开返回0*/
switch (request)
{
case CAN_BAUD_SET:
if (CanBaudSet(pChan, arg) != OK)
result = ERROR;
break;
case CAN_BAUD_GET:
*(int *)arg = pChan->baudRate;
return (OK);
case CAN_TXID_SET:
if (CanTxIDSet(pChan, arg) != OK)
result = ERROR;
break;
case CAN_TXID_GET:
*(int *)arg = pChan->TxID;
return (OK);
case CAN_RXID_SET:
if (CanRxIDSet(pChan, arg) != OK)
result = ERROR;
break;
case CAN_RXID_GET:
*(int *)arg = pChan->RxID;
return (OK);
default:
return (ERROR);
}
printf("CanIoctl funtion has been set \n");
return (result);
}
/******************************************************************************
*
* CanBaudSet - 改变can设备的波特率
*设置can的波特率，设置时不使能中断
*波特率只能为1M 500K 250K 125K 100K 75K 50K
*
* 返回:OK或者ERROR
*
******************************************************************************/
LOCAL STATUS CanBaudSet
(
Can_DEV * pcan_chan,
UINT32 baud
)
{
register int i;
i = 0;
if (!baud)
return (ERROR);
if (baud != pcan_chan->baudRate)
{
UINT32 val;
int oldlevel;
switch(baud)
{
case 1000000:
val = 0x045B2005;
break;
case 500000:
val = ((PRESDIV1(baud)) << 24)| CTRL_RJW | CTRL_PSEG1 | CTRL_PSEG2 | CTRL_CLK_SRC | CTRL_SMP | CTRL_PROPSEG;
break;
case 125000:
val = ((PRESDIV1(baud)) << 24)| CTRL_RJW | CTRL_PSEG1 | CTRL_PSEG2 | CTRL_CLK_SRC | CTRL_SMP | CTRL_PROPSEG;
break;
case 100000:
val = ((PRESDIV1(baud)) << 24)| CTRL_RJW | CTRL_PSEG1 | CTRL_PSEG2 | CTRL_CLK_SRC | CTRL_SMP | CTRL_PROPSEG;
break;
case 75000:
val = ((PRESDIV1(baud)) << 24)| CTRL_RJW | CTRL_PSEG1 | CTRL_PSEG2 | CTRL_CLK_SRC | CTRL_SMP | CTRL_PROPSEG;
break;
case 50000:
val = ((PRESDIV1(baud)) << 24)| CTRL_RJW | CTRL_PSEG1 | CTRL_PSEG2 | CTRL_CLK_SRC | CTRL_SMP | CTRL_PROPSEG;
break;
default:
return ERROR;
}
oldlevel = intLock ();
/*设置FRZ和HALT位，使CAN进入Freeze模式,进入管理模式*/
CANDEV_WRITE(pcan_chan->mcr,
MCR_MENE | MCR_FRZ | MCR_HALT | MCR_SUPV | MCR_MAXMB);
while((CANDEV_READ(pcan_chan->mcr) &amt; 0x01000000) == 0x00000000) //等待can进入Freeze模式
{
i++;
if(i >= 40000)
{
return ERROR;
}
}
CANDEV_WRITE(pcan_chan->ctrl,val);
/*退出FREEZE模式，退出管理模式*/
CANDEV_WRITE(pcan_chan->mcr,
MCR_MENE | MCR_MAXMB);
pcan_chan->baudRate = baud;
intUnlock (oldlevel);
}
return (OK);
}
/******************************************************************************
*
* CanIDTxSet - 改变can信息缓冲区MB0的ID
*设置信息缓冲区ID，设置时理论上可以不用使该CAN进入FREEZE模式
*但为了安全起见，还是考虑进入FREEZE模式并且不使能中断
*
* 返回:OK或者ERROR
*
******************************************************************************/
LOCAL STATUS CanTxIDSet
(
Can_DEV *pcan_chan,
UINT32 Id
)
{
register int i;
UINT32 MbufId;
int oldlevel;
i = 0;
if((Id ==0) || (Id > 2047))
{
printf("The TXID number is too large!\n");
return ERROR;
}
if(Id != pcan_chan->TxID)
{
MbufId = Id << 18;
oldlevel = intLock ();
/*设置FRZ和HALT位，使CAN进入Freeze模式,进入管理模式*/
CANDEV_WRITE(pcan_chan->mcr,
MCR_MENE | MCR_FRZ | MCR_HALT | MCR_SUPV | MCR_MAXMB);
while((CANDEV_READ(pcan_chan->mcr) &amt; 0x01000000) == 0x00000000) //等待can进入Freeze模式
{
i++;
if(i >= 40000)
{
printf("CAN didn't enter into freeze mode!");
return ERROR;
}
}
CANDEV_WRITE(pcan_chan->txcode,
TX_NOTENABLE | DEFAULT_LENGTH);
CANDEV_WRITE(pcan_chan->txID,MbufId); //写发送缓冲区ID
/*退出FREEZE模式，退出管理模式*/
CANDEV_WRITE(pcan_chan->mcr,
MCR_MENE | MCR_MAXMB);
pcan_chan->TxID = Id;
intUnlock (oldlevel);
}
return OK;
}
/******************************************************************************
*
* CanIDRxSet - 改变can信息缓冲区MB1的ID
*设置信息缓冲区ID，设置时理论上可以不用使该CAN进入FREEZE模式
*但为了安全起见，还是考虑进入FREEZE模式并且不使能中断
*
* 返回:OK或者ERROR
*
******************************************************************************/
LOCAL STATUS CanRxIDSet
(
Can_DEV *pcan_chan,
UINT32 Id
)
{
register int i;
i = 0;
if((Id ==0) || (Id > 2047))
{
printf("The RXID number is too large!\n");
return ERROR;
}
if(Id != pcan_chan->RxID)
{
UINT32 MbufId;
int oldlevel;
MbufId = Id << 18;
oldlevel = intLock ();
/*设置FRZ和HALT位，使CAN进入Freeze模式,进入管理模式*/
CANDEV_WRITE(pcan_chan->mcr,
MCR_MENE | MCR_FRZ | MCR_HALT | MCR_SUPV | MCR_MAXMB);
while((CANDEV_READ(pcan_chan->mcr) &amt; 0x01000000) == 0x00000000) //等待can进入Freeze模式
{
i++;
if(i >= 40000)
{
printf("CAN didn't enter into freeze mode!");
return ERROR;
}
}
CANDEV_WRITE(pcan_chan->rxcode,
RX_NOTENABLE | DEFAULT_LENGTH);
CANDEV_WRITE(pcan_chan->rxID,MbufId);//写接收缓冲区ID
CANDEV_WRITE(pcan_chan->rxcode,
RX_ENABLE | DEFAULT_LENGTH);
/*退出FREEZE模式，退出管理模式*/
CANDEV_WRITE(pcan_chan->mcr,
MCR_MENE | MCR_MAXMB);
pcan_chan->RxID = Id;
intUnlock (oldlevel);
}
return OK;
}
/******************************************************************************
*
* CanDevInit - can设备初始化程序
*初始化CAN设备结构寄存器地址，并调用Initcan函数对CAN寄存器进行初始化
*
*返回：无
*
*参数：无
******************************************************************************/
void CanDevInit (void)
{
int i;
for(i=0;i<NUM_CAN;i++)
{
can_chan_dev[i].clkRate = MASTER_CLOCK;/*默认系统主频为150MHz*/
can_chan_dev[i].baudRate = CAN_DEFAULT_BAUD;
if(i == 0)
{
can_chan_dev[i].TxID = 1;
can_chan_dev[i].RxID = 2;
}
else
{
can_chan_dev[i].TxID = 2;
can_chan_dev[i].RxID = 1;
}
can_chan_dev[i].Flag_canOpen = CAN_NO;
/*初始化发送缓冲区指针及发送计数器*/
can_chan_dev[i].ptx = can_chan_dev[i].tx_Buff;
can_chan_dev[i].tx_number = 0;
can_chan_dev[i].tx_length =0;
/*初始化接收缓冲区指针及接收计数器*/
can_chan_dev[i].prx_write = can_chan_dev[i].rx_Buff;
can_chan_dev[i].prx_read = can_chan_dev[i].rx_Buff;
can_chan_dev[i].rx_number = 0;
can_chan_dev[i].rx_length = 0;
if(i == 0)/* Initialize Port FECI2C PAR to have Can 0 TX/RX signals enabled */
{
#if 0
(*M523X_GPIO_PAR_FECI2C(IPS_BASE)) &amt;= 0xF0;
(*M523X_GPIO_PAR_FECI2C(IPS_BASE)) |= 0x0A;
#endif
(*M523X_GPIO_PAR_UART(IPS_BASE)) &amt;= 0xF0FF;
(*M523X_GPIO_PAR_UART(IPS_BASE)) |= 0x0A00;
}
else/* Initialize Port UART PAR to have Can 1 TX/RX signals enabled */
{
(*M523X_GPIO_PAR_UART(IPS_BASE)) |= 0x4000;
}
/*初始化Flex_can设备结构寄存器*/
can_chan_dev[i].mcr = M523X_CAN_CANMCR(IPS_BASE,i);
can_chan_dev[i].ctrl = M523X_CAN_CANCTRL(IPS_BASE,i);
can_chan_dev[i].timer = M523X_CAN_TIMER(IPS_BASE,i);
can_chan_dev[i].rxgmask = M523X_CAN_RXGMASK(IPS_BASE,i);
can_chan_dev[i].rx14mask = M523X_CAN_RX14MASK(IPS_BASE,i);
can_chan_dev[i].rx15mask = M523X_CAN_RX15MASK(IPS_BASE,i);
can_chan_dev[i].errcnt = M523X_CAN_ERRCNT(IPS_BASE,i);
can_chan_dev[i].errstat = M523X_CAN_ERRSTAT(IPS_BASE,i);
can_chan_dev[i].imask = M523X_CAN_IMASK(IPS_BASE,i);
can_chan_dev[i].iflag = M523X_CAN_IFLAG(IPS_BASE,i);
can_chan_dev[i].txcode = M523X_CAN_MBUF0_CTRL(IPS_BASE,i);
can_chan_dev[i].txlength = M523X_CAN_MBUF0_CTRL(IPS_BASE,i);
can_chan_dev[i].txtimestamp = M523X_CAN_MBUF0_TMSTP(IPS_BASE,i);
can_chan_dev[i].txID = M523X_CAN_MBUF0_ID(IPS_BASE,i);
can_chan_dev[i].txdata0 = M523X_CAN_MBUF0_BYTE0(IPS_BASE,i);
can_chan_dev[i].txdata1 = M523X_CAN_MBUF0_BYTE1(IPS_BASE,i);
can_chan_dev[i].txdata2 = M523X_CAN_MBUF0_BYTE2(IPS_BASE,i);
can_chan_dev[i].txdata3 = M523X_CAN_MBUF0_BYTE3(IPS_BASE,i);
can_chan_dev[i].txdata4 = M523X_CAN_MBUF0_BYTE4(IPS_BASE,i);
can_chan_dev[i].txdata5 = M523X_CAN_MBUF0_BYTE5(IPS_BASE,i);
can_chan_dev[i].txdata6 = M523X_CAN_MBUF0_BYTE6(IPS_BASE,i);
can_chan_dev[i].txdata7 = M523X_CAN_MBUF0_BYTE7(IPS_BASE,i);
can_chan_dev[i].rxcode = M523X_CAN_MBUF1_CTRL(IPS_BASE,i);
can_chan_dev[i].rxlength = M523X_CAN_MBUF1_CTRL(IPS_BASE,i);
can_chan_dev[i].rxtimestamp = M523X_CAN_MBUF1_TMSTP(IPS_BASE,i);
can_chan_dev[i].rxID = M523X_CAN_MBUF1_ID(IPS_BASE,i);
can_chan_dev[i].rxdata0 = M523X_CAN_MBUF1_BYTE0(IPS_BASE,i);
can_chan_dev[i].rxdata1 = M523X_CAN_MBUF1_BYTE1(IPS_BASE,i);
can_chan_dev[i].rxdata2 = M523X_CAN_MBUF1_BYTE2(IPS_BASE,i);
can_chan_dev[i].rxdata3 = M523X_CAN_MBUF1_BYTE3(IPS_BASE,i);
can_chan_dev[i].rxdata4 = M523X_CAN_MBUF1_BYTE4(IPS_BASE,i);
can_chan_dev[i].rxdata5 = M523X_CAN_MBUF1_BYTE5(IPS_BASE,i);
can_chan_dev[i].rxdata6 = M523X_CAN_MBUF1_BYTE6(IPS_BASE,i);
can_chan_dev[i].rxdata7 = M523X_CAN_MBUF1_BYTE7(IPS_BASE,i);
can_chan_dev[i].mb2code = M523X_CAN_MBUF2_CTRL(IPS_BASE,i);
can_chan_dev[i].mb2length = M523X_CAN_MBUF2_CTRL(IPS_BASE,i);
can_chan_dev[i].mb2timestamp = M523X_CAN_MBUF2_TMSTP(IPS_BASE,i);
can_chan_dev[i].mb2ID = M523X_CAN_MBUF2_ID(IPS_BASE,i);
can_chan_dev[i].mb2data0 = M523X_CAN_MBUF2_BYTE0(IPS_BASE,i);
can_chan_dev[i].mb2data1 = M523X_CAN_MBUF2_BYTE1(IPS_BASE,i);
can_chan_dev[i].mb2data2 = M523X_CAN_MBUF2_BYTE2(IPS_BASE,i);
can_chan_dev[i].mb2data3 = M523X_CAN_MBUF2_BYTE3(IPS_BASE,i);
can_chan_dev[i].mb2data4 = M523X_CAN_MBUF2_BYTE4(IPS_BASE,i);
can_chan_dev[i].mb2data5 = M523X_CAN_MBUF2_BYTE5(IPS_BASE,i);
can_chan_dev[i].mb2data6 = M523X_CAN_MBUF2_BYTE6(IPS_BASE,i);
can_chan_dev[i].mb2data7 = M523X_CAN_MBUF2_BYTE7(IPS_BASE,i);
can_chan_dev[i].mb3code = M523X_CAN_MBUF3_CTRL(IPS_BASE,i);
can_chan_dev[i].mb3length = M523X_CAN_MBUF3_CTRL(IPS_BASE,i);
can_chan_dev[i].mb3timestamp = M523X_CAN_MBUF3_TMSTP(IPS_BASE,i);
can_chan_dev[i].mb3ID = M523X_CAN_MBUF3_ID(IPS_BASE,i);
can_chan_dev[i].mb3data0 = M523X_CAN_MBUF3_BYTE0(IPS_BASE,i);
can_chan_dev[i].mb3data1 = M523X_CAN_MBUF3_BYTE1(IPS_BASE,i);
can_chan_dev[i].mb3data2 = M523X_CAN_MBUF3_BYTE2(IPS_BASE,i);
can_chan_dev[i].mb3data3 = M523X_CAN_MBUF3_BYTE3(IPS_BASE,i);
can_chan_dev[i].mb3data4 = M523X_CAN_MBUF3_BYTE4(IPS_BASE,i);
can_chan_dev[i].mb3data5 = M523X_CAN_MBUF3_BYTE5(IPS_BASE,i);
can_chan_dev[i].mb3data6 = M523X_CAN_MBUF3_BYTE6(IPS_BASE,i);
can_chan_dev[i].mb3data7 = M523X_CAN_MBUF3_BYTE7(IPS_BASE,i);
can_chan_dev[i].mb4code = M523X_CAN_MBUF4_CTRL(IPS_BASE,i);
can_chan_dev[i].mb4length = M523X_CAN_MBUF4_CTRL(IPS_BASE,i);
can_chan_dev[i].mb4timestamp = M523X_CAN_MBUF4_TMSTP(IPS_BASE,i);
can_chan_dev[i].mb4ID = M523X_CAN_MBUF4_ID(IPS_BASE,i);
can_chan_dev[i].mb4data0 = M523X_CAN_MBUF4_BYTE0(IPS_BASE,i);
can_chan_dev[i].mb4data1 = M523X_CAN_MBUF4_BYTE1(IPS_BASE,i);
can_chan_dev[i].mb4data2 = M523X_CAN_MBUF4_BYTE2(IPS_BASE,i);
can_chan_dev[i].mb4data3 = M523X_CAN_MBUF4_BYTE3(IPS_BASE,i);
can_chan_dev[i].mb4data4 = M523X_CAN_MBUF4_BYTE4(IPS_BASE,i);
can_chan_dev[i].mb4data5 = M523X_CAN_MBUF4_BYTE5(IPS_BASE,i);
can_chan_dev[i].mb4data6 = M523X_CAN_MBUF4_BYTE6(IPS_BASE,i);
can_chan_dev[i].mb4data7 = M523X_CAN_MBUF4_BYTE7(IPS_BASE,i);
can_chan_dev[i].mb5code = M523X_CAN_MBUF5_CTRL(IPS_BASE,i);
can_chan_dev[i].mb5length = M523X_CAN_MBUF5_CTRL(IPS_BASE,i);
can_chan_dev[i].mb5timestamp = M523X_CAN_MBUF5_TMSTP(IPS_BASE,i);
can_chan_dev[i].mb5ID = M523X_CAN_MBUF5_ID(IPS_BASE,i);
can_chan_dev[i].mb5data0 = M523X_CAN_MBUF5_BYTE0(IPS_BASE,i);
can_chan_dev[i].mb5data1 = M523X_CAN_MBUF5_BYTE1(IPS_BASE,i);
can_chan_dev[i].mb5data2 = M523X_CAN_MBUF5_BYTE2(IPS_BASE,i);
can_chan_dev[i].mb5data3 = M523X_CAN_MBUF5_BYTE3(IPS_BASE,i);
can_chan_dev[i].mb5data4 = M523X_CAN_MBUF5_BYTE4(IPS_BASE,i);
can_chan_dev[i].mb5data5 = M523X_CAN_MBUF5_BYTE5(IPS_BASE,i);
can_chan_dev[i].mb5data6 = M523X_CAN_MBUF5_BYTE6(IPS_BASE,i);
can_chan_dev[i].mb5data7 = M523X_CAN_MBUF5_BYTE7(IPS_BASE,i);
can_chan_dev[i].mb6code = M523X_CAN_MBUF6_CTRL(IPS_BASE,i);
can_chan_dev[i].mb6length = M523X_CAN_MBUF6_CTRL(IPS_BASE,i);
can_chan_dev[i].mb6timestamp = M523X_CAN_MBUF6_TMSTP(IPS_BASE,i);
can_chan_dev[i].mb6ID = M523X_CAN_MBUF6_ID(IPS_BASE,i);
can_chan_dev[i].mb6data0 = M523X_CAN_MBUF6_BYTE0(IPS_BASE,i);
can_chan_dev[i].mb6data1 = M523X_CAN_MBUF6_BYTE1(IPS_BASE,i);
can_chan_dev[i].mb6data2 = M523X_CAN_MBUF6_BYTE2(IPS_BASE,i);
can_chan_dev[i].mb6data3 = M523X_CAN_MBUF6_BYTE3(IPS_BASE,i);
can_chan_dev[i].mb6data4 = M523X_CAN_MBUF6_BYTE4(IPS_BASE,i);
can_chan_dev[i].mb6data5 = M523X_CAN_MBUF6_BYTE5(IPS_BASE,i);
can_chan_dev[i].mb6data6 = M523X_CAN_MBUF6_BYTE6(IPS_BASE,i);
can_chan_dev[i].mb6data7 = M523X_CAN_MBUF6_BYTE7(IPS_BASE,i);
can_chan_dev[i].mb7code = M523X_CAN_MBUF7_CTRL(IPS_BASE,i);
can_chan_dev[i].mb7length = M523X_CAN_MBUF7_CTRL(IPS_BASE,i);
can_chan_dev[i].mb7timestamp = M523X_CAN_MBUF7_TMSTP(IPS_BASE,i);
can_chan_dev[i].mb7ID = M523X_CAN_MBUF7_ID(IPS_BASE,i);
can_chan_dev[i].mb7data0 = M523X_CAN_MBUF7_BYTE0(IPS_BASE,i);
can_chan_dev[i].mb7data1 = M523X_CAN_MBUF7_BYTE1(IPS_BASE,i);
can_chan_dev[i].mb7data2 = M523X_CAN_MBUF7_BYTE2(IPS_BASE,i);
can_chan_dev[i].mb7data3 = M523X_CAN_MBUF7_BYTE3(IPS_BASE,i);
can_chan_dev[i].mb7data4 = M523X_CAN_MBUF7_BYTE4(IPS_BASE,i);
can_chan_dev[i].mb7data5 = M523X_CAN_MBUF7_BYTE5(IPS_BASE,i);
can_chan_dev[i].mb7data6 = M523X_CAN_MBUF7_BYTE6(IPS_BASE,i);
can_chan_dev[i].mb7data7 = M523X_CAN_MBUF7_BYTE7(IPS_BASE,i);
can_chan_dev[i].mb8code = M523X_CAN_MBUF8_CTRL(IPS_BASE,i);
can_chan_dev[i].mb8length = M523X_CAN_MBUF8_CTRL(IPS_BASE,i);
can_chan_dev[i].mb8timestamp = M523X_CAN_MBUF8_TMSTP(IPS_BASE,i);
can_chan_dev[i].mb8ID = M523X_CAN_MBUF8_ID(IPS_BASE,i);
can_chan_dev[i].mb8data0 = M523X_CAN_MBUF8_BYTE0(IPS_BASE,i);
can_chan_dev[i].mb8data1 = M523X_CAN_MBUF8_BYTE1(IPS_BASE,i);
can_chan_dev[i].mb8data2 = M523X_CAN_MBUF8_BYTE2(IPS_BASE,i);
can_chan_dev[i].mb8data3 = M523X_CAN_MBUF8_BYTE3(IPS_BASE,i);
can_chan_dev[i].mb8data4 = M523X_CAN_MBUF8_BYTE4(IPS_BASE,i);
can_chan_dev[i].mb8data5 = M523X_CAN_MBUF8_BYTE5(IPS_BASE,i);
can_chan_dev[i].mb8data6 = M523X_CAN_MBUF8_BYTE6(IPS_BASE,i);
can_chan_dev[i].mb8data7 = M523X_CAN_MBUF8_BYTE7(IPS_BASE,i);
can_chan_dev[i].mb9code = M523X_CAN_MBUF9_CTRL(IPS_BASE,i);
can_chan_dev[i].mb9length = M523X_CAN_MBUF9_CTRL(IPS_BASE,i);
can_chan_dev[i].mb9timestamp = M523X_CAN_MBUF9_TMSTP(IPS_BASE,i);
can_chan_dev[i].mb9ID = M523X_CAN_MBUF9_ID(IPS_BASE,i);
can_chan_dev[i].mb9data0 = M523X_CAN_MBUF9_BYTE0(IPS_BASE,i);
can_chan_dev[i].mb9data1 = M523X_CAN_MBUF9_BYTE1(IPS_BASE,i);
can_chan_dev[i].mb9data2 = M523X_CAN_MBUF9_BYTE2(IPS_BASE,i);
can_chan_dev[i].mb9data3 = M523X_CAN_MBUF9_BYTE3(IPS_BASE,i);
can_chan_dev[i].mb9data4 = M523X_CAN_MBUF9_BYTE4(IPS_BASE,i);
can_chan_dev[i].mb9data5 = M523X_CAN_MBUF9_BYTE5(IPS_BASE,i);
can_chan_dev[i].mb9data6 = M523X_CAN_MBUF9_BYTE6(IPS_BASE,i);
can_chan_dev[i].mb9data7 = M523X_CAN_MBUF9_BYTE7(IPS_BASE,i);
can_chan_dev[i].mb10code = M523X_CAN_MBUF10_CTRL(IPS_BASE,i);
can_chan_dev[i].mb10length = M523X_CAN_MBUF10_CTRL(IPS_BASE,i);
can_chan_dev[i].mb10timestamp = M523X_CAN_MBUF10_TMSTP(IPS_BASE,i);
can_chan_dev[i].mb10ID = M523X_CAN_MBUF10_ID(IPS_BASE,i);
can_chan_dev[i].mb10data0 = M523X_CAN_MBUF10_BYTE0(IPS_BASE,i);
can_chan_dev[i].mb10data1 = M523X_CAN_MBUF10_BYTE1(IPS_BASE,i);
can_chan_dev[i].mb10data2 = M523X_CAN_MBUF10_BYTE2(IPS_BASE,i);
can_chan_dev[i].mb10data3 = M523X_CAN_MBUF10_BYTE3(IPS_BASE,i);
can_chan_dev[i].mb10data4 = M523X_CAN_MBUF10_BYTE4(IPS_BASE,i);
can_chan_dev[i].mb10data5 = M523X_CAN_MBUF10_BYTE5(IPS_BASE,i);
can_chan_dev[i].mb10data6 = M523X_CAN_MBUF10_BYTE6(IPS_BASE,i);
can_chan_dev[i].mb10data7 = M523X_CAN_MBUF10_BYTE7(IPS_BASE,i);
can_chan_dev[i].mb11code = M523X_CAN_MBUF11_CTRL(IPS_BASE,i);
can_chan_dev[i].mb11length = M523X_CAN_MBUF11_CTRL(IPS_BASE,i);
can_chan_dev[i].mb11timestamp = M523X_CAN_MBUF11_TMSTP(IPS_BASE,i);
can_chan_dev[i].mb11ID = M523X_CAN_MBUF11_ID(IPS_BASE,i);
can_chan_dev[i].mb11data0 = M523X_CAN_MBUF11_BYTE0(IPS_BASE,i);
can_chan_dev[i].mb11data1 = M523X_CAN_MBUF11_BYTE1(IPS_BASE,i);
can_chan_dev[i].mb11data2 = M523X_CAN_MBUF11_BYTE2(IPS_BASE,i);
can_chan_dev[i].mb11data3 = M523X_CAN_MBUF11_BYTE3(IPS_BASE,i);
can_chan_dev[i].mb11data4 = M523X_CAN_MBUF11_BYTE4(IPS_BASE,i);
can_chan_dev[i].mb11data5 = M523X_CAN_MBUF11_BYTE5(IPS_BASE,i);
can_chan_dev[i].mb11data6 = M523X_CAN_MBUF11_BYTE6(IPS_BASE,i);
can_chan_dev[i].mb11data7 = M523X_CAN_MBUF11_BYTE7(IPS_BASE,i);
can_chan_dev[i].mb12code = M523X_CAN_MBUF12_CTRL(IPS_BASE,i);
can_chan_dev[i].mb12length = M523X_CAN_MBUF12_CTRL(IPS_BASE,i);
can_chan_dev[i].mb12timestamp = M523X_CAN_MBUF12_TMSTP(IPS_BASE,i);
can_chan_dev[i].mb12ID = M523X_CAN_MBUF12_ID(IPS_BASE,i);
can_chan_dev[i].mb12data0 = M523X_CAN_MBUF12_BYTE0(IPS_BASE,i);
can_chan_dev[i].mb12data1 = M523X_CAN_MBUF12_BYTE1(IPS_BASE,i);
can_chan_dev[i].mb12data2 = M523X_CAN_MBUF12_BYTE2(IPS_BASE,i);
can_chan_dev[i].mb12data3 = M523X_CAN_MBUF12_BYTE3(IPS_BASE,i);
can_chan_dev[i].mb12data4 = M523X_CAN_MBUF12_BYTE4(IPS_BASE,i);
can_chan_dev[i].mb12data5 = M523X_CAN_MBUF12_BYTE5(IPS_BASE,i);
can_chan_dev[i].mb12data6 = M523X_CAN_MBUF12_BYTE6(IPS_BASE,i);
can_chan_dev[i].mb12data7 = M523X_CAN_MBUF12_BYTE7(IPS_BASE,i);
can_chan_dev[i].mb13code = M523X_CAN_MBUF13_CTRL(IPS_BASE,i);
can_chan_dev[i].mb13length = M523X_CAN_MBUF13_CTRL(IPS_BASE,i);
can_chan_dev[i].mb13timestamp = M523X_CAN_MBUF13_TMSTP(IPS_BASE,i);
can_chan_dev[i].mb13ID = M523X_CAN_MBUF13_ID(IPS_BASE,i);
can_chan_dev[i].mb13data0 = M523X_CAN_MBUF13_BYTE0(IPS_BASE,i);
can_chan_dev[i].mb13data1 = M523X_CAN_MBUF13_BYTE1(IPS_BASE,i);
can_chan_dev[i].mb13data2 = M523X_CAN_MBUF13_BYTE2(IPS_BASE,i);
can_chan_dev[i].mb13data3 = M523X_CAN_MBUF13_BYTE3(IPS_BASE,i);
can_chan_dev[i].mb13data4 = M523X_CAN_MBUF13_BYTE4(IPS_BASE,i);
can_chan_dev[i].mb13data5 = M523X_CAN_MBUF13_BYTE5(IPS_BASE,i);
can_chan_dev[i].mb13data6 = M523X_CAN_MBUF13_BYTE6(IPS_BASE,i);
can_chan_dev[i].mb13data7 = M523X_CAN_MBUF13_BYTE7(IPS_BASE,i);
can_chan_dev[i].mb14code = M523X_CAN_MBUF14_CTRL(IPS_BASE,i);
can_chan_dev[i].mb14length = M523X_CAN_MBUF14_CTRL(IPS_BASE,i);
can_chan_dev[i].mb14timestamp = M523X_CAN_MBUF14_TMSTP(IPS_BASE,i);
can_chan_dev[i].mb14ID = M523X_CAN_MBUF14_ID(IPS_BASE,i);
can_chan_dev[i].mb14data0 = M523X_CAN_MBUF14_BYTE0(IPS_BASE,i);
can_chan_dev[i].mb14data1 = M523X_CAN_MBUF14_BYTE1(IPS_BASE,i);
can_chan_dev[i].mb14data2 = M523X_CAN_MBUF14_BYTE2(IPS_BASE,i);
can_chan_dev[i].mb14data3 = M523X_CAN_MBUF14_BYTE3(IPS_BASE,i);
can_chan_dev[i].mb14data4 = M523X_CAN_MBUF14_BYTE4(IPS_BASE,i);
can_chan_dev[i].mb14data5 = M523X_CAN_MBUF14_BYTE5(IPS_BASE,i);
can_chan_dev[i].mb14data6 = M523X_CAN_MBUF14_BYTE6(IPS_BASE,i);
can_chan_dev[i].mb14data7 = M523X_CAN_MBUF14_BYTE7(IPS_BASE,i);
can_chan_dev[i].mb15code = M523X_CAN_MBUF15_CTRL(IPS_BASE,i);
can_chan_dev[i].mb15length = M523X_CAN_MBUF15_CTRL(IPS_BASE,i);
can_chan_dev[i].mb15timestamp = M523X_CAN_MBUF15_TMSTP(IPS_BASE,i);
can_chan_dev[i].mb15ID = M523X_CAN_MBUF15_ID(IPS_BASE,i);
can_chan_dev[i].mb15data0 = M523X_CAN_MBUF15_BYTE0(IPS_BASE,i);
can_chan_dev[i].mb15data1 = M523X_CAN_MBUF15_BYTE1(IPS_BASE,i);
can_chan_dev[i].mb15data2 = M523X_CAN_MBUF15_BYTE2(IPS_BASE,i);
can_chan_dev[i].mb15data3 = M523X_CAN_MBUF15_BYTE3(IPS_BASE,i);
can_chan_dev[i].mb15data4 = M523X_CAN_MBUF15_BYTE4(IPS_BASE,i);
can_chan_dev[i].mb15data5 = M523X_CAN_MBUF15_BYTE5(IPS_BASE,i);
can_chan_dev[i].mb15data6 = M523X_CAN_MBUF15_BYTE6(IPS_BASE,i);
can_chan_dev[i].mb15data7 = M523X_CAN_MBUF15_BYTE7(IPS_BASE,i);
InitCan(&amt;can_chan_dev[i]);
}
}
/******************************************************************************
*
* InitCan - 初始化Flex_can 在默认状态下
*初始化CAN设备结构寄存器地址，并调用Initcan函数对CAN寄存器进行初始化
*
*返回：无
*
*参数：无
******************************************************************************/
LOCAL STATUS InitCan(Can_DEV *pcan_chan)
{
register int i;
int oldlevel;
i = 0;
oldlevel = intLock();
//打开can，设置FRZ和HALT位，使CAN进入Freeze模式,MB数目为2
CANDEV_WRITE(pcan_chan->mcr,
MCR_MENE | MCR_FRZ | MCR_HALT | MCR_SUPV | MCR_MAXMB);
while((CANDEV_READ(pcan_chan->mcr) &amt; MCR_FRZACK) == 0x00000000) //等待can进入Freeze模式
{
i++;
if(i >= 40000)
{
return ERROR;
}
}
/*配置S_CLK的预除因子，时钟源及时间分额数量*/
CANDEV_WRITE(pcan_chan->ctrl,
CTRL_PRESDIV | CTRL_RJW | CTRL_PSEG1 | CTRL_PSEG2 | CTRL_CLK_SRC | CTRL_SMP | CTRL_PROPSEG);
/*初始化MB0作为发送缓冲区,MB1作为接收缓冲区*/
CANDEV_WRITE(pcan_chan->txcode,
TX_NOTENABLE | DEFAULT_LENGTH);
CANDEV_WRITE(pcan_chan->rxcode,
RX_NOTENABLE | DEFAULT_LENGTH);
/*初始化发送缓冲区及接收缓冲区ID*/
CANDEV_WRITE(pcan_chan->txID,(pcan_chan->TxID)<<18);
CANDEV_WRITE(pcan_chan->rxID,(pcan_chan->RxID)<<18);
/*清除发送缓冲区数据*/
CANDEV_WRITE(pcan_chan->txdata0,0x00);
CANDEV_WRITE(pcan_chan->txdata1,0x00);
CANDEV_WRITE(pcan_chan->txdata2,0x00);
CANDEV_WRITE(pcan_chan->txdata3,0x00);
CANDEV_WRITE(pcan_chan->txdata4,0x00);
CANDEV_WRITE(pcan_chan->txdata5,0x00);
CANDEV_WRITE(pcan_chan->txdata6,0x00);
CANDEV_WRITE(pcan_chan->txdata7,0x00);
/*清除接收缓冲区数据*/
CANDEV_WRITE(pcan_chan->rxdata0,0x00);
CANDEV_WRITE(pcan_chan->rxdata1,0x00);
CANDEV_WRITE(pcan_chan->rxdata2,0x00);
CANDEV_WRITE(pcan_chan->rxdata3,0x00);
CANDEV_WRITE(pcan_chan->rxdata4,0x00);
CANDEV_WRITE(pcan_chan->rxdata5,0x00);
CANDEV_WRITE(pcan_chan->rxdata6,0x00);
CANDEV_WRITE(pcan_chan->rxdata7,0x00);
/*不用的缓冲区2~15全部作为接受缓冲区，并且不使能和清零缓冲区的数据*/
/*MB2*/
CANDEV_WRITE(pcan_chan->mb2code,
TX_NOTENABLE | 0);
CANDEV_WRITE(pcan_chan->mb2ID,0);
CANDEV_WRITE(pcan_chan->mb2data0,0x00);
CANDEV_WRITE(pcan_chan->mb2data1,0x00);
CANDEV_WRITE(pcan_chan->mb2data2,0x00);
CANDEV_WRITE(pcan_chan->mb2data3,0x00);
CANDEV_WRITE(pcan_chan->mb2data4,0x00);
CANDEV_WRITE(pcan_chan->mb2data5,0x00);
CANDEV_WRITE(pcan_chan->mb2data6,0x00);
CANDEV_WRITE(pcan_chan->mb2data7,0x00);
/*MB3*/
CANDEV_WRITE(pcan_chan->mb3code,TX_NOTENABLE | 0);
CANDEV_WRITE(pcan_chan->mb3ID,0);
CANDEV_WRITE(pcan_chan->mb3data0,0x00);
CANDEV_WRITE(pcan_chan->mb3data1,0x00);
CANDEV_WRITE(pcan_chan->mb3data2,0x00);
CANDEV_WRITE(pcan_chan->mb3data3,0x00);
CANDEV_WRITE(pcan_chan->mb3data4,0x00);
CANDEV_WRITE(pcan_chan->mb3data5,0x00);
CANDEV_WRITE(pcan_chan->mb3data6,0x00);
CANDEV_WRITE(pcan_chan->mb3data7,0x00);
/*MB4*/
CANDEV_WRITE(pcan_chan->mb4code,TX_NOTENABLE | 0);
CANDEV_WRITE(pcan_chan->mb4ID,0);
CANDEV_WRITE(pcan_chan->mb4data0,0x00);
CANDEV_WRITE(pcan_chan->mb4data1,0x00);
CANDEV_WRITE(pcan_chan->mb4data2,0x00);
CANDEV_WRITE(pcan_chan->mb4data3,0x00);
CANDEV_WRITE(pcan_chan->mb4data4,0x00);
CANDEV_WRITE(pcan_chan->mb4data5,0x00);
CANDEV_WRITE(pcan_chan->mb4data6,0x00);
CANDEV_WRITE(pcan_chan->mb4data7,0x00);
/*MB5*/
CANDEV_WRITE(pcan_chan->mb5code,TX_NOTENABLE | 0);
CANDEV_WRITE(pcan_chan->mb5ID,0);
CANDEV_WRITE(pcan_chan->mb5data0,0x00);
CANDEV_WRITE(pcan_chan->mb5data1,0x00);
CANDEV_WRITE(pcan_chan->mb5data2,0x00);
CANDEV_WRITE(pcan_chan->mb5data3,0x00);
CANDEV_WRITE(pcan_chan->mb5data4,0x00);
CANDEV_WRITE(pcan_chan->mb5data5,0x00);
CANDEV_WRITE(pcan_chan->mb5data6,0x00);
CANDEV_WRITE(pcan_chan->mb5data7,0x00);
/*MB8*/
CANDEV_WRITE(pcan_chan->mb6code,TX_NOTENABLE | 0);
CANDEV_WRITE(pcan_chan->mb6ID,0);
CANDEV_WRITE(pcan_chan->mb6data0,0x00);
CANDEV_WRITE(pcan_chan->mb6data1,0x00);
CANDEV_WRITE(pcan_chan->mb6data2,0x00);
CANDEV_WRITE(pcan_chan->mb6data3,0x00);
CANDEV_WRITE(pcan_chan->mb6data4,0x00);
CANDEV_WRITE(pcan_chan->mb6data5,0x00);
CANDEV_WRITE(pcan_chan->mb6data6,0x00);
CANDEV_WRITE(pcan_chan->mb6data7,0x00);
/*MB7*/
CANDEV_WRITE(pcan_chan->mb7code,TX_NOTENABLE | 0);
CANDEV_WRITE(pcan_chan->mb7ID,0);
CANDEV_WRITE(pcan_chan->mb7data0,0x00);
CANDEV_WRITE(pcan_chan->mb7data1,0x00);
CANDEV_WRITE(pcan_chan->mb7data2,0x00);
CANDEV_WRITE(pcan_chan->mb7data3,0x00);
CANDEV_WRITE(pcan_chan->mb7data4,0x00);
CANDEV_WRITE(pcan_chan->mb7data5,0x00);
CANDEV_WRITE(pcan_chan->mb7data6,0x00);
CANDEV_WRITE(pcan_chan->mb7data7,0x00);
/*MB8*/
CANDEV_WRITE(pcan_chan->mb8code,TX_NOTENABLE | 0);
CANDEV_WRITE(pcan_chan->mb8ID,0);
CANDEV_WRITE(pcan_chan->mb8data0,0x00);
CANDEV_WRITE(pcan_chan->mb8data1,0x00);
CANDEV_WRITE(pcan_chan->mb8data2,0x00);
CANDEV_WRITE(pcan_chan->mb8data3,0x00);
CANDEV_WRITE(pcan_chan->mb8data4,0x00);
CANDEV_WRITE(pcan_chan->mb8data5,0x00);
CANDEV_WRITE(pcan_chan->mb8data6,0x00);
CANDEV_WRITE(pcan_chan->mb8data7,0x00);
/*MB9*/
CANDEV_WRITE(pcan_chan->mb9code,TX_NOTENABLE | 0);
CANDEV_WRITE(pcan_chan->mb9ID,0);
CANDEV_WRITE(pcan_chan->mb9data0,0x00);
CANDEV_WRITE(pcan_chan->mb9data1,0x00);
CANDEV_WRITE(pcan_chan->mb9data2,0x00);
CANDEV_WRITE(pcan_chan->mb9data3,0x00);
CANDEV_WRITE(pcan_chan->mb9data4,0x00);
CANDEV_WRITE(pcan_chan->mb9data5,0x00);
CANDEV_WRITE(pcan_chan->mb9data6,0x00);
CANDEV_WRITE(pcan_chan->mb9data7,0x00);
/*MB10*/
CANDEV_WRITE(pcan_chan->mb10code,TX_NOTENABLE | 0);
CANDEV_WRITE(pcan_chan->mb10ID,0);
CANDEV_WRITE(pcan_chan->mb10data0,0x00);
CANDEV_WRITE(pcan_chan->mb10data1,0x00);
CANDEV_WRITE(pcan_chan->mb10data2,0x00);
CANDEV_WRITE(pcan_chan->mb10data3,0x00);
CANDEV_WRITE(pcan_chan->mb10data4,0x00);
CANDEV_WRITE(pcan_chan->mb10data5,0x00);
CANDEV_WRITE(pcan_chan->mb10data6,0x00);
CANDEV_WRITE(pcan_chan->mb10data7,0x00);
/*MB11*/
CANDEV_WRITE(pcan_chan->mb11code,TX_NOTENABLE | 0);
CANDEV_WRITE(pcan_chan->mb11ID,0);
CANDEV_WRITE(pcan_chan->mb11data0,0x00);
CANDEV_WRITE(pcan_chan->mb11data1,0x00);
CANDEV_WRITE(pcan_chan->mb11data2,0x00);
CANDEV_WRITE(pcan_chan->mb11data3,0x00);
CANDEV_WRITE(pcan_chan->mb11data4,0x00);
CANDEV_WRITE(pcan_chan->mb11data5,0x00);
CANDEV_WRITE(pcan_chan->mb11data6,0x00);
CANDEV_WRITE(pcan_chan->mb11data7,0x00);
/*MB12*/
CANDEV_WRITE(pcan_chan->mb12code,TX_NOTENABLE | 0);
CANDEV_WRITE(pcan_chan->mb12ID,0);
CANDEV_WRITE(pcan_chan->mb12data0,0x00);
CANDEV_WRITE(pcan_chan->mb12data1,0x00);
CANDEV_WRITE(pcan_chan->mb12data2,0x00);
CANDEV_WRITE(pcan_chan->mb12data3,0x00);
CANDEV_WRITE(pcan_chan->mb12data4,0x00);
CANDEV_WRITE(pcan_chan->mb12data5,0x00);
CANDEV_WRITE(pcan_chan->mb12data6,0x00);
CANDEV_WRITE(pcan_chan->mb12data7,0x00);
/*MB13*/
CANDEV_WRITE(pcan_chan->mb13code,TX_NOTENABLE | 0);
CANDEV_WRITE(pcan_chan->mb13ID,0);
CANDEV_WRITE(pcan_chan->mb13data0,0x00);
CANDEV_WRITE(pcan_chan->mb13data1,0x00);
CANDEV_WRITE(pcan_chan->mb13data2,0x00);
CANDEV_WRITE(pcan_chan->mb13data3,0x00);
CANDEV_WRITE(pcan_chan->mb13data4,0x00);
CANDEV_WRITE(pcan_chan->mb13data5,0x00);
CANDEV_WRITE(pcan_chan->mb13data6,0x00);
CANDEV_WRITE(pcan_chan->mb13data7,0x00);
/*MB14*/
CANDEV_WRITE(pcan_chan->mb14code,TX_NOTENABLE | 0);
CANDEV_WRITE(pcan_chan->mb14ID,0);
CANDEV_WRITE(pcan_chan->mb14data0,0x00);
CANDEV_WRITE(pcan_chan->mb14data1,0x00);
CANDEV_WRITE(pcan_chan->mb14data2,0x00);
CANDEV_WRITE(pcan_chan->mb14data3,0x00);
CANDEV_WRITE(pcan_chan->mb14data4,0x00);
CANDEV_WRITE(pcan_chan->mb14data5,0x00);
CANDEV_WRITE(pcan_chan->mb14data6,0x00);
CANDEV_WRITE(pcan_chan->mb14data7,0x00);
/*MB15*/
CANDEV_WRITE(pcan_chan->mb15code,TX_NOTENABLE | 0);
CANDEV_WRITE(pcan_chan->mb15ID,0);
CANDEV_WRITE(pcan_chan->mb15data0,0x00);
CANDEV_WRITE(pcan_chan->mb15data1,0x00);
CANDEV_WRITE(pcan_chan->mb15data2,0x00);
CANDEV_WRITE(pcan_chan->mb15data3,0x00);
CANDEV_WRITE(pcan_chan->mb15data4,0x00);
CANDEV_WRITE(pcan_chan->mb15data5,0x00);
CANDEV_WRITE(pcan_chan->mb15data6,0x00);
CANDEV_WRITE(pcan_chan->mb15data7,0x00);
/*设置ID屏蔽寄存器，检查所有的标准格式的ID位*/
CANDEV_WRITE(pcan_chan->rxgmask,0x1FFFFFFF);
/*屏蔽除MBO和MB1外的所有中断*/
CANDEV_WRITE(pcan_chan->imask,0x0003);
/*清除中断标志*/
CANDEV_WRITE(pcan_chan->iflag,0xFFFF);
/*退出FREEZE模式，退出管理模式*/
CANDEV_WRITE(pcan_chan->mcr,
MCR_MENE | MCR_MAXMB);
intUnlock (oldlevel);
/*创建发送接收信号量*/
printf("Create Sem...\n\r");
pcan_chan->tx_semSync = semBCreate(SEM_Q_FIFO,SEM_FULL); /*发送信号量初始状态为满*/
if(pcan_chan->tx_semSync == NULL)
{
printf("tx_semSync creat error\n");
return ERROR;
}
pcan_chan->rx_semSync = semBCreate(SEM_Q_FIFO,SEM_EMPTY);/*接收信号量初始状态为空*/
if(pcan_chan->rx_semSync == NULL)
{
printf("rx_semSync creat error\n");
return ERROR;
}
printf("Done.\n\r");
return OK;
}
/******************************************************************************
*
* WriteByte - 写字节到Flex_can的信息缓冲区中
*
*返回：成功返回OK，否则返回ERROR
*
*参数：
pcan_chan -- 要写入字节的can设备
byte -- 要写入的字节
num -- 该字节在信息缓冲区中的位置
******************************************************************************/
LOCAL STATUS WriteByte(Can_DEV *pcan_chan,UCHAR byte,int num)
{
if(num >= 8) return ERROR;
switch (num)
{
case 0:
CANDEV_WRITE(pcan_chan->txdata0,byte);
break;
case 1:
CANDEV_WRITE(pcan_chan->txdata1,byte);
break;
case 2:
CANDEV_WRITE(pcan_chan->txdata2,byte);
break;
case 3:
CANDEV_WRITE(pcan_chan->txdata3,byte);
break;
case 4:
CANDEV_WRITE(pcan_chan->txdata4,byte);
break;
case 5:
CANDEV_WRITE(pcan_chan->txdata5,byte);
break;
case 6:
CANDEV_WRITE(pcan_chan->txdata6,byte);
break;
case 7:
CANDEV_WRITE(pcan_chan->txdata7,byte);
break;
default:
return ERROR;
}
return OK;
}
/******************************************************************************
*
* Can0TxInterrupt - Flex_can0模块发送中断函数，调用相应的中断例程
*
*返回：无
*
*参数：无
******************************************************************************/
void Can0TxInterrupt (void)
{
UINT16 intStatus;
//logMsg("#can0 Tx Int!T#", 1, 2, 3, 4, 5, 6);
intStatus = CANDEV_READ(can_chan_dev[0].iflag);/*读中断状态标志*/
if((intStatus &amt; 0x0001) == 0x0001)
{
CanTxInterrupt(&amt;can_chan_dev[0]);
}
else
{
logMsg("#can0 Tx vacant Int!T#", 1, 2, 3, 4, 5, 6);
}
/*
if(intStatus &amt; CAN0_TX_INT_STATUS)
{
CanTxInterrupt(&amt;can_chan_dev[0]);
}
if(intStatus &amt; CAN0_RX_INT_STATUS)
{
CanRxInterrupt(&amt;can_chan_dev[0]);
}
*/
CANDEV_WRITE(can_chan_dev[0].iflag,0x0001);/*清除中断状态标志*/
}
/******************************************************************************
*
* Can0RxInterrupt - Flex_can0模块接收中断函数，调用相应的中断例程
*
*返回：无
*
*参数：无
******************************************************************************/
void Can0RxInterrupt (void)
{
UINT16 intStatus;
Rx_count++;
///logMsg("#can0 Rx Int!T#", 1, 2, 3, 4, 5, 6);
intStatus = CANDEV_READ(can_chan_dev[0].iflag);/*读中断状态标志*/
if((intStatus &amt; 0x0002) == 0x0002)
{
CanRxInterrupt(&amt;can_chan_dev[0]);
}
else
{
//logMsg("#can0 Rx vacant Int!T#", 1, 2, 3, 4, 5, 6);
}
/*
if(intStatus &amt; CAN0_TX_INT_STATUS)
{
CanTxInterrupt(&amt;can_chan_dev[0]);
}
if(intStatus &amt; CAN0_RX_INT_STATUS)
{
CanRxInterrupt(&amt;can_chan_dev[0]);
}
*/
CANDEV_WRITE(can_chan_dev[0].iflag,0x0002);/*清除中断状态标志*/
}
/******************************************************************************
*
* Can1TxInterrupt - Flex_can1模块发送中断函数，调用相应的中断例程
*
*返回：无
*
*参数：无
******************************************************************************/
void Can1TxInterrupt (void)
{
UINT16 intStatus;
Tx_count++;
//logMsg("#can1 Tx Int!T#", 1, 2, 3, 4, 5, 6);
intStatus = CANDEV_READ(can_chan_dev[1].iflag);/*读中断状态标志*/
if((intStatus &amt; 0x0001) == 0x0001)
{
CanTxInterrupt(&amt;can_chan_dev[1]);
}
else
{
//logMsg("#can1 Tx vacant Int!T#", 1, 2, 3, 4, 5, 6);
}
/*
if(intStatus &amt; CAN1_TX_INT_STATUS)
{
CanTxInterrupt(&amt;can_chan_dev[1]);
}
if(intStatus &amt; CAN1_RX_INT_STATUS)
{
logMsg("#T****T#", 1, 2, 3, 4, 5, 6);
CanRxInterrupt(&amt;can_chan_dev[1]);
}
*/
CANDEV_WRITE(can_chan_dev[1].iflag,0x0001);/*清除中断状态标志*/
}
/******************************************************************************
*
* Can1RxInterrupt - Flex_can1模块接收中断函数，调用相应的中断例程
*
*返回：无
*
*参数：无
******************************************************************************/
void Can1RxInterrupt (void)
{
UINT16 intStatus;
//logMsg("#can1 Rx Int!T#", 1, 2, 3, 4, 5, 6);
intStatus = CANDEV_READ(can_chan_dev[1].iflag);/*读中断状态标志*/
if((intStatus &amt; 0x0002) == 0x0002)
{
CanRxInterrupt(&amt;can_chan_dev[1]);
}
else
{
//logMsg("#can1 Rx vacant Int!T#", 1, 2, 3, 4, 5, 6);
}
/*
if(intStatus &amt; CAN1_TX_INT_STATUS)
{
CanTxInterrupt(&amt;can_chan_dev[1]);
}
if(intStatus &amt; CAN1_RX_INT_STATUS)
{
logMsg("#T****T#", 1, 2, 3, 4, 5, 6);
CanRxInterrupt(&amt;can_chan_dev[1]);
}
*/
CANDEV_WRITE(can_chan_dev[1].iflag,0x0002);/*清除中断状态标志*/
}
/******************************************************************************
*
* CanTxInterrupt - Flex_can模块发送中断服务函数
*
*返回：无
*
*参数：
pcan_chan -- 需要发送服务的CAN设备
******************************************************************************/
LOCAL void CanTxInterrupt (Can_DEV *pcan_chan)
{
UINT16 i;
UINT16 j;
UINT32 count;
UCHAR ch;
if(pcan_chan->tx_number == 0)
{
pcan_chan->ptx = pcan_chan->tx_Buff;/*重新定位发送指针，为下一次发送做准备*/
CANDEV_WRITE(pcan_chan->txcode,
TX_NOTENABLE | DEFAULT_LENGTH);
semGive(pcan_chan->tx_semSync); /*释放信号量*/
return;
}
if(( pcan_chan->tx_number > 0) &amt;&amt; ( pcan_chan->tx_number <= 8))
{
count = 0;
while(CheckBusStatus(pcan_chan) != OK) //检查CAN总线是否在空闲状态
{
count++;
if(count >= 40000) break;
}
if(count >= 40000) /*如果总线一直忙，则清发送缓冲区，由上层协议决定是否重发*/
{
//logMsg("#bus is busy!T#", 1, 2, 3, 4, 5, 6);
pcan_chan->ptx = pcan_chan->tx_Buff;/*重新定位发送指针，为下一次发送做准备*/
pcan_chan->tx_number = 0;
CANDEV_WRITE(pcan_chan->txcode,
TX_NOTENABLE | DEFAULT_LENGTH);
semGive(pcan_chan->tx_semSync); /*释放信号量*/
return;
}
CANDEV_WRITE(pcan_chan->txcode,
TX_NOTENABLE | DEFAULT_LENGTH);/*INACTIVE发送*/
j = pcan_chan->tx_number;
for(i = 0;i < j;i++)
{
ch = *pcan_chan->ptx;
WriteByte(pcan_chan,ch,i);
pcan_chan->ptx++;
}
pcan_chan->tx_length = j;
pcan_chan->tx_number = 0;
CANDEV_WRITE(pcan_chan->txcode, /*ACTIVE发送*/
TX_ENABLE | pcan_chan->tx_length);
return;
}
if( pcan_chan->tx_number > 8)
{
count = 0;
while(CheckBusStatus(pcan_chan) != OK) //检查CAN总线是否在空闲状态
{
count++;
if(count >= 40000) break;
}
if(count >= 40000) /*如果总线一直忙，则清发送缓冲区，由上层协议决定是否重发*/
{
//logMsg("#bus is busy!T#", 1, 2, 3, 4, 5, 6);
pcan_chan->ptx = pcan_chan->tx_Buff;/*重新定位发送指针，为下一次发送做准备*/
pcan_chan->tx_number = 0;
CANDEV_WRITE(pcan_chan->txcode,
TX_NOTENABLE | DEFAULT_LENGTH);
semGive(pcan_chan->tx_semSync); /*释放信号量*/
return;
}
CANDEV_WRITE(pcan_chan->txcode,
TX_NOTENABLE | DEFAULT_LENGTH);/*INACTIVE发送*/
j = 8;
for(i = 0;i < j;i++)
{
ch = *pcan_chan->ptx;
WriteByte(pcan_chan,ch,i);
pcan_chan->ptx++;
}
pcan_chan->tx_length = j;
pcan_chan->tx_number -= j;
CANDEV_WRITE(pcan_chan->txcode, /*ACTIVE发送*/
TX_ENABLE | pcan_chan->tx_length);
return;
}
}
/******************************************************************************
*
* CanRxInterrupt - Flex_can模块接收中断服务函数
*
*返回：无
*
*参数：
pcan_chan -- 需要发送服务的CAN设备
******************************************************************************/
LOCAL void CanRxInterrupt (Can_DEV *pcan_chan)
{
UINT16 c_s_word; /*控制/状态信息字*/
UINT32 freeRunTimer; /*控制/状态信息字*/
//UINT32 id; /*ID*/
UINT16 i,j;
c_s_word = CANDEV_READ(pcan_chan->rxcode); /*读控制/状态字 锁定该信息缓冲区*/
//id = CANDEV_READ(pcan_chan->rxID); /*信息ID*/
j = c_s_word &amt; 0x000F; /*获取接收数据长度*/
/*写数据到接收缓冲区中*/
for(i = 0;i < j;i++)
{
switch (i)
{
case 0:
if((pcan_chan->prx_write+1) != pcan_chan->prx_read)
{
*pcan_chan->prx_write = CANDEV_READ(pcan_chan->rxdata0);
pcan_chan->prx_write++;
if((pcan_chan->prx_write - pcan_chan->rx_Buff) == MAX_RX_BUFFER)
{//接收指针回绕
if(pcan_chan->prx_read == pcan_chan->rx_Buff)
{
pcan_chan->prx_write = pcan_chan->prx_write-1;
}
else
{
pcan_chan->prx_write = pcan_chan->rx_Buff;
}
}
}
break;
case 1:
if((pcan_chan->prx_write+1) != pcan_chan->prx_read)
{
*pcan_chan->prx_write = CANDEV_READ(pcan_chan->rxdata1);
pcan_chan->prx_write++;
if((pcan_chan->prx_write - pcan_chan->rx_Buff) == MAX_RX_BUFFER)
{//接收指针回绕
if(pcan_chan->prx_read == pcan_chan->rx_Buff)
{
pcan_chan->prx_write = pcan_chan->prx_write-1;
}
else
{
pcan_chan->prx_write = pcan_chan->rx_Buff;
}
}
}
break;
case 2:
if((pcan_chan->prx_write+1) != pcan_chan->prx_read)
{
*pcan_chan->prx_write = CANDEV_READ(pcan_chan->rxdata2);
pcan_chan->prx_write++;
if((pcan_chan->prx_write - pcan_chan->rx_Buff) == MAX_RX_BUFFER)
{//接收指针回绕
if(pcan_chan->prx_read == pcan_chan->rx_Buff)
{
pcan_chan->prx_write = pcan_chan->prx_write-1;
}
else
{
pcan_chan->prx_write = pcan_chan->rx_Buff;
}
}
}
break;
case 3:
if((pcan_chan->prx_write+1) != pcan_chan->prx_read)
{
*pcan_chan->prx_write = CANDEV_READ(pcan_chan->rxdata3);
pcan_chan->prx_write++;
if((pcan_chan->prx_write - pcan_chan->rx_Buff) == MAX_RX_BUFFER)
{//接收指针回绕
if(pcan_chan->prx_read == pcan_chan->rx_Buff)
{
pcan_chan->prx_write = pcan_chan->prx_write-1;
}
else
{
pcan_chan->prx_write = pcan_chan->rx_Buff;
}
}
}
break;
case 4:
if((pcan_chan->prx_write+1) != pcan_chan->prx_read)
{
*pcan_chan->prx_write = CANDEV_READ(pcan_chan->rxdata4);
pcan_chan->prx_write++;
if((pcan_chan->prx_write - pcan_chan->rx_Buff) == MAX_RX_BUFFER)
{//接收指针回绕
if(pcan_chan->prx_read == pcan_chan->rx_Buff)
{
pcan_chan->prx_write = pcan_chan->prx_write-1;
}
else
{
pcan_chan->prx_write = pcan_chan->rx_Buff;
}
}
}
break;
case 5:
if((pcan_chan->prx_write+1) != pcan_chan->prx_read)
{
*pcan_chan->prx_write = CANDEV_READ(pcan_chan->rxdata5);
pcan_chan->prx_write++;
if((pcan_chan->prx_write - pcan_chan->rx_Buff) == MAX_RX_BUFFER)
{//接收指针回绕
if(pcan_chan->prx_read == pcan_chan->rx_Buff)
{
pcan_chan->prx_write = pcan_chan->prx_write-1;
}
else
{
pcan_chan->prx_write = pcan_chan->rx_Buff;
}
}
}
break;
case 6:
if((pcan_chan->prx_write+1) != pcan_chan->prx_read)
{
*pcan_chan->prx_write = CANDEV_READ(pcan_chan->rxdata6);
pcan_chan->prx_write++;
if((pcan_chan->prx_write - pcan_chan->rx_Buff) == MAX_RX_BUFFER)
{//接收指针回绕
if(pcan_chan->prx_read == pcan_chan->rx_Buff)
{
pcan_chan->prx_write = pcan_chan->prx_write-1;
}
else
{
pcan_chan->prx_write = pcan_chan->rx_Buff;
}
}
}
break;
case 7:
if((pcan_chan->prx_write+1) != pcan_chan->prx_read)
{
*pcan_chan->prx_write = CANDEV_READ(pcan_chan->rxdata7);
pcan_chan->prx_write++;
if((pcan_chan->prx_write - pcan_chan->rx_Buff) == MAX_RX_BUFFER)
{//接收指针回绕
if(pcan_chan->prx_read == pcan_chan->rx_Buff)
{
pcan_chan->prx_write = pcan_chan->prx_write-1;
}
else
{
pcan_chan->prx_write = pcan_chan->rx_Buff;
}
}
}
break;
default:
break;
}
}
pcan_chan->rx_number += j;
pcan_chan->rx_length =j;
freeRunTimer = CANDEV_READ(pcan_chan->timer);/*读自由运行时间，释放该信息缓冲区*/
CANDEV_WRITE(pcan_chan->rxcode,
RX_ENABLE | DEFAULT_LENGTH);/*使能接收，为下一次接收做准备*/
semGive(pcan_chan->rx_semSync); /*释放信号量*/
}
/******************************************************************************
*
* CheckBusStatus - 检查can总线状态
*读can的ERRSTAT寄存器，IDLE位是否为1
*
* 返回:总线空闲返回OK，否则返回ERROR
*
******************************************************************************/
LOCAL STATUS CheckBusStatus(Can_DEV *pcan_chan)
{
UINT32 Status;
Status = CANDEV_READ(pcan_chan->errstat);
if((Status &amt; 0x00000080) == 0x00000080)
{
return OK;
}
else
{
return ERROR;
}
}