usbcpp.cpp

Simple code to test usb connections.Try it...

// This is the main DLL file.

#include "stdafx.h"

#using <UsbCs.dll>

#include "ezusbsys.h"
#include "usb100.h"

using namespace System;
using namespace System::Text;
using namespace System::Runtime::InteropServices;

namespace EzUsb
{
	[StructLayout(LayoutKind::Explicit, Size=18, CharSet=CharSet::Auto)]
	public __gc class UsbDeviceDescriptor 
	{
	public:
		[FieldOffset(0)] System::Byte bLength;
		[FieldOffset(1)] System::Byte bDescriptorType;
		[FieldOffset(2)] System::UInt16 bcdUSB;
		[FieldOffset(4)] System::Byte bDeviceClass;
		[FieldOffset(5)] System::Byte bDeviceSubClass;
		[FieldOffset(6)] System::Byte bDeviceProtocol;
		[FieldOffset(7)] System::Byte bMaxPacketSize0;
		[FieldOffset(8)] System::UInt16 idVendor;
		[FieldOffset(10)] System::UInt16 idProduct;
		[FieldOffset(12)] System::UInt16 bcdDevice;
		[FieldOffset(14)] System::Byte iManufacturer;
		[FieldOffset(15)] System::Byte iProduct;
		[FieldOffset(16)] System::Byte iSerialNumber;
		[FieldOffset(17)] System::Byte bNumConfigurations;
	};

	public __gc class Usb
	{
	private:
		HANDLE _hEzUsb;

		void ReportError( String* msg )
		{
			if( OnErrorMessage )
			{
				OnErrorMessage( this, new ErrorEventArgs( msg ) );
			}
		}

		void CheckWin32Error()
		{
			int errCode = GetLastError(); 
			if( errCode != 0 )
			{
				char msg[256];
				FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM, NULL, errCode, 0, 
					msg, 256, NULL );
				ReportError( msg );
			}
		}

	public:
		static const int MaxBlkSize = 64;

		__delegate void ErrorMessage( Object* sender, ErrorEventArgs* e );
		__event ErrorMessage* OnErrorMessage;

		Usb()
		{
			_hEzUsb = INVALID_HANDLE_VALUE;
		}

		~Usb()
		{
			if( _hEzUsb != INVALID_HANDLE_VALUE )
			{
				CloseHandle( _hEzUsb );
			}
		}

		bool Open( String* driverName )
		{
			char* lpFileName = new char[driverName->Length + 10];
			sprintf( lpFileName, "\\\\.\\%s", driverName );
			_hEzUsb = CreateFile( lpFileName,
									GENERIC_WRITE,
									FILE_SHARE_WRITE,
									NULL,
									OPEN_EXISTING,
									0,
									NULL);
			if( _hEzUsb == INVALID_HANDLE_VALUE )
			{
				CheckWin32Error();
			}
			delete lpFileName;

			return( _hEzUsb != INVALID_HANDLE_VALUE );
		}

		void Close()
		{
			CloseHandle( _hEzUsb );
		}

		Usb::UsbDeviceDescriptor* GetDeviceDescriptor()
		{
			BOOLEAN success;
			ULONG nBytes;
			PUSB_DEVICE_DESCRIPTOR pDeviceDiscriptor = new USB_DEVICE_DESCRIPTOR();

			if( _hEzUsb == INVALID_HANDLE_VALUE )
			{
				ReportError( "Driver not open." );
			}
			else
			{
				success = DeviceIoControl( _hEzUsb,
						IOCTL_Ezusb_GET_DEVICE_DESCRIPTOR,
						NULL,
						0,
						pDeviceDiscriptor,
						sizeof(USB_DEVICE_DESCRIPTOR),
						&nBytes,
						NULL );
				if( success == FALSE )
				{
					CheckWin32Error();
				}
			}

			UsbDeviceDescriptor* DeviceDiscriptor = new UsbDeviceDescriptor();
			DeviceDiscriptor = (UsbDeviceDescriptor*)Marshal::PtrToStructure(
					pDeviceDiscriptor, DeviceDiscriptor->GetType() );

			delete pDeviceDiscriptor;

			return( DeviceDiscriptor );
		}

		System::Byte BulkRead( int pipe ) []
		{
			if( _hEzUsb == INVALID_HANDLE_VALUE )
			{
				ReportError( "Driver not open." );
				return( 0 );
			}

			char lpOutBuffer[MaxBlkSize];

			BULK_TRANSFER_CONTROL btc;
			btc.pipeNum = pipe;
			BOOL success;
			int nBytes;

			success = DeviceIoControl( _hEzUsb,
						IOCTL_EZUSB_BULK_READ, 
						&btc,
						sizeof (BULK_TRANSFER_CONTROL),
						lpOutBuffer,
						MaxBlkSize,
						(unsigned long *)&nBytes,
						NULL);
			if( success == FALSE )
			{
				CheckWin32Error();
				return( 0 );
			}

			System::Byte buffer  __gc[] = new System::Byte[nBytes];
			IntPtr ptr( lpOutBuffer );
			Marshal::Copy( ptr, buffer, 0, nBytes );

			return( buffer );
		}

		int BulkWrite( System::Byte buffer __gc[], int pipe )
		{
			if( _hEzUsb == INVALID_HANDLE_VALUE )
			{
				ReportError( "Driver not open." );
				return( 0 );
			}

			char* lpOutBuffer = new char[buffer->Length];
			Marshal::Copy( buffer, 0, lpOutBuffer, buffer->Length );

			BULK_TRANSFER_CONTROL btc;
			BOOLEAN success;
			int nBytes;

			btc.pipeNum = pipe;

			success = DeviceIoControl( _hEzUsb,
						IOCTL_EZUSB_BULK_WRITE, 
						&btc,
						sizeof (BULK_TRANSFER_CONTROL),
						lpOutBuffer,
						buffer->Length,
						(unsigned long *)&nBytes,
						NULL);
			if( !success )
			{
				CheckWin32Error();
			}

			delete lpOutBuffer;

			return( nBytes );
		}
	};
}