d12api.c

经过测试成功的PDIUSBD12与Mega8的连接代码

#include <iom8v.h>
#include <macros.h>

#include "define.h"
#include "D12API.h"

/*******************************写USB命令******************************************/
void write_usb_command(unsigned char usb_command)
{
 USB_A0=USB_COMMAND_ADD;
 USB_DATA=usb_command;
 USB_WR=0;
 USB_WR=1;
 USB_DATA=0xFF;
}
/******************************************************************************/

/*********************写一字节USB数据*******************************************/
void write_a_usb_data(uint8 usb_data)       
{
 USB_A0=USB_DATA_ADD;
 USB_DATA=usb_data;
 USB_WR=0;
 USB_WR=1;
 USB_DATA=0XFF;
}
/******************************************************************************/

/****************************读一字节USB数据************************************/
uint8 read_a_usb_data(void)
{
 uint8 temp;
 USB_A0=USB_DATA_ADD;
 USB_RD=0;
 temp=USB_DATA;
 USB_RD=1;
 return temp;
}
/******************************************************************************/

/************************读USB中断寄存器**************************************/
void read_interrupt_register(void)
{
 write_usb_command(Read_Interrupt_Register);
 Interrupt_Register.Register[0]=read_a_usb_data();
 Interrupt_Register.Register[1]=read_a_usb_data();
}
/******************************************************************************/

/************************设置USB地址*******************************************/
void set_usb_addr(uint8 addr)
{

 write_usb_command(Set_Address);
 write_a_usb_data(0x80|addr);
 Prints("   设置地址.....................",1);
 Prints("       地址为：  ",0);
 PrintLongInt(addr);
 Prints("",1);
}
/******************************************************************************/

/*************************端点使能******************************************/
void set_endpoint_enable(void)
{
 write_usb_command(Set_Endpoint_Enable);
 write_a_usb_data(0x01);
}
/******************************************************************************/

/****************************选择终端点*************************************/
uint8 select_endpoint(uint8 endp)
{
 write_usb_command(Select_EndPoint+endp);
 return read_a_usb_data();
}
/******************************************************************************/

/****************************读端点最后状态**********************************/
uint8  read_last_status(uint8 endp)
{
 write_usb_command(Read_Last_Status+endp);
 return read_a_usb_data();
}
/******************************************************************************/

/****************************设置端点状态**************************************/
void set_endpoint_status(uint8 endp,uint8 status)  
{
 write_usb_command(0x40+endp);
 write_a_usb_data(!status);
}
/******************************************************************************/

/*****************************读端点状态**************************************/
uint8 read_endpoint_status(uint8 endp)
{
 write_usb_command(0x80+endp);
 return read_a_usb_data();
}
/******************************************************************************/

/************************清缓冲，在读取缓冲数据后调用**************************/
void clear_buffer(void)
{
 write_usb_command(Clear_Buffer);
}
/******************************************************************************/

/***********************缓冲区数据有效，在写缓冲后调用**************************/
void validate_buffer(void)
{
 write_usb_command(Validate_Buffer);
}
/******************************************************************************/

/***************************应答建立包************************************/
void ack_setup(uint8 endp)
{
 select_endpoint(endp);
 write_usb_command(Ack_Setup);
}
/******************************************************************************/

/***********************出错处理******************************************/
void error(uint8 number)
{
 Prints("有错误发生！！！",1);
 number=0;
}
/******************************************************************************/

/*************************读终端点缓冲****************************************/
uint8 read_endpoint_buff(uint8 endp,uint8 len,uint8 * buff)
{
 uint8 i,j;
 read_last_status(endp);
 if(!(select_endpoint(endp))&0x01){error(0); return 0;}
 read_endpoint_status(endp);
 write_usb_command(Read_Buffer);
 read_a_usb_data();
 j=read_a_usb_data();
 if(j>len)
  j=len;
 for(i=0;i<j;i++)
  {
   USB_RD=0;
   *(buff+i)=USB_DATA;
   USB_RD=1;
  }
 clear_buffer();
 return j;
}
/******************************************************************************/

/*************************写终端点缓冲*****************************************/
uint8 write_endpoint_buff(uint8 endp,uint8 len,uint8 * buff)
{
 uint8 i;
 read_last_status(endp);
 select_endpoint(endp);
 write_usb_command(Write_Buffer);
 write_a_usb_data(0);
 write_a_usb_data(len);
 for(i=0;i<len;i++)
  {
   USB_DATA=*(buff+i);
   USB_WR=0;
   USB_WR=1;
  }
 USB_DATA=0XFF;
 validate_buffer();
 return len;
}
/******************************************************************************/

/***************************断开USB连接****************************************/
void disconnect_usb(void)
{
 Prints("断开USB连接........................",1);
 write_usb_command(0xf3);
 write_a_usb_data(0x0e);
 write_a_usb_data(0x47);
 delay(100);
}
/******************************************************************************/

/*******************************连接USB**************************************/
void connect_usb(void)
{
 Prints("连接USB...............",1);
 write_usb_command(0xf3);                         //初始化USBD12
 write_a_usb_data(0x1e);                          //连接USB
 write_a_usb_data(0x47);                          //设置频率
}
/******************************************************************************/

/***************************初始化USB***************************************************/
void init_usb(void)               
{
 Prints("USBD12芯片初始化",1);
 set_usb_addr(0);
 set_endpoint_enable();
}
/******************************************************************************/

/****************************USB总线复位处理***********************************/
void usb_bus_reset(void)
{
 Prints("USB总线复位................................",1);
 usb_flags.Register=0;
 set_endpoint_enable();
}
/******************************************************************************/

/*****************************USB总线挂起处理**********************************/
void usb_bus_suspend(void)
{
 Prints("USB总线挂起................................",1);
}
/******************************************************************************/

/***************************设置地址***************************************/
void set_usb_address(void)
{
 usb_flags.flags.set_addr=1;
 while(select_endpoint(1)&0x01);
 write_endpoint_buff(1,0,0);
 set_usb_addr(Control_Data.DeviceRequest.wValue);
 usb_flags.flags.usb_endp0_in=0;
 usb_flags.flags.setup_packet_out=0;
}
/******************************************************************************/

/**************************获取状态响应*****************************************/
void get_status(uint8 receiver)
{
 uint8 status[2];
 switch (receiver)
  {
   case 0:                        //获取设备状态
    status[0]=0x00;
    status[1]=0x00;
    break;
   case 1:                        //获取接口状态
    status[0]=0x00;
    status[0]=0x00;
    break;
   case 2:                        //获取端点状态
    status[0]=0x00;
    status[1]=0x00;
    break;
   }
  write_endpoint_buff(1,2,status);
  usb_flags.flags.usb_endp0_in=0;
}
/******************************************************************************/

/*********************清除特性*******************************************/
void clear_feature(uint8 receiver)    
{
 Prints("    清除特性................................",1);
 receiver=0;
 write_endpoint_buff(1,0,0);
 usb_flags.flags.usb_endp0_in=0;
 usb_flags.flags.setup_packet_out=0;
}
/******************************************************************************/

/*******************设置特性**************************************************/
void set_feature(uint8 receiver)
{
 Prints("    设置特性................................",1);
 receiver=0;
 write_endpoint_buff(1,0,0);
 usb_flags.flags.usb_endp0_in=0;
 usb_flags.flags.setup_packet_out=0;
}
/******************************************************************************/

/*****************************设置描述*****************************************/
void set_descriptor(void)
{
 Prints("    设置描述符................................",1);
 usb_flags.flags.usb_endp0_in=0;
 usb_flags.flags.setup_packet_out=0;
}
/******************************************************************************/

/***************************设置配置*******************************************/
void set_configuration(void)
{
 Prints("    设置配置................................",1);
 write_endpoint_buff(1,0,0);
 usb_flags.flags.usb_endp0_in=0;
 usb_flags.flags.setup_packet_out=0;
}
/******************************************************************************/

/************************获取配置状态******************************************/
void get_configuration(void)
{ 
 uint8 value=0x01;
 Prints("    获取配置................................",1);
 write_endpoint_buff(1,1,&value);
 usb_flags.flags.usb_endp0_in=0;
}
/******************************************************************************/

/****************************设置接口************************************/
void set_interface(void)
{
 Prints("    设置接口................................",1);
 write_endpoint_buff(1,0,0);
 usb_flags.flags.usb_endp0_in=0;
 usb_flags.flags.setup_packet_out=0;
}
/******************************************************************************/

/***************************获取接口状态***************************************/
void get_interface(void)
{
 uint8 value=0x01;
 Prints("    获取接口................................",1);
 write_endpoint_buff(1,1,&value);
 usb_flags.flags.usb_endp0_in=0;
}
/******************************************************************************/

/***********************获取描述符*********************************************/
void get_descriptor(void)
{
 Prints("    获取描述符................................",1);
  if(!usb_flags.flags.not_end)
     {
      switch(MSB(Control_Data.DeviceRequest.wValue))
	   {
        case DEVICE_DESCRIPTOR:
		     Prints("        获取设备描述符................................",1);
	         Control_Data.wCount=sizeof(DEVICE_DESCRIPTOR_STRUCT);
 	         Control_Data.pData=(uint8 *)(&device_descriptor);
             break;
        case CONFIGURATION_DESCRIPTOR:
			 Prints("        获取配置描述符................................",1);
             Control_Data.wCount=SWAP16(con_int_endp_descriptor.configuration_descriptor.wTotalLength);
			 Control_Data.pData=(uint8 *)(&con_int_endp_descriptor);
             if(Control_Data.wLength<Control_Data.wCount)Control_Data.wCount=Control_Data.wLength;
             break;
		case STRING_DESCRIPTOR:
		     Prints("        获取字符串描述符................................",1);
			 switch(LSB(Control_Data.DeviceRequest.wValue))
			  {
			   case 0:
			    Prints("            获取语言ID................................",1);
			    Control_Data.wCount=LANGUAGE_ID[0];
                Control_Data.pData=LANGUAGE_ID;
   			    break;

			   case 1:
			    Prints("            获取厂商字符串................................",1);
			    Control_Data.wCount=ManufacturerString[0];
                Control_Data.pData=ManufacturerString;
			    break;

			   case 2:
			    Prints("            获取产品字符串................................",1);
			    Control_Data.wCount=ProducterString[0];
                Control_Data.pData=ProducterString;
			    break;

			   case 3:
                 Prints("            获取设备序列号................................",1);
			     Control_Data.wCount=device_serial_number[0];
			     Control_Data.pData=device_serial_number;
			   break;

			   default: break;
			  }
			 break;
		 default:
		     Prints("       获取其它描述符..................描述符索引为：",0);
			 PrintLongInt(MSB(Control_Data.DeviceRequest.wValue));
			 Prints("",1); 
		  break;
	   	}
      if(Control_Data.wLength<Control_Data.wCount)Control_Data.wCount=Control_Data.wLength;
	 }
	//写数据到D12输入端点
    if(Control_Data.wCount>=MAX_CONTROL_DATA_SIZE)
     {
	  write_endpoint_buff(1,MAX_CONTROL_DATA_SIZE,Control_Data.pData);
	  Control_Data.pData+=MAX_CONTROL_DATA_SIZE;
      Control_Data.wCount-=MAX_CONTROL_DATA_SIZE;
	  if(usb_flags.flags.set_addr)usb_flags.flags.not_end=1;
	   else usb_flags.flags.usb_endp0_in=0;
	  return;
	 }
    else
     {
	  write_endpoint_buff(1,Control_Data.wCount,Control_Data.pData);
      usb_flags.flags.setup_packet_in=0;
	  usb_flags.flags.usb_endp0_in=0;
	  return;
	 }      
}
/******************************************************************************/