candrv.c

vxWorks下的can总线驱动

* 
*参数：无
******************************************************************************/
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 & 0x0002) == 0x0002)
	{
		CanRxInterrupt(&can_chan_dev[0]);

	}
	else
	{
		//logMsg("#can0 Rx vacant Int!T#", 1, 2, 3, 4, 5, 6);
	}
	/*
	if(intStatus & CAN0_TX_INT_STATUS)
	{
		CanTxInterrupt(&can_chan_dev[0]);
	}
	if(intStatus & CAN0_RX_INT_STATUS)
	{
		CanRxInterrupt(&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 & 0x0001) == 0x0001)
	{
		CanTxInterrupt(&can_chan_dev[1]);
	}
	else
	{
		//logMsg("#can1 Tx vacant Int!T#", 1, 2, 3, 4, 5, 6);
	}
	/*
	if(intStatus & CAN1_TX_INT_STATUS)
	{

		CanTxInterrupt(&can_chan_dev[1]);
	}
	if(intStatus & CAN1_RX_INT_STATUS)
	{

		logMsg("#T****T#", 1, 2, 3, 4, 5, 6);
		CanRxInterrupt(&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 & 0x0002) == 0x0002)
	{
		CanRxInterrupt(&can_chan_dev[1]);
	}
	else
	{
		//logMsg("#can1 Rx vacant Int!T#", 1, 2, 3, 4, 5, 6);
	}
	/*
	if(intStatus & CAN1_TX_INT_STATUS)
	{

		CanTxInterrupt(&can_chan_dev[1]);
	}
	if(intStatus & CAN1_RX_INT_STATUS)
	{

		logMsg("#T****T#", 1, 2, 3, 4, 5, 6);
		CanRxInterrupt(&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) && ( 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 & 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 & 0x00000080) == 0x00000080)
	{
		return OK;
	}
	else
	{
		return ERROR;
	}

}