/// <summary> /// Refreshes the <see cref="MonoUsbProfile"/> list. /// </summary> /// <remarks> /// <para>This is your entry point into finding a USB device to operate.</para> /// <para>This return value of this function indicates the number of devices in the resultant list.</para> /// <para>The <see cref="MonoUsbProfileList"/> has a crude form of built-in device notification that works on all platforms. By adding an event handler to the <see cref="AddRemoveEvent"/> changes in the device profile list are reported when <see cref="Refresh"/> is called.</para> /// </remarks> /// <param name="sessionHandle">A valid <see cref="MonoUsbSessionHandle"/>.</param> /// <returns>The number of devices in the outputted list, or <see cref="MonoUsbError.ErrorNoMem"/> on memory allocation failure.</returns> /// <example> /// <code source="..\MonoLibUsb\MonoUsb.ShowInfo\ShowInfo.cs" lang="cs"/> /// </example> public int Refresh(MonoUsbSessionHandle sessionHandle) { lock (LockProfileList) { MonoUsbProfileList newList = new MonoUsbProfileList(); MonoUsbProfileListHandle monoUSBProfileListHandle; int ret = MonoUsbApi.GetDeviceList(sessionHandle, out monoUSBProfileListHandle); if (ret < 0 || monoUSBProfileListHandle.IsInvalid) { #if LIBUSBDOTNET UsbError.Error(ErrorCode.MonoApiError, ret, "Refresh:GetDeviceList Failed", this); #else System.Diagnostics.Debug.Print("libusb_get_device_list failed:{0} {1}", (MonoUsbError)ret, MonoUsbApi.StrError((MonoUsbError)ret)); #endif return(ret); } int stopCount = ret; foreach (MonoUsbProfileHandle deviceProfileHandle in monoUSBProfileListHandle) { newList.mList.Add(new MonoUsbProfile(deviceProfileHandle)); stopCount--; if (stopCount <= 0) { break; } } syncWith(newList); monoUSBProfileListHandle.Close(); return(ret); } }
private MonoUsbDeviceHandle getUsableAndOpenUsbHandle() { lock (_sync) { if (context != null) { if (!context.IsClosed) { context.Close(); } context.Dispose(); context = null; } context = new MonoUsbSessionHandle(); var usbHandle = MonoUsbApi.OpenDeviceWithVidPid(context, 1406, 12288); if (usbHandle != null) { if (MonoUsbApi.ClaimInterface(usbHandle, 0) == 0) { return(usbHandle); } usbHandle.Close(); } UnityEngine.Debug.Log("Failed"); return(null); } }
public static void SwitchAllFound() { MonoUsbSessionHandle session = new MonoUsbSessionHandle(); if (session.IsInvalid) { throw new Exception("The USB session handle was invalid."); } MonoUsbProfileList list = new MonoUsbProfileList(); if (list.Refresh(session) < 0) { throw new Exception("USB refresh profile list from session failed."); } // 0x4255:0x0001 (Config Mode) // 0x4255:0x1000 (Mass Storage Mode) foreach (MonoUsbProfile profile in list) { short vendor_id = profile.DeviceDescriptor.VendorID; short product_id = profile.DeviceDescriptor.ProductID; if (vendor_id == 0x4255 && product_id == 0x0001) { // BodyCam Configuration Mode HandleConfigModeDevice(profile); } profile.Close(); } }
/// <summary> /// Refreshes the <see cref="MonoUsbProfile"/> list. /// </summary> /// <remarks> /// <para>This is your entry point into finding a USB device to operate.</para> /// <para>This return value of this function indicates the number of devices in the resultant list.</para> /// <para>The <see cref="MonoUsbProfileList"/> has a crude form of built-in device notification that works on all platforms. By adding an event handler to the <see cref="AddRemoveEvent"/> changes in the device profile list are reported when <see cref="Refresh"/> is called.</para> /// </remarks> /// <param name="sessionHandle">A valid <see cref="MonoUsbSessionHandle"/>.</param> /// <returns>The number of devices in the outputted list, or <see cref="MonoUsbError.ErrorNoMem"/> on memory allocation failure.</returns> /// <example> /// <code source="..\MonoLibUsb\MonoUsb.ShowInfo\ShowInfo.cs" lang="cs"/> /// </example> public int Refresh(MonoUsbSessionHandle sessionHandle) { lock (LockProfileList) { MonoUsbProfileList newList = new MonoUsbProfileList(); MonoUsbProfileListHandle monoUSBProfileListHandle; int ret = MonoUsbApi.GetDeviceList(sessionHandle, out monoUSBProfileListHandle); if (ret < 0 || monoUSBProfileListHandle.IsInvalid) { MonoUsbErrorMessage.Error(ErrorCode.MonoApiError, ret, "Refresh:GetDeviceList Failed", this); return(ret); } int stopCount = ret; foreach (MonoUsbProfileHandle deviceProfileHandle in monoUSBProfileListHandle) { newList.mList.Add(new MonoUsbProfile(deviceProfileHandle)); stopCount--; if (stopCount <= 0) { break; } } syncWith(newList); monoUSBProfileListHandle.Dispose(); return(ret); } }
public bool Connect() { bool isConnect = false; Console.WriteLine("usb:connect"); if ((bt_vid == -1) || (bt_pid == -1)) { throw new Exception("USBDevice identification data not set"); } controlTransferDelegate = ControlTransferCB; sessionHandle = new MonoUsbSessionHandle(); if (sessionHandle.IsInvalid) { throw new Exception(String.Format("failed init libusb contenxt {0}:{1}", MonoUsbSessionHandle.LastErrorCode, MonoUsbSessionHandle.LastErrorString)); } profileList = new MonoUsbProfileList(); MonoUsbDeviceList = MonoUsbDevice.MonoUsbDeviceList; MyUsbDeviceArray = new UsbDevice[MAX_USB_DEVICE_COUNT]; UsbDeviceCount = 0; DiscoveryUsbDevice(true); SetConfigUsbDevice(); return(isConnect); }
public void Dispose() { if (sessionHandle != null) { sessionHandle.Dispose(); sessionHandle = null; } }
public void Initilise() { // Assign the control transfer delegate to the callback function. controlTransferDelegate = ControlTransferCB; // Initialize the context. sessionHandle = new MonoUsbSessionHandle(); if (sessionHandle.IsInvalid) { throw new Exception(String.Format("Failed intializing libusb context.\n{0}:{1}", MonoUsbSessionHandle.LastErrorCode, MonoUsbSessionHandle.LastErrorString)); } }
public void Disconnect(bool setConnectionStatus = true) { lock (_sync) { if (context != null) { context.Dispose(); context = null; } if (setConnectionStatus) { Connected = false; } } }
//////////////////////////////////////////////////////////////////////// // Methods //////////////////////////////////////////////////////////////////////// bool initialize() { if (initialized) { return(initialized); } monoUsbSession = new MonoUsbSessionHandle(); if (monoUsbSession.IsInvalid) { logger.error("init: Failed to initialize context"); return(false); } MonoUsbApi.SetDebug(monoUsbSession, 0); controlTransferDelegate = ControlTransferCallback; findWasatchProfiles(); initialized = true; return(initialized); }
// there is no connect, we just check if we can open and claim an interface, and if we can then we can "connect" public bool Connect() { lock (_sync) { if (context != null) { if (!context.IsClosed) { context.Close(); } context.Dispose(); context = null; } context = new MonoUsbSessionHandle(); var usbHandle = MonoUsbApi.OpenDeviceWithVidPid(context, 1406, 12288); if (usbHandle != null) { if (MonoUsbApi.ClaimInterface(usbHandle, 0) == 0) { MonoUsbApi.ReleaseInterface(usbHandle, 0); usbHandle.Close(); Connected = true; return(true); } usbHandle.Close(); } else { throw new Exception("Console not found or usb driver failed to open device. Is the console connected and is libusb configured correctly?"); } Connected = false; UnityEngine.Debug.Log("Failed"); return(false); } }
public static int Main(string[] args) { MonoUsbDeviceHandle device_handle = null; int r = 0; int transferred; byte[] testWriteData = new byte[TEST_WRITE_LEN]; byte[] testReadData = new byte[TEST_READ_LEN]; if (args.Length > 0) { switch (args[0].ToLower()) { case "sync": TEST_MODE = TestMode.Sync; break; case "async": TEST_MODE = TestMode.Async; break; } } fillTestData(testWriteData, TEST_WRITE_LEN); memset(testReadData, 0, TEST_READ_LEN); int loopCount = 0; 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 != 0) { break; } // Claim interface Console.WriteLine("Set Interface.."); r = MonoUsbApi.ClaimInterface(device_handle, MY_INTERFACE); if (r != 0) { break; } ///////////////////// // Write test data // ///////////////////// int packetCount = 0; int transferredTotal = 0; 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 == 0) { packetCount++; transferredTotal += transferred; } // Keep writing data until an error occurs or // 4 packets have been sent. } while (r == 0 && packetCount < 5); 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 != 0) { // An error, other than ErrorTimeout was received. Console.WriteLine("Write failed:{0}", (MonoUsbError)r); break; } //////////////////// // Read test data // //////////////////// Console.WriteLine("Reading test data.."); packetCount = 0; transferredTotal = 0; 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 != 0) { // 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, 0, transferred)); } // Keep reading data until an error occurs, (ErrorTimeout) } while (r == 0); } 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); }
public static int Main(string[] args) { MonoUsbDeviceHandle device_handle = null; int r = 0; int transferred; byte[] testWriteData = new byte[TEST_WRITE_LEN]; byte[] testReadData = new byte[TEST_READ_LEN]; if (args.Length > 0) { switch (args[0].ToLower()) { case "sync": TEST_MODE = TestMode.Sync; break; case "async": TEST_MODE = TestMode.Async; break; } } fillTestData(testWriteData, TEST_WRITE_LEN); memset(testReadData, 0, TEST_READ_LEN); int loopCount = 0; 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 != 0) break; // Claim interface Console.WriteLine("Set Interface.."); r = MonoUsbApi.ClaimInterface(device_handle, MY_INTERFACE); if (r != 0) break; ///////////////////// // Write test data // ///////////////////// int packetCount = 0; int transferredTotal = 0; 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 == 0) { packetCount++; transferredTotal += transferred; } // Keep writing data until an error occurs or // 4 packets have been sent. } while (r == 0 && packetCount < 5); 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 != 0) { // An error, other than ErrorTimeout was received. Console.WriteLine("Write failed:{0}", (MonoUsbError) r); break; } //////////////////// // Read test data // //////////////////// Console.WriteLine("Reading test data.."); packetCount = 0; transferredTotal = 0; 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 != 0) { // 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, 0, transferred)); } // Keep reading data until an error occurs, (ErrorTimeout) } while (r == 0); } 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; }
public static void ShowConfig(RichTextBox rtb) { // Initialize the context. sessionHandle = new MonoUsbSessionHandle(); if (sessionHandle.IsInvalid) { throw new Exception(String.Format("Failed intialized libusb context.\n{0}:{1}", MonoUsbSessionHandle.LastErrorCode, MonoUsbSessionHandle.LastErrorString)); } MonoUsbProfileList profileList = new MonoUsbProfileList(); // The list is initially empty. // Each time refresh is called the list contents are updated. int ret = profileList.Refresh(sessionHandle); if (ret < 0) { throw new Exception("Failed to retrieve device list."); } rtb.AppendText(string.Format("{0} device(s) found.\r\n", ret)); // Use the GetList() method to get a generic List of MonoUsbProfiles // Find all profiles that match in the MyVidPidPredicate. List <MonoUsbProfile> myVidPidList = profileList.GetList().FindAll(MyVidPidPredicate); // myVidPidList reresents a list of connected USB devices that matched // in MyVidPidPredicate. foreach (MonoUsbProfile profile in myVidPidList) { MonoUsbDeviceHandle h = profile.OpenDeviceHandle();// Usb.OpenDeviceWithVidPid(sessionHandle, 0x1915, 0x007B); if (h.IsInvalid) { throw new Exception(string.Format("Failed opening device handle.\r\n{0}: {1}", MonoUsbDeviceHandle.LastErrorCode, MonoUsbDeviceHandle.LastErrorString)); } Usb.SetConfiguration(h, 1); Usb.ClaimInterface(h, 1); MonoUsbProfileHandle ph = Usb.GetDevice(h); int packetSize = Usb.GetMaxIsoPacketSize(ph, 0x88); // Write the VendorID and ProductID to console output. rtb.AppendText(string.Format("[Device] Vid:{0:X4} Pid:{1:X4}\r\n", profile.DeviceDescriptor.VendorID, profile.DeviceDescriptor.ProductID)); // Loop through all of the devices configurations. for (byte i = 0; i < profile.DeviceDescriptor.ConfigurationCount; i++) { // Get a handle to the configuration. MonoUsbConfigHandle configHandle; if (MonoUsbApi.GetConfigDescriptor(profile.ProfileHandle, i, out configHandle) < 0) { continue; } if (configHandle.IsInvalid) { continue; } // Create a MonoUsbConfigDescriptor instance for this config handle. MonoUsbConfigDescriptor configDescriptor = new MonoUsbConfigDescriptor(configHandle); // Write the bConfigurationValue to console output. rtb.AppendText(string.Format(" [Config] bConfigurationValue:{0}\r\n", configDescriptor.bConfigurationValue)); // Interate through the InterfaceList foreach (MonoUsbInterface usbInterface in configDescriptor.InterfaceList) { // Interate through the AltInterfaceList foreach (MonoUsbAltInterfaceDescriptor usbAltInterface in usbInterface.AltInterfaceList) { // Write the bInterfaceNumber and bAlternateSetting to console output. rtb.AppendText(string.Format(" [Interface] bInterfaceNumber:{0} bAlternateSetting:{1}\r\n", usbAltInterface.bInterfaceNumber, usbAltInterface.bAlternateSetting)); // Interate through the EndpointList foreach (MonoUsbEndpointDescriptor endpoint in usbAltInterface.EndpointList) { // Write the bEndpointAddress, EndpointType, and wMaxPacketSize to console output. rtb.AppendText(string.Format(" [Endpoint] bEndpointAddress:{0:X2} EndpointType:{1} wMaxPacketSize:{2}\r\n", endpoint.bEndpointAddress, (EndpointType)(endpoint.bmAttributes & 0x3), endpoint.wMaxPacketSize)); if (endpoint.bEndpointAddress == 0x88) { } } } } // Not neccessary, but good programming practice. configHandle.Close(); } } // Not neccessary, but good programming practice. profileList.Close(); // Not neccessary, but good programming practice. sessionHandle.Close(); }
public bool DiscoveryUsbDevice(Boolean assignFlag = false) { UsbRegDeviceList allDevices = UsbDevice.AllDevices; if (assignFlag) { profileList = new MonoUsbProfileList(); sessionHandle = new MonoUsbSessionHandle(); if (sessionHandle.IsInvalid) { throw new Exception(String.Format("libusb {0}:{1}", MonoUsbSessionHandle.LastErrorCode, MonoUsbSessionHandle.LastErrorString)); } MyUsbDeviceArray = new UsbDevice[MAX_USB_DEVICE_COUNT]; } else { } foreach (UsbRegistry usbRegistry in allDevices) { System.Console.WriteLine("Open one more "); if (usbRegistry.Open(out MyUsbDevice)) { if ((bt_vid == MyUsbDevice.Info.Descriptor.VendorID) && (bt_pid == MyUsbDevice.Info.Descriptor.ProductID)) { MyUsbDeviceArray[UsbDeviceCount] = MyUsbDevice; UsbDeviceCount++; } else { System.Console.WriteLine(String.Format("device vid {0} pid {1}", MyUsbDevice.Info.Descriptor.VendorID, MyUsbDevice.Info.Descriptor.ProductID)); } for (int iConfig = 0; iConfig < MyUsbDevice.Configs.Count; iConfig++) { UsbConfigInfo configInfo = MyUsbDevice.Configs[iConfig]; Console.WriteLine(configInfo.ToString()); } } } System.Console.WriteLine(String.Format("Open {0}", UsbDeviceCount)); System.Console.WriteLine("begin"); if (profileList != null) { profileList.Refresh(sessionHandle); } MonoUsbProfile myProfile = profileList.GetList().Find(MyVidPidPredicate); MatchingUsbDeviceList = profileList.GetList().FindAll(MyVidPidPredicate); if (myProfile == null) { Console.WriteLine("myProfile is 0"); return(false); } // Open the device handle to perfom I/O myDeviceHandle = myProfile.OpenDeviceHandle(); if (myDeviceHandle.IsInvalid) { throw new Exception(String.Format("{0}, {1}", MonoUsbDeviceHandle.LastErrorCode, MonoUsbDeviceHandle.LastErrorString)); } for (int i = 0; i < UsbDeviceCount; i++) { object thisHubPort; int thisPortNum = -1; int thisHubNum = -1; char[] separatingChars = { '_', '.', '#' }; MyUsbDeviceArray[i].UsbRegistryInfo.DeviceProperties.TryGetValue("LocationInformation", out thisHubPort); System.Console.WriteLine(String.Format("thisHubPort {0}", thisHubPort)); string[] words = thisHubPort.ToString().Split(separatingChars, System.StringSplitOptions.RemoveEmptyEntries); if (words[0].Equals("Port")) { thisPortNum = Convert.ToInt32(words[1]); } if (words[2].Equals("Hub")) { thisHubNum = Convert.ToInt32(words[3]); } if (assignFlag) { usbDeviceInfo = new UsbDeviceInfo(); usbDeviceInfo.MyUsbDevice = MyUsbDeviceArray[i]; usbDeviceInfo.Port = thisPortNum; usbDeviceInfo.Hub = thisHubNum; Console.WriteLine(String.Format("info {0},{1}", thisPortNum, thisHubNum)); FinalDeviceIndex = (short)i; } else { if ((usb_port == thisPortNum) && (usb_hub == thisHubNum)) { System.Console.WriteLine(String.Format("usb_port {0}, usb_hub {1}", usb_port, usb_hub)); FinalDeviceIndex = (short)i; break; } } } return(true); }
static void Main(string[] args) { MonoUsbSessionHandle sessionHandle = null; MonoUsbDeviceHandle rapidradio = null; try { if (args.Length == 1 && args[0] == "--help") { Usage(); return; } var cmdParams = ParseCmdParams(args); // set up USB lib sessionHandle = new MonoUsbSessionHandle(); if (sessionHandle.IsInvalid) { throw new Exception("Invalid session handle."); } MonoUsbProfileListHandle list; MonoUsbApi.GetDeviceList(sessionHandle, out list); var profileList = new MonoUsbProfileList(); profileList.Refresh(sessionHandle); var rapidradios = profileList.Where(d => d.DeviceDescriptor != null && d.DeviceDescriptor.VendorID == Vid && d.DeviceDescriptor.ProductID == Pid).ToArray(); if (rapidradios.Length == 0) { Error("rapidradio USB device not found"); } if (rapidradios.Length > 1) { // more than 1 rapidradio USB attached Error(string.Format("Detected {0} rapidradio USB modules - currently only one device is supported.", rapidradios.Length), false); } rapidradio = rapidradios[0].OpenDeviceHandle(); if (rapidradio == null || rapidradio.IsInvalid) { throw new Exception("Invalid session handle."); } var r = MonoUsbApi.SetConfiguration(rapidradio, 1); if (r != 0) { Error("SetConfiguration error: " + GetErrorMessage(r)); } r = MonoUsbApi.ClaimInterface(rapidradio, 0); if (r != 0) { Error("ClaimInterface error: " + GetErrorMessage(r)); } _unmanagedReadBuff = Marshal.AllocHGlobal(32); _unmanagedWriteBuff = Marshal.AllocHGlobal(32); // send configuration to endpoint 4 var settings = cmdParams.Serialize(); SendData(rapidradio, 4, settings, settings.Length, 200); // send custom register settings (if any) foreach (var regPacket in cmdParams.SerializeRfmRegisters()) { if (cmdParams.Verbose) { Info(string.Format("Setting register R{0}={1}", regPacket[1], regPacket[2])); } SendData(rapidradio, 4, regPacket, regPacket.Length); } var stopWatch = new Stopwatch(); if (_stats) { stopWatch.Start(); } if (cmdParams.Verbose) { Info(string.Format("Address = 0x{0}", cmdParams.Address.ToString("X8"))); Info(string.Format("Channel = {0}", cmdParams.Channel)); Info(string.Format("Mode = {0}", cmdParams.SinglePacket == null ? cmdParams.Mode.ToString() : "Single Packet Mode")); Info(string.Format("ACK {0}", cmdParams.Ack ? "enabled" : "disabled")); Info(string.Format("Retries = {0}", cmdParams.Retries)); if (cmdParams.SinglePacket == null) { Info(string.Format("Packet Numbering {0}", cmdParams.PacketNumbering ? "enabled" : "disabled")); } } if (cmdParams.SinglePacket != null) { // send exactly one packet StartReadingThread(rapidradio); SendData(rapidradio, 2, cmdParams.SinglePacket.ToArray(), cmdParams.SinglePacket.Count); StopReadingThread(); } else { switch (cmdParams.Mode) { case RadioMode.Listening: Listening(rapidradio, cmdParams); break; case RadioMode.Sending: Sending(rapidradio, cmdParams); break; default: throw new ArgumentOutOfRangeException("Unknown mode"); } } if (_stats) { Info("Transmission took " + stopWatch.Elapsed); } // switch off the radio TurnOff(rapidradio); } catch (Exception e) { Error("An error occured: " + GetRecursiveMessage(e, 10)); } finally { { // Free and close resources if (rapidradio != null) { if (!rapidradio.IsInvalid) { MonoUsbApi.ReleaseInterface(rapidradio, 0); rapidradio.Close(); } } if (sessionHandle != null) { sessionHandle.Close(); } Marshal.FreeHGlobal(_unmanagedReadBuff); Marshal.FreeHGlobal(_unmanagedWriteBuff); } } }
public static void ShowConfig(RichTextBox rtb) { // Assign the control transfer delegate to the callback function. controlTransferDelegate = ControlTransferCB; // Initialize the context. sessionHandle = new MonoUsbSessionHandle(); if (sessionHandle.IsInvalid) { throw new Exception(String.Format("Failed intializing libusb context.\n{0}:{1}", MonoUsbSessionHandle.LastErrorCode, MonoUsbSessionHandle.LastErrorString)); } MonoUsbProfileList profileList = new MonoUsbProfileList(); MonoUsbDeviceHandle myDeviceHandle = null; try { // The list is initially empty. // Each time refresh is called the list contents are updated. profileList.Refresh(sessionHandle); // Use the GetList() method to get a generic List of MonoUsbProfiles // Find the first profile that matches in MyVidPidPredicate. MonoUsbProfile myProfile = profileList.GetList().Find(MyVidPidPredicate); if (myProfile == null) { rtb.AppendText("Device not connected."); return; } // Open the device handle to perform I/O myDeviceHandle = myProfile.OpenDeviceHandle(); if (myDeviceHandle.IsInvalid) { throw new Exception(String.Format("Failed opening device handle.\n{0}:{1}", MonoUsbDeviceHandle.LastErrorCode, MonoUsbDeviceHandle.LastErrorString)); } int ret; MonoUsbError e; // Set Configuration e = (MonoUsbError)(ret = MonoUsbApi.SetConfiguration(myDeviceHandle, 1)); if (ret < 0) { throw new Exception(String.Format("Failed SetConfiguration.\n{0}:{1}", e, MonoUsbApi.StrError(e))); } // Claim Interface e = (MonoUsbError)(ret = MonoUsbApi.ClaimInterface(myDeviceHandle, 0)); if (ret < 0) { throw new Exception(String.Format("Failed ClaimInterface.\n{0}:{1}", e, MonoUsbApi.StrError(e))); } // Create a vendor specific control setup, allocate 1 byte for return control data. byte requestType = (byte)(UsbCtrlFlags.Direction_In | UsbCtrlFlags.Recipient_Device | UsbCtrlFlags.RequestType_Vendor); byte request = 0x0F; MonoUsbControlSetupHandle controlSetupHandle = new MonoUsbControlSetupHandle(requestType, request, 0, 0, 1); // Transfer the control setup packet ret = libusb_control_transfer(myDeviceHandle, controlSetupHandle, 1000); if (ret > 0) { rtb.AppendText("\nSuccess!\n"); byte[] ctrlDataBytes = controlSetupHandle.ControlSetup.GetData(ret); string ctrlDataString = Helper.HexString(ctrlDataBytes, String.Empty, "h "); rtb.AppendText(string.Format("Return Length: {0}", ret)); rtb.AppendText(string.Format("DATA (hex) : [ {0} ]\n", ctrlDataString.Trim())); } MonoUsbApi.ReleaseInterface(myDeviceHandle, 0); } finally { profileList.Close(); if (myDeviceHandle != null) { myDeviceHandle.Close(); } sessionHandle.Close(); } }
public void CreateAnUsbSession() { usbSession = new MonoUsbSessionHandle(); }
public MonoLibUsbTests() { usbSession = new MonoUsbSessionHandle(); }