d12.h

经过改进之后的CAN－USB接口卡固件程序

				}			
								
				CMD_EXE_STATUS[7] = CMD_EXE_SUCCESS;
				break;	
								
			case CMD_SET_BTR:
				CAN_BTR0 = (UCHAR)device_request.wValue;
				CAN_BTR1 = (UCHAR)(device_request.wValue>>8);
				if(device_request.wIndex == 0)//设置CAN0的波特率
				{					
					CAN0_Initial();
				}
				else if(device_request.wIndex == 1)//设置CAN1的波特率
				{
					CAN1_Initial();
				}
				else if(device_request.wIndex == 2)//设置CAN0和CAN1的波特率
				{
					CAN0_Initial();
					CAN1_Initial();
				}	
				//注意初始化之后,CAN端口接收中断是关闭的.
				
				CMD_EXE_STATUS[7] = CMD_EXE_SUCCESS;			
				break;
			default:
				;				
		}
		if(req == CMD_REQ_TEST)
			return;
		
		//回复8个字节的状态字
		EP0_Request_PData = CMD_EXE_STATUS;		
		single_transmit(EP0_Request_PData, 8);	
		EP0_state = IDLE;
	}
	else//PC不需要设备向上传输数据
	{
		switch(req)
		{			
			case 0x01:
			
				break;
			case 0x02:
				break;
			case 0x03:
				break;
			default :
				;
		}
	}
	
}

void EP0_Out()
{
    UCHAR ep_last;

	ep_last = D12_ReadLastTransactionStatus(0); //清中断标志	

	if (ep_last & 0x20)  //接收到SETUP包++++++++++
    {    	
		EP0_Request_wLength = 0;
		EP0_Request_wCount = 0;

		if( D12_ReadEndpoint(0,8,&device_request) != 8)
        {
			//SETUP包出错,返回
			D12_SetEndpointStatus(0, 1);
			D12_SetEndpointStatus(1, 1);
			return;
		}		
		
		device_request.wValue = SWAP(device_request.wValue);
		device_request.wIndex = SWAP(device_request.wIndex);
		device_request.wLength = SWAP(device_request.wLength);
		
		//对控制端点的输入/输出进行应答
		D12_AcknowledgeEndpoint(0);
		D12_AcknowledgeEndpoint(1);		

		EP0_Request_wLength = device_request.wLength;
		EP0_Request_wCount = 0;

        if(device_request.bmRequestType == 0xA1)//GET MAX LUN
        {
             Get_Max_Lun();
             return;
        }
        if(device_request.bmRequestType == 0x01)//Set_Interface
        {
             Set_Interface();
             return;
        }
        if((device_request.bmRequestType & 0x60) == 0x40)//厂商请求
        {
        	LW_Request(device_request.bRequest);//USB命令接收历程
        	return;
        }

		if (device_request.bmRequestType & 0x80) //从主机传输数据
            get_descriptor();    //获取设备描述符或者配置描述符    get command
		else if (device_request.wLength == 0)
        {
			if(device_request.bRequest == 0x05)
                set_address();    // set command
            else if(device_request.bRequest == 0x09)
                set_configuration();   // set command
            else
                stall_ep0();
		}
    }//接收到SETUP包-----------
    else
    {    	
    	EP0_Receive_wLength = 0;//注意：这句话放在这里不合适
		EP0_Receive_wCount = 0;//注意：这句话放在这里不合适
		
		EP0_Receive_wLength = D12_ReadEndpoint(0,16,EP0_Receive_PData);
		
		//对控制端点的输入/输出进行应答
		D12_AcknowledgeEndpoint(0);
		D12_AcknowledgeEndpoint(1);
		
		//下面对所收到的数据进行处理...
		;
    }
}

void EP0_In()
{
    unsigned int i = EP0_Request_wLength - EP0_Request_wCount;

	D12_ReadLastTransactionStatus(1); //清中断标志位

	if (EP0_state != TRANSMIT)
		return;//非发送状态,返回

	if( i >= 16)       //剩下数据大于16字节,发送16字节
    {
		D12_WriteEndpoint(1, 16, EP0_Request_PData + EP0_Request_wCount);
		EP0_Request_wCount += 16;
		EP0_state = TRANSMIT;
	}
	else if( i != 0)   //发送剩下数据
    {
		D12_WriteEndpoint(1, i, EP0_Request_PData + EP0_Request_wCount);
		EP0_Request_wCount += i;
		EP0_state = IDLE;
	}
	else if (i == 0)   //发送完毕,发送0字节
    {
		D12_WriteEndpoint(1, 0, 0);
		EP0_state = IDLE;
	}
}

UINT EP1_Send_to_PC(ULONG len,UINT * buf)
{
//以下代码为测试使用
	int i = 0;
	for(i=0;i<64;i++)
		EP1_Request_PData[i] = i;//注意：这里并没有使用函数传进来的buf。
		
	if (EP1_state != TRANSMIT)
		return 0;//非发送状态,返回

	if( len >= 16)       //剩下数据大于16字节,发送16字节
    {
		D12_WriteEndpoint(3, 16, EP1_Request_PData + (EP1_Request_wCount%64));
		EP1_Request_wCount += 16;
		EP1_state = TRANSMIT;
		return 16;
	}
	else if( len != 0)   //发送剩下数据
    {
		D12_WriteEndpoint(3, len, EP1_Request_PData + (EP1_Request_wCount%64));
		EP1_Request_wCount += len;
		EP1_state = IDLE;
		return len;
	}
	else if (len == 0)   //发送完毕,发送0字节
    {
		D12_WriteEndpoint(3, 0, 0);
		EP1_state = IDLE;
		return len;
	}		
}

void EP1_Out()
{
	UINT len = 0;
	
	D12_ReadLastTransactionStatus(2); //清中断标志位
	
	//对EP1端点的输入/输出进行应答
	D12_AcknowledgeEndpoint(2);
	
	len = D12_ReadEndpoint(2,sizeof(EP1_Out_buf),EP1_Out_buf);	
	
	if(len == 4)//测试代码++++++++++++++++++++++
	{
		EP1_CMD = (0xFF00 & (EP1_Out_buf[0]<<8)) + (0x00FF & EP1_Out_buf[1]);
		EP1_Request_wLength = (0xFF00 & (EP1_Out_buf[2]<<8)) + (0x00FF & EP1_Out_buf[3]);
				
		switch(EP1_CMD)
		{
			case 0xAAAA:
				EP1_Request_wCount = 0;
				EP1_state = TRANSMIT;
				EP1_Send_to_PC(EP1_Request_wLength-EP1_Request_wCount,EP1_Request_PData);				
				break;
			case 0xBBBB:
				;
				break;
			default:
				;		
		}
	}//测试代码---------------------------
}

void EP1_In()
{	
	D12_ReadLastTransactionStatus(3); //清中断标志位	
	D12_AcknowledgeEndpoint(3);
	
	if(EP1_Request_wLength > EP1_Request_wCount)
		EP1_Send_to_PC(EP1_Request_wLength-EP1_Request_wCount,EP1_Request_PData);	
}

UINT EP2_Send_to_PC(ULONG len,UCHAR * buf)
{
	if (EP2_state != TRANSMIT)
		return 0;//非发送状态,返回

	if( len >= 64)       //剩下数据大于64字节,发送64字节
    {
		D12_WriteEndpoint(5, 64, buf + EP2_Request_wCount);
		EP2_Request_wCount += 64;
		EP2_state = TRANSMIT;
		return 64;
	}
	else if( len != 0)   //发送剩下数据
    {
		D12_WriteEndpoint(5, len, buf + EP2_Request_wCount);
		EP2_Request_wCount += len;
		EP2_state = IDLE;
		
		//一次发送完毕,把标志位置0
		USB_Packet[1-USB_Packet_Use_flag].USB_Packet_struct.CAN_frame_num = 0;
		Recv_index[1-USB_Packet_Use_flag] = -1;
		
		
		return len;
	}
	else if (len == 0)   //发送完毕,发送0字节
    {
		D12_WriteEndpoint(5, 0, 0);
		EP2_state = IDLE;
		
		//一次发送完毕,把标志位置0
		USB_Packet[1-USB_Packet_Use_flag].USB_Packet_struct.CAN_frame_num = 0;
		Recv_index[1-USB_Packet_Use_flag] = -1;
		
		return len;
	}		
}

void EP2_Out()
{
	UINT len,epstatus,i;
	ULONG CAN_packet_length;

	
	D12_ReadLastTransactionStatus(4); //清中断标志位
	epstatus = D12_ReadEndpointStatus(4);
	epstatus &= 0x60;
	
	//接受数据 现在还没有处理一次接收大于64字节的数据.
	len = D12_ReadEndpoint(4,64,EP2_Out_buf);
	if(epstatus == 0x60)
		len = D12_ReadEndpoint(4,64,EP2_Out_buf);//读取双缓冲区的数据
		
	//对EP2端点的输入/输出进行应答
	D12_AcknowledgeEndpoint(4);	
	
	if(len != 0)//测试代码++++++++++++++++++++++
	{
		EP2_CMD = (0xFF00 & (EP2_Out_buf[0]<<8)) + (0x00FF & EP2_Out_buf[1]);
		EP2_Request_wLength = (0xFF00 & (EP2_Out_buf[2]<<8)) + (0x00FF & EP2_Out_buf[3]);
				
		switch(EP2_CMD)
		{
		//-----------------------------------------------------------------------------------------
			case 0x0001://读取CAN接收的数据
							
				if(CAN0RIER & 0x01)//等待CAN0最后一帧接收完成
					while(Recv_Over_Flag[0] == 0);
				if(CAN1RIER & 0x01)//等待CAN1最后一帧接收完成
					while(Recv_Over_Flag[1] == 0);
				
				USB_Packet_Use_flag = 1 - USB_Packet_Use_flag;//交换缓冲区
					
				EP2_Request_wCount = 0;
				EP2_state = TRANSMIT;
				CAN_packet_length = 4 + 4 + USB_Packet[1-USB_Packet_Use_flag].USB_Packet_struct.CAN_frame_num*sizeof(ASCL_CAN_OBJ) + 4;
				if(CAN_packet_length > EP2_Request_wLength)
					CAN_packet_length = EP2_Request_wLength;
				else
					EP2_Request_wLength = CAN_packet_length;
				
				USB_Packet[1-USB_Packet_Use_flag].Bytes[CAN_packet_length-1] = 0xCD;//USB_Packet.USB_Packet_struct.end;
				
			//	for(i=0;i<USB_Packet[1-USB_Packet_Use_flag].USB_Packet_struct.CAN_frame_num;i++)//串口调试
			//		Write_To_SCI1_DATA_ASCII(USB_Packet[1-USB_Packet_Use_flag].USB_Packet_struct.Recv_Frame[i].Data[0]);
					
				EP2_Request_PData = USB_Packet[1-USB_Packet_Use_flag].Bytes;
				EP2_Send_to_PC(EP2_Request_wLength-EP2_Request_wCount,EP2_Request_PData);
				
				break;
		//-----------------------------------------------------------------------------------------	
			case 0x0002://发送一帧CAN数据			
				SendFrame.RemoteFlag = EP2_Out_buf[3];
				SendFrame.ExternFlag = EP2_Out_buf[4];
				SendFrame.ID = (((ULONG)EP2_Out_buf[5])<<24) + (((ULONG)EP2_Out_buf[6])<<16) + (((ULONG)EP2_Out_buf[7])<<8) + (ULONG)EP2_Out_buf[8];
				SendFrame.Priority = EP2_Out_buf[9];
				SendFrame.DataLen = EP2_Out_buf[10];
				for(i=0;i<SendFrame.DataLen;i++)
					SendFrame.Data[i] = EP2_Out_buf[11+i];
				
				if(	EP2_Out_buf[2] == 0)
	    			CAN0TIER = 0x07;
				else if(EP2_Out_buf[2] == 1)
					CAN1TIER = 0x07;
				else
				{
					CAN0TIER = 0x07;
					CAN1TIER = 0x07;
				}
				
				break;
		//-----------------------------------------------------------------------------------------		
			case 0xAAAA://测试
				EP2_Request_wCount = 0;
				EP2_state = TRANSMIT;		

				EP2_Request_PData = EP2_Test_data;
				
				EP2_Send_to_PC(EP2_Request_wLength-EP2_Request_wCount,EP2_Request_PData);				
				break;
			case 0xBBBB:
				;
				break;
			
			default:
				;		
		}
	}//测试代码---------------------------	
}

void EP2_In()
{
	D12_ReadLastTransactionStatus(5); //清中断标志位
	D12_AcknowledgeEndpoint(5);
	
	if(EP2_Request_wLength > EP2_Request_wCount)
		EP2_Send_to_PC(EP2_Request_wLength-EP2_Request_wCount,EP2_Request_PData);			
}