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