USB3014-应用程序开发(2)

Dear 丶 2022-10-15 04:52 154阅读 0赞

参考：CyAPI.pdf

USB四种传输方式：[https://blog.csdn.net/shenjin\_s/article/details/86229307][https_blog.csdn.net_shenjin_s_article_details_86229307]

1、控制(Control)方式传输

2、同步(isochronous)方式传输

3、中断(interrupt)方式传输

4、大量(bulk)传输

对应函数：

![20210526100327939.png][]

读写示例：

// usb3t.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include <iostream>
    #include <string>
    using namespace std;
    
    #include <wtypes.h>
    #include <dbt.h>
    
    #include "..\\cpp\\inc\\CyAPI.h"
    #pragma comment(lib, "..\\cpp\\lib\\x86\\CyAPI.lib")
    //
    //A-65 z-90 a-97 z-122  97-65=32 0-48 1-49
    int  hex2int(char c)
    {
    	int t = 0;
    	//A-F => a-f
    	if ('A' <= c && c <= 'F')
    		c += 32;
    	//0-9
    	if (c<'a')
    		t = c - '0';
    	else
    		t = c - 'a' + 10;
    	return t;
    
    }
    
    
    
    char str_b[16][5] = { "0000",\
    "0001",\
    "0010",\
    "0011",\
    "0100",\
    "0101",\
    "0110",\
    "0111",\
    "1000",\
    "1001",\
    "1010",\
    "1011",\
    "1100",\
    "1101",\
    "1110",\
    "1111"
    };
    
    char* hex2bin(char c)
    {
    	return (char*)str_b[hex2int(c)];
    
    }
    //
    
    
    //hex_ck
    //fial return 0，else return the length of the string!
    int hex_check(char* s)
    {
    	int t = 0;
    	int i = 0;
    	while (s[i])
    	{
    		if (('0' <= s[i] && s[i] <= '9') || ('a' <= s[i] && s[i] <= 'f') || ('A' <= s[i] && s[i] <= 'F'))
    		{
    			t++;
    		}
    		else
    		{
    			return 0;
    		}
    		//
    		i++;
    	}
    	return t;
    }
    
    //32bit
    unsigned int hexstr2int(char* DataLineT,int slen)
    {
    	//char DataLineT[64] = "\0";
    	unsigned int res = 0;
    	unsigned int a, b, c, d, e, f, g, h;
        unsigned int index = 0;
    if(slen>=8)
        if (hex_check(DataLineT + index))
    	{
    		a = hex2int(DataLineT[index   ]);
    		b = hex2int(DataLineT[index+1 ]);
    		c = hex2int(DataLineT[index+2 ]);
    		d = hex2int(DataLineT[index+3 ]);
    		e = hex2int(DataLineT[index+4 ]);
    		f = hex2int(DataLineT[index+5 ]);
    		g = hex2int(DataLineT[index+6 ]);
    		h = hex2int(DataLineT[index+7 ]);
    		//printf("%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\r\n", a, b, c, d, e, f, g, h);
    		//
    		//printf("%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\r\n", hex2bin(DataLineT[index]), \
    		//	hex2bin(DataLineT[index+1 ]), \
    		//	hex2bin(DataLineT[index+2 ]), \
    		//	hex2bin(DataLineT[index+3 ]), \
    		//	hex2bin(DataLineT[index+4 ]), \
    		//	hex2bin(DataLineT[index+5 ]), \
    		//	hex2bin(DataLineT[index+6 ]), \
    		//	hex2bin(DataLineT[index+7 ]));
    		//
    		//char s_bin[33] = { 0 };
    		//for (unsigned int ii = 0;ii<32;ii++)
    		//{
    		//	char * s_t = hex2bin(DataLineT[index + (ii / 4)]);
    		//	s_bin[ii] = s_t[ii % 4];
    
    		//}
    		//s_bin[32] = 0;
    		//printf("%s\n", s_bin);
    		//
    
    
    
    		//
    		res = h + (g << 4) + (f << 8) + (e << 12) + (d << 16) + (c << 20) + (b << 24) + (a << 28);
    		printf("hexstr2int: %d \r\n", res);
    		return res;
    	}
    	else
    	{
    		printf("none a hex>>>> \r\n");
            return 0;
    	}
    else
      return 0;
    
    
    
    }
    
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	
    	printf("Hello World!\n");
    //------------------------------------------------------
    	// This code snippet lists all the endpoints reported
    	// by the device under all interfaces and configurations.
    	CCyUSBDevice *USBDevice = new CCyUSBDevice(NULL);
    	/*
    	char buf[512];
    	string s;
        //BOS
    	CCyUSBBOS *bos = USBDevice->UsbBos;
    	sprintf_s(buf,"BOS Descriptor\n");
    	s.append(buf);
    	sprintf_s(buf,"--------------------------------\n");
    	s.append(buf);
    	sprintf_s(buf,"bLength: 0x%x\n",bos->bLength);
    	s.append(buf);
    	sprintf_s(buf,"bDescriptorType: %d\n",bos->bDescriptorType);
    	s.append(buf);
    	sprintf_s(buf,"wTotalLength: %d\n",bos->wTotalLength);
    	s.append(buf);
    	sprintf_s(buf,"bNumDeviceCaps: %d\n",bos->bNumDeviceCaps);
    	s.append(buf);
    	sprintf_s(buf,"**********************************\n");
    	s.append(buf);
    	cout<<s;
    	s.clear();
    	// Print the USB 2.0 Device Extension descriptor if found
    	if(bos->pUSB20_DeviceExt)
    	{
    		CCyBosUSB20Extesnion *Usb20Ext = bos->pUSB20_DeviceExt;
    		sprintf_s(buf,"USB20 Device Extension Descriptor\n");
    		s.append(buf);
    		sprintf_s(buf,"--------------------------------\n");
    		s.append(buf);
    		sprintf_s(buf,"bLength: 0x%x\n",Usb20Ext->bLength);
    		s.append(buf);
    		sprintf_s(buf,"bDescriptorType: %d\n",Usb20Ext->bDescriptorType);
    		s.append(buf);
    		sprintf_s(buf,"bDevCapabilityType: %d\n",Usb20Ext->bDevCapabilityType);
    		s.append(buf);
    		sprintf_s(buf,"bmAttribute: %d\n",Usb20Ext->bmAttribute);
    		s.append(buf);
    		sprintf_s(buf,"**********************************\n");
    		s.append(buf);
    		cout<<s;
    		s.clear();
    	}
    	// Print the SuperSpeed Device Capability descriptor if found
    	if(bos->pSS_DeviceCap)
    	{
    		CCyBosSuperSpeedCapability *ssCap = bos->pSS_DeviceCap;
    		sprintf_s(buf,"Super Speed Device capability Descriptor\n");
    		s.append(buf);
    		sprintf_s(buf,"--------------------------------\n");
    		s.append(buf);
    		sprintf_s(buf,"bLength: 0x%x\n",ssCap->bLength);
    		s.append(buf);
    		sprintf_s(buf,"bDescriptorType: %d\n",ssCap->bDescriptorType);
    		s.append(buf);
    		sprintf_s(buf,"bDevCapabilityType: %d\n",ssCap->bDevCapabilityType);
    		s.append(buf);
    		sprintf_s(buf,"bmAttribute: %d\n",ssCap->bmAttribute);
    		s.append(buf);
    		sprintf_s(buf,"SpeedsSuported: %d\n",ssCap->SpeedsSuported);
    		s.append(buf);
    		sprintf_s(buf,"bFunctionalitySupported: %d\n",ssCap->bFunctionalitySupporte);
    		s.append(buf);
    		sprintf_s(buf,"bU1DevExitLat: %d\n",ssCap->bU1DevExitLat);
    		s.append(buf);
    		sprintf_s(buf,"bU2DevExitLat: %d\n",ssCap->bU2DevExitLat);
    		s.append(buf);
    		sprintf_s(buf,"**********************************\n");
    		s.append(buf);
    		cout<<s;
    		s.clear();
    	}
    
    	// Print the Container ID descriptor if found
    	if(bos->pContainer_ID)
    	{
    		CCyBosContainerID *ContID = bos->pContainer_ID;
    		sprintf_s(buf,"Container ID Descriptor\n");
    		s.append(buf);
    		sprintf_s(buf,"--------------------------------\n");
    		s.append(buf);
    		sprintf_s(buf,"bLength: 0x%x\n",ContID->bLength);
    		s.append(buf);
    		sprintf_s(buf,"bDescriptorType: %d\n",ContID->bDescriptorType);
    		s.append(buf);
    		sprintf_s(buf,"bDevCapabilityType: %d\n",ContID->bDevCapabilityType);
    		s.append(buf);
    		sprintf_s(buf,"bReserved: %d\n",ContID->bReserved);
    		s.append(buf);
    		sprintf_s(buf,"ContainerID: %s\n",ContID->ContainerID);
    		s.append(buf);
    		sprintf_s(buf,"**********************************\n");
    		s.append(buf);
    		cout<<s;
    		s.clear();
    	}
    
    
    
    	//------------------
    	for (int c=0; c<USBDevice->ConfigCount(); c++)
    	{
    		CCyUSBConfig cfg = USBDevice->GetUSBConfig(c);
    		// Print all configuration descriptor fields
    		printf("\nPrint all configuration descriptor fields!\n");
    		sprintf_s(buf,"bLength: 0x%x\n",cfg.bLength);
    		s.append(buf);
    		sprintf_s(buf,"bDescriptorType: %d\n",cfg.bDescriptorType);
    		s.append(buf);
    		sprintf_s(buf,"wTotalLength: %d (0x%x)\n",cfg.wTotalLength,cfg.
    		wTotalLength);
    		s.append(buf);
    		sprintf_s(buf,"bNumInterfaces: %d\n",cfg.bNumInterfaces);
    		s.append(buf);
    
    		sprintf_s(buf,"bConfigurationValue: %d\n",cfg.bConfigurationValue);
    		s.append(buf);
    		sprintf_s(buf,"iConfiguration: %d\n",cfg.iConfiguration);
    		s.append(buf);
    		sprintf_s(buf,"bmAttributes: 0x%x\n",cfg.bmAttributes);
    		s.append(buf);
    		sprintf_s(buf,"MaxPower: %d\n",cfg.MaxPower);
    		s.append(buf);
    		s.append("**********************************\n");
    		cout<<s;
    		s.erase(0,s.length()-1);
    		//s.clear();
    		for (int i=0; i<cfg.AltInterfaces; i++)
    		{
    			// Print all interface descriptor fields
    			CCyUSBInterface *ifc = cfg.Interfaces[i];
    			sprintf_s(buf,"Interface Descriptor:%d\n",(i+1));
    			s.append(buf);
    			sprintf_s(buf,"--------------------------------\n");
    			s.append(buf);
    			sprintf_s(buf,"bLength: 0x%x\n",ifc->bLength);
    			s.append(buf);
    			sprintf_s(buf,"bDescriptorType: %d\n",ifc->bDescriptorType);
    			s.append(buf);
    			sprintf_s(buf,"bInterfaceNumber: %d\n",ifc->bInterfaceNumber);
    			s.append(buf);
    			sprintf_s(buf,"bAlternateSetting: %d\n",ifc->bAlternateSetting);
    			s.append(buf);
    			sprintf_s(buf,"bNumEndpoints: %d\n",ifc->bNumEndpoints);
    			s.append(buf);
    			sprintf_s(buf,"bInterfaceClass: %d\n",ifc->bInterfaceClass);
    			s.append(buf);
    			sprintf_s(buf,"**********************************\n");s.append(buf);
    			cout<<s;
    			//s.clear();
    			s.erase(0,s.length()-1);
    			for (int e=0; e<ifc->bNumEndpoints; e++)
    			{
    				// Print all endpoint descriptor fields
    				CCyUSBEndPoint *ept = ifc->EndPoints[e+1];
    				sprintf_s(buf,"EndPoint Descriptor:%d\n",(e+1));
    
    				s.append(buf);
    				sprintf_s(buf,"--------------------------------\n");
    				s.append(buf);
    				sprintf_s(buf,"bLength: 0x%x\n",ept->DscLen);
    				s.append(buf);
    				sprintf_s(buf,"bDescriptorType: %d\n",ept->DscType);
    				s.append(buf);
    				sprintf_s(buf,"bEndpointAddress: 0x%x\n",ept->Address);
    				s.append(buf);
    				sprintf_s(buf,"bmAttributes: 0x%x\n",ept->Attributes);
    				s.append(buf);
    				sprintf_s(buf,"wMaxPacketSize: %d\n",ept->MaxPktSize);
    				s.append(buf);
    				sprintf_s(buf,"bInterval: %d\n",ept->Interval);
    				s.append(buf);
    				s.append("**********************************\n");
    				cout<<s;
    				//s.clear();
    				s.erase(0,s.length()-1);
    			}
    		}
    	}
    */
    //-------------------------------------------------------
    
    
    //CCyUSBDevice *USBDevice = new CCyUSBDevice(NULL);
    //if (USBDevice->BulkOutEndPt) {
    //   unsigned char buf[128];
    //   LONG length = 128;
    //   USBDevice->BulkOutEndPt->XferData(buf, length);
    //}
    
    
    //if (USBDevice->BulkInEndPt) {
    //   unsigned char buf[10384];
    //   LONG length = 10384;
    //   unsigned int res = USBDevice->BulkInEndPt->XferData(buf, length);
    //   unsigned int t =0;
    //   if(res)
    //   {
    //	   printf("length:%#x\n",length);
    //           for(t=0; t < length ; t++)
    //        	  printf("%#x\t",buf[t]);
    //		   printf("\n---------------\n");
    //   }
    //   else
    //   {
    //	    printf("rd error!time out\n");
    //   }
    //}
    //
    //
    //	printf("Done!\n");
    //	getchar();
    //	return 0;
    
    	//BeginDataXfer is an advanced method for performing asynchronous IO
    // This example assumes that the device automatically sends back,
    // over its bulk-IN endpoint, any bytes that were received over its
    // bulk-OUT endpoint (commonly referred to as a loopback function)
        //CCyUSBDevice *USBDevice = new CCyUSBDevice(NULL);
    	OVERLAPPED outOvLap, inOvLap;
    	//outOvLap.hEvent = CreateEvent(NULL, false, false, L"CYUSB_OUT");
    	outOvLap.hEvent = CreateEvent(NULL, false, false, "CYUSB_OUT");
    	//
    	unsigned char buffer[10384];
    	ZeroMemory(buffer, 10384);
        LONG length = 0;
    	//------------------------------------------------------
    
        FILE* fp = fopen("USB3T.txt", "r");//只读方式打开，不存在则为NULL
        if (fp != NULL)
        {
            char DataLineT[128];
            memset(DataLineT,0,128);
            //if (fgets(DataLineT, 128, fp))
    		while (fgets(DataLineT, 128, fp))
            {
    			DataLineT[8]=0;
                unsigned int l = strlen(DataLineT);
    			unsigned int hex_t=0;
    			hex_t=hexstr2int(DataLineT,l);
    			unsigned int *uint_p = (unsigned int*)(buffer+length);
                uint_p[0] = hex_t;
    			printf("[MSB-LSB]: %#x %#x %#x %#x\n",(buffer+length)[3],(buffer+length)[2],(buffer+length)[1],(buffer+length)[0]);
    			length += 4;
            }
    		printf("The length of TX:%d\n",length);
            //
            fclose(fp);
        }
        else
        {
            length = 28;
    		buffer[0] = 0xa0;//LSB
    		buffer[1] = 0x10;
    		buffer[2] = 0x20;
    		buffer[3] = 0x30;//MSB
    
    		buffer[12] = 0xb0;
    		buffer[13] = 0xc0;
    		buffer[14] = 0xd6;
    		buffer[15] = 0xe8;
    
    
    		buffer[16] = 0x40;
    		buffer[17] = 0x50;
    		buffer[18] = 0x26;
    		buffer[19] = 0x38;
    
    
    		buffer[20] = 0x5b;
    
    		buffer[24] = 0xc5;
    		buffer[25] = 0x10;
    		buffer[26] = 0x20;
    		buffer[27] = 0x30;
    
        }
    
    	//-------------------------------------------------------------
    	// Request the return data before initiating the loopback
    	UCHAR *outContext = USBDevice->BulkOutEndPt->BeginDataXfer(buffer, length,&outOvLap);
    	USBDevice->BulkOutEndPt->WaitForXfer(&outOvLap,100);
    	USBDevice->BulkOutEndPt->FinishDataXfer(buffer, length, &outOvLap,outContext);
    	CloseHandle(outOvLap.hEvent);
    
    
    //
    /*
          inOvLap.hEvent = CreateEvent(NULL, false, false, "CYUSB_IN");
    	  unsigned char inBuf[10384];
    	  ZeroMemory(inBuf, 10384);
    	  UCHAR *inContext = USBDevice->BulkInEndPt->BeginDataXfer(inBuf, length,&inOvLap);
          USBDevice->BulkInEndPt->WaitForXfer(&inOvLap,100);
          USBDevice->BulkInEndPt->FinishDataXfer(inBuf, length, &inOvLap, inContext);
    	  CloseHandle(inOvLap.hEvent);
        
    
          for(int t =0;t<length;t++)
            	  printf("%#x\n",inBuf[t]);
    */
    
    //--------------------------------------------------------
    	
    	printf("Done!\n");
    	getchar();
    	return 0;
    }

![20210523173135459.png][]

设置timeout:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTEzMjk5Njc_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTEzMjk5Njc_size_16_color_FFFFFF_t_70 1][]

[https_blog.csdn.net_shenjin_s_article_details_86229307]: https://blog.csdn.net/shenjin_s/article/details/86229307
[20210526100327939.png]: /images/20221014/29ea7b2253074d5fb6bab180e18d0b5c.png
[20210523173135459.png]: /images/20221014/1875dfb2d554447a9f8ac6bc72a3b0ff.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTEzMjk5Njc_size_16_color_FFFFFF_t_70]: /images/20221014/7538a1d847d24bdfa6a8309919c5f163.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTEzMjk5Njc_size_16_color_FFFFFF_t_70 1]: /images/20221014/eb726c02c2af4d708efd218aa674ffb3.png