Драйвер виртуального com порта stm32 windows 10

Is Your PC Behaving Abnormal & Needs Instant Optimzation?

We recommend you to choose Advanced System Repair Suite which is dedicated to offer complete options to optimize a PC, fix any Windows error, and remove malware threats in easy. The software is award winning and suggested as the best malware fix application supporting all Windows versions including XP/Vista/7/8/8.1/10. Just 3 steps to avail error free PC.

1. Download Advanced System Repair and install on your PC. (Follow all on screen instructions when installer is executed)
2. Click “Scan Your PC” button to scan all present issues, errors, junk files, and malware threats.
3. Finally, click “Start Repair” to fix all detected problems in next few minutes.

	//макрос адресации
	#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);

«WOW! Finally my PC got up to speed!» Melany Kim 7/18/2016

Our main support OS are: Windows 7, Windows 7 64 bit, Windows 7 32 bit, Windows 10, Windows 10 64 bit, Windows 10 32 bit, and Windows 8.

Stm32 Virtual Com Port Driver Details:

Stm32 Virtual Com Port File Name: stm32_virtual_com_port.zip

Stm32 Virtual Com Port Driver Version: 763XHEXA

Stm32 Virtual Com Port ZIP Size: 129.kb

Manufacturer: Stm32

Stm32 Virtual Com Port was fully scanned at: 2/2/2023

Scan Status: OK

Stm32 Virtual Com Port Download Stats:

Driver Uploaded: 1/5/2019

Direct Downloads: 184
Most Recent Download: 11/9/2019

Managed Downloads: 484
Most Recent Download: 11/20/2019

Download Mirrors: 5
Current Delay: 21 Seconds
Driver License: Free Software

Please help us maintain a helpfull driver collection.
After downloading and installing Stm32 Virtual Com Port, or the driver installation manager, take a few minutes to send us a report:
* Only registered users can upload a report.

Don’t have a password?
Please register, and get one.

Stm32 Virtual Com Port may sometimes be at fault for other drivers ceasing to function

These are the driver scans of 2 of our recent wiki members*

*Scans were performed on computers suffering from Stm32 Virtual Com Port disfunctions.

Scan performed on 4/25/2019, Computer: Sony PCG-U101 — Windows 7 64 bit

Outdated or Corrupted drivers:5/19

Scan performed on 4/25/2019, Computer: Sony VGN-TZ170C — Windows 7 32 bit

Outdated or Corrupted drivers:9/21

description

Compatible with the x86 and x64 platforms The STSW-STM32102 software package contains four installation files based on the various versions of the Microsoft® operating system.
OS versions prior to Windows® 7 are compatible with the Windows® 7 installations included in the package.
Starting from Windows® 10, the STSW-STM32102 driver is no more adequate and the usage of the native inbox driver is recommended.

All functions

Virtual COM port driver installation package for Windows® operating systems: 98SE, 2000, XP, Vista®, 7, and 8.x

Website:

https://www.st.com/zh/development-tools/stsw-stm32102.html 

https://www.st.com/content/st_com/en/products/development-tools/software-development-tools/stm32-software-development-tools/stm32-utilities/stsw-stm32102.html

Volume new plus folder PATH list
 Volume serial number 000000E3 AED4: 4CF9
 D:  High Speed ​​USB Transport  STM32 USB VCP Driver Install  En.stsw-STM32102-STM32 Virtual COM Port Driver-1.5.0
    readme.txt
    VCP_V1.5.0_Setup_W7_x64_64bits.exe
    VCP_V1.5.0_Setup_W7_x86_32bits.exe
    VCP_V1.5.0_Setup_W8_x64_64bits.exe
    VCP_V1.5.0_Setup_W8_x86_32bits.exe
    version.txt
    
 No subfolder 

Preface The stm32 serial port communication is a commonly used function in development, basically everyone will need it to transmit some information to other devices or PC. However, most people cannot…

In a project a year ago, due to the shortage of serial port resources, the hardware used the mainMCU-STM32F030C8T6, Both of its hardware serial ports are used, and the communication between the other …

The USB virtual serial port is a communication interface implemented using the USB CDC (CDC is communication device class (virtual port com)) class. Use STM32’s built-in USB slave function to implemen…

STM32 USB Virtual Serial Port Receiving Data 1.STM32 USB Virtual Serial Port Send Data Function 2.STM32 USB Virtual Serial Port Received Data Code (can receive any length of data, maximum reception le…

STM32HAL library, processing virtual serial port data (full double work processing) Today I will tell you the development of virtual serial port data below to solve the problem of the hardware of the …