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();
}
