private static void showTransfer(UsbTransferQueue.Handle handle, int transferIndex)
{
if (mStartTime == DateTime.MinValue)
{
mStartTime = DateTime.Now;
Console.WriteLine("Synchronizing..");
return;
}
mTotalBytes += handle.Transferred;
double bytesSec = mTotalBytes / (DateTime.Now - mStartTime).TotalSeconds;
Console.WriteLine("#{0} complete. {1} bytes/sec ({2} bytes) Data[1]={3:X2}",
transferIndex,
Math.Round(bytesSec, 2),
handle.Transferred,
handle.Data[1]);
}
private static void showTransfer(UsbTransferQueue.Handle handle, int transferIndex)
{
if (mStartTime == DateTime.MinValue)
{
mStartTime = DateTime.Now;
Console.WriteLine("Synchronizing..");
return;
}
mTotalBytes += handle.Transferred;
double bytesSec = mTotalBytes / (DateTime.Now - mStartTime).TotalSeconds;
if (ImuDataUpdate != null)
{
short tmpQ_w = (short)(((handle.Data[1] & 0xFF) << 8) | (handle.Data[0] & 0xFF));
short tmpQ_x = (short)(((handle.Data[3] & 0xFF) << 8) | (handle.Data[2] & 0xFF));
short tmpQ_y = (short)(((handle.Data[5] & 0xFF) << 8) | (handle.Data[4] & 0xFF));
short tmpQ_z = (short)(((handle.Data[7] & 0xFF) << 8) | (handle.Data[6] & 0xFF));
Double w = (((Double)tmpQ_w) / ((Double)(1 << 14)));
Double x = (((Double)tmpQ_x) / ((Double)(1 << 14)));
Double y = (((Double)tmpQ_y) / ((Double)(1 << 14)));
Double z = (((Double)tmpQ_z) / ((Double)(1 << 14)));
Double m = Math.Sqrt((x * x) + (y * y) + (z * z) + (w * w));
if (Math.Abs(1 - m) < 0.005)
{
//Console.WriteLine("ImuDataUpdate x:{0},y:{1},z:{2},w:{3}", x, y, z, w);
ImuDataUpdate(x, y, z, w);
}
}
/*
* Console.WriteLine("#{0} complete. {1} bytes/sec ({2} bytes) Data[1]={3:X2}",
* transferIndex,
* Math.Round(bytesSec, 2),
* handle.Transferred,
* handle.Data[1]);
*/
}
private void showTransfer(UsbTransferQueue.Handle handle, int transferIndex)
{
if (mStartTime == DateTime.MinValue)
{
mStartTime = DateTime.Now;
form.setText("Synchronizing..\r\n");
return;
}
mTotalBytes += handle.Transferred;
double bytesSec = mTotalBytes / (DateTime.Now - mStartTime).TotalSeconds;
form.setText(string.Format("#{0} complete. {1} bytes/sec ({2} bytes)\r\n",
transferIndex,
Math.Round(bytesSec, 2),
handle.Transferred,
handle.Data[1]));
form.setText(string.Format("Data: "));
for (int i = 0; i < handle.Data.Length; i++)
{
form.setText(string.Format("{0:X2} ", handle.Data[i]));
}
form.setText("\r\n");
}
private static void ImuDataPolling()
{
ErrorCode ec = ErrorCode.None;
UsbTransferQueue transferQeue = null;
try
{
UsbRegDeviceList regList = null;
do
{
regList = UsbDevice.AllDevices.FindAll(MyUsbFinder);
if (regList.Count > 0)
{
break;
}
Thread.Sleep(2000);
} while (true);
// Find and open the usb device.
UsbInterfaceInfo usbInterfaceInfo = null;
UsbEndpointInfo usbEndpointInfo = null;
// Look through all conected devices with this vid and pid until
// one is found that has and and endpoint that matches TRANFER_ENDPOINT.
//
foreach (UsbRegistry regDevice in regList)
{
if (regDevice.Open(out MyUsbDevice))
{
if (MyUsbDevice.Configs.Count > 0)
{
// if TRANFER_ENDPOINT is 0x80 or 0x00, LookupEndpointInfo will return the
// first read or write (respectively).
if (UsbEndpointBase.LookupEndpointInfo(MyUsbDevice.Configs[0], TRANFER_ENDPOINT,
out usbInterfaceInfo, out usbEndpointInfo))
{
break;
}
MyUsbDevice.Close();
MyUsbDevice = null;
}
}
}
// 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-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))
{
// 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(usbInterfaceInfo.Descriptor.InterfaceID);
}
// open read endpoint.
UsbEndpointReader reader = MyUsbDevice.OpenEndpointReader(
(ReadEndpointID)usbEndpointInfo.Descriptor.EndpointID,
0,
(EndpointType)(usbEndpointInfo.Descriptor.Attributes & 0x3));
if (ReferenceEquals(reader, null))
{
throw new Exception("Failed locating read endpoint.");
}
reader.Reset();
// The benchmark device firmware works with this example but it must be put into PC read mode.
#if IS_BENCHMARK_DEVICE
int transferred;
byte[] ctrlData = new byte[1];
UsbSetupPacket setTestTypePacket =
new UsbSetupPacket((byte)(UsbCtrlFlags.Direction_In | UsbCtrlFlags.Recipient_Device | UsbCtrlFlags.RequestType_Vendor),
0x0E, 0x01, usbInterfaceInfo.Descriptor.InterfaceID, 1);
MyUsbDevice.ControlTransfer(ref setTestTypePacket, ctrlData, 1, out transferred);
#endif
TRANFER_SIZE -= (TRANFER_SIZE % usbEndpointInfo.Descriptor.MaxPacketSize);
transferQeue = new UsbTransferQueue(reader,
TRANFER_MAX_OUTSTANDING_IO,
TRANFER_SIZE,
5000,
usbEndpointInfo.Descriptor.MaxPacketSize);
do
{
UsbTransferQueue.Handle handle = null;
// Begin submitting transfers until TRANFER_MAX_OUTSTANDING_IO has benn reached.
// then wait for the oldest outstanding transfer to complete.
//
ec = transferQeue.Transfer(out handle);
if (ec != ErrorCode.Success)
{
throw new Exception("Failed getting async result");
}
// Show some information on the completed transfer.
showTransfer(handle, mTransferCount++);
} while (true);
}
catch (Exception ex)
{
if (transferQeue != null)
{
transferQeue.Free();
}
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.
if (transferQeue != null)
{
// Cancels any oustanding transfers and free's the transfer queue handles.
// NOTE: A transfer queue can be reused after it's freed.
transferQeue.Free();
Console.WriteLine("\r\nDone!\r\n");
}
IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
// Release interface #0.
wholeUsbDevice.ReleaseInterface(0);
}
MyUsbDevice.Close();
}
MyUsbDevice = null;
}
// Wait for user input..
//Console.ReadKey();
// Free usb resources
//UsbDevice.Exit();
ImuDataThreadStart();
}
}
private static void showTransfer(UsbTransferQueue.Handle handle, int transferIndex, TransferParams tParams)
{
double samplesPerSecond = 0;
int numBytesTransferred = handle.Data.Length;
int maxTransferSize = handle.Context.IsoPacketSize;
int x = handle.Context.Transmitted;
int packetCounter = 0;
int[][] jagaPacketData;
int[] potentialErrors;
int cachedOldRemnantLength = 0;
if (old_remnant != null)
{
cachedOldRemnantLength = old_remnant.Length;
}
AlignTransfersIntoJagaPackets(handle.Data, old_remnant, out jagaPacketData, out new_remnant, handle.Transferred, maxTransferSize != 160, out potentialErrors);
old_remnant = new_remnant;
StringBuilder sbCurrentTransfer = new StringBuilder();
int header = FindHeaderBoundary(handle.Transferred, handle.Data);
bool hasErroneousPacket = false;
bool hasCorrectedPacket = false;
sbCurrentTransfer.Append("\r\nTransfer ");
// Show transfer # at beginning of each line
sbCurrentTransfer.Append((transfersReceived++).ToString() + ":\t");
// Show bytes in transfer
for (int j = 0; j < handle.Transferred; j++)
{
sbCurrentTransfer.Append(String.Format(" {0:X2}", handle.Data[j]));
}
sbCurrentTransfer.Append(string.Format("\t:{0} bytes in transfer", handle.Transferred));
if (cachedOldRemnantLength > 0)
{
sbCurrentTransfer.Append(", appended to " + cachedOldRemnantLength.ToString() + " from previous transfer");
}
if (new_remnant != null && new_remnant.Length > 0)
{
sbCurrentTransfer.Append(", with " + new_remnant.Length.ToString() + " left over for next transfer");
}
if (header >= 0 && handle.Data.Length >= header + 13)
{
samplesPerPacket = handle.Data[header + 10];
channels = handle.Data[header + 9];
sample_rate = (handle.Data[header + 11] << 8) + handle.Data[header + 12];
sbCurrentTransfer.Append(" HEADER PACKET");
sb_header.Append(string.Format("Header info: version {0}, channels {1}, samples per packet {2}, sample rate {3}", handle.Data[header + 8], channels, samplesPerPacket, sample_rate));
}
if (jagaPacketData.Length > 0)
{
// Now show packets
sbCurrentTransfer.Append("\r\n");
}
for (int packetNum = 0; packetNum < jagaPacketData.Length; packetNum++)
{
if (jagaPacketData[packetNum] == null)
{
// The # of packets is not deterministic. Once we hit nulls, we are done.
break;
}
packetCounter = 0;
sbCurrentTransfer.Append("\r\nPacket " + mTotalPacketsHandled.ToString() + ":\t");
int numSamples = jagaPacketData[packetNum].Length;
for (int j = 0; j < numSamples; j++)
{
// Calculate packet counter from LSB
int val = jagaPacketData[packetNum][j];
packetCounter = packetCounter * 2 + (val & 1);
if (j % 4 == 0)
{
sbCurrentTransfer.Append(" ");
}
sbCurrentTransfer.Append(String.Format(" {0:X4}", val));
}
mTotalPacketsHandled++;
// Append packet counter
sbCurrentTransfer.Append(String.Format("\t: Counter {0:X4}", packetCounter));
if (prevPacketCounter >= 0)
{
int increment = CalculateIncrement14_bit(prevPacketCounter, packetCounter);
sbCurrentTransfer.Append(String.Format("\tIncrement {0}", increment));
if (increment <= 0)
{
// Check if bit reversal restores correct count
if (potentialErrors[0] >= 0)
{
int bitToFlip = 15 - (potentialErrors[0] / 2);
bitToFlip = 1 << bitToFlip;
if ((packetCounter & bitToFlip) == 0)
{
// Switch 0 to 1
int adjustedCounter = packetCounter + bitToFlip;
if (CalculateIncrement14_bit(prevPacketCounter, adjustedCounter) == 1)
{
// We have fixed packet counter
sbCurrentTransfer.Append(" \tCorrected packet counter from " + packetCounter + " to " + adjustedCounter);
packetCounter = adjustedCounter;
packetsCorrected++;
increment = 1;
hasCorrectedPacket = true;
}
}
if (!hasCorrectedPacket)
{
sbCurrentTransfer.Append(" \tUnable to correct packet counter - error location " + potentialErrors[0].ToString() + ", bitToFlip is " + bitToFlip.ToString());
}
}
}
if (increment > 0)
{
apparentPacketsTransmitted += increment;
}
if (increment != 1)
{
hasErroneousPacket = true;
sbCurrentTransfer.Append(" ERROR IN PACKET COUNTER, EXPECTED " + (packetCounter + 1).ToString());
packetErrors++;
}
}
prevPacketCounter = packetCounter;
}
sbCurrentTransfer.Append(", ");
samplesPerSecond = apparentPacketsTransmitted * samplesPerPacket / channels / 2 / (DateTime.Now - mStartTime).TotalSeconds;
sbCurrentTransfer.Append(String.Format("{0} avg samples/sec\r\n\r\n", Math.Round(samplesPerSecond, 2)));
if (header >= 0)
{
sb_header.Append(String.Format(", Calculated sample rate = {0} samples/sec", Math.Round(samplesPerSecond, 2)));
}
if (hasErroneousPacket || hasCorrectedPacket)
{
sb_error_rate.Append(string.Format("Counter errors {0}, error rate {3:F2}%, corrected packet counters {1}, total packets {2}",
packetErrors, packetsCorrected, mTotalPacketsHandled, packetErrors * 100.0 / mTotalPacketsHandled));
}
bool showThisPacket;
if (tParams.showAll)
{
showThisPacket = true;
}
else
{
showThisPacket = (tParams.showErroneous && hasErroneousPacket) || (tParams.showHeaders && header >= 0) || (tParams.showCorrected && hasCorrectedPacket);
}
if (showThisPacket)
{
if (!tParams.showAll && (tParams.showCorrected || tParams.showErroneous))
{
// For errors, show previous transfers, to help understand error.
sb.Append("\r\n\r\n");
if (handle.Transferred < 50)
{
// If transfers are small, then show previous two, since each transfer doesn't have that much info.
sb.Append(sbPreviousTransfer2);
}
sb.Append(sbPreviousTransfer);
}
// Append to ongoing string that will eventually get sent to screen
sb.Append(sbCurrentTransfer);
}
// Done:
// Save current text so that if we are showing only anomalous packets, then next time we can show both current and previous packets (since anomalous packets usually arise from
// irregularities involving a packet spanning two transfers.
sbPreviousTransfer2.Clear();
sbPreviousTransfer2.Append(sbPreviousTransfer);
sbPreviousTransfer.Clear();
sbPreviousTransfer.Append(sbCurrentTransfer);
}