public async Task SendBytes(byte[] message)
{
HidOutputReport outReport = _device.CreateOutputReport(0);
DataWriter dataWriter = new DataWriter();
dataWriter.WriteBytes(message);
if (message.Length < outReport.Data.Capacity)
{
int repeat = ((int)outReport.Data.Capacity) - message.Length;
IEnumerable <byte> bytes = Enumerable.Repeat <byte>(0, repeat);
dataWriter.WriteBytes(bytes.ToArray());
}
outReport.Data = dataWriter.DetachBuffer();
try
{
await _device.SendOutputReportAsync(outReport);
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
throw;
}
}
public static void imm_FormatMetaUTC(HidOutputReport report, bool padWithEmpty)
{
byte[] raw = new byte[USB_PKT_SIZE + 1];
raw[0] = 0;
raw[1] = (YGenericHub.YSTREAM_META << 3);
raw[2] = (byte)(YPKT_STREAM + (YGenericHub.USB_META_UTCTIME_SIZE << 2));
raw[3] = YGenericHub.USB_META_UTCTIME;
double totalSeconds = (DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;
UInt32 currUtcTime = (UInt32)totalSeconds;
raw[4] = (byte)(currUtcTime & 0xff);
raw[5] = (byte)((currUtcTime >> 8) & 0xff);
raw[6] = (byte)((currUtcTime >> 16) & 0xff);
raw[7] = (byte)((currUtcTime >> 24) & 0xff);
// 1/250 seconds
double val = (totalSeconds * 250) % 250;
raw[8] = (byte)((uint)val & 0xff);
if (padWithEmpty)
{
raw[9] = 0 + (YGenericHub.YSTREAM_EMPTY << 3);
raw[10] = (byte)(YPKT_STREAM + ((55) << 2));
}
report.Data = raw.AsBuffer();
}
/// <summary>
/// Broken. Due to an unknown glitch in the output report's data cannot operate at all.
/// </summary>
/// <param name="reportID">One of the Wiimotes known reportID identifiers</param>
/// <param name="commands">A list of 1 or more command parameters</param>
/// <returns>Succesful or not</returns>
public async Task <bool> WriteWiiMoteAsync(WiiMoteReportID reportID, WiiMoteCommand[] commands)
{
//Create report
HidOutputReport outReport = device.CreateOutputReport();
//Create data
var writer = new DataWriter();
writer.WriteByte((byte)prefix);
writer.WriteByte((byte)reportID);
for (int i = 0; i < 20 - commands.Length; i++)
{
writer.WriteByte(0);
}
foreach (WiiMoteCommand c in commands)
{
writer.WriteByte((byte)c);
}
outReport.Data = writer.DetachBuffer();
//Send data
try {
uint result = await device.SendOutputReportAsync(outReport);
}
catch (Exception)
{
System.Diagnostics.Debug.WriteLine("Failed to send report");
return(false);
}
return(true);
}
internal async Task Setup(uint pktVersion)
{
_currentTask = new TaskCompletionSource <bool>();
// construct a HID output report to send to the device
HidOutputReport outReport = Hid.CreateOutputReport();
YUSBPkt.imm_FormatConfReset(outReport, pktVersion);
// Send the output report asynchronously
_devState = DevState.ResetSend;
var u = await Hid.SendOutputReportAsync(outReport);
if (u != 65)
{
_devState = DevState.IOError;
throw new YAPI_Exception(YAPI.IO_ERROR, "Unable to send Reset PKT");
}
Task <bool> task = _currentTask.Task;
Task taskDone = await Task.WhenAny(task, Task.Delay(1000));
if (taskDone != task)
{
throw new YAPI_Exception(YAPI.IO_ERROR, "Device does not respond to reset");
}
}
private async Task SendOutputMessage(byte[] message)
{
if (_hidDevice != null)
{
HidOutputReport report = _hidDevice.CreateOutputReport();
report.Data = message.AsBuffer();
await _hidDevice.SendOutputReportAsync(report);
}
}
public static void imm_FormatConfStart(HidOutputReport report, byte nbinface, byte pktAckDelay)
{
byte[] raw = new byte[USB_PKT_SIZE + 1];
raw[0] = 0;
raw[1] = 0 + (USB_CONF_START << 3);
raw[2] = YPKT_CONF + (USB_MAX_PKT_CONTENT_SIZE << 2);
raw[3] = nbinface; // nbifac
raw[4] = pktAckDelay; // ifaceno
report.Data = raw.AsBuffer();
}
private async Task WriteAsyncInternal(byte[] data)
{
if (_hidDevice == null)
{
return;
}
HidOutputReport report = _hidDevice.CreateOutputReport();
data.CopyTo(0, report.Data, 1, data.Length);
await _hidDevice.SendOutputReportAsync(report);
}
public static void imm_FormatConfReset(HidOutputReport report, uint api_version)
{
byte[] raw = new byte[USB_PKT_SIZE + 1];
raw[0] = 0;
raw[1] = 0 + (USB_CONF_RESET << 3);
raw[2] = YPKT_CONF + (USB_MAX_PKT_CONTENT_SIZE << 2);
raw[3] = (byte)(api_version & 0xff);
raw[4] = (byte)(api_version >> 8);
raw[5] = 1; // nbifac
raw[6] = 0; // ifaceno
raw[7] = 1; // nbifac
IBuffer buf = raw.AsBuffer();
report.Data = buf;
}
internal async void SendReport(IBuffer buffer)
{
byte[] parameters = buffer.ToArray();
HidOutputReport report = device.CreateOutputReport();
Array.Resize(ref parameters, (int)report.Data.Length);
report.Data = parameters.AsBuffer();
now = DateTime.Now;
await device.SendOutputReportAsync(report);
int ms = DateTime.Now.Subtract(now).Milliseconds;
Debug.WriteLine("TX - {0} bytes sent in {1}ms.", report.Data.Length.ToString(), ms);
}
public async void SendReport()
{
byte[] parameters = { 0, 85, 85, 9, (int)RobotCommand.BusServoInfoRead, 6, 1, 2, 3, 4, 5, 6 };
HidOutputReport report = device.CreateOutputReport();
Array.Resize(ref parameters, (int)report.Data.Length);
report.Data = parameters.AsBuffer();
now = DateTime.Now;
await device.SendOutputReportAsync(report);
int ms = DateTime.Now.Subtract(now).Milliseconds;
Debug.WriteLine("TX - {0} bytes sent in {1}ms.", report.Data.Length.ToString(), ms);
}
internal async Task Start(byte pktAckDelay)
{
// construct a HID output report to send to the device
HidOutputReport outReport = Hid.CreateOutputReport();
//("Activate USB pkt ack (%dms)\n", dev->pktAckDelay);
YUSBPkt.imm_FormatConfStart(outReport, 1, pktAckDelay);
// Send the output report asynchronously
_devState = DevState.StartSend;
var u = await Hid.SendOutputReportAsync(outReport);
if (u != 65)
{
_devState = DevState.IOError;
throw new YAPI_Exception(YAPI.IO_ERROR, "Unable to send Start PKT");
}
}
private async Task checkMetaUTC()
{
if (_lastMetaUTC + META_UTC_DELAY < YAPI.GetTickCount())
{
HidOutputReport outReport = Hid.CreateOutputReport();
YUSBPkt.imm_FormatMetaUTC(outReport, true);
var u = await Hid.SendOutputReportAsync(outReport);
if (u != 65)
{
_devState = DevState.IOError;
throw new YAPI_Exception(YAPI.IO_ERROR, "Unable to send Start PKT");
}
_lastMetaUTC = YAPI.GetTickCount();
}
}
public static int imm_FormatTCP(HidOutputReport outReport, byte[] request, int pos, bool padWithEmpty)
{
int size, streamType, remaining;
if (request != null)
{
int toWrite = request.Length - pos;
streamType = YGenericHub.YSTREAM_TCP;
if (toWrite < USB_MAX_PKT_CONTENT_SIZE)
{
size = toWrite;
remaining = USB_PKT_SIZE - size - 2;
}
else
{
size = USB_MAX_PKT_CONTENT_SIZE;
remaining = 0;
}
}
else
{
streamType = YGenericHub.YSTREAM_TCP_CLOSE;
size = 0;
remaining = USB_PKT_SIZE - 2;
}
byte[] raw = new byte[USB_PKT_SIZE + 1];
raw[0] = 0;
raw[1] = (byte)(streamType << 3);
raw[2] = (byte)(YPKT_STREAM + (size << 2));
if (size > 0)
{
Buffer.BlockCopy(request, pos, raw, 3, size);
}
if (remaining > 2 && padWithEmpty)
{
raw[3 + size] = 0 + (YGenericHub.YSTREAM_EMPTY << 3);
raw[4 + size] = (byte)(YPKT_STREAM + ((remaining - 2) << 2));
}
outReport.Data = raw.AsBuffer();
return(size);
}
private async Task sendRequest(byte[] request, YGenericHub.RequestAsyncResult asyncResult, object asyncContext)
{
int pos = 0;
try {
if (_currentRequest != null)
{
await _currentRequest.GetResponse();
}
//Debug.WriteLine(string.Format("{0}:Check last request is sent", Environment.CurrentManagedThreadId));
_currentRequest = new YRequest(request, asyncResult, asyncContext, 10000);
while (pos < request.Length)
{
// construct a HID output report to send to the device
HidOutputReport outReport = Hid.CreateOutputReport();
int size = YUSBPkt.imm_FormatTCP(outReport, request, pos, true);
// Send the output report asynchronously
var u = await Hid.SendOutputReportAsync(outReport);
if (u != 65)
{
_devState = DevState.IOError;
_watcher.imm_removeUsableDevice(this);
return;
}
pos += size;
}
//Debug.WriteLine(string.Format("{0}:sent", Environment.CurrentManagedThreadId));
} catch (Exception ex) {
_devState = DevState.IOError;
_currentRequest = null;
throw new YAPI_Exception(YAPI.IO_ERROR, ex.Message);
}
}
public void Write(byte[] buffer, uint cbToWrite)
{
if (buffer[0] != 0)
{
buffer = AddToBegining(buffer, 0);
}
if (buffer.Length < cbToWrite)
{
byte[] temp = new byte[cbToWrite];
for (int x = 0; x < buffer.Length; x++)
{
temp[x] = buffer[x];
}
for (int x = buffer.Length; x < cbToWrite; x++)
{
temp[x] = 0;
}
buffer = temp;
}
HidOutputReport y = NativeDevice.CreateOutputReport();
y.Data = buffer.AsBuffer();
_ = NativeDevice.SendOutputReportAsync(y);
}
internal async Task streamHandler(List <YPktStreamHead> streams)
{
foreach (YPktStreamHead s in streams)
{
uint streamType = s.StreamType;
switch (streamType)
{
case YGenericHub.YSTREAM_NOTICE:
case YGenericHub.YSTREAM_NOTICE_V2:
imm_handleNotifcation(s);
break;
case YGenericHub.YSTREAM_TCP_CLOSE:
case YGenericHub.YSTREAM_TCP:
if (_devState != DevState.StreamReadyReceived || _currentRequest == null)
{
continue;
}
_currentRequest.imm_AddIncommingData(s);
if (streamType == YGenericHub.YSTREAM_TCP_CLOSE)
{
// construct a HID output report to send to the device
HidOutputReport outReport = Hid.CreateOutputReport();
YUSBPkt.imm_FormatTCP(outReport, null, 0, true);
// Send the output report asynchronously
var u = await Hid.SendOutputReportAsync(outReport);
if (u != 65)
{
_devState = DevState.IOError;
_watcher.imm_removeUsableDevice(this);
return;
}
_currentRequest.imm_Close();
}
break;
case YGenericHub.YSTREAM_EMPTY:
break;
case YGenericHub.YSTREAM_REPORT:
if (_devState == DevState.StreamReadyReceived)
{
imm_handleTimedNotification(s);
}
break;
case YGenericHub.YSTREAM_REPORT_V2:
if (_devState == DevState.StreamReadyReceived)
{
handleTimedNotificationV2(s);
}
break;
default:
_yctx._Log("drop unknown ystream:" + s);
break;
}
}
}
public async Task <int> SendOutputReportAsync(HidOutputReport report, CancellationToken cancellationToken = new CancellationToken())
{
var result = await device.SendOutputReportAsync(report).AsTask(cancellationToken);
return((int)result);
}
public UwpOutputReport(HidOutputReport report)
{
this.report = report;
Data = new ArraySegment<byte>(new byte[report.Data.Capacity-1]);
}
public async Task<int> SendOutputReportAsync(HidOutputReport report, CancellationToken cancellationToken = new CancellationToken())
{
var result = await device.SendOutputReportAsync(report).AsTask(cancellationToken);
return (int)result;
}
public UwpOutputReport(HidOutputReport report)
{
this.report = report;
Data = new ArraySegment <byte>(new byte[report.Data.Capacity - 1]);
}