与Wii控制手柄通信的托管代码库(转)

‘ read/write handle to the device
Private mHandle As SafeFileHandle

‘ a pretty .NET stream to read/write from/to
Private mStream As FileStream
Private found As Boolean = False
Private guid As Guid
Private index As UInteger = 0

‘ 1. get the GUID of the HID class
HIDImports.HidD_GetHidGuid(guid)

‘ 2. get a handle to all devices that are part of the HID class
Dim hDevInfo As IntPtr = HIDImports.SetupDiGetClassDevs(guid, Nothing, IntPtr.Zero, HIDImports.DIGCF_DEVICEINTERFACE) ‘ | HIDImports.DIGCF_PRESENT);

‘ create a new interface data struct and initialize its size
Dim diData As HIDImports.SP_DEVICE_INTERFACE_DATA = New HIDImports.SP_DEVICE_INTERFACE_DATA()
diData.cbSize = Marshal.SizeOf(diData)

‘ 3. get a device interface to a single device (enumerate all devices)
Do While HIDImports.SetupDiEnumDeviceInterfaces(hDevInfo, IntPtr.Zero, guid, index, diData)
    ‘ create a detail struct and set its size
    Dim diDetail As HIDImports.SP_DEVICE_INTERFACE_DETAIL_DATA = New HIDImports.SP_DEVICE_INTERFACE_DETAIL_DATA()
    diDetail.cbSize = 5 ‘should be: (uint)Marshal.SizeOf(diDetail);, but that‘s the wrong size

    Dim size As UInt32 = 0

    ‘ get the buffer size for this device detail instance (returned in the size parameter)
    HIDImports.SetupDiGetDeviceInterfaceDetail(hDevInfo, diData, IntPtr.Zero, 0, size, IntPtr.Zero)

    ‘ actually get the detail struct
    If HIDImports.SetupDiGetDeviceInterfaceDetail(hDevInfo, diData, diDetail, size, size, IntPtr.Zero) Then
        ‘ open a read/write handle to our device using the DevicePath returned
        mHandle = HIDImports.CreateFile(diDetail.DevicePath, FileAccess.ReadWrite, FileShare.ReadWrite, IntPtr.Zero, FileMode.Open, HIDImports.EFileAttributes.Overlapped, IntPtr.Zero)

        ‘ 4. create an attributes struct and initialize the size
        Dim attrib As HIDImports.HIDD_ATTRIBUTES = New HIDImports.HIDD_ATTRIBUTES()
        attrib.Size = Marshal.SizeOf(attrib)

        ‘ get the attributes of the current device
        If HIDImports.HidD_GetAttributes(mHandle.DangerousGetHandle(), attrib) Then
            ‘ if the vendor and product IDs match up
            If attrib.VendorID = VID AndAlso attrib.ProductID = PID Then
                ‘ 5. create a nice .NET FileStream wrapping the handle above
                mStream = New FileStream(mHandle, FileAccess.ReadWrite, REPORT_LENGTH, True)
            Else
                mHandle.Close()
            End If
        End If
    End If

    ‘ move to the next device
    index += 1
Loop

‘ 6. clean up our list
HIDImports.SetupDiDestroyDeviceInfoList(hDevInfo)

// read/write handle to the device
private SafeFileHandle mHandle;

// a pretty .NET stream to read/write from/to
private FileStream mStream;
bool found = false;
Guid guid;
uint index = 0;

// 1. get the GUID of the HID class
HIDImports.HidD_GetHidGuid(out guid);

// 2. get a handle to all devices that are part of the HID class
IntPtr hDevInfo = HIDImports.SetupDiGetClassDevs(ref guid, null, IntPtr.Zero, HIDImports.DIGCF_DEVICEINTERFACE);// | HIDImports.DIGCF_PRESENT);

// create a new interface data struct and initialize its size
HIDImports.SP_DEVICE_INTERFACE_DATA diData = new HIDImports.SP_DEVICE_INTERFACE_DATA();
diData.cbSize = Marshal.SizeOf(diData);

// 3. get a device interface to a single device (enumerate all devices)
while(HIDImports.SetupDiEnumDeviceInterfaces(hDevInfo, IntPtr.Zero, ref guid, index, ref diData))
{
    // create a detail struct and set its size
    HIDImports.SP_DEVICE_INTERFACE_DETAIL_DATA diDetail = new HIDImports.SP_DEVICE_INTERFACE_DETAIL_DATA();
    diDetail.cbSize = 5; //should be: (uint)Marshal.SizeOf(diDetail);, but that‘s the wrong size

    UInt32 size = 0;

    // get the buffer size for this device detail instance (returned in the size parameter)
    HIDImports.SetupDiGetDeviceInterfaceDetail(hDevInfo, ref diData, IntPtr.Zero, 0, out size, IntPtr.Zero);

    // actually get the detail struct
    if(HIDImports.SetupDiGetDeviceInterfaceDetail(hDevInfo, ref diData, ref diDetail, size, out size, IntPtr.Zero))
    {
        // open a read/write handle to our device using the DevicePath returned
        mHandle = HIDImports.CreateFile(diDetail.DevicePath, FileAccess.ReadWrite, FileShare.ReadWrite, IntPtr.Zero, FileMode.Open, HIDImports.EFileAttributes.Overlapped, IntPtr.Zero);

        // 4. create an attributes struct and initialize the size
        HIDImports.HIDD_ATTRIBUTES attrib = new HIDImports.HIDD_ATTRIBUTES();
        attrib.Size = Marshal.SizeOf(attrib);

        // get the attributes of the current device
        if(HIDImports.HidD_GetAttributes(mHandle.DangerousGetHandle(), ref attrib))
        {
            // if the vendor and product IDs match up
            if(attrib.VendorID == VID && attrib.ProductID == PID)
            {
                // 5. create a nice .NET FileStream wrapping the handle above
                mStream = new FileStream(mHandle, FileAccess.ReadWrite, REPORT_LENGTH, true);
            }
            else
                mHandle.Close();
        }
    }

    // move to the next device
    index++;
}

// 6. clean up our list
HIDImports.SetupDiDestroyDeviceInfoList(hDevInfo);

‘ sure, we could find this out the hard way using HID, but trust me, it‘s 22
Private Const REPORT_LENGTH As Integer = 22

‘ report buffer
Private mBuff As Byte() = New Byte(REPORT_LENGTH - 1){}

Private Sub BeginAsyncRead()
    ‘ if the stream is valid and ready
    If mStream.CanRead Then
        ‘ create a read buffer of the report size
        Dim buff As Byte() = New Byte(REPORT_LENGTH - 1){}

        ‘ setup the read and the callback
        mStream.BeginRead(buff, 0, REPORT_LENGTH, New AsyncCallback(AddressOf OnReadData), buff)
    End If
End Sub

Private Sub OnReadData(ByVal ar As IAsyncResult)
    ‘ grab the byte buffer
    Dim buff As Byte() = CType(ar.AsyncState, Byte())

    ‘ end the current read
    mStream.EndRead(ar)

    ‘ start reading again
    BeginAsyncRead()

    ‘ handle data....
End Sub

// sure, we could find this out the hard way using HID, but trust me, it‘s 22
private const int REPORT_LENGTH = 22;

// report buffer
private byte[] mBuff = new byte[REPORT_LENGTH];

private void BeginAsyncRead()
{
    // if the stream is valid and ready
    if(mStream.CanRead)
    {
        // create a read buffer of the report size
        byte[] buff = new byte[REPORT_LENGTH];

        // setup the read and the callback
        mStream.BeginRead(buff, 0, REPORT_LENGTH, new AsyncCallback(OnReadData), buff);
    }
}

private void OnReadData(IAsyncResult ar)
{
    // grab the byte buffer
    byte[] buff = (byte[])ar.AsyncState;

    // end the current read
    mStream.EndRead(ar);

    // start reading again
    BeginAsyncRead();
    
    // handle data....
}

Imports WiimoteLib

Private Sub Form1_Load(ByVal sender As Object, ByVal e As EventArgs)
    ‘ create a new instance of the Wiimote
    Dim wm As Wiimote = New Wiimote()

    ‘ setup the event to handle state changes
    AddHandler wm.WiimoteChanged, AddressOf wm_WiimoteChanged

    ‘ setup the event to handle insertion/removal of extensions
    AddHandler wm.WiimoteExtensionChanged, AddressOf wm_WiimoteExtensionChanged

    ‘ connect to the Wiimote
    wm.Connect()

    ‘ set the report type to return the IR sensor and accelerometer data (buttons always come back)
    wm.SetReportType(Wiimote.InputReport.IRAccel, True)
End Sub


Private Sub wm_WiimoteExtensionChanged(ByVal sender As Object, ByVal args As WiimoteExtensionChangedEventArgs)
    If args.Inserted Then
        wm.SetReportType(Wiimote.InputReport.IRExtensionAccel, True) ‘ return extension data
    Else
        wm.SetReportType(Wiimote.InputReport.IRAccel, True) ‘ back to original mode
    End If
End Sub

Private Sub wm_OnWiimoteChanged(ByVal sender As Object, ByVal args As WiimoteChangedEventArgs)
    ‘ current state information
    Dim ws As WiimoteState = args.WiimoteState

    ‘ write out the state of the A button    
    Debug.WriteLine(ws.ButtonState.A)
End Sub

using WiimoteLib;

private void Form1_Load(object sender, EventArgs e)
{
    // create a new instance of the Wiimote
    Wiimote wm = new Wiimote();
    
    // setup the event to handle state changes
    wm.WiimoteChanged += wm_WiimoteChanged;
    
    // setup the event to handle insertion/removal of extensions
    wm.WiimoteExtensionChanged += wm_WiimoteExtensionChanged;
    
    // connect to the Wiimote
    wm.Connect();
    
    // set the report type to return the IR sensor and accelerometer data (buttons always come back)
    wm.SetReportType(Wiimote.InputReport.IRAccel, true);
}


void wm_WiimoteExtensionChanged(object sender, WiimoteExtensionChangedEventArgs args)
{
    if(args.Inserted)
        wm.SetReportType(Wiimote.InputReport.IRExtensionAccel, true);    // return extension data
    else
        wm.SetReportType(Wiimote.InputReport.IRAccel, true);            // back to original mode
}

void wm_WiimoteChanged(object sender, WiimoteChangedEventArgs args)
{
    // current state information
    WiimoteState ws = args.WiimoteState;

    // write out the state of the A button    
    Debug.WriteLine(ws.ButtonState.A);
}

Dim wc As New WiimoteCollection()
wc.FindAllWiimotes()

For Each wm As Wiimote In wc
    AddHandler wm.WiimoteChanged, AddressOf wm_WiimoteChanged
    AddHandler wm.WiimoteExtensionChanged, AddressOf wm_WiimoteExtensionChanged
    
    wm.Connect()
    wm.SetReportType(InputReport.IRAccel, True)
Next wm

WiimoteCollection wc = new WiimoteCollection();
wc.FindAllWiimotes();

foreach(Wiimote wm in wc)
{
    wm.WiimoteChanged += wm_WiimoteChanged;
    wm.WiimoteExtensionChanged += wm_WiimoteExtensionChanged;
    
    wm.Connect();
    wm.SetReportType(InputReport.IRAccel, true);
}