public AboutBox()
{
Version v;
InitializeComponent();
// Dialog title
this.Text = String.Format("About {0}", AssemblyTitle);
// Copyright
this.labelCopyright.Text = AssemblyCopyright;
// Application name
v = new Version(AssemblyVersion);
this.labelProductName.Text = String.Format("{0} v{1}.{2}.{3}", AssemblyProduct, v.Major, v.Minor, v.Build);
// Assembly version
v = Assembly.GetAssembly(typeof(QuickUsb)).GetName().Version;
this.labelAssemblyVersion.Text = String.Format("QuickUSB Assembly v{0}.{1}.{2}", v.Major, v.Minor, v.Build);
// DLL Version
ushort major, minor, build;
QuickUsb.GetDllVersion(out major, out minor, out build);
this.labelDllVersion.Text = String.Format("QuickUSB DLL v{0}.{1}.{2}", major, minor, build);
// Driver Version
QuickUsb.GetDriverVersion(out major, out minor, out build);
this.labelDriverVersion.Text = String.Format("QuickUSB Driver v{0}.{1}.{2}", major, minor, build);
}
public void QuickUsbConstructorTest()
{
string devname = "QUSB-0";
QuickUsb target = new QuickUsb(devname);
Assert.AreEqual(devname, target.Name);
}
///////////////////////////////////////
// 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];
}
}
public void MakeTest()
{
QuickUsb target = new QuickUsb("QUSB-0");
string actual;
actual = target.Make;
Assert.AreEqual(actual, "Bitwise Systems");
}
public void ModelTest()
{
QuickUsb target = new QuickUsb("QUSB-0");
string actual;
actual = target.Model;
Assert.AreEqual(actual.StartsWith("QuickUSB QUSB2 Module v2.15.1"), true);
}
public void IsOpenedTest()
{
QuickUsb target = new QuickUsb("QUSB-0");
bool actual;
actual = target.IsOpened;
Assert.AreEqual(actual, false);
}
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);
}
public void OpenTest1()
{
QuickUsb target = new QuickUsb("QUSB-0");
bool expected = true;
bool actual;
actual = target.Open();
Assert.AreEqual(expected, actual);
}
public Form1()
{
InitializeComponent();
// This is how you call FindModules to get the names of all the connected modules
string[] moduleNames = QuickUsb.FindModules();
listBox1.Items.AddRange(moduleNames);
listBox1.SelectedIndex = 0;
}
public void SerialTest()
{
QuickUsb target = new QuickUsb("QUSB-0");
string actual;
int snum;
actual = target.Serial;
Assert.AreEqual(Int32.TryParse(actual, out snum), true);
}
public void StartFpgaConfigurationTest()
{
QuickUsb target = new QuickUsb("QUSB-0");
bool expected = true;
bool actual;
actual = target.StartFpgaConfiguration();
Assert.AreEqual(expected, actual);
}
public void NameTest()
{
QuickUsb target = new QuickUsb("QUSB-0");
string expected = "QUSB-0";
string actual;
actual = target.Name;
Assert.AreEqual(expected, actual);
}
public void SetTimeoutTest()
{
QuickUsb target = new QuickUsb("QUSB-0");
uint timeOut = 1000;
bool expected = true;
bool actual;
actual = target.SetTimeout(timeOut);
Assert.AreEqual(expected, actual);
}
public void OpenTest()
{
QuickUsb target = new QuickUsb();
string devname = "QUSB-0";
bool expected = true;
bool actual;
actual = target.Open(devname);
Assert.AreEqual(expected, actual);
}
public void IsFpgaConfiguredTest()
{
QuickUsb target = new QuickUsb("QUSB-0");
bool isConfigured;
bool expected = true;
bool actual;
actual = target.IsFpgaConfigured(out isConfigured);
Assert.AreEqual(expected, actual);
}
public void FlushRS232Test()
{
QuickUsb target = new QuickUsb("QUSB-0");
byte portNum = 0;
bool expected = true;
bool actual;
actual = target.FlushRS232(portNum);
Assert.AreEqual(expected, actual);
}
public void ConfigureFpgaTest()
{
QuickUsb target = new QuickUsb("QUSB-0");
string filePath = "C:\\Projects\\Bitwise\\QuickUSB\\Hardware\\EvaluationBoard\\Samples\\Rev A\\Verilog\\QUSBEVB_REVA_EP2C20_Counter\\QUSBEVB_REVA_EP2C20_Counter.rbf";
bool expected = true;
bool actual;
actual = target.ConfigureFpga(filePath);
Assert.AreEqual(expected, actual);
}
public void SetRS232BaudRateTest()
{
QuickUsb target = new QuickUsb("QUSB-0");
uint baudrate = 115200;
bool expected = true;
bool actual;
actual = target.SetRS232BaudRate(baudrate);
Assert.AreEqual(expected, actual);
}
public void FindModulesTest()
{
string expected = "QUSB";
string[] actual;
actual = QuickUsb.FindModules();
for (int k = 0; k < actual.Length; ++k)
{
Assert.AreEqual(expected, actual[k].Split('-')[0]);
}
}
public void GetDllVersionTest()
{
Version version = null;
Version versionExpected = new Version(2, 15, 0);
bool expected = true;
bool actual;
actual = QuickUsb.GetDllVersion(out version);
Assert.AreEqual(versionExpected, version);
Assert.AreEqual(expected, actual);
}
public void GetStringDescriptorTest()
{
QuickUsb target = new QuickUsb("QUSB-0");
QuickUsb.StringDescriptor stringIndex = QuickUsb.StringDescriptor.Make;
string expected = "Bitwise Systems";
string actual;
actual = target.GetStringDescriptor(stringIndex);
Assert.AreEqual(expected, actual);
}
///////////////////////////////////////
// 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)
}
public void GetFirmwareVersionTest1()
{
QuickUsb target = new QuickUsb("QUSB-0");
Version version;
Version versionExpected = new Version(2, 15, 0); // This may change
bool expected = true;
bool actual;
actual = target.GetFirmwareVersion(out version);
Assert.AreEqual(versionExpected, version);
Assert.AreEqual(expected, actual);
}
public void WritePortTest1()
{
QuickUsb target = new QuickUsb("QUSB-0");
QuickUsb.Port address = QuickUsb.Port.E;
byte data = 0x7e;
bool expected = true;
bool actual;
actual = target.WritePort(address, data);
Assert.AreEqual(expected, actual);
}
public void OpenExTest()
{
QuickUsb target = new QuickUsb();
string devname = "QUSB-0";
QuickUsb.OpenFlag flags = QuickUsb.OpenFlag.Normal;
bool expected = true;
bool actual;
actual = target.OpenEx(devname, flags);
Assert.AreEqual(expected, actual);
}
public void WriteDefaultTest()
{
QuickUsb target = new QuickUsb("QUSB-0");
QuickUsb.Setting address = QuickUsb.Setting.PortA;
ushort value = 0xff00;
bool expected = true;
bool actual;
actual = target.WriteDefault(address, value);
Assert.AreEqual(expected, actual);
}
public void WriteVerifyFirmwareTest()
{
QuickUsb target = new QuickUsb("QUSB-0");
bool expected = true;
bool actual;
actual = target.WriteFirmware(@"C:\Projects\Bitwise\QuickUSB\Library\Firmware\QuickUSB Firmware v2.15.1\quickusb-simple v2.15.1.qusb", QuickUsb.Programming.PreserveDefaults | QuickUsb.Programming.PreserveSerial, null, IntPtr.Zero);
Assert.AreEqual(expected, actual);
actual = target.VerifyFirmware(@"C:\Projects\Bitwise\QuickUSB\Library\Firmware\QuickUSB Firmware v2.15.1\quickusb-simple v2.15.1.qusb", null, IntPtr.Zero);
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();
}
public void UploadFpgaTest()
{
QuickUsb target = new QuickUsb("QUSB-0");
string path = "C:\\Projects\\Bitwise\\QuickUSB\\Hardware\\EvaluationBoard\\Samples\\Rev A\\Verilog\\QUSBEVB_REVA_EP2C20_Counter\\QUSBEVB_REVA_EP2C20_Counter.rbf";
QuickUsb.PercentCompleteDelegate updateProgress = null;
bool expected = true;
bool actual;
actual = target.UploadFpga(path, updateProgress);
Assert.AreEqual(expected, actual);
}
public void ReadPortDirTest()
{
QuickUsb target = new QuickUsb("QUSB-0");
QuickUsb.Port address = QuickUsb.Port.A;
byte data;
bool expected = true;
bool actual;
actual = target.ReadPortDir(address, out data);
Assert.AreEqual(expected, actual);
}
