success6.c

在单片机系统下实现基本的固件枚举,对应用开发者大有裨益

	} 
	else
		stall_ep0();
}

void reserved(void)
{
	stall_ep0();
}

code void (*StandardDeviceRequest[])(void) =
{
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	set_address,
	get_descriptor,
	reserved,
	get_configuration,
	set_configuration,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved,
	reserved
};

void control_handler(void)
{
	unsigned char req;

	req = ControlData.DeviceRequest.bRequest & 0x0f;  // & 0x0F

   (*StandardDeviceRequest[req])(); // 调用标准请求
}

void main()
{
	unsigned short temp;
	
  	init_MCS51();    
 	bEPPflags.bits.setup_packet = 0;
 	
  	delay(191);           // 延时10ms
  	delay(191);
  	delay(191);
  	delay(191);
   
  	while(TRUE)
  	{
  		reconnect_USB();
  		TR1=1;
  	
  		temp=D12_ReadChipID();
  		serial_output(temp>>8);
  		serial_output(temp);
  		
  		if(temp==0x1012) 
  		{
  			EA=1;
  	   		while( TRUE )
			{
				if (bEPPflags.bits.setup_packet)   // Setup包处理
				{
					DISABLE;
					bEPPflags.bits.setup_packet = 0;				
					control_handler();             // 调用请求处理子程序
			    	ENABLE;	
				} // if setup_packet
        
			} // Main Loop               
  		}     // if 结束
	}         // 外层循环  
	 
}


/****************************** 中断处理 ***********************************************/

unsigned char D12_WriteEndpoint_ist(unsigned char endp, unsigned char len, unsigned char * buf) // 写端点
{                                                                                      // 返回数据的长度
	unsigned char i;

	outportb(D12_COMMAND, endp);    // 选管道
	i = inportb(D12_DATA);

	outportb(D12_COMMAND, 0xF0);    // 写缓冲区
	outportb(D12_DATA, 0);          // 第一字节保留，为0
	outportb(D12_DATA, len);        // 第二字节为数据字节长度

	for(i=0; i<len; i++)
		outportb(D12_DATA, *(buf+i)); // 写入数据

	outportb(D12_COMMAND, 0xFA);      // 使缓冲区有效


	return len;
}

void ep0_txdone(void)                       // 端点0 IN处理
{
	short i = ControlData.wLength - ControlData.wCount;
	D12_ReadLastTransactionStatus(1);       // 清中断标志位
	if (bEPPflags.bits.control_state != USB_TRANSMIT) 
		return;                             // 非发送状态,返回

	if( i >= EP0_PACKET_SIZE)               // 剩下数据大于16字节,发送16字节
	{		
		D12_WriteEndpoint_ist(1, EP0_PACKET_SIZE, ControlData.pData + ControlData.wCount);
		ControlData.wCount += EP0_PACKET_SIZE;
		bEPPflags.bits.control_state = USB_TRANSMIT;
	}
	else if( i != 0)                       // 发送剩下数据
	{		
		D12_WriteEndpoint_ist(1, i, ControlData.pData + ControlData.wCount);
		ControlData.wCount += i;
		bEPPflags.bits.control_state = USB_IDLE;
	}
	else if (i == 0)                      // 发送完毕,发送0字节
	{
		D12_WriteEndpoint_ist(1, 0, 0); 
		bEPPflags.bits.control_state = USB_IDLE;
	}
}

void ep0_rxdone(void)                           // 端点0 OUT中断
{
	unsigned char ep_last, i;

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

	if (ep_last & D12_SETUPPACKET)              //接收到SETUP包
	{		
		ControlData.wLength = 0;
		ControlData.wCount = 0;

		if( D12_ReadEndpoint(0, sizeof(ControlData.DeviceRequest),
			(unsigned char *)(&(ControlData.DeviceRequest))) != sizeof(DEVICE_REQUEST) ) 
		{                              // 数据读到 ControlData.DeviceRequest 里
			// SETUP包出错,返回
			D12_SetEndpointStatus(0, 1);
			D12_SetEndpointStatus(1, 1);
			bEPPflags.bits.control_state = USB_IDLE;
			return;
		}

		ControlData.DeviceRequest.wValue = SWAP(ControlData.DeviceRequest.wValue);
		ControlData.DeviceRequest.wIndex = SWAP(ControlData.DeviceRequest.wIndex);
		ControlData.DeviceRequest.wLength = SWAP(ControlData.DeviceRequest.wLength);

		// 对控制端点的输入/输出进行应答
		D12_AcknowledgeEndpoint(0); // 对控制输出管道应答
		D12_AcknowledgeEndpoint(1); // 对控制输入管道应答

		ControlData.wLength = ControlData.DeviceRequest.wLength;
		ControlData.wCount = 0;
/********************************************************************************************/
         	serial_output(ControlData.DeviceRequest.bmRequestType);
         	serial_output(ControlData.DeviceRequest.bRequest);
         	serial_output(ControlData.DeviceRequest.wValue>>8);
         	serial_output(ControlData.DeviceRequest.wValue);
         	serial_output(ControlData.DeviceRequest.wIndex>>8);
         	serial_output(ControlData.DeviceRequest.wIndex);
         	serial_output(ControlData.DeviceRequest.wLength>>8);
         	serial_output(ControlData.DeviceRequest.wLength);
/********************************************************************************************/
		if (ControlData.DeviceRequest.bmRequestType & 0x80) 
		{
			// 从设备到主机传输数据
			bEPPflags.bits.setup_packet = 1;
			bEPPflags.bits.control_state = USB_TRANSMIT;		/* get command */
		}
		else // 从主机到设备
		{
			if (ControlData.DeviceRequest.wLength == 0) 
			{
				bEPPflags.bits.setup_packet = 1;
				bEPPflags.bits.control_state = USB_IDLE;		/* set command */
			}
			else 
			{
				if(ControlData.DeviceRequest.wLength > MAX_CONTROLDATA_SIZE) 
				{
					// 接收数据长度为0
					bEPPflags.bits.control_state = USB_IDLE;
					D12_SetEndpointStatus(0, 1);  // 设置控制输出管道处于停止状态
					D12_SetEndpointStatus(1, 1);  // 设置控制输入管道处于停止状态
				}
				else 
				{
					bEPPflags.bits.control_state = USB_RECEIVE;	// 设置接收状态
				}
			} // set command with data
		} // else set command
	} // if setup packet

	else if (bEPPflags.bits.control_state == USB_RECEIVE) 
	{
		    // 接收数据                                       // 地址偏移量
		i =	D12_ReadEndpoint(0, EP0_PACKET_SIZE, ControlData.dataBuffer + ControlData.wCount);
		ControlData.wCount += i;             
		if( i != EP0_PACKET_SIZE || ControlData.wCount >= ControlData.wLength) 
		{
			// 数据接收完毕
			bEPPflags.bits.setup_packet = 1;
			bEPPflags.bits.control_state = USB_IDLE;
		}
	}
	else 
	{
		bEPPflags.bits.control_state = USB_IDLE;//进入等待状态
	}
}

void ep1_txdone(void)                 // 端点1 OUT处理
{
	D12_ReadLastTransactionStatus(3); // 清中断标志位
}

void ep1_rxdone(void)                 // 端点1 IN处理
{
	unsigned char xdata len;

	D12_ReadLastTransactionStatus(2);    // 清中断标志位
	len = D12_ReadEndpoint(2, sizeof(GenEpBuf), GenEpBuf); // 读取数据
	if(len != 0)
		bEPPflags.bits.ep1_rxdone = 1;   // 标志接收到数据
}

void main_txdone(void)               // 主端点 In控制
{	
	unsigned char len,i;
	D12_ReadLastTransactionStatus(5); //清中断标志位
	len = D12_WriteEndpoint_ist(5, 64, EpBufL);
	serial_output(len);
	for(i=0;i<len;i++)
		serial_output(EpBufL[i]);
}

void main_rxdone(void)               // 主端点接收
{
	unsigned char  len,i;
    unsigned char  EpBuf[EP2_PACKET_SIZE];
	D12_ReadLastTransactionStatus(4); //清中断标志位

	// 接收数据
	len = D12_ReadEndpoint(4, 64, EpBuf);
	serial_output(len);
	for(i=0;i<len;i++)
		serial_output(EpBuf[i]);
	
}

void usb_isr(void) interrupt 2         // USB中断服务子程序
{
	
	unsigned int i_st;
    DISABLE;
	bEPPflags.bits.in_isr = 1;

	i_st = D12_ReadInterruptRegister();      // 读取中断寄存器
    serial_output(i_st);
    serial_output(i_st>>8);
    
	if(i_st != 0)
	{
		if(i_st & D12_INT_BUSRESET) 
		{
		//	bus_reset();                     // USB总线重起,通过读中断寄存器就可以清掉
			bEPPflags.bits.bus_reset = 1;    // 上电连接主机后读的第一个中断
			serial_output(0xaa);
		}

		if(i_st & D12_INT_SUSPENDCHANGE)
		{
			bEPPflags.bits.suspend = 1;      // 挂起改变,,通过读中断寄存器就可以清掉
            serial_output(0xbb);             // 上电连接主机后读的第二个中断
        }
		if(i_st & D12_INT_ENDP0IN)
		{
		   	ep0_txdone();                    // 端点0 IN中断,以后6个中断必须通过读最后处理状态才能清掉
			serial_output(0xcc);
			serial_output(0xcc);
		}
		if(i_st & D12_INT_ENDP0OUT)
		{
			ep0_rxdone();                    // 端点0 OUT中断
   			serial_output(0xdd);
   			serial_output(0xdd);
		}
		if(i_st & D12_INT_ENDP1IN)
			ep1_txdone();                    // 端点1 IN中断
		if(i_st & D12_INT_ENDP1OUT)
			ep1_rxdone();                    // 端点1 OUT中断
		if(i_st & D12_INT_ENDP2IN)
			main_txdone();                   // 端点2 IN中断
		if(i_st & D12_INT_ENDP2OUT)
			main_rxdone();                   // 端点2 OUT中断
	}

	bEPPflags.bits.in_isr = 0;
	ENABLE;
}