private void bStopStreaming_Click(object sender, EventArgs e) { bool qResult; tbLog.AppendText(String.Format("********** Stopping stream **********\n", qusbError)); // Stop the timer timer.Stop(); // Stop the data stream qResult = qusb.StopStream(streamID, false); if (!qResult) { qusbError = qusb.LastError(); tbLog.AppendText(String.Format("BulkDataStopStream failed with error {0}\n", qusbError)); } // Close the module qResult = qusb.Close(); if (!qResult) { Console.WriteLine("QuickUSB Error: {0}", qusb.LastError()); return; } // Reset variables streaming = false; // Reset buttons bStartStreaming.Enabled = true; bStopStreaming.Enabled = false; }
// QuickUSB Asynchronous Imaging Example void Acquire() { int k = 0; if (!aquiring) { return; } // Wait for the transaction to complete (The completion routine will be called) do { qResult = qusb.BulkWait(BulkStream[k], false); if (!qResult) { qusbError = qusb.LastError(); if (qusbError == QuickUsb.Error.Timeout) { // While we wait for this request to complete, we could be performing some // background tasks timer1.Enabled = false; Application.DoEvents(); timer1.Enabled = true; } } } while (!qResult && qusb.LastError() == QuickUsb.Error.Timeout); if (!qResult) { qusbError = qusb.LastError(); return; } // Calculate FPS QueryPerformanceCounter(out tEnd); tElapsed = (double)(tEnd - tStart) / (double)(freq); tStart = tEnd; toolStripStatusLabel1.Text = String.Format("FPS: {0:0.0}", 1.0 / tElapsed); // Blit data to screen BitmapData bData = image.LockBits(new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed); MoveMemory(bData.Scan0, BufferArray[0], FrameByteSize); image.UnlockBits(bData); pbFrame.Invalidate(); // Issue a new transaction qResult = qusb.ReadBulkDataAsync( BufferArray[0], FrameByteSize, BulkStream[0], cbDelegate, IntPtr.Zero); if (!qResult) { toolStripStatusLabel1.Text = "Error: Unable to issue data read"; qusb.Close(); return; } }
public void LastErrorTest() { QuickUsb target = new QuickUsb("QUSB-0"); QuickUsb.Error expected = QuickUsb.Error.NoError; QuickUsb.Error actual; actual = target.LastError(); Assert.AreEqual(expected, actual); }
private void bStartStreaming_Click(object sender, EventArgs e) { bool qResult; qusb = qusbControl.SelectedModule; tbLog.AppendText(String.Format("********** Starting stream **********\n", qusbError)); // Open the module qResult = qusb.Open(); if (!qResult) { tbLog.AppendText(String.Format("Unable to open module\n", qusbError)); return; } // Start the data stream if (UserAllocatedBuffers) { // Start streaming data to our user allocated data buffers qResult = qusb.ReadBulkDataStartStream(BufferArray, NumBuffers, BufferByteSize, cbDelegate, IntPtr.Zero, out streamID, NumThreads, ThreadConcurrency); } else { // Start streaming data to data buffers that will be allocated interally by the Streaming API qResult = qusb.ReadBulkDataStartStream(IntPtr.Zero, NumBuffers, BufferByteSize, cbDelegate, IntPtr.Zero, out streamID, NumThreads, ThreadConcurrency); } // Check for an error starting the stream if (!qResult) { qusbError = qusb.LastError(); qusb.Close(); tbLog.AppendText(String.Format("ReadBulkDataStartStream failed with error {0}\n", qusbError)); return; } // Reset buttons bStartStreaming.Enabled = false; bStopStreaming.Enabled = true; // Reset variables TotalKiloBytes = 0; ErrorCount = 0; streaming = true; // Start throughput timer QueryPerformanceFrequency(out freq); QueryPerformanceCounter(out tStart); // Start timer timer.Start(); }
private void timer_Tick(object sender, EventArgs e) { if (numPendingRequests != 0) { // If we are not multithreading the stream in this example, we must // allow time for processing requests. Processing requests simply // means checking if a request has completed, execute its completion // routine, and re-issue the requests. QuickUsb.ProcessStream will // return when either any request has completed or the specified time // has elapsed. if (NumThreads == 0) { // Check if the next request has completed bool qResult = qusb.BulkWait(bulkStream[nextRequestToProcess], true); // Don't block if (!qResult) { qusbError = qusb.LastError(); if (qusbError != QuickUsb.Error.NotCompleted) { Console.WriteLine("ProcessStream failed with error {0}", qusbError); } } } } else { // All the requests have completed bIssueRead.Enabled = true; bIssueWrite.Enabled = true; timer.Stop(); // Close the module now that we're done with it qusb.Close(); } // Report our data throughput dataRate.Text = String.Format("Data Rate: {0:0.0} MB/s Overall, {1:0.0} MB/s Instantaneously", overallRate, instRate); // Dump data to log lock (log) { tbLog.AppendText(log.ToString()); log = new StringBuilder(); } }
private void timer_Tick(object sender, EventArgs e) { // If we are not multithreading the stream in this example, we must // allow time for processing requests. Processing requests simply // means checking if a request has completed, execute its completion // routine, and re-issue the requests. QuickUsb.ProcessStream will // return when either any request has completed or the specified time // has elapsed. if (NumThreads == 0) { bool qResult = qusb.ProcessStream(streamID, 50); if (!qResult) { qusbError = qusb.LastError(); Console.WriteLine("ProcessStream failed with error {0}", qusbError); } } // Time data rates QueryPerformanceCounter(out tEnd); double tElapsed = (double)(tEnd - tStart) / (double)(freq); double tElapsedInst = (double)(tEnd - tLast) / (double)(freq); double overallRate = (TotalKiloBytes / 1024.0) / tElapsed; double instRate = (InstKiloBytes / 1024.0) / tElapsedInst; InstKiloBytes = 0; tLast = tEnd; // Report our data throughput dataRate.Text = String.Format("Data Rate: {0:0.0} MB/s Overall, {1:0.0} MB/s Instantaneously", overallRate, instRate); // Dump data to log lock (log) { tbLog.AppendText(log.ToString()); log = new StringBuilder(); } }
private void bIssueWrite_Click(object sender, EventArgs e) { bool qResult; qusb = qusbControl.SelectedModule; tbLog.AppendText(String.Format("********** Issuing {0} async writes **********\n", NumRequests)); // Open the module qResult = qusb.Open(); if (!qResult) { tbLog.AppendText(String.Format("Unable to open module\n", qusbError)); return; } // Reset buttons bIssueRead.Enabled = false; bIssueWrite.Enabled = true; // Reset variables TotalKiloBytes = 0; ErrorCount = 0; numPendingRequests = 0; nextRequestToProcess = 0; // Set num threads and thread concurrency qResult = qusb.SetNumAsyncThreads(NumThreads, ThreadConcurrency); if (!qResult) { qusbError = qusb.LastError(); tbLog.AppendText(String.Format("SetNumAsyncThreads failed with error {0}\n", qusbError)); bIssueRead.Enabled = false; bIssueWrite.Enabled = false; qusb.Close(); return; } // Start throughput timer QueryPerformanceFrequency(out freq); QueryPerformanceCounter(out tStart); // Start streaming data to our user allocated data buffers for (int k = 0; k < NumRequests; ++k) { qResult = qusb.WriteBulkDataAsync(BufferArray[k], BufferByteSize, bulkStream[k], cbDelegate, IntPtr.Zero); // Check for an error issuing the request if (!qResult) { qusbError = qusb.LastError(); tbLog.AppendText(String.Format("WriteBulkDataAsync failed with error {0}\n", qusbError)); } else { ++numPendingRequests; } } // Start timer timer.Start(); }