C#开发usb通知之bulk传输

usb通信分为4种传输方式，下位机通信协议用的是块传输，也就是bulk传输，C#下实现的usb通信使用的是开源的LibUsbDotNet，主要的就是需要在C#中添加LibUsbDotNet.dll引用文件，安装后的LibUsbDotNet里面有

我是参考bulk传输实例,这个需要libusb-1.0.dll文件放在程序的根目录下或者在windows/system32/目录下，否则会报错，提示找不到这个文件：

using System;
using System.Runtime.InteropServices;
using MonoLibUsb.Transfer;
using Usb = MonoLibUsb.MonoUsbApi;

namespace MonoLibUsb.ShowInfo
{
    internal enum TestMode
    {
        Sync,
        Async
    }

    internal class BulkReadWrite
    {
        #region DEVICE SETUP
        private const int MY_CONFIG = ;
        private const byte MY_EP_READ = 0x81;//读端点口地址
        private const byte MY_EP_WRITE = 0x01;//写端点口地址
        private const int MY_INTERFACE = ;//接口地址
        private const short MY_PID = 0x0053;//设备的VID PID信息
        private const short MY_VID = 0x04d8;
        #endregion

        #region TEST SETUP
        private const int MY_TIMEOUT = ;//读写超时时间
        private const int TEST_LOOP_COUNT = ;

        private const int TEST_READ_LEN = ;

        private const bool TEST_REST_DEVICE = true;
        private const int TEST_WRITE_LEN = ;

        private static TestMode TEST_MODE = TestMode.Async;
        #endregion

        private static MonoUsbSessionHandle sessionHandle  = null;

        private static void fillTestData(byte[] data, int len)
        {
            int i;
            for (i = ; i < len; i++)
                data[i] = (byte) ( + (i & 0xf));
        }

        private static void memset(byte[] data, int value, int len)
        {
            int i;
            for (i = ; i < len; i++)
                data[i] = (byte) (value);
        }

        // This function originated from bulk_transfer_cb()
        // in sync.c of the Libusb-1.0 source code.
        private static void bulkTransferCB(MonoUsbTransfer transfer)
        {
            Marshal.WriteInt32(transfer.PtrUserData, );
            /* caller interprets results and frees transfer */
        }

        // This function originated from do_sync_bulk_transfer()
        // in sync.c of the Libusb-1.0 source code.
        private static MonoUsbError doBulkAsyncTransfer(MonoUsbDeviceHandle dev_handle,
                                                          byte endpoint,
                                                          byte[] buffer,
                                                          int length,
                                                          out int transferred,
                                                          int timeout)
        {
            transferred = ;
            MonoUsbTransfer transfer = new MonoUsbTransfer();
            if (transfer.IsInvalid) return MonoUsbError.ErrorNoMem;

            MonoUsbTransferDelegate monoUsbTransferCallbackDelegate = bulkTransferCB;
            int[] userCompleted = new int[] {};
            GCHandle gcUserCompleted = GCHandle.Alloc(userCompleted, GCHandleType.Pinned);

            MonoUsbError e;
            GCHandle gcBuffer = GCHandle.Alloc(buffer, GCHandleType.Pinned);
            transfer.FillBulk(
                dev_handle,
                endpoint,
                gcBuffer.AddrOfPinnedObject(),
                length,
                monoUsbTransferCallbackDelegate,
                gcUserCompleted.AddrOfPinnedObject(),
                timeout);

            e = transfer.Submit();
            if ((int) e < )
            {
                transfer.Free();
                gcUserCompleted.Free();
                return e;
            }
            int r;
            Console.WriteLine("Transfer Submitted..");
            while (userCompleted[] == )
            {
                e = (MonoUsbError) (r = Usb.HandleEvents(sessionHandle));
                if (r < )
                {
                    if (e == MonoUsbError.ErrorInterrupted)
                        continue;
                    transfer.Cancel();
                    while (userCompleted[] == )
                        if (Usb.HandleEvents(sessionHandle) < )
                            break;
                    transfer.Free();
                    gcUserCompleted.Free();
                    return e;
                }
            }

            transferred = transfer.ActualLength;
            e = MonoUsbApi.MonoLibUsbErrorFromTransferStatus(transfer.Status);
            transfer.Free();
            gcUserCompleted.Free();
            return e;
        }

        public static int Main(string[] args)
        {
            MonoUsbDeviceHandle device_handle = null;

            int r = ;
            int transferred;
            byte[] testWriteData = new byte[TEST_WRITE_LEN];
            byte[] testReadData = new byte[TEST_READ_LEN];

            if (args.Length > )
            {
                switch (args[].ToLower())
                {
                    case "sync":
                        TEST_MODE = TestMode.Sync;
                        break;
                    case "async":
                        TEST_MODE = TestMode.Async;
                        break;
                }
            }

            fillTestData(testWriteData, TEST_WRITE_LEN);
            memset(testReadData, , TEST_READ_LEN);

            int loopCount = ;
            do
            {
                try
                {
                    do
                    {
                        sessionHandle=new MonoUsbSessionHandle();
                        if (sessionHandle.IsInvalid) throw new Exception("Invalid session handle.");

                        Console.WriteLine("Opening Device..");
                        device_handle = MonoUsbApi.OpenDeviceWithVidPid(sessionHandle, MY_VID, MY_PID);
                        if ((device_handle == null) || device_handle.IsInvalid) break;

                        // If TEST_REST_DEVICE = True, reset the device and re-open
                        if (TEST_REST_DEVICE)
                        {
                            MonoUsbApi.ResetDevice(device_handle);
                            device_handle.Close();
                            device_handle = MonoUsbApi.OpenDeviceWithVidPid(sessionHandle, MY_VID, MY_PID);
                            if ((device_handle == null) || device_handle.IsInvalid) break;
                        }

                        // Set configuration
                        Console.WriteLine("Set Config..");
                        r = MonoUsbApi.SetConfiguration(device_handle, MY_CONFIG);
                        if (r != ) break;

                        // Claim interface
                        Console.WriteLine("Set Interface..");
                        r = MonoUsbApi.ClaimInterface(device_handle, MY_INTERFACE);
                        if (r != ) break;

                        /////////////////////
                        // Write test data //
                        /////////////////////
                        int packetCount = ;
                        int transferredTotal = ;
                        do
                        {
                            Console.WriteLine("Sending test data..");

                            // If the Async TEST_MODE enumeration is set, use
                            // the internal transfer function
                            if (TEST_MODE == TestMode.Async)
                            {
                                r = (int)doBulkAsyncTransfer(device_handle,
                                                                MY_EP_WRITE,
                                                                testWriteData,
                                                                TEST_WRITE_LEN,
                                                                out transferred,
                                                                MY_TIMEOUT);
                            }
                            else
                            {
                                // Use the sync bulk transfer API function
                                r = MonoUsbApi.BulkTransfer(device_handle,
                                                                       MY_EP_WRITE,
                                                                       testWriteData,
                                                                       TEST_WRITE_LEN,
                                                                       out transferred,
                                                                       MY_TIMEOUT);
                            }
                            if (r == )
                            {
                                packetCount++;
                                transferredTotal += transferred;
                            }
                            // Keep writing data until an error occurs or
                            // 4 packets have been sent.
                        } while (r ==  && packetCount < );

                        if (r == (int) MonoUsbError.ErrorTimeout)
                        {
                            // This is considered normal operation
                            Console.WriteLine("Write Timed Out. {0} packet(s) written ({1} bytes)", packetCount, transferredTotal);
                        }
                        else if (r != (int) MonoUsbError.ErrorTimeout && r != )
                        {
                            // An error, other than ErrorTimeout was received.
                            Console.WriteLine("Write failed:{0}", (MonoUsbError) r);
                            break;
                        }
                        ////////////////////
                        // Read test data //
                        ////////////////////
                        Console.WriteLine("Reading test data..");
                        packetCount = ;
                        transferredTotal = ;
                        do
                        {
                            // If the Async TEST_MODE enumeration is set, use
                            // the internal transfer function
                            if (TEST_MODE == TestMode.Async)
                            {
                                r = (int) doBulkAsyncTransfer(device_handle,
                                                                MY_EP_READ,
                                                                testReadData,
                                                                TEST_READ_LEN,
                                                                out transferred,
                                                                MY_TIMEOUT);
                            }
                            else
                            {
                                // Use the sync bulk transfer API function
                                r = MonoUsbApi.BulkTransfer(device_handle,
                                                                       MY_EP_READ,
                                                                       testReadData,
                                                                       TEST_READ_LEN,
                                                                       out transferred,
                                                                       MY_TIMEOUT);
                            }
                            if (r == (int) MonoUsbError.ErrorTimeout)
                            {
                                // This is considered normal operation
                                Console.WriteLine("Read Timed Out. {0} packet(s) read ({1} bytes)", packetCount, transferredTotal);
                            }
                            else if (r != )
                            {
                                // An error, other than ErrorTimeout was received.
                                Console.WriteLine("Read failed:{0}", (MonoUsbError)r);
                            }
                            else
                            {
                                transferredTotal += transferred;
                                packetCount++;

                                // Display test data.
                                Console.Write("Received: ");
                                Console.WriteLine(System.Text.Encoding.Default.GetString(testReadData, , transferred));
                            }
                            // Keep reading data until an error occurs, (ErrorTimeout)
                        } while (r == );
                    } while (false);
                }
                finally
                {
                    // Free and close resources
                    if (device_handle != null)
                    {
                        if (!device_handle.IsInvalid)
                        {
                            MonoUsbApi.ReleaseInterface(device_handle, MY_INTERFACE);
                            device_handle.Close();
                        }
                    }
                    if (sessionHandle!=null)
                    {
                        sessionHandle.Close();
                        sessionHandle = null;
                    }
                }
                // Run the entire test TEST_LOOP_COUNT times.
            } while (++loopCount < TEST_LOOP_COUNT);

            Console.WriteLine("\nDone!  [Press any key to exit]");
            Console.ReadKey();

            return r;
        }
    }
}

我在winfrom的主要思路和上面差不多，但是还有有点区别的，毕竟控制端程序和桌面程序在代码上还是有点区别的。由于项目的要求只能放部分代码

1.设置相关的通信信息，和上面的差不多

        //设置设备信息，包括接口、断点等信息
        private void setDevice()
        {
            sessionHandle = new MonoUsbSessionHandle();
            if (sessionHandle.IsInvalid) throw new Exception("Invalid session handle.");
            //Console.WriteLine("Opening Device..");
            device_handle = MonoUsbApi.OpenDeviceWithVidPid(sessionHandle, MY_VID, MY_PID);
            if ((device_handle == null) || device_handle.IsInvalid)
            {
                Console.WriteLine("device_handle为空");
                isContinue = false;
                labelInfo.Text = "未找到设备";
                ScanBtn.Enabled = false;
            }
            else
            {
                //设置配置信息
                r = MonoUsbApi.SetConfiguration(device_handle, MY_CONFIG);
                if (r != ) { Console.WriteLine("config出错"); };
                // 索赔接口
                r = MonoUsbApi.ClaimInterface(device_handle, MY_INTERFACE);
                if (r != ) { Console.WriteLine("interface出错"); };
                labelInfo.Text = "成功打开设备";
            }
        }

2.然后在按钮的监听器里面实现发送命令的方法：

        private void sendCommand()
        {
            if (device_handle == null)
            {
                setDevice();
            }
            byte[] data = DataFix.getCommand(interTimes, scanCounts, manual);
            //r = (int)doBulkAsyncTransfer(device_handle, MY_EP_WRITE, command, command.Length, out transferred, MY_TIMEOUT);
            r = MonoUsbApi.BulkTransfer(device_handle, MY_EP_WRITE, data, data.Length, out transferred, MY_TIMEOUT);
            if (r == (int)MonoUsbError.ErrorTimeout)
            {
                // 写入超时错误信息
                //Console.WriteLine("Write Timed Out. {0} packet(s) written ({1} bytes)", packetCount, transferredTotal);
            }
            else if (r != (int)MonoUsbError.ErrorTimeout && r != )
            {
                Console.WriteLine("Write failed:{0}", (MonoUsbError)r);
            }
            resultList.Clear();
        }

3.其实最终的就是第三点，你需要在程序启动的时候就开启一个新的线程，然后里面实现while(true)循环的监听端点口数据的返回

#region 开启一个新的线程
xferData = new Thread(DataGetFromPoint);
xferData.IsBackground = true;
xferData.Priority = ThreadPriority.Highest;
xferData.Start();
#endregion

DataGetFromPoint()方法

        public void DataGetFromPoint()
        {
            bufDataIn = new byte[inLength];
            while (isContinue)
            {
                //Console.WriteLine("Reading data....");
                r = MonoUsbApi.BulkTransfer(device_handle, MY_EP_READ, bufDataIn, inLength, out transferred, MY_TIMEOUT);
                if (r == (int)MonoUsbError.ErrorTimeout)
                {
                    //这个可以看出是一个正常的操作
                    //Console.WriteLine("Read Timed Out.");
                }
                else if (r != )
                {
                    //除了写入超时错误的信息外，其他的信息会在这里显示
                    Console.WriteLine("Read failed:{0}", (MonoUsbError)r);
                }
                else
                {
                    Console.writeln(DataFix.byteToHexString(bufDataIn));//字节数组转换成16进制字符串显示
                }
                //Thread.Sleep(1);//如果线程休眠的话，导致接受的数据不完整....
            }
        }