/// <summary> /// Initializes a new instance of the LIB USB class. /// </summary> /// <param name="vendorId">Vendor identifier.</param> /// <param name="productId">Product identifier.</param> /// <param name="readId">Read identifier.</param> /// <param name="writeId">Write identifier.</param> public LibUsb(short vendorId, short productId, ReadEndpointID readId, WriteEndpointID writeId) { this.vendorId = vendorId; this.productId = productId; this.readId = readId; this.writeId = writeId; myUsbFinder = new UsbDeviceFinder(this.vendorId, this.productId); }
public UsbDevStream(IUsbDevice dev, WriteEndpointID writePipe, ReadEndpointID readPipe) { device = dev; WritePipe = writePipe; ReadPipe = readPipe; writer = device.OpenEndpointWriter(writePipe); reader = device.OpenEndpointReader(readPipe); Flush(); }
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 UsbLibDotNetHIDDevice() { this.m_vendorID = -1; this.m_productID = -1; this.m_configID = 255; this.m_interfaceID = 255; this.m_readEndpoint = ReadEndpointID.Ep01; this.m_writeEndpoint = WriteEndpointID.Ep01; this.m_usbDevice = null; this.m_usbReader = null; this.m_usbWriter = null; }
/// <summary> /// Opens an endpoint for reading /// </summary> /// <param name="readEndpointID">Endpoint number for read operations.</param> /// <param name="readBufferSize">Size of the read buffer allocated for the <see cref="UsbEndpointReader.DataReceived"/> event.</param> /// <param name="endpointType">The type of endpoint to open.</param> /// <returns>A <see cref="UsbEndpointReader"/> class ready for reading. If the specified endpoint is already been opened, the original <see cref="UsbEndpointReader"/> class is returned.</returns> public virtual UsbEndpointReader OpenEndpointReader(ReadEndpointID readEndpointID, int readBufferSize, EndpointType endpointType) { foreach (UsbEndpointBase activeEndpoint in mActiveEndpoints) { if (activeEndpoint.EpNum == (byte)readEndpointID) { return((UsbEndpointReader)activeEndpoint); } } UsbEndpointReader epNew = new UsbEndpointReader(this, readBufferSize, readEndpointID, endpointType); return((UsbEndpointReader)mActiveEndpoints.Add(epNew)); }
/// <summary> /// Opens an endpoint for reading /// </summary> /// <param name="readEndpointID">Endpoint number for read operations.</param> /// <param name="readBufferSize">Size of the read buffer allocated for the <see cref="UsbEndpointReader.DataReceived"/> event.</param> /// <param name="endpointType">The type of endpoint to open.</param> /// <returns>A <see cref="UsbEndpointReader"/> class ready for reading. If the specified endpoint is already been opened, the original <see cref="UsbEndpointReader"/> class is returned.</returns> public virtual UsbEndpointReader OpenEndpointReader(ReadEndpointID readEndpointID, int readBufferSize, EndpointType endpointType) { foreach (UsbEndpointBase activeEndpoint in mActiveEndpoints) { if (activeEndpoint.EpNum == (byte)readEndpointID) { return((UsbEndpointReader)activeEndpoint); } } byte altIntefaceID = mClaimedInterfaces.Count == 0 ? UsbAltInterfaceSettings[0] : UsbAltInterfaceSettings[mClaimedInterfaces[mClaimedInterfaces.Count - 1]]; UsbEndpointReader epNew = new UsbEndpointReader(this, readBufferSize, altIntefaceID, readEndpointID, endpointType); return((UsbEndpointReader)mActiveEndpoints.Add(epNew)); }
public static bool TryExtractEndpointPair(this UsbDevice device, out ReadEndpointID readId, out WriteEndpointID writeId) { var ids = ( from info in device.Configs.SelectMany(config => config.InterfaceInfoList) let r = info.EndpointInfoList.Select(ep => ep.Descriptor.EndpointID).FirstOrDefault(id => (id & 0x80) > 0) let w = info.EndpointInfoList.Select(ep => ep.Descriptor.EndpointID).FirstOrDefault(id => (id & 0x80) == 0) where r > 0 && w > 0 select new { ReadId = (ReadEndpointID)r, WriteId = (WriteEndpointID)w, }).FirstOrDefault(); readId = ids?.ReadId ?? 0; writeId = ids?.WriteId ?? 0; return(ids != null); }
/// <summary> /// ctor. /// </summary> /// <param name="shouter">The shouter instance.</param> /// <param name="vendorId">The vendor id.</param> /// <param name="productId">The product id.</param> /// <param name="configuration">The configuration id.</param> /// <param name="@interface">The interface id.</param> /// <param name="readEndpointInt">The read endpoint id.</param> /// <param name="writeEndpointInt">The write end point id.</param> public RawUsbBulkDevice( IShouter shouter, int vendorId, int productId, byte configuration, int @interface, int readEndpointInt, int writeEndpointInt) { Shouter = shouter; VendorId = vendorId; ProductId = productId; Configuration = configuration; Interface = @interface; ReadEndpointID = (ReadEndpointID)readEndpointInt; WriteEndpointID = (WriteEndpointID)writeEndpointInt; Init(); }
public UsbDevStream OpenStream(WriteEndpointID WriteEp, ReadEndpointID ReadEp) => new UsbDevStream(dev, WriteEp, ReadEp);
/// <summary> /// Gets endpoint policies for the specified endpoint id. /// </summary> /// <param name="epNum">The endpoint ID to retrieve <see cref="PipePolicies"/> for.</param> /// <returns>A <see cref="PipePolicies"/> class.</returns> public PipePolicies EndpointPolicies(ReadEndpointID epNum) { return(new PipePolicies(mUsbHandle, (byte)epNum)); }
internal UsbEndpointReader(UsbDevice usbDevice, int readBufferSize, ReadEndpointID readEndpointID, EndpointType endpointType) : base(usbDevice, (Byte)readEndpointID, endpointType) { mReadBufferSize = readBufferSize; }
public abstract UsbEndpointReader OpenEndpointReader(ReadEndpointID readEndpointID);
/// <summary> /// Opens a <see cref="EndpointType.Bulk"/> endpoint for reading /// </summary> /// <param name="readEndpointID">Endpoint number for read operations.</param> /// <param name="readBufferSize">Size of the read buffer allocated for the <see cref="UsbEndpointReader.DataReceived"/> event.</param> /// <returns>A <see cref="UsbEndpointReader"/> class ready for reading. If the specified endpoint is already been opened, the original <see cref="UsbEndpointReader"/> class is returned.</returns> public UsbEndpointReader OpenEndpointReader(ReadEndpointID readEndpointID, int readBufferSize) { return OpenEndpointReader(readEndpointID, readBufferSize, EndpointType.Bulk); }
public static void USBPrint(string printerName, byte[] document) { _log.Debug(String.Format("USBPrint to printerName: [{0}], document: [{1}]", printerName, document.ToString())); UsbDevice usbDevice; UsbEndpointWriter usbWriter; ErrorCode usbErrorCode = ErrorCode.None; //int vid = Convert.ToInt32(ConfigurationManager.AppSettings["printerVID"], 16); //int pid = Convert.ToInt32(ConfigurationManager.AppSettings["printerPID"], 16); //WriteEndpointID endpoint = GetEnumFromString(ConfigurationManager.AppSettings["printerEndPoint"]); //string printerPort = ConfigurationManager.AppSettings["printerPort"]; //string[] printerParam = printerPort.Split('|'); string[] printerParam = printerName.Split('|'); int vid = Convert.ToInt32(printerParam[0], 16); int pid = Convert.ToInt32(printerParam[1], 16); WriteEndpointID endpointWrite = GetWriteEndpointFromString(printerParam[2]); ReadEndpointID endpointRead = GetReadEndpointFromString(printerParam[2]); try { //Init Usb Finder 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) // it will have an IUsbDevice interface. If not (WinUSB) the // variable will be null indicating this is an interface of a // device. 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 wholeUsbDevice.SetConfiguration(1); // Claim interface wholeUsbDevice.ClaimInterface(1); } // open read endpoint UsbEndpointReader reader = usbDevice.OpenEndpointReader(endpointRead); reader.DataReceived += Reader_DataReceived; // open write endpoint usbWriter = usbDevice.OpenEndpointWriter(endpointWrite); //byte[] document = Encoding.ASCII.GetBytes("Hello World"); try { // write data, read data int bytesWritten; usbErrorCode = usbWriter.Write(document, 2000, out bytesWritten); if (usbErrorCode != ErrorCode.None) { Close(usbDevice); // Write that output to the console. throw new Exception(UsbDevice.LastErrorString); } } catch (Exception ex) { Console.WriteLine(ex.Message); } } catch (Exception ex) { _log.Error((usbErrorCode != ErrorCode.None ? usbErrorCode + ":" : String.Empty) + ex.Message); } }
internal UsbEndpointReader(UsbDevice usbDevice, int readBufferSize, byte alternateInterfaceID, ReadEndpointID readEndpointID, EndpointType endpointType) : base(usbDevice, alternateInterfaceID, (Byte)readEndpointID, endpointType) { mReadBufferSize = readBufferSize; }
public UsbEndpointReader OpenEndpointReader(ReadEndpointID readEndpointID) { return usbDevice.OpenEndpointReader(readEndpointID); }
/// <summary> /// Gets endpoint policies for the specified endpoint id. /// </summary> /// <param name="epNum">The endpoint ID to retrieve <see cref="PipePolicies"/> for.</param> /// <returns>A <see cref="PipePolicies"/> class.</returns> public PipePolicies EndpointPolicies(ReadEndpointID epNum) { return new PipePolicies(mUsbHandle, (byte) epNum); }
public UsbEndpointReader OpenEndpointReader(ReadEndpointID readEndpointID) { return(usbDevice.OpenEndpointReader(readEndpointID)); }
internal MonoUsbEndpointReader(UsbDevice usbDevice, int readBufferSize, ReadEndpointID readEndpointID, EndpointType endpointType) : base(usbDevice, readBufferSize, readEndpointID, endpointType) { }
/// <summary> /// Opens a <see cref="EndpointType.Bulk"/> endpoint for reading /// </summary> /// <param name="readEndpointID">Endpoint number for read operations.</param> /// <returns>A <see cref="UsbEndpointReader"/> class ready for reading. If the specified endpoint is already been opened, the original <see cref="UsbEndpointReader"/> class is returned.</returns> public UsbEndpointReader OpenEndpointReader(ReadEndpointID readEndpointID) { return OpenEndpointReader(readEndpointID, UsbEndpointReader.DefReadBufferSize); }
public UsbEndpointReader OpenEndpointReader(ReadEndpointID readEndpointID, int readBufferSize, EndpointType endpointType) { return(_device.OpenEndpointReader(readEndpointID, readBufferSize, endpointType)); }
/// <summary> /// Opens an endpoint for reading /// </summary> /// <param name="readEndpointID">Endpoint number for read operations.</param> /// <param name="readBufferSize">Size of the read buffer allocated for the <see cref="UsbEndpointReader.DataReceived"/> event.</param> /// <param name="endpointType">The type of endpoint to open.</param> /// <returns>A <see cref="UsbEndpointReader"/> class ready for reading. If the specified endpoint is already been opened, the original <see cref="UsbEndpointReader"/> class is returned.</returns> public virtual UsbEndpointReader OpenEndpointReader(ReadEndpointID readEndpointID, int readBufferSize, EndpointType endpointType) { foreach (UsbEndpointBase activeEndpoint in mActiveEndpoints) if (activeEndpoint.EpNum == (byte) readEndpointID) return (UsbEndpointReader) activeEndpoint; byte altIntefaceID = mClaimedInterfaces.Count == 0 ? UsbAltInterfaceSettings[0] : UsbAltInterfaceSettings[mClaimedInterfaces[mClaimedInterfaces.Count - 1]]; UsbEndpointReader epNew = new UsbEndpointReader(this, readBufferSize, altIntefaceID, readEndpointID, endpointType); return (UsbEndpointReader) mActiveEndpoints.Add(epNew); }
public UsbEndpointReader(IUsbDevice usbDevice, int readBufferSize, byte alternateInterfaceID, ReadEndpointID readEndpointID, EndpointType endpointType) : base(usbDevice, alternateInterfaceID, (byte)readEndpointID, endpointType) { this.mReadBufferSize = readBufferSize; }
internal MonoUsbEndpointReader(UsbDevice usbDevice, int readBufferSize, byte alternateInterfaceID, ReadEndpointID readEndpointID, EndpointType endpointType) : base(usbDevice, readBufferSize, alternateInterfaceID, readEndpointID, endpointType) { }
/// <summary> /// Opens an endpoint for reading /// </summary> /// <param name="readEndpointID">Endpoint number for read operations.</param> /// <param name="readBufferSize">Size of the read buffer allocated for the <see cref="UsbEndpointReader.DataReceived"/> event.</param> /// <param name="endpointType">The type of endpoint to open.</param> /// <returns>A <see cref="UsbEndpointReader"/> class ready for reading. If the specified endpoint is already been opened, the original <see cref="UsbEndpointReader"/> class is returned.</returns> public UsbEndpointReader OpenEndpointReader(ReadEndpointID readEndpointID, int readBufferSize, EndpointType endpointType) { byte altIntefaceID = this.mClaimedInterfaces.Count == 0 ? this.usbAltInterfaceSettings[0] : this.usbAltInterfaceSettings[this.mClaimedInterfaces[this.mClaimedInterfaces.Count - 1]]; return(new UsbEndpointReader(this, readBufferSize, altIntefaceID, readEndpointID, endpointType)); }
/// <summary> /// Opens a <see cref="EndpointType.Bulk"/> endpoint for reading /// </summary> /// <param name="readEndpointID">Endpoint number for read operations.</param> /// <returns>A <see cref="UsbEndpointReader"/> class ready for reading. If the specified endpoint is already been opened, the original <see cref="UsbEndpointReader"/> class is returned.</returns> public UsbEndpointReader OpenEndpointReader(ReadEndpointID readEndpointID) { return(OpenEndpointReader(readEndpointID, UsbEndpointReader.DefReadBufferSize)); }
/// <summary> /// Opens an endpoint for reading /// </summary> /// <param name="readEndpointID">Endpoint number for read operations.</param> /// <param name="readBufferSize">Size of the read buffer allocated for the <see cref="UsbEndpointReader.DataReceived"/> event.</param> /// <param name="endpointType">The type of endpoint to open.</param> /// <returns>A <see cref="UsbEndpointReader"/> class ready for reading. If the specified endpoint is already been opened, the original <see cref="UsbEndpointReader"/> class is returned.</returns> public override UsbEndpointReader OpenEndpointReader(ReadEndpointID readEndpointID, int readBufferSize, EndpointType endpointType) { foreach (UsbEndpointBase activeEndpoint in mActiveEndpoints) if (activeEndpoint.EpNum == (byte)readEndpointID) return (UsbEndpointReader)activeEndpoint; UsbEndpointReader epNew = new LibUsbEndpointReader(this, readBufferSize, readEndpointID, endpointType); return (UsbEndpointReader) ActiveEndpoints.Add(epNew); }
/// <summary> /// Opens a <see cref="EndpointType.Bulk"/> endpoint for reading /// </summary> /// <param name="readEndpointID">Endpoint number for read operations.</param> /// <param name="readBufferSize">Size of the read buffer allocated for the <see cref="UsbEndpointReader.DataReceived"/> event.</param> /// <returns>A <see cref="UsbEndpointReader"/> class ready for reading. If the specified endpoint is already been opened, the original <see cref="UsbEndpointReader"/> class is returned.</returns> public UsbEndpointReader OpenEndpointReader(ReadEndpointID readEndpointID, int readBufferSize) { return(OpenEndpointReader(readEndpointID, readBufferSize, EndpointType.Bulk)); }
internal UsbEndpointReader(UsbDevice usbDevice, int readBufferSize, ReadEndpointID readEndpointID, EndpointType endpointType) : base(usbDevice, (Byte) readEndpointID, endpointType) { mReadBufferSize = readBufferSize; }
/// <summary> /// Get Result Of Latest CMD. /// </summary> /// <param name="cmd">The Expected Command.</param> /// <param name="inPipe">1 For CMD Response and 0 for Image Data.</param> /// <returns></returns> public async Task <byte[]> GetResults(byte cmd, string cmdName, ReadEndpointID inPipe = ClearShotDevice.GET_COMMAND_RESULT_INPOINT) { return(await Task.Run(() => { if (_targetDevice == null) { return null; } lock (_myLock) { //Reader. var reader = _targetDevice.OpenEndpointReader(inPipe); //Get First data. byte[] result = new byte[64]; int length; ErrorCode eReturn; if ((eReturn = reader.Read(result, 10000, out length)) == ErrorCode.None) { Debug.WriteLine($"* {cmdName} - {length} bytes read."); } else { Debug.WriteLine($"* {cmdName} - No data to read! " + eReturn); } //Make sure this is result of command that we want. if (result[0] != cmd) { Debug.WriteLine($"* {cmdName} - Result not for expected command."); } else { //Change result depending on size. var size = BitConverter.ToUInt32(result, 1); if (size > result.Count()) { Debug.WriteLine($"* {cmdName} - Getting extra data....."); byte[] newResult = new byte[size - result.Length]; eReturn = reader.Read(newResult, 10000, out length); if (eReturn == ErrorCode.None) { var newRes = ConcatArrays(result, newResult); result = newRes; } else { Debug.WriteLine($"* {cmdName} - Error reading extra data! " + eReturn); } Debug.WriteLine($"* {cmdName} - Done getting extra data."); } //Remove padded zeros and return. if (size < result.Count()) { return result.Take((int)size).ToArray(); } } return result; } })); }