public async Task<bool> SendControl(int cmd1, int cmd2, int cmd3) { var bytes = new[] { Convert.ToByte(cmd1), Convert.ToByte(cmd2), Convert.ToByte(cmd3) }; var buffer = bytes.AsBuffer(); var setupPacket = new UsbSetupPacket(); var requestType = new UsbControlRequestType(); requestType.ControlTransferType = UsbControlTransferType.Vendor; requestType.Direction = UsbTransferDirection.Out; requestType.Recipient = UsbControlRecipient.Device; setupPacket.RequestType = requestType; setupPacket.Request = 6; setupPacket.Value = 0x0100; setupPacket.Length = buffer.Length; setupPacket.Index = 0; var transferred = await _usbDevice.SendControlOutTransferAsync(setupPacket, buffer); return (transferred == buffer.Length); }
public override unsafe IAsyncResult BeginControlTransfer(UsbControlRequestType requestType, byte request, short value, short index, byte[] buffer, int offset, int length, AsyncCallback callback, Object state) { if (offset < 0 || length < 0 || (buffer == null && length != 0) || (buffer != null && offset + length > buffer.Length)) { throw new ArgumentOutOfRangeException("length", "The specified offset and length exceed the buffer length"); } int code; Byte[] inbuffer; if ((requestType & UsbControlRequestType.EndpointMask) == UsbControlRequestType.EndpointIn) { if (buffer == null) { buffer = new Byte[0]; } inbuffer = new Byte[sizeof(LibUsbRequest)]; } else { inbuffer = new Byte[length + LibUsbRequest.Size]; if (length > 0) { Buffer.BlockCopy(buffer, offset, inbuffer, LibUsbRequest.Size, length); } buffer = null; offset = length = 0; } fixed(Byte *inbufferp = inbuffer) PrepareControlTransfer(requestType, request, value, index, length, ref *((LibUsbRequest *)inbufferp), out code); return(BeginDeviceIoControl(code, inbuffer, buffer, offset, length, callback, state)); }
/// <summary> /// SET_LINE_CODING CDC request. /// </summary> /// <param name="index">Interface index.</param> /// <param name="dteRate">Data terminal rate, in bits per second.</param> /// <param name="charFormat">Stop bits.</param> /// <param name="parityType">Parity.</param> /// <param name="dataBits">Data bits.</param> /// <returns> /// The result of Task contains a length of bytes actually sent to the serial port. /// </returns> private Task <uint> SetLineCoding( uint index, uint dteRate, byte charFormat, byte parityType, byte dataBits ) { // SetLineCoding var writer = new Windows.Storage.Streams.DataWriter(); writer.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian; writer.WriteUInt32(dteRate); writer.WriteByte(charFormat); writer.WriteByte(parityType); writer.WriteByte(dataBits); var buffer = writer.DetachBuffer(); var requestType = new UsbControlRequestType(); requestType.AsByte = RequestType.Set; return(UsbControlRequestForSet( index, requestType, RequestCode.SetLineCoding, 0, buffer)); }
public virtual IAsyncResult BeginControlTransfer(UsbControlRequestType requestType, byte request, short value, short index, byte[] buffer, int offset, int length, AsyncCallback callback, Object state) { if (controlTransferFunc == null) { controlTransferFunc = ControlTransfer; } return(controlTransferFunc.BeginInvoke(requestType, request, value, index, buffer, offset, length, callback, state)); }
public override int ControlTransfer(UsbControlRequestType requestType, byte request, short value, short index, byte[] buffer, int offset, int length) { int ret = EndDeviceIoControl(BeginControlTransfer(requestType, request, value, index, buffer, offset, length, null, null)); if ((requestType & UsbControlRequestType.EndpointMask) == UsbControlRequestType.EndpointOut) { ret = length; } return(ret); }
/// <summary> /// Sends a raw CDC request. /// </summary> /// <param name="request">CDC request code.</param> /// <param name="value">value, corresponded with the request code.</param> /// <param name="buffer">data, corresponded with the request code.</param> /// <returns> /// The result of IAsyncOperation contains a length of bytes actually sent. /// </returns> public Windows.Foundation.IAsyncOperation <uint> SetControlRequest( byte request, ushort value, Windows.Storage.Streams.IBuffer buffer ) { return(Task.Run(async() => { var requestType = new UsbControlRequestType(); requestType.AsByte = RequestType.Set; return await UsbControlRequestForSet(this.cdcControl.InterfaceNumber, requestType, request, value, buffer); } ).AsAsyncOperation <uint>()); }
public override unsafe int ControlTransfer(UsbControlRequestType requestType, byte request, short value, short index, byte[] buffer, int offset, int length) { SafeWinUsbInterfaceHandle ih = PrepareControlTransfer(requestType, index, ref buffer, offset, length); fixed(Byte *b = buffer) { if (!WinUsb_ControlTransfer(ih, new UsbSetupPacket((byte)requestType, request, value, index, (short)length), (IntPtr)(b + offset), length, out length, IntPtr.Zero)) { throw new Win32Exception(); } return(length); } }
public static UsbSetupPacket CreateSetupPacket(SetupPacketPurpose purpose) { var vendorControlOutRequestType = new UsbControlRequestType { ControlTransferType = UsbControlTransferType.Vendor, Direction = UsbTransferDirection.Out, Recipient = UsbControlRecipient.Device }; switch (purpose) { case SetupPacketPurpose.SetupDeviceForFirmwareUpdate: return(new UsbSetupPacket { RequestType = vendorControlOutRequestType, Request = 0xC5, Value = 0, Index = 0, Length = 0 }); case SetupPacketPurpose.WriteSector: /// <summary> /// Value, Index, Length must be filled in later with information specifically about the data being transfered /// </summary> return(new UsbSetupPacket { RequestType = vendorControlOutRequestType, Request = 0xC2, }); case SetupPacketPurpose.ResetDevice: return(new UsbSetupPacket { RequestType = vendorControlOutRequestType, Request = 0xDA, Value = 0, Index = 0, Length = 0 }); } return(null); }
public static UsbSetupPacket CreateSetupPacket(SetupPacketPurpose purpose) { var vendorControlOutRequestType = new UsbControlRequestType { ControlTransferType = UsbControlTransferType.Vendor, Direction = UsbTransferDirection.Out, Recipient = UsbControlRecipient.Device }; switch (purpose) { case SetupPacketPurpose.SetupDeviceForFirmwareUpdate: return new UsbSetupPacket { RequestType = vendorControlOutRequestType, Request = 0xC5, Value = 0, Index = 0, Length = 0 }; case SetupPacketPurpose.WriteSector: /// <summary> /// Value, Index, Length must be filled in later with information specifically about the data being transfered /// </summary> return new UsbSetupPacket { RequestType = vendorControlOutRequestType, Request = 0xC2, }; case SetupPacketPurpose.ResetDevice: return new UsbSetupPacket { RequestType = vendorControlOutRequestType, Request = 0xDA, Value = 0, Index = 0, Length = 0 }; } return null; }
public override unsafe int ControlTransfer(UsbControlRequestType requestType, byte request, short value, short index, byte[] buffer, int offset, int length) { Byte[] bigbuffer = new Byte[sizeof(UsbSetupPacket) + length]; Boolean isout = (requestType & UsbControlRequestType.EndpointMask) == UsbControlRequestType.EndpointOut; if (isout && length > 0) { Buffer.BlockCopy(buffer, offset, bigbuffer, sizeof(UsbSetupPacket), length); fixed(Byte *ptr = bigbuffer) * (UsbSetupPacket *)ptr = new UsbSetupPacket((Byte)requestType, request, value, index, (short)length); int dlen = BlockTransfer(USBSUP_TRANSFER_TYPE.USBSUP_TRANSFER_TYPE_MSG, isout ? USBSUP_DIRECTION.USBSUP_DIRECTION_OUT : USBSUP_DIRECTION.USBSUP_DIRECTION_IN, USBSUP_XFER_FLAG.USBSUP_FLAG_NONE, 0, bigbuffer, 0, bigbuffer.Length); dlen -= sizeof(UsbSetupPacket); if (dlen > length) { dlen = length; } if (dlen < 0) dlen = 0; } if (!isout) Buffer.BlockCopy(bigbuffer, sizeof(UsbSetupPacket), buffer, offset, dlen); }
/// <summary> /// SET_CONTROL_LINE_STATE CDC request. /// </summary> /// <param name="index">Interface index.</param> /// <returns> /// The result of Task contains a length of bytes actually sent to the serial port. Should be zero. /// </returns> private Task <uint> SetControlLineState( uint index ) { // SetControlLineState var requestType = new UsbControlRequestType(); requestType.AsByte = RequestType.Set; var value = (this.RtsEnable ? 1 : 0) << 1 | (this.DtrEnable ? 1 : 0); return(UsbControlRequestForSet( index, requestType, RequestCode.SetControlLineState, (ushort)value, null )); }
public override int ControlTransfer(UsbControlRequestType requestType, byte request, short value, short index, byte[] buffer, int offset, int length) { if (buffer == null) { buffer = new Byte[0]; } if (offset < 0 || length < 0 || length > ushort.MaxValue || offset + length > buffer.Length) { throw new ArgumentOutOfRangeException("length"); fixed(Byte *b = buffer) { int ret = libusb1.libusb_control_transfer(Handle, (Byte)requestType, request, (ushort)value, (ushort)index, b + offset, (ushort)length, 0); if (ret < 0) { throw new LibUsb1Exception("libusb_control_transfer", ret); } return(ret); } }
public override unsafe IAsyncResult BeginControlTransfer(UsbControlRequestType requestType, byte request, short value, short index, byte[] buffer, int offset, int length, AsyncCallback callback, Object state) { SafeWinUsbInterfaceHandle ih = PrepareControlTransfer(requestType, index, ref buffer, offset, length); WindowsOverlappedAsyncResult ar = new WindowsOverlappedAsyncResult(callback, state); try { fixed(Byte *b = buffer) { Boolean success = WinUsb_ControlTransfer(ih, new UsbSetupPacket((byte)requestType, request, value, index, (short)length), (IntPtr)(b + offset), length, out length, (IntPtr)ar.PackOverlapped(buffer)); ar.SyncResult(success, length); return(ar); } } catch { ar.ErrorCleanup(); throw; } }
SafeWinUsbInterfaceHandle PrepareControlTransfer(UsbControlRequestType requestType, short index, ref Byte[] buffer, int offset, int length) { if (buffer == null) { buffer = new Byte[0]; } if (offset < 0 || length < 0 || length > short.MaxValue || offset + length > buffer.Length) { throw new ArgumentOutOfRangeException("length"); } SafeWinUsbInterfaceHandle ih = InterfaceHandles[0]; switch ((UsbControlRequestType)requestType & UsbControlRequestType.RecipMask) { case UsbControlRequestType.RecipInterface: ih = GetInterfaceHandle(index & 0xff); break; case UsbControlRequestType.RecipEndpoint: ih = GetInterfaceHandleForEndpoint(index & 0xff); break; case UsbControlRequestType.RecipOther: break; } return(ih); }
/// <summary> /// GET_LINE_CODING CDC request. /// </summary> /// <param name="index">Interface index.</param> /// <returns> /// The result of Task contains a buffer of Line Coding structure. /// </returns> private Task <Windows.Storage.Streams.IBuffer> GetLineCoding( uint index ) { return(Task.Run(async() => { var buffer = new Windows.Storage.Streams.Buffer(Constants.ExpectedResultGetLineCoding); buffer.Length = Constants.ExpectedResultGetLineCoding; var requestType = new UsbControlRequestType(); requestType.AsByte = RequestType.Get; var packet = new UsbSetupPacket(); packet.RequestType = requestType; packet.Request = RequestCode.GetLineCoding; packet.Value = 0; packet.Length = buffer.Length; packet.Index = index; return await this.device.SendControlInTransferAsync(packet, buffer); })); }
void PrepareControlTransfer(UsbControlRequestType requestType, byte request, short value, short index, int length, ref LibUsbRequest req, out int code) { code = LibUsbIoCtl.CONTROL_TRANSFER; req.Timeout = UsbConstants.DEFAULT_TIMEOUT; req.Control.RequestType = (Byte)requestType; req.Control.Request = request; req.Control.Value = (ushort)value; req.Control.Index = (ushort)index; req.Control.Length = (ushort)length; switch ((UsbControlRequestType)((int)requestType & (0x03 << 5))) { case UsbControlRequestType.TypeStandard: switch ((UsbStandardRequest)request) { case UsbStandardRequest.GetStatus: req.Status.Recipient = (int)requestType & 0x1F; req.Status.Index = index; code = LibUsbIoCtl.GET_STATUS; break; case UsbStandardRequest.ClearFeature: req.Feature.Recipient = (int)requestType & 0x1F; req.Feature.ID = value; req.Feature.Index = index; code = LibUsbIoCtl.CLEAR_FEATURE; break; case UsbStandardRequest.SetFeature: req.Feature.Recipient = (int)requestType & 0x1F; req.Feature.ID = value; req.Feature.Index = index; code = LibUsbIoCtl.SET_FEATURE; break; case UsbStandardRequest.GetDescriptor: req.Descriptor.Recipient = (int)requestType & 0x1F; req.Descriptor.Type = (value >> 8) & 0xFF; req.Descriptor.Index = value & 0xFF; req.Descriptor.LangID = index; code = LibUsbIoCtl.GET_DESCRIPTOR; break; case UsbStandardRequest.SetDescriptor: req.Descriptor.Recipient = (int)requestType & 0x1F; req.Descriptor.Type = (value >> 8) & 0xFF; req.Descriptor.Index = value & 0xFF; req.Descriptor.LangID = index; code = LibUsbIoCtl.SET_DESCRIPTOR; break; case UsbStandardRequest.GetConfiguration: code = LibUsbIoCtl.GET_CONFIGURATION; break; case UsbStandardRequest.SetConfiguration: req.Config.ID = value; code = LibUsbIoCtl.SET_CONFIGURATION; break; case UsbStandardRequest.GetInterface: req.Iface.ID = index; code = LibUsbIoCtl.GET_INTERFACE; break; case UsbStandardRequest.SetInterface: req.Iface.ID = index; req.Iface.AlternateID = value; code = LibUsbIoCtl.SET_INTERFACE; break; default: throw new ArgumentException(String.Format("Invalid request: 0x{0:X8}", request)); } break; case UsbControlRequestType.TypeVendor: case UsbControlRequestType.TypeClass: req.Vendor.Type = ((byte)requestType >> 5) & 0x03; req.Vendor.Recipient = (int)requestType & 0x1F; req.Vendor.Request = (int)request; req.Vendor.ID = value; req.Vendor.Index = index; code = ((byte)requestType & 0x80) != 0 ? LibUsbIoCtl.VENDOR_READ : LibUsbIoCtl.VENDOR_WRITE; break; case UsbControlRequestType.TypeReserved: default: throw new ArgumentException(String.Format("Invalid or unsupported request type: 0x{0:X8}", requestType)); } }
public override unsafe int ControlTransfer(UsbControlRequestType requestType, byte request, short value, short index, byte[] buffer, int offset, int length) { if (buffer == null) { if (offset != 0 || length != 0) { throw new ArgumentOutOfRangeException("length", "The specified offset and length exceed the buffer length"); } } else { if (offset < 0 || length < 0 || offset + length > buffer.Length) { throw new ArgumentOutOfRangeException("length", "The specified offset and length exceed the buffer length"); } } switch (requestType & UsbControlRequestType.TypeMask) { case UsbControlRequestType.TypeStandard: switch ((UsbStandardRequest)request) { case UsbStandardRequest.GetDescriptor: return(GetDescriptor((Byte)(value >> 8), (Byte)value, index, buffer, offset, length)); case UsbStandardRequest.GetConfiguration: fixed(Byte *b = buffer) return(DeviceIoControl(DeviceHandle, IOCTL_USBIO_GET_CONFIGURATION, IntPtr.Zero, 0, (IntPtr)(b + offset), length)); case UsbStandardRequest.SetConfiguration: Configuration = (Byte)value; return(0); default: throw new ArgumentException(String.Format("Invalid request: 0x{0:X8}", request)); } case UsbControlRequestType.TypeVendor: case UsbControlRequestType.TypeClass: USBIO_CLASS_OR_VENDOR_REQUEST req = new USBIO_CLASS_OR_VENDOR_REQUEST() { Flags = USBIO_SHORT_TRANSFER_OK, Type = (USBIO_REQUEST_TYPE)((int)(requestType & UsbControlRequestType.TypeMask) >> 5), Recipient = (USBIO_REQUEST_RECIPIENT)((int)(requestType & UsbControlRequestType.RecipMask) >> 0), RequestTypeReservedBits = 0, Request = request, Value = value, Index = index, }; fixed(Byte *b = buffer) { if ((requestType & UsbControlRequestType.EndpointMask) == UsbControlRequestType.EndpointIn) { return(DeviceIoControl(DeviceHandle, IOCTL_USBIO_CLASS_OR_VENDOR_IN_REQUEST, (IntPtr)(&req), sizeof(USBIO_CLASS_OR_VENDOR_REQUEST), (IntPtr)(b + offset), length)); } else { return(DeviceIoControl(DeviceHandle, IOCTL_USBIO_CLASS_OR_VENDOR_OUT_REQUEST, (IntPtr)(&req), sizeof(USBIO_CLASS_OR_VENDOR_REQUEST), (IntPtr)(b + offset), length)); } } case UsbControlRequestType.TypeReserved: default: throw new ArgumentException(String.Format("Invalid or unsupported request type: 0x{0:X8}", requestType)); } }
/// <summary> /// Sends a raw CDC request. /// </summary> /// <param name="request">CDC request code.</param> /// <param name="value">value, corresponded with the request code.</param> /// <param name="buffer">data, corresponded with the request code.</param> /// <returns> /// The result of IAsyncOperation contains a length of bytes actually sent. /// </returns> public Windows.Foundation.IAsyncOperation<uint> SetControlRequest( byte request, ushort value, Windows.Storage.Streams.IBuffer buffer ) { return Task.Run(async () => { var requestType = new UsbControlRequestType(); requestType.AsByte = RequestType.Set; return await UsbControlRequestForSet(this.cdcControl.InterfaceNumber, requestType, request, value, buffer); } ).AsAsyncOperation<uint>(); }
/// <summary> /// SET_LINE_CODING CDC request. /// </summary> /// <param name="index">Interface index.</param> /// <param name="dteRate">Data terminal rate, in bits per second.</param> /// <param name="charFormat">Stop bits.</param> /// <param name="parityType">Parity.</param> /// <param name="dataBits">Data bits.</param> /// <returns> /// The result of Task contains a length of bytes actually sent to the serial port. /// </returns> private Task<uint> SetLineCoding( uint index, uint dteRate, byte charFormat, byte parityType, byte dataBits ) { // SetLineCoding var writer = new Windows.Storage.Streams.DataWriter(); writer.ByteOrder = Windows.Storage.Streams.ByteOrder.LittleEndian; writer.WriteUInt32(dteRate); writer.WriteByte(charFormat); writer.WriteByte(parityType); writer.WriteByte(dataBits); var buffer = writer.DetachBuffer(); var requestType = new UsbControlRequestType(); requestType.AsByte = RequestType.Set; return UsbControlRequestForSet( index, requestType, RequestCode.SetLineCoding, 0, buffer); }
IAsyncResult IUsbInterface.BeginControlTransfer(UsbControlRequestType requestType, byte request, short value, short index, Byte[] buffer, int offset, int length, AsyncCallback callback, Object state) { throw new NotImplementedException(); }
public abstract int ControlTransfer(UsbControlRequestType requestType, byte request, short value, short index, byte[] buffer, int offset, int length);
public virtual int ControlTransfer(UsbControlRequestType requestType, byte request, short value, short index) { return(ControlTransfer(requestType, request, value, index, null, 0, 0)); }
/// <summary> /// SET_CONTROL_LINE_STATE CDC request. /// </summary> /// <param name="index">Interface index.</param> /// <returns> /// The result of Task contains a length of bytes actually sent to the serial port. Should be zero. /// </returns> private Task<uint> SetControlLineState( uint index ) { // SetControlLineState var requestType = new UsbControlRequestType(); requestType.AsByte = RequestType.Set; var value = (this.RtsEnable ? 1 : 0) << 1 | (this.DtrEnable ? 1 : 0); return UsbControlRequestForSet( index, requestType, RequestCode.SetControlLineState, (ushort)value, null ); }
/// <summary> /// GET_LINE_CODING CDC request. /// </summary> /// <param name="index">Interface index.</param> /// <returns> /// The result of Task contains a buffer of Line Coding structure. /// </returns> private Task<Windows.Storage.Streams.IBuffer> GetLineCoding( uint index ) { return Task.Run(async () => { var buffer = new Windows.Storage.Streams.Buffer(Constants.ExpectedResultGetLineCoding); buffer.Length = Constants.ExpectedResultGetLineCoding; var requestType = new UsbControlRequestType(); requestType.AsByte = RequestType.Get; var packet = new UsbSetupPacket(); packet.RequestType = requestType; packet.Request = RequestCode.GetLineCoding; packet.Value = 0; packet.Length = buffer.Length; packet.Index = index; return await this.device.SendControlInTransferAsync(packet, buffer); }); }
int IUsbInterface.ControlTransfer(UsbControlRequestType requestType, byte request, short value, short index, byte[] buffer, int offset, int length) { throw new NotImplementedException(); }