///////////////////////////////////////
// The BulkStream completion routine //
///////////////////////////////////////
static void CompletionRoutine(QuickUsb.BulkStream BulkStream)
{
// Check for general errors
if (BulkStream == null)
{
Console.WriteLine("Bulkstream error: {0}", QuickUsb.GetLastError());
return;
}
// Note: If we needed to reteive a reference to the managed QuickUsb object
// associated with this BulkStream object because, for example, the 'qusb'
// variable was inaccessible to this function, we would do the following:
//QuickUsb qusb = QuickUsb.RetreiveManagedQuickUsbObject(BulkStream.Handle);
// Check for errors
if (BulkStream.Error != 0)
{
Console.WriteLine("--> ERROR! (" + DateTime.Now.ToString() + ") Request failed with error {0} ({1} of {2} bytes)", BulkStream.Error, BulkStream.BytesTransferred, BulkStream.BytesRequested);
++ErrorCount;
}
else
{
//Console.WriteLine("--> CR: Completed Request for {0} bytes", BulkStream.BytesTransferred);
}
// Keep a running count of bytes transferred
TotalBytes += (int)BulkStream.BytesTransferred;
++TransCount;
//
// Now that this request has completed we may process the data
//
// Retreive a reference to the managed data buffer from the BulkStream.Buffer
//byte[] buffer = QuickUsb.RetrieveManagedByteDataBuffer(BulkStream.Buffer);
ushort[] buffer = QuickUsb.RetrieveManagedUShortDataBuffer(BulkStream.Buffer);
if (buffer == null)
{
Console.WriteLine("ERROR! Unable to retrieve managed data buffer");
}
//Thread.Sleep(50); // Simulate data processing (to force the use of more threads)
// Keep track of the thread that is executing this completion routine
int id = Thread.CurrentThread.ManagedThreadId;
if (!ThreadIds.ContainsKey(id))
{
if (id == 0)
{
return;
}
ThreadIds[id] = 1;
}
else
{
++ThreadIds[id];
}
}
///////////////////////////////////////
// The BulkStream completion routine //
///////////////////////////////////////
static void CompletionRoutine(QuickUsb.BulkStream BulkStream)
{
// Check for general errors
if (BulkStream == null)
{
Console.WriteLine("BulkStream Error: {0}", QuickUsb.GetLastError());
return;
}
// Note: If we needed to reteive a reference to the managed QuickUsb object
// associated with this BulkStream object because, for example, the 'qusb'
// variable was inaccessible to this function, we would do the following:
//QuickUsb qusb = QuickUsb.RetreiveManagedQuickUsbObject(BulkStream.Handle);
// Retrieve our user data (the 'tag' in the async function call)
GCHandle hTag = GCHandle.FromIntPtr(BulkStream.Tag);
BulkStreamTag tag = (BulkStreamTag)hTag.Target;
// Check for errors
if (BulkStream.Error != 0)
{
Console.WriteLine("--> CR: ERROR! Request #{0} failed with error {1} ({2} of {3} bytes)", tag.Id, BulkStream.Error, BulkStream.BytesTransferred, BulkStream.BytesRequested);
++ErrorCount;
}
else
{
//Console.WriteLine("--> CR: Completed Request #{0} for {1} bytes on thread {2}", tag.Id, BulkStream.BytesTransferred, Thread.CurrentThread.ManagedThreadId);
//
// Now that this request has completed we may process the data
//
// Retreive a reference to the managed data buffer from the BulkStream.Buffer
//byte[] buffer = QuickUsb.RetrieveManagedByteDataBuffer(BulkStream.Buffer);
ushort[] buffer = QuickUsb.RetrieveManagedUShortDataBuffer(BulkStream.Buffer);
if (buffer == null)
{
Console.WriteLine(String.Format("{0}: ERROR! Unable to retrieve managed data buffer", DateTime.Now));
}
// TODO: Process data
//Thread.Sleep(50); // Simulate data processing (to force use of more threads)
}
// Keep a running count of bytes transferred
TotalBytes += (int)BulkStream.BytesTransferred;
// Keep track of the number of oustanding requests
--RefCount;
hTag.Free();
}
private void bReadToFile_Click(object sender, EventArgs e)
{
// Show the save as file dialog
using (var diag = new SaveFileDialog())
{
diag.Filter = "Raw data file (*.txt)|*.txt|All files (*.*)|*.*";
diag.OverwritePrompt = true;
if (diag.ShowDialog() == DialogResult.OK)
{
// Read all eeprom and write to a file
DisplayStatusMessage("Reading EEPROM...");
Application.DoEvents();
byte[] memory;
memory = new byte[2048];
if (qusbControl.SelectedModule.ReadStorage(0, memory, (ushort)memory.Length))
{
using (var fout = new BinaryWriter(diag.OpenFile()))
{
fout.Write(memory, 0, memory.Length);
}
}
else
{
DisplayStatusMessage(String.Format("QuickMux.ReadEeprom returned error code: QuickMux.Error.{0}", QuickUsb.GetLastError().ToString()));
}
}
}
}
private void readEepromToGrid()
{
dgvEeprom.Enabled = (qusbControl.SelectedModules.Length == 1);
if (qusbControl.SelectedModules.Length != 1)
{
return;
}
DisplayStatusMessage("Reading EEPROM...");
byte[] memory = new byte[2048];
if (!qusbControl.SelectedModule.ReadStorage(0, memory, (ushort)memory.Length))
{
DisplayStatusMessage(String.Format("QuickMux.ReadEeprom returned error code: QuickMux.Error.{0}", QuickUsb.GetLastError().ToString()));
}
else
{
// Write memory contents to grid control (This process is way too slow!)
DisplayStatusMessage("Filling in grid...");
int k, j;
for (k = 0; k < dgvEeprom.Rows.Count; ++k)
{
for (j = 0; j < numByteCols; ++j)
{
dgvEeprom.Rows[k].Cells[j].Value = String.Format("0x{0}", memory[(k * numByteCols) + j].ToString("X2"));
}
Application.DoEvents();
}
}
}
private void bClearAll_Click(object sender, EventArgs e)
{
if (MessageBox.Show("Are you sure you want to clear all memory? This set all user EEPROM to zero.", "Clear Memory", MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation) == DialogResult.Yes)
{
// Clear eeprom
DisplayStatusMessage("Clearing EEPROM...");
byte[] memory = new byte[2048];
for (int k = 0; k < 2048; ++k)
{
memory[k] = 0xff;
}
if (!qusbControl.SelectedModule.WriteStorage(0, memory, (ushort)memory.Length))
{
DisplayStatusMessage(String.Format("QuickMux.WriteEeprom returned error code: QuickMux.Error.{0}", QuickUsb.GetLastError()));
return;
}
// Now perform a read to update the grid with the actual memory contents
readEepromToGrid();
}
}
private void bWriteFromFile_Click(object sender, EventArgs e)
{
// Show the open file dialog
using (var diag = new OpenFileDialog())
{
diag.Filter = "Raw data file (*.txt)|*.txt|All files (*.*)|*.*";
if (diag.ShowDialog() == DialogResult.OK)
{
// Read file
byte[] memory = new byte[2048];
ushort bytes;
using (var fout = diag.OpenFile())
{
bytes = (ushort)fout.Read(memory, 0, memory.Length);
}
// Write the data to eeprom
DisplayStatusMessage("Writing EEPROM...");
Application.DoEvents();
Array.Resize(ref memory, bytes);
if (!qusbControl.SelectedModule.WriteStorage(0, memory, (ushort)memory.Length))
{
DisplayStatusMessage(String.Format("QuickMux.WriteEeprom returned error code: QuickMux.Error.{0}", QuickUsb.GetLastError().ToString()));
return;
}
// Now perform a read to update the grid with the actual memory contents
readEepromToGrid();
}
}
}
///////////////////////////////////////
// The BulkStream completion routine //
///////////////////////////////////////
void CompletionRoutine(QuickUsb.BulkStream BulkStream)
{
// Check for general errors
if (BulkStream == null)
{
log.AppendLine(String.Format("{0}: ERROR! BulkStream error: {1}\n", DateTime.Now, QuickUsb.GetLastError()));
return;
}
// Note: If we needed to reteive a reference to the managed QuickUsb object
// associated with this BulkStream object because, for example, the 'qusb'
// variable was inaccessible to this function, we would do the following:
//QuickUsb qusb = QuickUsb.RetreiveManagedQuickUsbObject(BulkStream.Handle);
// Check for errors
if (BulkStream.Error != 0)
{
lock (log)
{
log.AppendLine(String.Format("{0}: ERROR! Request failed with error {0} ({1} of {2} bytes)\n", DateTime.Now, BulkStream.BytesTransferred, BulkStream.BytesRequested));
}
++ErrorCount;
}
else
{
lock (log)
{
log.AppendLine(String.Format("{0}: Completed Request for {1} bytes", DateTime.Now, BulkStream.BytesTransferred));
}
}
// Keep a running count of bytes transferred
TotalKiloBytes += (double)(BulkStream.BytesTransferred) / 1024.0;
InstKiloBytes += (double)(BulkStream.BytesTransferred) / 1024.0;
//
// Now that this request has completed we may process the data
//
// Retreive a reference to the managed data buffer from the BulkStream.Buffer
//byte[] buffer = QuickUsb.RetrieveManagedByteDataBuffer(BulkStream.Buffer);
ushort[] buffer = QuickUsb.RetrieveManagedUShortDataBuffer(BulkStream.Buffer);
if (buffer == null)
{
lock (log)
{
log.AppendLine(String.Format("{0}: ERROR! Unable to retrieve managed data buffer", DateTime.Now));
}
}
// TODO: Process data
//Thread.Sleep(50); // Simulate data processing (to force use of more threads)
}
////////////////////////////
// The completion routine //
////////////////////////////
void CompletionRoutine(QuickUsb.BulkStream BulkStream)
{
// Check for general errors
if (BulkStream == null)
{
lock (log)
{
log.AppendLine(String.Format("{0}: ERROR! BulkStream error: {1}\n", DateTime.Now, QuickUsb.GetLastError()));
}
return;
}
// Note: If we needed to reteive a reference to the managed QuickUsb object
// associated with this BulkStream object because, for example, the 'qusb'
// variable was inaccessible to this function, we would do the following:
//QuickUsb qusb = QuickUsb.RetreiveManagedQuickUsbObject(BulkStream.Handle);
// Check for errors
if (BulkStream.Error != 0)
{
lock (log)
{
log.AppendLine(String.Format("{0}: ERROR! Request failed with error {1} ({2} of {3} bytes)\n", DateTime.Now, BulkStream.Error, BulkStream.BytesTransferred, BulkStream.BytesRequested));
}
++ErrorCount;
}
else
{
lock (log)
{
log.AppendLine(String.Format("{0}: Completed Request for {1} bytes", DateTime.Now, BulkStream.BytesTransferred));
}
}
// Keep a running count of bytes transferred
TotalKiloBytes += (double)(BulkStream.BytesTransferred) / 1024.0;
InstKiloBytes += (double)(BulkStream.BytesTransferred) / 1024.0;
// Keep track of outstanding requests and the nuext request that will complete
++nextRequestToProcess;
--numPendingRequests;
// Time data rates
QueryPerformanceCounter(out tEnd);
double tElapsed = (double)(tEnd - tStart) / (double)(freq);
double tElapsedInst = (double)(tEnd - tLast) / (double)(freq);
overallRate = (TotalKiloBytes / 1024.0) / tElapsed;
instRate = (numPendingRequests == 0) ? 0 : ((InstKiloBytes / 1024.0) / tElapsedInst);
InstKiloBytes = 0;
tLast = tEnd;
//
// Now that this request has completed we may process the data
//
// Retreive a reference to the managed data buffer from the BulkStream.Buffer
//byte[] buffer = QuickUsb.RetrieveManagedByteDataBuffer(BulkStream.Buffer);
ushort[] buffer = QuickUsb.RetrieveManagedUShortDataBuffer(BulkStream.Buffer);
if (buffer == null)
{
lock (log)
{
log.AppendLine(String.Format("{0}: ERROR! Unable to retrieve managed data buffer", DateTime.Now));
}
}
// TODO: Process data
//Thread.Sleep(50); // Simulate data processing (to force use of more threads)
}
public void GetLastErrorTest()
{
QuickUsb.Error actual;
actual = QuickUsb.GetLastError();
}
