Stm32 virtual com port in fs mode driver windows 10

	//макрос адресации
	#define REG(x)  (*((volatile unsigned int )(x)))
	
	//базовый адрес регистров драйвера
	#define USB_BASE_ADDR   0x40005C00
	//адрес начала области памяти драйвера USB          
	#define USB_PMA_ADDR    0x40006000
	
	//регистры состояния конечных точек
	#define EP0R	REG(USB_BASE_ADDR)
	#define EP1R	REG(0x40005C04)
	#define EP2R	REG(0x40005C08)
	#define EP3R	REG(0x40005C0C)
	#define EP4R	REG(0x40005C10)
	#define EP5R	REG(0x40005C14)
	#define EP6R	REG(0x40005C18)
	#define EP7R	REG(0x40005C1C)
	#define ENDPOINT(bEpNum)        REG(USB_BASE_ADDR + (bEpNum)*4)
	#define PMA_BUF(INum)        REG(USB_PMA_ADDR + (INum)4) 
	#define PMA_SBUF(SINum)        (((volatile unsigned short int *)(USB_PMA_ADDR + (SINum)*2)))
	
	//остальные регистры
	#define CNTR	REG(USB_BASE_ADDR + 0x40)   
	#define ISTR	REG(USB_BASE_ADDR + 0x44)   
	#define DADDR	REG(USB_BASE_ADDR + 0x4C) 
	#define BTABLE	REG(USB_BASE_ADDR + 0x50)

//Это то, что находится в  файле system_stm32f10x.c стандартной библиотеки.

#include "stm32f10x.h"
/* Reset the RCC clock configuration to the default reset state(for debug purpose) */ 
/* Set HSION bit */ 
RCC->CR |= (uint32_t)0x00000001;
/* Reset SW, HPRE, PPRE1, PPRE2, ADCPRE and MCO bits */ 
RCC->CFGR &= (uint32_t)0xF8FF0000;
/* Reset HSEON, CSSON and PLLON bits */ 
RCC->CR &= (uint32_t)0xFEF6FFFF;
/* Reset HSEBYP bit */ 
RCC->CR &= (uint32_t)0xFFFBFFFF;
/* Reset PLLSRC, PLLXTPRE, PLLMUL and USBPRE/OTGFSPRE bits */ 
RCC->CFGR &= (uint32_t)0xFF80FFFF;
/* Disable all interrupts and clear pending bits  */ 
RCC->CIR = 0x009F0000;
/* Configure the System clock frequency, HCLK, PCLK2 and PCLK1 prescalers */ 
/* Configure the Flash Latency cycles and enable prefetch buffer */

__IO uint32_t StartUpCounter = 0, HSEStatus = 0;

/* SYSCLK, HCLK, PCLK2 and PCLK1 configuration ---------------------------*/ 
/* Enable HSE */ 
RCC->CR |= ((uint32_t)RCC_CR_HSEON); 
//  RCC->CR |= ((uint32_t)RCC_CR_HSION);

/* Wait till HSE is ready and if Time out is reached exit */ 
do { 
HSEStatus = RCC->CR & RCC_CR_HSERDY; 
//    HSEStatus = RCC->CR & RCC_CR_HSIRDY; 
StartUpCounter++; 
} while(((RCC->CR & RCC_CR_HSERDY) == 0) && (StartUpCounter < HSE_STARTUP_TIMEOUT));

if ((RCC->CR & RCC_CR_HSERDY) != RESET) //	  if ((RCC->CR & RCC_CR_HSIRDY) != RESET) 
{ 
//HSEStatus = (uint32_t)0x01;    
/* Enable Prefetch Buffer */
     FLASH->ACR |= FLASH_ACR_PRFTBE;      
/* Flash 2 wait state */
     FLASH->ACR &= (uint32_t)((uint32_t)~FLASH_ACR_LATENCY);
     FLASH->ACR |= (uint32_t)FLASH_ACR_LATENCY_2;       
/* HCLK = SYSCLK */     
RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV1;      
/* PCLK2 = HCLK */     
RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE2_DIV1;
      /* PCLK1 = HCLK */     
	  RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE1_DIV2; 

    /*  PLL configuration: PLLCLK = HSE * 9 = 72 MHz */
	RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_PLLSRC | RCC_CFGR_PLLXTPRE |                                         RCC_CFGR_PLLMULL));     
	RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_HSE | RCC_CFGR_PLLMULL9);   
	//PLLMULL9 - for 8MHz 
	//    RCC->CFGR |= (uint32_t)(RCC_CFGR_PLLSRC_HSI_Div2 | RCC_CFGR_PLLMULL9);   
	//PLLMULL9 - for 8MHz     
	/* Enable PLL */
	RCC->CR |= RCC_CR_PLLON;      
	/* Wait till PLL is ready */     
	while((RCC->CR & RCC_CR_PLLRDY) == 0)     {     }      /* Select PLL as system clock source */     
	RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));     
	RCC->CFGR |= (uint32_t)RCC_CFGR_SW_PLL;      
	/* Wait till PLL is used as system clock source */     
	while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)0x08)     {     } 
	}SCB->VTOR = FLASH_BASE | VECT_TAB_OFFSET; 
	/* Vector Table Relocation in Internal FLASH. */

SystemInit();

//Содержимое SystemInit описано выше. 
//Сама функция находится в  файле system_stm32f10x.c стандартной библиотеки.

// Enable USB_DISCONNECT GPIO clock 
RCC->APB2ENR |= RCC_APB2Periph_GPIOF;

// Использование 11 пина как USB pull-up pin 
GPIOF->CRH &= 0xFFFF0FFF; 
GPIOF->CRH |= 0x00007000; 

//general output, open drain, 50MHz
//Конфигурация тактирования 
*(__IO uint32_t *) (0x424200D8) = 0;
//включить тактирование шины USB 
RCC->APB1ENR |=RCC_APB1Periph_USB;
//Приоритет прерывания (низший приоритет из возможных 0xf0, высший 0x10)
NVIC->IP[USB_LP_CAN1_RX0_IRQn] = 0xA0; 
//pending - будем проверять в цикле 
NVIC->ISER[(uint32_t)(USB_LP_CAN1_RX0_IRQn) >> 0x05] = (uint32_t)0x01 << (USB_LP_CAN1_RX0_IRQn & (uint8_t)0x1F);

USB_RESET();

#define EP0RX_OFFSET 	0x80
#define EP0TX_OFFSET 	0x40
#define EP1TX_OFFSET 	0xC0
#define EP2TX_OFFSET 	0x100
#define EP3RX_OFFSET 	0x110

BTABLE = 0;	// Адрес таблицы дискрипторов внутри PMA

//EP 0 - нулевая конечная точка 
	// ADDR_TX 
	PMA_BUF(0) = EP0TX_OFFSET; 
	// COUNT_TX = 0 нужно заполнять перед отправкой данных 
	PMA_BUF(1) = 0; 
	// ADDR_RX 
	PMA_BUF(2) = EP0RX_OFFSET; 
	// Указываем размер буфера приема 64 байта, BL_size = 1 (32 байта на блок), 2 штуки 
	PMA_BUF(3) = 0x8400;
	EP0R = ((EP0R ^ 0x3020) & 0x3030) | 0x0200; 

//EP 1 CDC TX 
	PMA_BUF(4) = EP1TX_OFFSET; 
	PMA_BUF(5) = 0; 
	PMA_BUF(6) = 0; 
	PMA_BUF(7) = 0; 
	ENDPOINT(1) = ((ENDPOINT(1) ^ 0x0020) & 0x3030);

//EP 2 CDC interrupt 
	PMA_BUF(8) = EP2TX_OFFSET; 
	PMA_BUF(9) = 0; 
	PMA_BUF(10) = 0; 
	PMA_BUF(11) = 0; 
	ENDPOINT(2) = ((ENDPOINT(2) ^ 0x0020) & 0x3030)|0x0600;

//EP 3 CDC RX 
	PMA_BUF(12) = 0; 
	PMA_BUF(13) = 0; 
	PMA_BUF(14) = EP3RX_OFFSET; 
	PMA_BUF(15) = 0x8400; 
	ENDPOINT(3) = ((ENDPOINT(3) ^ 0x3000) & 0x3030);

//Данные глобальные переменные нужны для формирования ответов на запросы хоста:
USB_Feature = 0xC0;
USB_Configuration = 0;
USB_Interface = 0;

//Обнуляем прерывание
ISTR = 0;
// Включаем модуль USB, адрес устройства 0
DADDR = 0x80;
// Дополнительно сбрасываем флаги прерываний(событий) USB
ISTR &= ~ISTR_RESET;

const char DeviceDiscriptor[] = { 
0x12,   		// bLength / 
0x01,     		// bDescriptorType / 
0x00, 0x02,		// bcdUSB = 2.00 / 

// класс и протокол перечислены на сайте https://www.usb.org/defined-class-codes
0x02, 	// bDeviceClass: CDC / 
0x00,   // bDeviceSubClass / 
0x00,   // bDeviceProtocol / 
0x40,   // bMaxPacketSize0 / 

//STMicroelectronics  СDC
// данные с сайта https://www.the-sz.com/products/usbid/index.php?v=0x04830x83, 
0x04,   		// idVendor = 0x0483 / 
0x40, 0x57,		// idProduct = 0x7540 / 
0x00, 0x02,		// bcdDevice = 2.00 / 1,              

// Index of string descriptor describing manufacturer / 
2,              // Index of string descriptor describing product / 
3,              // Index of string descriptor describing the device's serial number / 
0x01    		// bNumConfigurations / 
};

 const char ConfigDescriptor[] = { 
//Configuration Descriptor 
0x09,   // bLength: Configuration Descriptor size 
0x02,	// bDescriptorType: Configuration 
67,		// wTotalLength:no of returned bytes 
0x00, 0x02,   // bNumInterfaces: 2 interface 
0x01,   // bConfigurationValue: Configuration value 
0x00,   // iConfiguration: Index of string descriptor describing the configuration 
0xC0,   // bmAttributes: self powered 
0x32,   // MaxPower 0 mA 
//Interface Descriptor 
0x09,   // bLength: Interface Descriptor size 
0x04,	// bDescriptorType: Interface 
// Interface descriptor type 
0x00,   // bInterfaceNumber: Number of Interface 
0x00,   // bAlternateSetting: Alternate setting 
0x01,   // bNumEndpoints: One endpoints used 
0x02,   // bInterfaceClass: Communication Interface Class 
0x02,   // bInterfaceSubClass: Abstract Control Model 
0x01,   // bInterfaceProtocol: Common AT commands 
0x00,   // iInterface: 
//Header Functional Descriptor 
0x05,   // bLength: Endpoint Descriptor size 
0x24,   // bDescriptorType: CS_INTERFACE 
0x00,   // bDescriptorSubtype: Header Func Desc 
0x10,   // bcdCDC: spec release number 
0x01,	//Call Management Functional Descriptor 
0x05,   // bFunctionLength 
0x24,   // bDescriptorType: CS_INTERFACE 
0x01,   // bDescriptorSubtype: Call Management Func Desc 
0x00,   // bmCapabilities: D0+D1 
0x01,   // bDataInterface: 1 
//ACM Functional Descriptor 
0x04,   // bFunctionLength 
0x24,   // bDescriptorType: CS_INTERFACE 
0x02,   // bDescriptorSubtype: Abstract Control Management desc 
0x02,   // bmCapabilities 
//Union Functional Descriptor 
0x05,   // bFunctionLength 
0x24,   // bDescriptorType: CS_INTERFACE 
0x06,   // bDescriptorSubtype: Union func desc 
0x00,   // bMasterInterface: Communication class interface 
0x01,   // bSlaveInterface0: Data Class Interface 
//Endpoint 2 Descriptor 
0x07,   // bLength: Endpoint Descriptor size 
0x05,   // bDescriptorType: Endpoint 
0x82,   // bEndpointAddress: (IN2) 
0x03,   // bmAttributes: Interrupt 
8,   	// wMaxPacketSize: 
0x00, 0xFF,   // bInterval: 
//Data class interface descriptor 
0x09,   // bLength: Endpoint Descriptor size 
0x04,  // bDescriptorType: 
0x01,   // bInterfaceNumber: Number of Interface 
0x00,   // bAlternateSetting: Alternate setting 
0x02,   // bNumEndpoints: Two endpoints used 
0x0A,   // bInterfaceClass: CDC 
0x00,   // bInterfaceSubClass: 
0x00,   // bInterfaceProtocol: 
0x00,   // iInterface: 
//Endpoint 3 Descriptor 
0x07,   // bLength: Endpoint Descriptor size 
0x05,   // bDescriptorType: Endpoint 
0x03,   // bEndpointAddress: (OUT3) 
0x02,   // bmAttributes: Bulk 
64,		// wMaxPacketSize: 0x00, 
0x00,   // bInterval: ignore for Bulk transfer 
//Endpoint 1 Descriptor 
0x07,   // bLength: Endpoint Descriptor size 
0x05,   // bDescriptorType: Endpoint 
0x81,   // bEndpointAddress: (IN1) 
0x02,   // bmAttributes: Bulk 
64,		// wMaxPacketSize: 
0x00, 0x00	// bInterval  
};

При подключении устройство никак не определялось до конца. Вроде COM, но какой-то скомканный. Оказалось, компилятор не смог один из дескрипторов расположить в памяти единым куском. А читаю то я его «от забора и до обеда»! Так что компьютер, вместо того чтобы получить на свой запрос «как ты работаешь», вместо заранее заготовленного ответа «я делаю вот это и вот это» получал ответ «через Ж…» и прекращал дальнейшее общение с устройством. Пришлось этот дескриптор разбить на несколько частей по 16 байт и слать их одну за другой. Заработало.

Потом оказалось, что этот дескриптор я переобъявлял в другом файле, и от костыля удалось избавиться. Теперь каждый раз перепроверяю свои дефайны.

typedef enum _CONTROL_STATE{
	WAIT_SETUP, SETTING_UP, IN_DATA, OUT_DATA, LAST_IN_DATA, LAST_OUT_DATA, WAIT_STATUS_IN, WAIT_STATUS_OUT, STALLED, PAUSE
} CONTROL_STATE; 

//массивы и переменные, через которые мы будем работать 
unsigned char USB_Buff1[64]; 
unsigned char USB_COM_TX_Buff1[64]; 
uint16_t USB_RX_Start_pointer=0; 
uint16_t USB_Recieved_bytes=0; 
uint16_t USB_Bytes_to_send_left = 0;

//Эта переменная нужна нам для общения с внешним миром 
uint8_t USB_Function_flags=0; 
//1 - запрос оправки данных на хост(IN) 
//2 - запрос получения данных от хоста (OUT) 
//4 - есть, что обработать 
//8 - Данные от хоста в EP3 обработаны

//переменные для хранения команд, полученных контрольной точкой  
uint16_t USB_Command; 
uint16_t USB_wValue; 
uint16_t USB_wLength;
//Стадия процесса обработки команды от хоста 
CONTROL_STATE USB_state_flag = WAIT_SETUP;
//параметры контрольной конечной точки и конфигурация устройства 
uint8_t USB_DADDR = 0; 
uint8_t USB_Feature; 
uint8_t USB_Configuration; 
uint8_t USB_Interface; 
uint8_t EPindex; 
uint16_t BKIstr=0;
uint16_t SaveTState;

//P1 - указатель на первый элемент массива, откуда читаем
//P2 - позиция в массиве PMA, с которой записываем данные
//N - количество байт
//max - размер области PMA размеченный для данной операции
void TO_WRITE_PMA(uint16_t *P1, uint32_t P2, uint16_t N, uint16_t max){
	uint8_t i;
	N = (N > max)? max : N; 
	for(i=0; i<N; i+=2){ 
		PMA_SBUF(P2+i) = *P1;
		P1++; 
	}
}

void TO_READ_PMA(uint32_t P2, uint16_t *P1, uint16_t N, uint16_t max){
	uint8_t i;
	N = (N > max)? max : N; 
	for(i=0; i<N; i+=2){ 
		*P1 = PMA_SBUF(P2+i); 
		P1++; 
	}
}

//генерация текстовых дескрипторов.
//строка Str[] должна оканчиваться пустым символом
//EP - целевая конечная точка
void USB_Message (char Str[], uint8_t EP){
	uint16_t b1 = PMA_BUF(EP * 4);
	uint8_t i;
	//не более 31 символа, т.к. всего у нас 64 байта,
	//из которых 2 - это заголовок 
	//(младший байт - количество, старший - тип дескриптора),
	//а остальные - текст в юникоде 
	for (i = 0; (Str[i] && i < 31); i++) { 
		b1 += 2; 
		PMA_SBUF(b1) = Str[i]; 
	}
	i =i * 2 + 2 b1 = PMA_BUF(EP * 4); 
	PMA_SBUF(b1) = i | 0x0300; 
	//N bytes, 3 - string descriptor 
	PMA_BUF(EP * 4+1) = i;
}

void USB_LP_CAN1_RX0_IRQHandler(){
	BKIstr = ISTR;
	if(BKIstr & ISTR_CTR){
		CTR_LP_CTRX();
	}  
	if(BKIstr & ISTR_RESET){
		USB_RESET();
	}
}

#define ISTR_CTR		0x8000
#define ISTR_EP_ID	0x000F
#define EP_CTR_TX		0x0080
#define EP_CTR_RX		0x8000
#define USB_EP0_MAX_PACKET_SIZE	0x0040

void CTR_LP_CTRX() {
uint16_t TempEP;
uint8_t Related_Endpoint, Reserved;
uint16_t USB_wIndex;

while (((BKIstr = ISTR) & ISTR_CTR)) {
    // extract highest priority endpoint number 
    EPindex = (uint8_t)(BKIstr & ISTR_EP_ID);

  if (EPindex == 1 && (EP1R & EP_CTR_TX)){ //CDC Transmit
      EP1R &= 0x8F0F;
      USB_Function_flags |= 1;
	} else if (EPindex == 3 && (EP3R & EP_CTR_RX)){ //CDC Receive
			USB_Function_flags &= 0xEF;
			USB_RX_Start_pointer = 0;

			//you can save up current time
    	//in case you have a limited timeframe for processing this data
    	EP3R = (EP3R ^ 0x2000) & 0x3F8F;
    	USB_Recieved_bytes = (PMA_BUF(15)&0x3FF);
    	TO_READ_PMA(EP3RX_OFFSET, USB_Buff1, 64,64);
			USB_Function_flags |= 2;

        // Decode and service non control endpoints interrupt 
        // process related endpoint register 

    } else if(EPindex == 0){

        // Decode and service control endpoint interrupt 
        // calling related service routine 
        // (Setup0_Process, In0_Process, Out0_Process) 

        // save RX & TX status 
        // and set both to NAK 

  	    SaveTState = EP0R & 0x3030;

  	    EP0R = (EP0R^0x2020)&0xBFBF;
        // DIR bit = origin of the interrupt 
        if (BKIstr & ISTR_DIR) {
            // DIR = 1 */
            // DIR = 1 & CTR_RX       => SETUP or OUT int 
            // DIR = 1 & (CTR_TX | CTR_RX) => 2 int pending 
            	EP0R &=0x0F8F;// SETUP bit kept frozen while CTR_RX = 1 
            	USB_state_flag = STALLED;
            if (EP0R & EP_SETUP) {

              USB_Command = PMA_SBUF(EP0RX_OFFSET);
              USB_wValue  = PMA_SBUF(EP0RX_OFFSET+2);
              USB_wIndex  = PMA_SBUF(EP0RX_OFFSET+4);
              USB_wLength = PMA_SBUF(EP0RX_OFFSET+6);
              if (USB_wLength == 0)
              {
                // Setup with no data stage 

            	  USB_state_flag = WAIT_STATUS_IN;// After no data stage SETUP
            	  PMA_BUF(1) = 0;
            	  if (USB_Command == 0x0900){    // SET_CONFIGURATION
            			  USB_Configuration = USB_wValue;
            	  } else if (USB_Command == 0x0500){//SET ADDRESS
            		  USB_DADDR = USB_wValue | DADDR_EF;
            	  } else if ((USB_Command &0xFDFF) == 0x0100){//SET FEATURE for Device 0300, CLEAR FEATURE for Device 0100

            	  } else if (USB_Command == 0x0B01 && (USB_Configuration) && ((USB_wIndex & 0xFF) <= 1)){//SET INTERFACE
            			  USB_Interface = USB_wIndex;
            	  } else if (USB_Command == 0x0102){
            		  //EndPoint Clear Feature
            		  Related_Endpoint = USB_wIndex & 0x7F;
            	      if ((USB_wValue == 0)//ENDPOINT_STALL)
            	          && (USB_wIndex > 0x100) && USB_Configuration)
            	      {
            		        //Get Status of endpoint & stall the request if the related_ENdpoint
            		        is Disabled
            	    	  TempEP = ENDPOINT(Related_Endpoint);
            	    	  if (USB_wIndex & 0x80) {
            	    		  // IN endpoint 
            			      if ((TempEP&0x0030)==0x0010)
            			      {
            			          ENDPOINT(Related_Endpoint) = (TempEP ^ 0x0030)&0x8FFF;
            			      }
            		      } else {
            		    	  // OUT endpoint
            		    	  if ((TempEP&0x3000)==0x1000)
            		    	  {
            		    		  if (Related_Endpoint == 0)
            			          {
            			            // After clear the STALL, enable the default endpoint receiver 
            			        	  PMA_BUF(3) = 0x8400;
            			        	  EP0R = (EP0R ^ 0x3000)&0xBF8F;
            			          }
            			          else
            			          {
            			            ENDPOINT(Related_Endpoint) = (TempEP ^ 0x3000)&0xFF8F;
            			          }
            		    	  }
            		      }
            	      }
            	  } else if (USB_Command == 0x0302){
									// get Status of endpoint & stall the request if the related_ENdpoint is Disabled
            	      Related_Endpoint = USB_wIndex & 0x7F;
            	      if ((USB_wValue==0) && USB_Configuration){
            	    	  TempEP = ENDPOINT(Related_Endpoint);
            	    	  if (USB_wIndex & 0x80) {
            				    
            				    if(TempEP&0x0030){
            				    	ENDPOINT(Related_Endpoint) = (TempEP ^ 0x0010)&0x8FBF;
            				    }
            			  } else {
            				    if(TempEP&0x3000){
            				    	ENDPOINT(Related_Endpoint) = (TempEP ^ 0x1000)&0xBF8F;
            				    }
            			  }
            	      }

            	  } else if ((USB_Command & 0xDDFF) == 0x0021){
                  //SET_COMM_FEATURE 0221
                  //SET_CONTROL_LINE_STATE 2221
                  //SET Linecoding 2021
         
                  USB_Message("Device connectedr",1);
            		  USB_main_COM_react();

            	  } else {
            		  USB_state_flag = STALLED;
            	  }

            	  SaveTState |= 0x0030;
              } else {
                // Setup with data stage 
            	  USB_state_flag =  LAST_IN_DATA;
            	  PMA_BUF(1) = USB_wLength;
            		if (USB_Command == 0x0680){//GET DESCRIPTOR
            		      if (USB_wValue == 0x0100){
            		    	  TO_WRITE_PMA(DeviceDiscriptor,EP0TX_OFFSET,0x12,USB_EP0_MAX_PACKET_SIZE);
            		    	  PMA_BUF(1)= 0x12;
            		      } else if (USB_wValue == 0x0200){
            		    	  TO_WRITE_PMA(ConfigDescriptor,EP0TX_OFFSET,64,USB_EP0_MAX_PACKET_SIZE);

            		    	  if (USB_wLength>9){
                          
            		    		  PMA_BUF(1)= USB_EP0_MAX_PACKET_SIZE;
            		    		  USB_state_flag = IN_DATA;
            		    	  }
							  
            		      } else if (USB_wValue == 0x0300){
            		    	  PMA_SBUF(EP0TX_OFFSET) = 0x0304; // 3 - string descriptor, N=4
            		    	  PMA_SBUF(EP0TX_OFFSET + 2) = 0x0409;//Lang ID - US
            		    	  PMA_BUF(1)= 4;
            		      } else if (USB_wValue == 0x0301){
            		    	  USB_Message("VENDOR",0);
            		      } else if (USB_wValue == 0x0302){
            		    	  USB_Message("Device name",0);
            		      } else if (USB_wValue == 0x0303){
            		    	  uint32_t buf1 = *(__IO uint32_t*)(0x1FFFF7F0);//get unique chip ID
            		    	  for (Reserved = 2; Reserved<24; Reserved+=2){
            		    		  PMA_SBUF(EP0TX_OFFSET + Reserved)= (buf1 & 0x7) + '0';
            		    		  buf1 >>= 3;
            		    	  }
            		    	  PMA_SBUF(EP0TX_OFFSET)= 0x0318;
            		    	  PMA_BUF(1)=24;
            		      }// End of GET_DESCRIPTOR
            		} else if ((USB_Command&0xFFFE) == 0x0080){// GET STATUS for Device, GET STATUS for Interface
            			Reserved = 0;
            			if (USB_Command == 0x0080){
            			    if (USB_Feature & 0x20){// is Remote Wakeup enabled?
            			    	Reserved |= 2;
            			    }
            			    if (USB_Feature & 0x40){// is Bus-powered?
            			    	Reserved |= 1;
            			    }
            			}
            			PMA_SBUF(EP0TX_OFFSET) = Reserved; 
            		} else if (USB_Command == 0x0082){// GET STATUS for EndPoint
            			Related_Endpoint = USB_wIndex & 0x7F;
            			PMA_SBUF(EP0TX_OFFSET) =0;
            			TempEP = ENDPOINT(Related_Endpoint);
           				if (USB_wIndex & 0x80) {
            					// get Status of endpoint & stall the request if the related_ENdpoint is Disabled
            					if(TempEP&0x0030 == 0x0010){
            						PMA_SBUF(EP0TX_OFFSET) =1;// IN Endpoint stalled 
            					}
            				} else {
            					if(TempEP&0x3000 == 0x1000){
            						PMA_SBUF(EP0TX_OFFSET) =1;//OUT Endpoint stalled 
            					}
            				}

            		} else if (USB_Command == 0x0880){//GET CONFIGURATION
            			PMA_SBUF(EP0TX_OFFSET) = USB_Configuration;

            		} else if ((USB_Command & 0xFE7F) == 0x2021){
                  //Get (21A1)/set (20A1) Line Coding
            			PMA_BUF(EP0TX_OFFSET) = 9600;//baudrate
            			PMA_SBUF(EP0TX_OFFSET+4) = 0;//parity*256+format
            			PMA_SBUF(EP0TX_OFFSET+6) = 8;//datatype
            		} else {
            			USB_state_flag = STALLED;
            		}
            	    SaveTState = (0x3030);
               }
            }
        } else {
            // DIR = 0 
            // DIR = 0      => IN  int 
            // DIR = 0 implies that (EP_CTR_TX = 1) always  
        	EP0R &=0x8F0F;

        	if (USB_state_flag == IN_DATA){
            //last 3 bytes of Config Descriptor
            //no need to use procedure as there is only 2 assignments
		    		PMA_SBUF(EP0TX_OFFSET) = 0x0040;
		    		PMA_SBUF(EP0TX_OFFSET + 2) = 0;
		    		USB_state_flag =  LAST_IN_DATA;
		    		PMA_BUF(1)= 3;
		    		SaveTState = (0x3030);
        	} else if (USB_state_flag == LAST_IN_DATA){
        		USB_state_flag = WAIT_STATUS_OUT;
      			SaveTState = (0x3010);
        	} else {
        		if (USB_DADDR){//SetDeviceAddress
        			for (Reserved = 0; Reserved < EP_NUM; Reserved++) {
        				ENDPOINT(Reserved) = (ENDPOINT(Reserved) & 0x8F80) | Reserved ;
        			}
        			DADDR = USB_DADDR; // set device address and enable device function
        			USB_DADDR = 0;
        		}
        		USB_state_flag = STALLED;
        	}

        }
        PMA_BUF(3) = 0x8400;
       
        if (USB_state_flag == STALLED) SaveTState = 0x1010;

        EP0R = (EP0R^(SaveTState))&0xBFBF;
        return;
    }

  }
}

Поместить данные (пакет не больше чем USB_EP1_MAX_PACKET_SIZE_TX) в рабочий буфер USB_COM_TX_Buff1,

записать в переменную USB_Bytes_to_send_left количество отправляемых байт в текущем пакете

Вызвать процедуру

#define USB_EP1_MAX_PACKET_SIZE_TX	0x40

//фактическая отправка данных хосту
//данные и их количество записаны в USB_COM_TX_Buff1
//и в USB_Bytes_to_send_left соответственно.
void USB_main_COM_react(){

	if (USB_Bytes_to_send_left){
		//send pack back to the Host
		USB_Function_flags &= 0xFE;
		TO_WRITE_PMA(USB_COM_TX_Buff1 ,EP1TX_OFFSET, 64, USB_EP1_MAX_PACKET_SIZE_TX);
		PMA_BUF(5) = USB_Bytes_to_send_left;
		EP1R = (EP1R^0x0030)&0x8FBF;
		USB_Bytes_to_send_left = 0;

		uint32_t i = 5000;
		while (((EP1R & 0x80) == 0) && (i)) {i--;}
  }
}

Данные лежат в массиве USB_Buff1

их количество записано в переменной USB_Recieved_bytes

после обработки выполнить этот код:

PMA_BUF(15) = 0x8400;
EP3R = (EP3R^0x3000)&0xBF8F;

Из прерывания мы вошли в процедуру и в цикл внутри этой процедуры. Выяснили, что у нас 0 конечная точка. На всякий случай сохраняем состояние приёма и передачи (SaveTState = EP0R & 0x3030), а затем переводим нулевую конечную точку в состояние NAK (обработка данных) и по каналу приёма, и по каналу передачи. Так у нас будет время сформировать ответ хосту.

На этом этапе направление передачи (ISTR_DIR) должно быть OUT (бит поднят), Бит EP_SETUP поднят. Бит EP_CTR_RX тоже поднят(его опускаем).

Копируем данные из области PMA, размеченной для приёма в рабочие переменные. Это будет команда USB_Command = PMA_SBUF(EP0RX_OFFSET);
параметр USB_wValue = PMA_SBUF(EP0RX_OFFSET+2);
индекс USB_wIndex = PMA_SBUF(EP0RX_OFFSET+4);
и длина требуемого ответа USB_wLength = PMA_SBUF(EP0RX_OFFSET+6);