/// <summary> /// Open the connection /// </summary> /// <returns>whether the connection was opened successfully</returns> public async Task<bool> OpenAsync() { dev = UsbDevice.OpenUsbDevice(new UsbDeviceFinder(0x10C4, 0xEAC9)); if (dev == null) { dev = UsbDevice.OpenUsbDevice(new UsbDeviceFinder(0x10C4, 0xEACA)); if (dev == null) return false; } IUsbDevice wholeUsbDevice = dev as IUsbDevice; if (!ReferenceEquals(wholeUsbDevice, null)) { // This is a "whole" USB device. Before it can be used, // the desired configuration and interface must be selected. // Select config #1 wholeUsbDevice.SetConfiguration(1); // Claim interface #0. wholeUsbDevice.ClaimInterface(0); } writer = dev.OpenEndpointWriter(WriteEndpointID.Ep01, EndpointType.Interrupt); reader = dev.OpenEndpointReader(ReadEndpointID.Ep01, 64, EndpointType.Interrupt); return true; }
/// <summary> /// Creates and initializes an instance of a Crazyradio USB dongle driver. /// </summary> /// <param name="crazyradioUsbDevice"> The UsbDevice to use in this driver. </param> public CrazyradioDriver(UsbDevice crazyradioUsbDevice) { Log.Debug("Received UsbDevice to use in CrazyradioDriver."); if (crazyradioUsbDevice == null) { Log.Error("UsbDevice is null."); throw new ArgumentNullException("crazyradioUsbDevice"); } _crazyradioUsbDevice = crazyradioUsbDevice; if (IsCrazyradioUsbDongle(_crazyradioUsbDevice)) { Log.Debug("UsbDevice is in fact a Crazyradio USB dongle."); CheckFirmwareVersion(); } else { const string message = "UsbDevice is not a Crazyradio USB dongle."; Log.Error(message); throw new CrazyradioDriverException(message); } if (_crazyradioUsbDevice.IsOpen) { Log.Debug("UsbDevice is open. Closing until user opens to prevent inconsistent driver state."); _crazyradioUsbDevice.Close(); } }
private bool GetDelcomBuildLight() { try { MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder); // If the device is open and ready if (MyUsbDevice == null) throw new Exception("Device Not Found."); IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice; if (!ReferenceEquals(wholeUsbDevice, null)) { // This is a "whole" USB device. Before it can be used, // the desired configuration and interface must be selected. // Select config #1 wholeUsbDevice.SetConfiguration(1); // Claim interface #0. wholeUsbDevice.ClaimInterface(0); } return true; } catch (Exception) { return false; } }
public Receiver(USBManager manager, UsbDevice device) { //m_manager = manager; //m_reader = device.OpenEndpointReader(readEndpoint); // On ouvre le canal de lecture //m_engaged = true; //readThread = new Thread(this.doRead); //// Start to read //readThread.Start(); }
public UsbTool() { if(MyUsbDevice == null) { // Find and open the usb device. MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder); // If the device is open and ready if (MyUsbDevice == null) throw new Exception("Device Not Found."); // If this is a "whole" usb device (libusb-win32, linux libusb) // it will have an IUsbDevice interface. If not (WinUSB) the // variable will be null indicating this is an interface of a // device. IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice; if (!ReferenceEquals(wholeUsbDevice, null)) { // This is a "whole" USB device. Before it can be used, // the desired configuration and interface must be selected. wholeUsbDevice.SetConfiguration(1); wholeUsbDevice.ClaimInterface(0); wholeUsbDevice.ClaimInterface(1); } } }
public CHDKPTPDevice(UsbDevice dev) : base(dev) { this.CHDKVersionMajor = -1; this.CHDKVersionMinor = -1; this.CHDKSupported = false; }
public void CloseDevice() { if(_usbDevice == null || !_usbDevice.IsOpen) return; if(_epReader != null) { _epReader.Dispose(); _epReader = null; } if(_epWriter != null) { _epWriter.Abort(); _epWriter.Dispose(); _epWriter = null; } // If this is a "whole" usb device (libusb-win32, linux libusb) // it will have an IUsbDevice interface. If not (WinUSB) the // variable will be null indicating this is an interface of a // device. var wholeUsbDevice = _usbDevice as IUsbDevice; if(!ReferenceEquals(wholeUsbDevice, null)) wholeUsbDevice.ReleaseInterface(0); // Release interface #0. _usbDevice.Close(); _usbDevice = null; }
/** * Finds all of the connected Playstation controllers. */ public static UsbDevice[] getControllers() { List<UsbDevice> controllersL = new List<UsbDevice>(); //UsbDevice[] controllers = new UsbDevice[4]; UsbDevice[] devices = new UsbDevice[20]; UsbRegDeviceList allDevices = UsbDevice.AllDevices; Console.WriteLine("numDevices: " + allDevices.Count); int i = 0; foreach (UsbRegistry usbRegistry in allDevices) { //Console.WriteLine("device"+i); if (usbRegistry.Open(out devices[i])) { Console.WriteLine(devices[i].Info.ToString()); if (devices[i].Info.ToString().Contains("PLAYSTATION")) { /*int index = 0; for (int j = 0; j < 4; j++) { if (controllers[j] == null) { index = j; break; } } controllers[index] = devices[i];*/ controllersL.Add(devices[i]); } } i++; } return controllersL.ToArray(); }
// Connect to the arm public bool Connect() { // Vendor ID/Product ID here UsbDeviceFinder USBFinder = new UsbDeviceFinder(0x1267, 0x0); // Try to open the device RobotArm = UsbDevice.OpenUsbDevice(USBFinder); // Did we connect OK? if ((RobotArm == null)) return false; // If this is a "whole" usb device (libusb-win32, linux libusb) // it will have an IUsbDevice interface. If not (WinUSB) the // variable will be null indicating this is an interface of a // device. IUsbDevice wholeUsbDevice = RobotArm as IUsbDevice; if (!ReferenceEquals(wholeUsbDevice, null)) { // This is a "whole" USB device. Before it can be used, // the desired configuration and interface must be selected. // Select config #1 wholeUsbDevice.SetConfiguration(1); // Claim interface #0. wholeUsbDevice.ClaimInterface(0); } // Connected and have interface to the arm return true; }
public LibUsb_AsyncUsbStream (string port) { var splited = port.Split ('-'); var finder = new UsbDeviceFinder (int.Parse (splited [0]), int.Parse (splited [1])); device = UsbDevice.OpenUsbDevice (finder); if (device == null) { throw new Exception ("Failed to find device:" + port); } if (!device.IsOpen) { throw new Exception ("Device is not open:" + port); } var usbDevice = device as IUsbDevice; var interfaceInfo = device.Configs [0].InterfaceInfoList [0]; if (usbDevice != null) { usbDevice.SetConfiguration (device.Configs [0].Descriptor.ConfigID); usbDevice.ClaimInterface (interfaceInfo.Descriptor.InterfaceID); deviceInterfaceId = interfaceInfo.Descriptor.InterfaceID; } foreach (var ep in interfaceInfo.EndpointInfoList) { if ((ep.Descriptor.EndpointID & 0x80) > 0) { reader = device.OpenEndpointReader ((ReadEndpointID)ep.Descriptor.EndpointID); reader.DataReceived += HandleDataReceived; reader.DataReceivedEnabled = true; } else { writer = device.OpenEndpointWriter ((WriteEndpointID)ep.Descriptor.EndpointID); } } }
/// <summary> /// Try to connect to the device /// </summary> /// <returns>1 for success, 0 for fail</returns> public int connect() { try { // Find and open the usb device. MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder); // If the device is open and ready if (MyUsbDevice == null) throw new Exception("Device Not Found."); // If this is a "whole" usb device (libusb-win32, linux libusb) // it will have an IUsbDevice interface. If not (WinUSB) the // variable will be null indicating this is an interface of a // device. IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice; if (!ReferenceEquals(wholeUsbDevice, null)) { // This is a "whole" USB device. Before it can be used, // the desired configuration and interface must be selected. // Select config #1 wholeUsbDevice.SetConfiguration(1); // Claim interface #0. wholeUsbDevice.ClaimInterface(0); } return 1; // Device found! } catch { return 0; // Failed to find one. } }
public override void Close() { try { write_lock.WaitOne (); if (ep_reader != null) { // detach read event ep_reader.DataReceivedEnabled = false; ep_reader.DataReceived -= (read_usb); } ep_reader = null; ep_writer = null; if (IsOpen ()) { // close devices usb_device.Close (); wholeUsbDevice.ReleaseInterface (1); wholeUsbDevice.Close (); } // release devices usb_device = null; wholeUsbDevice = null; UsbDevice.Exit(); } catch (Exception) { // Ignore everything } finally { write_lock.ReleaseMutex(); } }
public void open() { // Find and open the usb device. MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder); if (MyUsbDevice == null) throw new Exception("Device Not Found."); UsbEndpointReader reader = MyUsbDevice.OpenEndpointReader(ReadEndpointID.Ep01); }
public void Close() { if (usbDevice == null) return; usbDevice.Close(); usbDevice = null; }
private static void InitDevice() { MyUsbFinder = new UsbDeviceFinder(0x045E, 0x02B0); MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder); // If the device is open and ready if (MyUsbDevice == null) throw new Exception("Device Not Found."); // If this is a "whole" usb device (libusb-win32, linux libusb) // it will have an IUsbDevice interface. If not (WinUSB) the // variable will be null indicating this is an interface of a // device. IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice; if (!ReferenceEquals(wholeUsbDevice, null)) { // This is a "whole" USB device. Before it can be used, // the desired configuration and interface must be selected. // Select config #1 wholeUsbDevice.SetConfiguration(1); // Claim interface #0. wholeUsbDevice.ClaimInterface(0); } }
/** * Finds all of the connected Playstation controllers. */ public static UsbDevice[] getControllers() { UsbDevice[] controllers = new UsbDevice[4]; UsbDevice[] devices = new UsbDevice[20]; UsbRegDeviceList allDevices = UsbDevice.AllDevices; int i = 0; foreach (UsbRegistry usbRegistry in allDevices) { if (usbRegistry.Open(out devices[i])) { if (devices[i].Info.ToString().Contains("PLAYSTATION")) { int index = 0; for (int j = 0; j < 4; j++) { if (controllers[j] == null) { index = j; break; } } controllers[index] = devices[i]; } } i++; } return controllers; }
private void DeviceFound(LibUsbDotNet.UsbDevice scopeUsbDevice) { string serial = null; try { SmartScopeUsbInterfaceLibUsb f = new SmartScopeUsbInterfaceLibUsb(scopeUsbDevice); //FIXME: should use ScopeUsbDevice.serial but not set with smartscope serial = scopeUsbDevice.Info.SerialString; if (serial == "" || serial == null) { throw new ScopeIOException("This device doesn't have a serial number, can't work with that"); } if (interfaces.ContainsKey(serial)) { Common.Logger.Warn("Can't re-register device with this serial " + serial); throw new ScopeIOException("This device was already registered. This is a bug"); } C.Logger.Debug("Device found with serial [" + serial + "]"); interfaces.Add(serial, f); if (onConnect != null) { onConnect(f, true); } } catch (ScopeIOException e) { C.Logger.Error("Error while opening device: " + e.Message); if (serial != null) { interfaces.Remove(serial); } } }
public static void OpenDevice(Int32 vid, Int32 pid) { if (usbDevice != null) Program.ShowError("A device is already openned, please close it first."); Logger.Log("Connecting to device vid." + vid + " pid." + pid); UsbDeviceFinder usbFinder = new UsbDeviceFinder(vid, pid); // Find and open the usb device. usbDevice = UsbDevice.OpenUsbDevice(usbFinder); // If the device is open and ready if (usbDevice == null) throw new Exception("Device Not Found."); // If this is a "whole" usb device (libusb-win32, linux libusb-1.0) // it exposes an IUsbDevice interface. If not (WinUSB) the // 'wholeUsbDevice' variable will be null indicating this is // an interface of a device; it does not require or support // configuration and interface selection. IUsbDevice wholeUsbDevice = usbDevice as IUsbDevice; if (!ReferenceEquals(wholeUsbDevice, null)) { // This is a "whole" USB device. Before it can be used, // the desired configuration and interface must be selected. // Select config #1 wholeUsbDevice.SetConfiguration(1); // Claim interface #0. wholeUsbDevice.ClaimInterface(0); } }
public override bool OpenDevice () { // Find and open the usb device. if (device == null) device = UsbDevice.OpenUsbDevice (deviceFinder); // If the device is open and ready if (device == null) throw new Exception ("Device Not Found."); // If this is a "whole" usb device (libusb-win32, linux libusb) // it will have an IUsbDevice interface. If not (WinUSB) the // variable will be null indicating this is an interface of a // device. IUsbDevice wholeUsbDevice = device as IUsbDevice; if (!ReferenceEquals (wholeUsbDevice, null)) { // This is a "whole" USB device. Before it can be used, // the desired configuration and interface must be selected. // Select config #1 wholeUsbDevice.SetConfiguration (1); // Claim interface #0. wholeUsbDevice.ClaimInterface (0); } else { return false; } connectedToDriver = true; return true; }
public override bool Open(out UsbDevice usbDevice) { usbDevice = null; MacUsbDevice macUsbDevice; bool bSuccess = Open(out macUsbDevice); if (bSuccess) usbDevice = macUsbDevice; return bSuccess; }
public UsbConnection(UsbRegistry regDevice) { this.DevicePath = regDevice.SymbolicName; device = regDevice.Device; SerialNumber = device.Info.SerialString; Name = device.Info.ProductString; Version = device.Info.Descriptor.BcdDevice; }
public PTPDevice(UsbDevice dev) { _Device = dev; PTPSupported = false; _Name = dev.Info.ProductString; // TODO: try get better name Reader = null; Writer = null; ConfigurationID = 1; InterfaceID = 0; ReaderEndpointID = ReadEndpointID.Ep01; WriterEndpointID = WriteEndpointID.Ep02; }
public PTPDevice(UsbDevice dev) { this.Device = dev; this.PTPSupported = false; this._Name = dev.Info.ProductString; // TODO: try get better name this.Reader = null; this.Writer = null; this.ConfigurationID = 1; this.InterfaceID = 0; this.ReaderEndpointID = ReadEndpointID.Ep01; this.WriterEndpointID = WriteEndpointID.Ep02; }
public USBFadecandy(int pixelCount = 0, string serialNumber = "") : base(pixelCount) { if(pixelCount > 512) throw new ArgumentOutOfRangeException("pixelCount"); var packets = pixelCount/21; // Can fit 21 pixels into each packet activeBuffer = new byte[64 * packets]; // Each packet needs to be 64 bytes queuedBuffer = new byte[64 * packets]; // Setup control bytes for all packets. Never wiped out, only needs to be done once. for (int i = 0; i < packets; i++) { byte packet_index = (byte)(i & 0x1F); // Bits 0-4, packet index byte final = (byte)(i == packets - 1 ? 1 : 0); // Bit 5, final bit (denotes last packet) //byte type = 0; // Bits 6-7, type code (0 for video data) activeBuffer[i*64] = (byte)(packet_index & (final >> 5)); // First byte in each packet is a bitfield } Array.Copy(activeBuffer, queuedBuffer, activeBuffer.Length); dirty = false; UsbDeviceFinder usbFinder = string.IsNullOrEmpty(serialNumber) ? new UsbDeviceFinder(0x1d50, 0x607a) : new UsbDeviceFinder(0x1d50, 0x607a, serialNumber); ErrorCode ec = ErrorCode.None; // Find and open the usb device. fcdevice = UsbDevice.OpenUsbDevice(usbFinder); // If the device is open and ready if (fcdevice == null) throw new Exception("Device Not Found."); // If this is a "whole" usb device (libusb-win32, linux libusb) // it will have an IUsbDevice interface. If not (WinUSB) the // variable will be null indicating this is an interface of a // device. IUsbDevice wholeUsbDevice = fcdevice as IUsbDevice; if (!ReferenceEquals(wholeUsbDevice, null)) { // This is a "whole" USB device. Before it can be used, // the desired configuration and interface must be selected. // Select config #1 wholeUsbDevice.SetConfiguration(1); // Claim interface #0. wholeUsbDevice.ClaimInterface(0); } // open write endpoint 1. writer = fcdevice.OpenEndpointWriter(WriteEndpointID.Ep01); }
internal void OpenDevice (UsbRegistry registry) { this._device = registry.Device; IUsbDevice wholeUsbDevice = _device as IUsbDevice; if (!ReferenceEquals (wholeUsbDevice, null)) { // Select config #1 wholeUsbDevice.SetConfiguration (1); // Claim interface #0. wholeUsbDevice.ClaimInterface (0); } }
public void Close() { this.Dispose(); if (MyUsbDevice != null) { if (MyUsbDevice.DriverMode == UsbDevice.DriverModeType.MonoLibUsb) { try { MyUsbDevice.Close(); } catch { } } MyUsbDevice = null; } }
public GarminUnit(UsbDevice Device) { Configuration = new Dictionary<string, ushort>(); IUsbDevice wholedevice = Device as IUsbDevice; if ( !ReferenceEquals(wholedevice, null)) { wholedevice.SetConfiguration(1); wholedevice.ClaimInterface(0); } Reader = Device.OpenEndpointReader(ReadEndpointID.Ep01); Writer = Device.OpenEndpointWriter(WriteEndpointID.Ep02); }
public bool Connect() { foreach (int mode in Enum.GetValues(typeof(DeviceMode))) { if (! ReferenceEquals((mDevice = UsbDevice.OpenUsbDevice(new UsbDeviceFinder(mVendor, mode))), null)) { //write debug log "OK" return true; } } //write debug log "FAIL" return false; }
public void close() { if (MyUsbDevice != null) { if (MyUsbDevice.IsOpen) { setToBlack(); update(); MyUsbDevice.Close(); } MyUsbDevice = null; UsbDevice.Exit(); } }
public static void Connect() { device = UsbDevice.OpenUsbDevice(finder); if (device == null) throw new DeviceNotFoundException(); IUsbDevice usbDev = device as IUsbDevice; if (!ReferenceEquals(usbDev, null)) { usbDev.SetConfiguration(1); usbDev.ClaimInterface(0); } }
public void Thu() { ErrorCode ec = ErrorCode.None; UsbRegDeviceList lu = LibUsbDotNet.UsbDevice.AllDevices; MyUsbFinder = new UsbDeviceFinder(1614, 33024); LibUsbDotNet.UsbDevice MyUsbDevice = null; try { // Find and open the usb device. MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder); //MyUsbDevice = lu[0].Device; // If the device is open and ready if (MyUsbDevice == null) { throw new Exception("Device Not Found."); } // If this is a "whole" usb device (libusb-win32, linux libusb) // it will have an IUsbDevice interface. If not (WinUSB) the // variable will be null indicating this is an interface of a // device. IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice; if (!ReferenceEquals(wholeUsbDevice, null)) { // This is a "whole" USB device. Before it can be used, // the desired configuration and interface must be selected. // Select config wholeUsbDevice.SetConfiguration(1); // Claim interface wholeUsbDevice.ClaimInterface(1); } // open read endpoint UsbEndpointReader reader = MyUsbDevice.OpenEndpointReader(ReadEndpointID.Ep02); // open write endpoint0123456789 UsbEndpointWriter writer = MyUsbDevice.OpenEndpointWriter(WriteEndpointID.Ep03); // write data, read data int bytesWritten; //ec = writer.Write(new byte[] { 0x00, 0x03, 0x00, 0x00, 0x00, // 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, 2000, out bytesWritten); //if (ec != ErrorCode.None) // throw new Exception(UsbDevice.LastErrorString); ec = ErrorCode.None; byte[] readBuffer = new byte[1024]; while (ec == ErrorCode.None) { int bytesRead; // If the device hasn't sent data in the last 100 milliseconds, // a timeout error (ec = IoTimedOut) will occur. ec = reader.Read(readBuffer, 100, out bytesRead); if (bytesRead == 0) { throw new Exception("No more bytes!"); } // Write that output to the console. // PrintHex(readBuffer, bytesRead); } //Console.WriteLine("\r\nDone!\r\n"); } catch (Exception ex) { //Console.WriteLine(); //Console.WriteLine((ec != ErrorCode.None ? ec + ":" : String.Empty) + ex.Message); } finally { if (MyUsbDevice != null) { if (MyUsbDevice.IsOpen) { // If this is a "whole" usb device (libusb-win32, linux libusb-1.0) // it exposes an IUsbDevice interface. If not (WinUSB) the // 'wholeUsbDevice' variable will be null indicating this is // an interface of a device; it does not require or support // configuration and interface selection. IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice; if (!ReferenceEquals(wholeUsbDevice, null)) { // Release interface wholeUsbDevice.ReleaseInterface(1); } MyUsbDevice.Close(); } MyUsbDevice = null; // Free usb resources UsbDevice.Exit(); } } }
public static void CloseDevice() { if (usbDevice != null) { if (usbDevice.IsOpen) { Logger.Log("Closing device"); // If this is a "whole" usb device (libusb-win32, linux libusb-1.0) // it exposes an IUsbDevice interface. If not (WinUSB) the // 'wholeUsbDevice' variable will be null indicating this is // an interface of a device; it does not require or support // configuration and interface selection. IUsbDevice wholeUsbDevice = usbDevice as IUsbDevice; if (!ReferenceEquals(wholeUsbDevice, null)) { // Release interface #0. wholeUsbDevice.ReleaseInterface(0); } usbDevice.Close(); } usbDevice = null; // Free usb resources UsbDevice.Exit(); } }