|
public OpenEndpointReader ( ReadEndpointID readEndpointID ) : |
||
| readEndpointID | ReadEndpointID | Endpoint number for read operations. |
| 리턴 | ||
/// <summary>
/// Class constructor for the traq|paq
/// </summary>
public TraqpaqDevice()
{
// find the device
traqpaqDeviceFinder = new UsbDeviceFinder(Constants.VID, Constants.PID);
// open the device
this.MyUSBDevice = UsbDevice.OpenUsbDevice(traqpaqDeviceFinder);
// If the device is open and ready
if (MyUSBDevice == null) throw new TraqPaqNotConnectedException("Device not found");
this.reader = MyUSBDevice.OpenEndpointReader(ReadEndpointID.Ep01);
this.writer = MyUSBDevice.OpenEndpointWriter(WriteEndpointID.Ep02);
// create the battery object
this.battery = new Battery(this);
// get a list of saved tracks
getAllTracks();
// get the record table data
tableReader = new RecordTableReader(this);
tableReader.readRecordTable();
this.recordTableList = tableReader.recordTable;
}
public void open()
{
// Find and open the usb device.
MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder);
if (MyUsbDevice == null) throw new Exception("Device Not Found.");
UsbEndpointReader reader = MyUsbDevice.OpenEndpointReader(ReadEndpointID.Ep01);
}
public SmartScopeUsbInterfaceLibUsb(UsbDevice usbDevice)
{
if (usbDevice is IUsbDevice)
{
bool succes1 = (usbDevice as IUsbDevice).SetConfiguration(1);
if (!succes1)
throw new ScopeIOException("Failed to set usb device configuration");
bool succes2 = (usbDevice as IUsbDevice).ClaimInterface(0);
if (!succes2)
throw new ScopeIOException("Failed to claim usb interface");
}
device = usbDevice;
serial = usbDevice.Info.SerialString;
dataEndpoint = usbDevice.OpenEndpointReader(ReadEndpointID.Ep01);
commandWriteEndpoint = usbDevice.OpenEndpointWriter(WriteEndpointID.Ep02);
commandReadEndpoint = usbDevice.OpenEndpointReader(ReadEndpointID.Ep03);
Common.Logger.Debug("Created new ScopeUsbInterface from device with serial " + serial);
}
public GarminUnit(UsbDevice Device)
{
Configuration = new Dictionary<string, ushort>();
IUsbDevice wholedevice = Device as IUsbDevice;
if ( !ReferenceEquals(wholedevice, null))
{
wholedevice.SetConfiguration(1);
wholedevice.ClaimInterface(0);
}
Reader = Device.OpenEndpointReader(ReadEndpointID.Ep01);
Writer = Device.OpenEndpointWriter(WriteEndpointID.Ep02);
}
public PolhemusStream()
{
try
{
// Find and open the usb device.
PolhemusUsbDevice = UsbDevice.OpenUsbDevice(UsbFinder);
// If the device is open and ready
if (PolhemusUsbDevice == null) throw new Exception("Polhemus not found.");
// If this is a "whole" usb device (libusb-win32, linux libusb)
// it will have an IUsbDevice interface. If not (WinUSB) the
// variable will be null indicating this is an interface of a
// device.
IUsbDevice wholeUsbDevice = PolhemusUsbDevice 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(0);
}
//Polhemus uses EndPoint 2 for both read and write
PolhemusReader = PolhemusUsbDevice.OpenEndpointReader(ReadEndpointID.Ep02);
PolhemusWriter = PolhemusUsbDevice.OpenEndpointWriter(WriteEndpointID.Ep02);
}
catch (Exception e)
{
throw new Exception("Error in PolhemusStream constructor: " + e.Message);
}
}
/// <summary>
/// The method performs the main function of the service. It runs on
/// a thread pool worker thread.
/// </summary>
/// <param name="state"></param>
private void ServiceWorkerThread(object state)
{
GetIDs();
ErrorCode ec = ErrorCode.None;
try
{
// Find and open the usb device.
MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder);
// If the device is open and ready
if (MyUsbDevice == null) throw new Exception("Device Not Found.");
IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
wholeUsbDevice.SetConfiguration(1);
wholeUsbDevice.ClaimInterface(0);
}
// open read endpoint 1.
UsbEndpointReader reader = MyUsbDevice.OpenEndpointReader(ReadEndpointID.Ep01);
byte[] readBuffer = new byte[1024];
int bytesRead = 0;
// Periodically check if the service is stopping.
while (!this.stopping)
{
//Thread.Sleep(2000); // Simulate some lengthy operations.
ec = reader.Read(readBuffer, 30000, out bytesRead);
if (bytesRead > 0)
{
string trackString = Encoding.Default.GetString(readBuffer, 0, bytesRead);
string[] words = trackString.Split('?');
System.IO.StreamWriter fileReader2 = new System.IO.StreamWriter(trackFile, true);
if (words.Length > 0)
{
//Console.WriteLine();
string[] track1 = words[0].Split('%');
if (track1.Length > 1 && track1[1].Length > 0)
{
fileReader2.WriteLine(track1[1]);
//Console.WriteLine(track1[1]);
}
}
if (words.Length > 1)
{
string[] track2 = words[1].Split(';');
if (track2.Length > 1 && track2[1].Length > 0)
{
fileReader2.WriteLine(track2[1]);
//Console.WriteLine(track2[1]);
}
}
if (words.Length > 2)
{
string[] track3 = words[2].Split(';');
if (track3.Length > 1 && track3[1].Length > 0)
{
fileReader2.WriteLine(track3[1]);
//Console.WriteLine(track3[1]);
}
}
fileReader2.Close();
}
}
}
catch (Exception ex)
{
System.IO.StreamWriter file = new System.IO.StreamWriter(logFile, true);
file.WriteLine();
file.WriteLine((ec != ErrorCode.None ? ec + ":" : String.Empty) + ex.Message);
file.Close();
}
finally
{
if (MyUsbDevice != null)
{
if (MyUsbDevice.IsOpen)
{
IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
// Release interface #0.
wholeUsbDevice.ReleaseInterface(0);
}
MyUsbDevice.Close();
}
MyUsbDevice = null;
UsbDevice.Exit();
}
}
// Signal the stopped event.
this.stoppedEvent.Set();
}
public bool Open()
{
bool success = true;
//
try
{
// Find and open the usb device.
myUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder);
//
// If the device is open and ready
if (myUsbDevice == null) throw new Exception("X10 CM15Pro device not connected.");
//
// If this is a "whole" usb device (libusb-win32, linux libusb)
// it will have an IUsbDevice interface. If not (WinUSB) the
// variable will be null indicating this is an interface of a
// device.
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(0);
}
//
// open read endpoint 1.
reader = myUsbDevice.OpenEndpointReader(ReadEndpointID.Ep01);
// open write endpoint 2.
writer = myUsbDevice.OpenEndpointWriter(WriteEndpointID.Ep02);
//
this.WriteData(new byte[] { 0x8B }); // status request
}
catch
{
success = false;
//throw new Exception("Error opening X10 CM15Pro device.");
}
return success;
}
private void OpenDevice()
{
if(_usbDevice != null && _usbDevice.IsOpen)
return;
// Find and open the usb device.
_usbDevice = UsbDevice.OpenUsbDevice(_usbFinder);
// If the device is open and ready
Debug.Assert(_usbDevice != null, string.Format("No device with PID: {0:X4} & VID: {1:X4} Found!", _pid, _vid));
// If this is a "whole" usb device (libusb-win32, linux libusb)
// it will have an IUsbDevice interface. If not (WinUSB) the
// variable will be null indicating this is an interface of a
// device.
var wholeUsbDevice = _usbDevice 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(0);
}
// open read endpoint 1.
_epReader = _usbDevice.OpenEndpointReader((ReadEndpointID) EpIn);
_epReader.Flush();
// open write endpoint 1.
_epWriter = _usbDevice.OpenEndpointWriter((WriteEndpointID) EpOut);
LibMain.OnConnectedChanged(true);
}
public Battery(UsbDevice usb = null)
{
usbDevice = usb;
// If this is a "whole" usb device (libusb-win32, linux libusb)
// it will have an IUsbDevice interface. If not (WinUSB) the
// variable will be null indicating this is an interface of a
// device.
IUsbDevice wholeUsbDevice = usbDevice 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(0);
}
// open read endpoint 1
UsbEndpointReader batInfoReader = usbDevice.OpenEndpointReader(ReadEndpointID.Ep01);
ErrorCode ec = ErrorCode.None;
byte[] batInfoReadBuffer = new byte[64];
int bytesRead = 0;
// If the device hasn't sent data in the last 100 milliseconds,
// a timeout error (ec = IoTimedOut) will occur.
ec = batInfoReader.Read(batInfoReadBuffer, 100, out bytesRead);
if (bytesRead == 0) throw new Exception("No more bytes!");
// create BinaryReader and set source to readBuffer
BatteryBinaryReader batInfoBReader = new BatteryBinaryReader(batInfoReadBuffer);
// set battery variables using binary reader
fwVersion = batInfoBReader.ReadByte() + ((float) batInfoBReader.ReadByte()) / 10;
id = new string(batInfoBReader.ReadChars(6));
name = new string(batInfoBReader.ReadChars(20));
currentTime = batInfoBReader.ReadInt32();
lastSyncTime = batInfoBReader.ReadInt32();
capacity = batInfoBReader.ReadUInt16();
lastFullCap = batInfoBReader.ReadUInt16();
factoryCap = batInfoBReader.ReadUInt16();
percentage = 100 * capacity / lastFullCap;
int eepromPages = batInfoBReader.ReadUInt16();
// get unix time
int time = (Int32)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;
// check if battery time is correct
if (currentTime != time || currentTime != time - 1)
{
// open write endpoint 1
UsbEndpointWriter writer = usbDevice.OpenEndpointWriter(WriteEndpointID.Ep01);
// convert time to byte array
byte[] timeArray = BitConverter.GetBytes(time);
int bytesWritten = 0;
// write time to endpoint 1
ec = writer.Write(timeArray, 100, out bytesWritten);
}
UsbTransfer usbReadTransfer;
UsbEndpointReader dataReader = usbDevice.OpenEndpointReader(ReadEndpointID.Ep02);
int bytesToRead = 128 * eepromPages;
byte[] dataReadBuffer = new byte[bytesToRead];
// reset error code
ec = ErrorCode.None;
// read logged data using async bulk transfer
ec = dataReader.SubmitAsyncTransfer(dataReadBuffer, 0, bytesToRead, 100, out usbReadTransfer);
// dispose of the usb transfer
usbReadTransfer.Dispose();
// create a string array with the lines of text
var dataReadString = System.Text.Encoding.Default.GetString(dataReadBuffer);
// Set a variable to the My Documents path
string docPath =
Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
// write the string array to a new file named "DAS_battery.txt".
using (StreamWriter outputFile = new StreamWriter(docPath + @"\DAS_battery.txt"))
{
outputFile.Write(dataReadString);
}
}
public void Thu()
{
ErrorCode ec = ErrorCode.None;
UsbRegDeviceList lu = LibUsbDotNet.UsbDevice.AllDevices;
MyUsbFinder = new UsbDeviceFinder(1614, 33024);
LibUsbDotNet.UsbDevice MyUsbDevice = null;
try
{
// Find and open the usb device.
MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder);
//MyUsbDevice = lu[0].Device;
// 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)
// it will have an IUsbDevice interface. If not (WinUSB) the
// variable will be null indicating this is an interface of a
// device.
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
wholeUsbDevice.SetConfiguration(1);
// Claim interface
wholeUsbDevice.ClaimInterface(1);
}
// open read endpoint
UsbEndpointReader reader =
MyUsbDevice.OpenEndpointReader(ReadEndpointID.Ep02);
// open write endpoint0123456789
UsbEndpointWriter writer =
MyUsbDevice.OpenEndpointWriter(WriteEndpointID.Ep03);
// write data, read data
int bytesWritten;
//ec = writer.Write(new byte[] { 0x00, 0x03, 0x00, 0x00, 0x00,
// 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, 2000, out bytesWritten);
//if (ec != ErrorCode.None)
// throw new Exception(UsbDevice.LastErrorString);
ec = ErrorCode.None;
byte[] readBuffer = new byte[1024];
while (ec == ErrorCode.None)
{
int bytesRead;
// If the device hasn't sent data in the last 100 milliseconds,
// a timeout error (ec = IoTimedOut) will occur.
ec = reader.Read(readBuffer, 100, out bytesRead);
if (bytesRead == 0)
{
throw new Exception("No more bytes!");
}
// Write that output to the console.
// PrintHex(readBuffer, bytesRead);
}
//Console.WriteLine("\r\nDone!\r\n");
}
catch (Exception ex)
{
//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.
IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
// Release interface
wholeUsbDevice.ReleaseInterface(1);
}
MyUsbDevice.Close();
}
MyUsbDevice = null;
// Free usb resources
UsbDevice.Exit();
}
}
}
public static void Main(string[] args)
{
ErrorCode ec = ErrorCode.None;
try
{
// Find and open the usb device.
MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder);
// 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(0);
}
// open read endpoint 1.
UsbEndpointReader reader = MyUsbDevice.OpenEndpointReader(ReadEndpointID.Ep01);
// open write endpoint 1.
UsbEndpointWriter writer = MyUsbDevice.OpenEndpointWriter(WriteEndpointID.Ep01);
// Remove the exepath/startup filename text from the begining of the CommandLine.
string cmdLine = Regex.Replace(
Environment.CommandLine, "^\".+?\"^.*? |^.*? ", "", RegexOptions.Singleline);
if (!String.IsNullOrEmpty(cmdLine))
{
reader.DataReceived += (OnRxEndPointData);
reader.DataReceivedEnabled = true;
int bytesWritten;
ec = writer.Write(Encoding.Default.GetBytes(cmdLine), 2000, out bytesWritten);
if (ec != ErrorCode.None) throw new Exception(UsbDevice.LastErrorString);
LastDataEventDate = DateTime.Now;
while ((DateTime.Now - LastDataEventDate).TotalMilliseconds < 100)
{
}
// Always disable and unhook event when done.
reader.DataReceivedEnabled = false;
reader.DataReceived -= (OnRxEndPointData);
Console.WriteLine("\r\nDone!\r\n");
}
else
throw new Exception("Nothing to do.");
}
catch (Exception ex)
{
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.
IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
// Release interface #0.
wholeUsbDevice.ReleaseInterface(0);
}
MyUsbDevice.Close();
}
}
MyUsbDevice = null;
// Free usb resources
UsbDevice.Exit();
// Wait for user input..
Console.ReadKey();
}
}
//
//переделать всё
//
private void connect()
{
if (comboBox1.SelectedIndex != -1)
MyUsbFinder = new UsbDeviceFinder(Convert.ToInt32(devices_libusb[comboBox1.SelectedIndex].VID, 16),
Convert.ToInt32(devices_libusb[comboBox1.SelectedIndex].PID, 16));
DataPoint temp = new DataPoint();
ErrorCode ec = ErrorCode.None;
try
{
//открываем поток
MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder);
if (MyUsbDevice == null) throw new Exception("Device Not Found.");
IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
wholeUsbDevice.SetConfiguration(1);
wholeUsbDevice.ClaimInterface(0);
}
//читает 1ый эндпоинт
UsbEndpointReader reader = MyUsbDevice.OpenEndpointReader((ReadEndpointID)comboBox2.SelectedItem);
byte[] readBuffer = new byte[1024];
int bytesRead;
//Возвращает данные или ошибку, если через 5 секунд ничего не было возвращено
ec = reader.Read(readBuffer, 5000, out bytesRead);
if (bytesRead == 0) throw new Exception(string.Format("{0}:No more bytes!", ec));
try
{
if (trying)
{
temp.SetValueXY(i,
Convert.ToDouble(Encoding.Default.GetString(readBuffer, 0, bytesRead).Replace('.', ',')));
i++;
chart1.Series[0].Points.Add(temp);
data.Add(Encoding.Default.GetString(readBuffer, 0, bytesRead));
}
}
catch
{
trying = false;
}
textBox2.AppendText(Encoding.Default.GetString(readBuffer, 0, bytesRead));
}
catch (Exception ex)
{
//кидает ошибку и останавливает таймер при ошибке
timer1.Stop();
MessageBox.Show((ec != ErrorCode.None ? ec + ":" : String.Empty) + ex.Message);
}
finally
{
//закрывает поток
if (MyUsbDevice != null)
{
if (MyUsbDevice.IsOpen)
{
IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
wholeUsbDevice.ReleaseInterface(0);
}
MyUsbDevice.Close();
}
MyUsbDevice = null;
UsbDevice.Exit();
}
}
}
private void button2_Click(object sender, EventArgs e)
{
try
{
MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder);
if (MyUsbDevice == null)
{
throw new Exception("Device Not Found.");
//connected = false;
}
else
{
Device_l.Text = "Device: Connected";
//connected = true;
Scan_b.Enabled = true;
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(0);
}
reader = MyUsbDevice.OpenEndpointReader(ReadEndpointID.Ep03);
writer = MyUsbDevice.OpenEndpointWriter(WriteEndpointID.Ep04);
}
}
catch (Exception ex)
{
MessageBox.Show((ec != ErrorCode.None ? ec + ":" : String.Empty) + ex.Message);
}
}
private bool openAsTestDevice(UsbRegistry usbRegistry)
{
if (!ReferenceEquals(mUsbDevice, null))
closeTestDevice(mUsbDevice);
mUsbDevice = null;
try
{
if (usbRegistry.Open(out mUsbDevice))
{
UsbInterfaceInfo readInterfaceInfo;
UsbInterfaceInfo writeInterfaceInfo;
UsbDevice.UsbErrorEvent += OnUsbError;
if (!UsbEndpointBase.LookupEndpointInfo(mUsbDevice.Configs[0],
0x80,
out readInterfaceInfo,
out mReadEndpointInfo))
{
throw new Exception("failed locating read endpoint.");
}
mBenchMarkParameters.BufferSize -= (mBenchMarkParameters.BufferSize%(mReadEndpointInfo.Descriptor.MaxPacketSize));
if (!UsbEndpointBase.LookupEndpointInfo(mUsbDevice.Configs[0],
0x00,
out writeInterfaceInfo,
out mWriteEndpointInfo))
{
throw new Exception("failed locating write endpoint.");
}
if (((mWriteEndpointInfo.Descriptor.Attributes & 3)==(int) EndpointType.Isochronous) ||
((mReadEndpointInfo.Descriptor.Attributes & 3)==(int) EndpointType.Isochronous))
{
throw new Exception("buenchmark GUI application does not support ISO endpoints. Use BenchmarkCon instead.");
}
mBenchMarkParameters.BufferSize -= (mBenchMarkParameters.BufferSize%(mWriteEndpointInfo.Descriptor.MaxPacketSize));
if (writeInterfaceInfo.Descriptor.InterfaceID != readInterfaceInfo.Descriptor.InterfaceID)
throw new Exception("read/write endpoints must be on the same interface.");
mEP1Reader = mUsbDevice.OpenEndpointReader(
(ReadEndpointID)mReadEndpointInfo.Descriptor.EndpointID,
mBenchMarkParameters.BufferSize,
(EndpointType)(mReadEndpointInfo.Descriptor.Attributes & 3));
mEP1Writer = mUsbDevice.OpenEndpointWriter(
(WriteEndpointID) mWriteEndpointInfo.Descriptor.EndpointID,
(EndpointType) (mWriteEndpointInfo.Descriptor.Attributes & 3));
mInterfaceInfo = writeInterfaceInfo;
mEP1Reader.ReadThreadPriority = mBenchMarkParameters.Priority;
mEP1Reader.DataReceived += OnDataReceived;
makeTestBytes(out loopTestBytes, mBenchMarkParameters.BufferSize);
// If this is a "whole" usb device (libusb-win32, linux libusb)
// it will have an IUsbDevice interface. If not (WinUSB) the
// variable will be null indicating this is an interface of a
// device.
IUsbDevice wholeUsbDevice = mUsbDevice 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(mInterfaceInfo.Descriptor.InterfaceID);
}
return true;
}
}
catch(Exception ex)
{
SetStatus(ex.Message, true);
}
if (!ReferenceEquals(mUsbDevice,null))
{
try
{
closeTestDevice(mUsbDevice);
}
finally
{
mUsbDevice = null;
mEP1Reader = null;
mEP1Writer = null;
}
}
return false;
}
private static bool Get_connect_PlanetCNC()
{
//vid 2121 pid 2130 в десятичной системе будет как 8481 и 8496 соответственно
UsbDeviceFinder myUsbFinder = new UsbDeviceFinder(8481, 8496);
// Попытаемся установить связь
_myUsbDevice = UsbDevice.OpenUsbDevice(myUsbFinder);
if (_myUsbDevice == null)
{
string StringError = "Не найден подключенный контроллер.";
_connected = false;
AddMessage(StringError);
//запустим событие о разрыве связи
if (WasDisconnected != null) WasDisconnected(null, new DeviceEventArgsMessage(StringError));
return false;
}
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(0);
}
// open read endpoint 1.
_usbReader = _myUsbDevice.OpenEndpointReader(ReadEndpointID.Ep01);
// open write endpoint 1.
_usbWriter = _myUsbDevice.OpenEndpointWriter(WriteEndpointID.Ep01);
return true;
}
public iPhoneWrapper(UsbDevice USBDevice, bool bAFC2)
{
if (USBDevice == null)
throw new Exception("Failed to create iPhone wrapper");
StartTime = DateTime.UtcNow;
iPhoneUSBDevice = USBDevice;
MUXConnections = new List<USBMUXConnection>();
IUsbDevice LibUsbDevice = iPhoneUSBDevice as IUsbDevice;
if (!ReferenceEquals(LibUsbDevice, null))
{
// This is a "whole" USB device. Before it can be used,
// the desired configuration and interface must be selected.
// Select config #3
LibUsbDevice.SetConfiguration(3);
// Claim interface #1.
LibUsbDevice.ClaimInterface(1);
}
// Open read endpoint 5.
iPhoneEndpointReader = iPhoneUSBDevice.OpenEndpointReader(ReadEndpointID.Ep05);
// Open write endpoint 4.
iPhoneEndpointWriter = iPhoneUSBDevice.OpenEndpointWriter(WriteEndpointID.Ep04);
// Say hello to the device and set up lockdown.
if (!Initialize())
throw new Exception("Couldn't initialize iPhone");
// Try to start AFC2 if requested. If it doesn't work (not jailbroken), start AFC.
int nAFCPort = 0;
if (bAFC2)
{
try { nAFCPort = Lockdown.StartService("com.apple.afc2"); }
catch
{
nAFCPort = Lockdown.StartService("com.apple.afc");
}
if (nAFCPort != 0)
{
AFC = new AFCConnection(this, 5, (ushort)nAFCPort);
MUXConnections.Add(AFC);
}
}
else
{
nAFCPort = Lockdown.StartService("com.apple.afc");
AFC = new AFCConnection(this, 5, (ushort)nAFCPort);
MUXConnections.Add(AFC);
}
int nNPPort = Lockdown.StartService("com.apple.mobile.notification_proxy");
NP = new NotificationProxyConnection(this, 6, (ushort)nNPPort);
MUXConnections.Add(NP);
Global.Log("Shutting down lockdownd (don't need it anymore).\n");
try { Lockdown.CloseConnection(); } catch { }
MUXConnections.Remove(Lockdown);
}
public static void Main(string[] args)
{
ErrorCode ec = ErrorCode.None;
try
{
// Find and open the usb device.
MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder);
// 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)
// it will have an IUsbDevice interface. If not (WinUSB) the
// variable will be null indicating this is an interface of a
// device.
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(0);
}
// open read endpoint 1.
UsbEndpointReader reader = MyUsbDevice.OpenEndpointReader(ReadEndpointID.Ep01);
// open write endpoint 1.
UsbEndpointWriter writer = MyUsbDevice.OpenEndpointWriter(WriteEndpointID.Ep01);
// Remove the exepath/startup filename text from the begining of the CommandLine.
string cmdLine = Regex.Replace(
Environment.CommandLine, "^\".+?\"^.*? |^.*? ", "", RegexOptions.Singleline);
if (!String.IsNullOrEmpty(cmdLine))
{
int bytesWritten;
ec = writer.Write(Encoding.Default.GetBytes(cmdLine), 2000, out bytesWritten);
if (ec != ErrorCode.None) throw new Exception(UsbDevice.LastErrorString);
byte[] readBuffer = new byte[1024];
while (ec == ErrorCode.None)
{
int bytesRead;
// If the device hasn't sent data in the last 100 milliseconds,
// a timeout error (ec = IoTimedOut) will occur.
ec = reader.Read(readBuffer, 100, out bytesRead);
if (bytesRead == 0) throw new Exception("No more bytes!");
// Write that output to the console.
Console.Write(Encoding.Default.GetString(readBuffer, 0, bytesRead));
}
Console.WriteLine("\r\nDone!\r\n");
}
else
throw new Exception("Nothing to do.");
}
catch (Exception ex)
{
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.
IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
// Release interface #0.
wholeUsbDevice.ReleaseInterface(0);
}
MyUsbDevice.Close();
}
MyUsbDevice = null;
// Free usb resources
UsbDevice.Exit();
}
// Wait for user input..
Console.ReadKey();
}
}
public static UsbDeviceFinder MyUsbFinder = new UsbDeviceFinder(0x0F44, 0xEF12); //Polhemus Patriot
#endregion Fields
#region Methods
public static void Main(string[] args)
{
byte[] writeBuffer;
byte[] readBuffer;
ErrorCode ec = ErrorCode.None;
try
{
// Find and open the usb device.
MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder);
// 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)
// it will have an IUsbDevice interface. If not (WinUSB) the
// variable will be null indicating this is an interface of a
// device.
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(0);
}
//Polhemus uses EndPoint 2 for both read and write
UsbEndpointReader reader = MyUsbDevice.OpenEndpointReader(ReadEndpointID.Ep02);
UsbEndpointWriter writer = MyUsbDevice.OpenEndpointWriter(WriteEndpointID.Ep02);
while (true)
{
Console.Write("New command: ");
string cmdLine = Console.ReadLine();
if (cmdLine == "") break;
if (cmdLine.Substring(0, 1) == "^") //control code
{
int ib = Encoding.ASCII.GetBytes(cmdLine.Substring(1, 1))[0];
writeBuffer = new byte[cmdLine.Length];
writeBuffer[0] = (byte)(ib & 0x1F); //calculate control code
if (cmdLine.Length > 2) //then there are arguments
{
byte[] arg = Encoding.ASCII.GetBytes(cmdLine.Substring(2)); //get arguments
for (int i = 0; i < arg.Length; i++) //and place in buffer
writeBuffer[i + 1] = arg[i];
}
writeBuffer[writeBuffer.Length - 1] = 0x0D; //CR
}
else //straight ASCII string command
writeBuffer = Encoding.ASCII.GetBytes(cmdLine +
((cmdLine != "P") ? "\r" : ""));
int bytesWritten;
ec = writer.Write(writeBuffer, 1000, out bytesWritten);
if (ec != ErrorCode.None) throw new Exception(UsbDevice.LastErrorString);
readBuffer = new byte[1024];
while (ec == ErrorCode.None)
{
int bytesRead;
// If the device hasn't sent data in the last 100 milliseconds,
// a timeout error (ec = IoTimedOut) will occur.
ec = reader.Read(readBuffer, 100, out bytesRead);
if (bytesRead == 0) break;
// Write that output to the console.
Console.Write(Encoding.Default.GetString(readBuffer, 0, bytesRead));
int byteCount = 1;
for (int i = 0; i < bytesRead; i++, byteCount++)
{
Console.Write(readBuffer[i].ToString("X2"));
if (byteCount >= 16)
{
byteCount = 0;
Console.Write(Environment.NewLine);
}
else
Console.Write(" ");
}
if (byteCount != 0) Console.Write(Environment.NewLine);
}
}
}
catch (Exception ex)
{
Console.WriteLine();
Console.WriteLine((ec != ErrorCode.None ? ec + ":" : String.Empty) + ex.Message);
Console.Read();
}
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.
IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
// Release interface #0.
wholeUsbDevice.ReleaseInterface(0);
}
MyUsbDevice.Close();
}
MyUsbDevice = null;
// Free usb resources
UsbDevice.Exit();
}
}
}
public void Open()
{
_device = UsbDevice.OpenUsbDevice(new UsbDeviceFinder(_vendorId, _productId));
if (_device != null)
{
IUsbDevice whole = _device as IUsbDevice;
if (!ReferenceEquals(whole, null))
{
whole.SetConfiguration(1);
whole.ClaimInterface(1);
}
//Set up the endpoints
var hci = _device.OpenEndpointReader(ReadEndpointID.Ep01);
_reader = _device.OpenEndpointReader(ReadEndpointID.Ep02);
_writer = _device.OpenEndpointWriter(WriteEndpointID.Ep02);
_isoReader = _device.OpenEndpointReader(ReadEndpointID.Ep03);
_isoWriter = _device.OpenEndpointWriter(WriteEndpointID.Ep03);
//Set up our read callback(s)
hci.DataReceived += hci_DataReceived;
hci.DataReceivedEnabled = true;
_reader.DataReceived += reader_DataReceived;
_reader.DataReceivedEnabled = true;
_isoReader.DataReceived += _isoReader_DataReceived;
_isoReader.DataReceivedEnabled = true;
//Reset the device
Reset();
}
}
public LibUsb_AsyncUsbStream (string port)
{
var splited = port.Split ('-');
var finder = new UsbDeviceFinder (int.Parse (splited [0]), int.Parse (splited [1]));
device = UsbDevice.OpenUsbDevice (finder);
if (device == null) {
throw new Exception ("Failed to find device:" + port);
}
if (!device.IsOpen) {
throw new Exception ("Device is not open:" + port);
}
var usbDevice = device as IUsbDevice;
var interfaceInfo = device.Configs [0].InterfaceInfoList [0];
if (usbDevice != null) {
usbDevice.SetConfiguration (device.Configs [0].Descriptor.ConfigID);
usbDevice.ClaimInterface (interfaceInfo.Descriptor.InterfaceID);
deviceInterfaceId = interfaceInfo.Descriptor.InterfaceID;
}
foreach (var ep in interfaceInfo.EndpointInfoList) {
if ((ep.Descriptor.EndpointID & 0x80) > 0) {
reader = device.OpenEndpointReader ((ReadEndpointID)ep.Descriptor.EndpointID);
reader.DataReceived += HandleDataReceived;
reader.DataReceivedEnabled = true;
} else {
writer = device.OpenEndpointWriter ((WriteEndpointID)ep.Descriptor.EndpointID);
}
}
}
public static void Main(string[] args)
{
ErrorCode ec = ErrorCode.None;
try
{
// Find and open the usb device.
MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder);
// 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)
// it will have an IUsbDevice interface. If not (WinUSB) the
// variable will be null indicating this is an interface of a
// device.
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(0);
}
// open read endpoint 1.
UsbEndpointReader reader = MyUsbDevice.OpenEndpointReader(ReadEndpointID.Ep01);
// open write endpoint 1.
UsbEndpointWriter writer = MyUsbDevice.OpenEndpointWriter(WriteEndpointID.Ep01);
// the write test data.
string testWriteString = "ABCDEFGH";
ErrorCode ecWrite;
ErrorCode ecRead;
int transferredOut;
int transferredIn;
UsbTransfer usbWriteTransfer;
UsbTransfer usbReadTransfer;
byte[] bytesToSend = Encoding.Default.GetBytes(testWriteString);
byte[] readBuffer = new byte[1024];
int testCount = 0;
do
{
// Create and submit transfer
ecRead = reader.SubmitAsyncTransfer(readBuffer, 0, readBuffer.Length, 100, out usbReadTransfer);
if (ecRead != ErrorCode.None) throw new Exception("Submit Async Read Failed.");
ecWrite = writer.SubmitAsyncTransfer(bytesToSend, 0, bytesToSend.Length, 100, out usbWriteTransfer);
if (ecWrite != ErrorCode.None)
{
usbReadTransfer.Dispose();
throw new Exception("Submit Async Write Failed.");
}
WaitHandle.WaitAll(new WaitHandle[] { usbWriteTransfer.AsyncWaitHandle, usbReadTransfer.AsyncWaitHandle },200,false);
if (!usbWriteTransfer.IsCompleted) usbWriteTransfer.Cancel();
if (!usbReadTransfer.IsCompleted) usbReadTransfer.Cancel();
ecWrite = usbWriteTransfer.Wait(out transferredOut);
ecRead = usbReadTransfer.Wait(out transferredIn);
usbWriteTransfer.Dispose();
usbReadTransfer.Dispose();
Console.WriteLine("Read :{0} ErrorCode:{1}", transferredIn, ecRead);
Console.WriteLine("Write :{0} ErrorCode:{1}", transferredOut, ecWrite);
Console.WriteLine("Data :" + Encoding.Default.GetString(readBuffer, 0, transferredIn));
testCount++;
} while (testCount < 5);
Console.WriteLine("\r\nDone!\r\n");
}
catch (Exception ex)
{
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.
IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
// Release interface #0.
wholeUsbDevice.ReleaseInterface(0);
}
MyUsbDevice.Close();
}
MyUsbDevice = null;
// Free usb resources
UsbDevice.Exit();
}
// Wait for user input..
Console.ReadKey();
}
}
public static void Main(string[] args)
{
ErrorCode ec = ErrorCode.None;
try
{
// Find and open the usb device.
MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder);
// 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(0);
}
// open read endpoint 1.
UsbEndpointReader reader = MyUsbDevice.OpenEndpointReader(ReadEndpointID.Ep01);
byte[] readBuffer = new byte[1024];
while (ec == ErrorCode.None)
{
int bytesRead;
// If the device hasn't sent data in the last 5 seconds,
// a timeout error (ec = IoTimedOut) will occur.
ec = reader.Read(readBuffer, 5000, out bytesRead);
if (bytesRead == 0) throw new Exception(string.Format("{0}:No more bytes!", ec));
Console.WriteLine("{0} bytes read", bytesRead);
// Write that output to the console.
Console.Write(Encoding.Default.GetString(readBuffer, 0, bytesRead));
}
Console.WriteLine("\r\nDone!\r\n");
}
catch (Exception ex)
{
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.
IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
// Release interface #0.
wholeUsbDevice.ReleaseInterface(0);
}
MyUsbDevice.Close();
}
MyUsbDevice = null;
// Free usb resources
UsbDevice.Exit();
}
// Wait for user input..
Console.ReadKey();
}
}
private bool DeviceInit(int vendorID, int productID, bool deviceReset = true)
{
try {
_vendorID = vendorID;
_productID = productID;
Device = UsbDevice.OpenUsbDevice(new UsbDeviceFinder(vendorID, productID));
if(Device == null) {
Main.SendDebug(string.Format("No Device Found with VendorID: 0x{0:X04} and ProductID: 0x{1:X04}", vendorID, productID));
Release();
return false;
}
if(deviceReset) {
Release();
Thread.Sleep(1000);
return DeviceInit(vendorID, productID, false);
}
DeviceConfigInfo = Device.Configs[0];
var wholeUsbDevice = Device as IUsbDevice;
if(!ReferenceEquals(wholeUsbDevice, null)) {
wholeUsbDevice.SetConfiguration(DeviceConfigInfo.Descriptor.ConfigID);
wholeUsbDevice.ClaimInterface(0);
}
_reader = Device.OpenEndpointReader((ReadEndpointID) 0x82);
ClearReadBuffer();
_writer = Device.OpenEndpointWriter((WriteEndpointID) 0x05);
UsbDevice.UsbErrorEvent += UsbDeviceOnUsbErrorEvent;
return true;
}
catch(Exception ex) {
Main.SendDebug(String.Format("Device Init exception occured: {0}", ex.Message));
throw;
}
}
public void OnDeviceNotifyEvent(object sender, DeviceNotifyEventArgs e)
{
// A Device system-level event has occured
//Console.SetCursorPosition(0, Console.CursorTop);
//MessageBox.Show(e.Device.IdVendor.ToString());
if (e.EventType == EventType.DeviceArrival && e.Device.IdVendor == 0x16C0 && e.Device.IdProduct == 0x05DD)
{
try
{
MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder);
if (MyUsbDevice == null)
{
//throw new Exception("Device Not Found.");
connected = false;
}
else
{
Device_l.Text = "Device: Connected";
connected = true;
Scan_b.Enabled = true;
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(0);
}
//MessageBox.Show(ReadEndpointID.Ep04.ToString());
reader = MyUsbDevice.OpenEndpointReader(ReadEndpointID.Ep01);
writer = MyUsbDevice.OpenEndpointWriter(WriteEndpointID.Ep01);
mode = 4;
backgroundWorker1.RunWorkerAsync();
}
}
catch (Exception ex)
{
MessageBox.Show((ec != ErrorCode.None ? ec + ":" : String.Empty) + ex.Message);
}
}
if (e.EventType == EventType.DeviceRemoveComplete && e.Device.IdVendor == 0x16C0 && e.Device.IdProduct == 0x05DD)
{
timer1.Enabled = false;
connected = false;
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.
IUsbDevice wholeUsbDevice = MyUsbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
// Release interface #0.
wholeUsbDevice.ReleaseInterface(0);
}
MyUsbDevice.Close();
}
MyUsbDevice = null;
// Free usb resources
UsbDevice.Exit();
Device_l.Text = "Device: Not Connected";
Scan_b.Enabled = false;
DumpRAM_b.Enabled = false;
DumpROM_b.Enabled = false;
WriteRAM_b.Enabled = false;
Banks_l.Text = "Banks: ";
MBC_l.Text = "MBC: ";
RAM_l.Text = "RAM Size: ";
Size_l.Text = "Size:";
Title_l.Text = "Title:";
}
}
// Console.WriteLine(e.ToString()); // Dump the event info to output.
//Console.WriteLine();
//Console.Write("[Press any key to exit]");
}
// USB connection and adapter management
public override void Open()
{
this.Close();
try
{
caLibUsbAdapter.write_lock.WaitOne();
usb_finder = new UsbDeviceFinder(this.vid, this.pid);
Debug.Assert(this.usb_finder != null);
// open device
usb_device = UsbDevice.OpenUsbDevice(usb_finder);
if (usb_device == null)
{
throw new Exception("No compatible adapters found");
}
wholeUsbDevice = usb_device as IUsbDevice;
if (!ReferenceEquals (wholeUsbDevice, null)) {
wholeUsbDevice.SetConfiguration(1);
wholeUsbDevice.ClaimInterface(1);
} else {
throw new Exception("Failed to claim interface");
}
// open endpoints
ep_reader = usb_device.OpenEndpointReader(this.read_ep_id);
ep_writer = usb_device.OpenEndpointWriter(this.write_ep_id);
if(ep_reader == null || ep_writer == null)
{
throw new Exception("Failed to open endpoints");
}
// clear garbage from input
this.ep_reader.ReadFlush();
// attach read event
ep_reader.DataReceived += (read_usb);
ep_reader.DataReceivedEnabled = true;
} catch (Exception e) {
this.Close();
throw e;
} finally {
caLibUsbAdapter.write_lock.ReleaseMutex();
}
}
public Form1()
{
InitializeComponent();
// Hook the device notifier event
UsbDeviceNotifier.OnDeviceNotify += OnDeviceNotifyEvent;
usb_command = new byte[64];
try
{
MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder);
if (MyUsbDevice == null)
{
//throw new Exception("Device Not Found.");
connected = false;
}
else
{
Device_l.Text = "Device: Connected";
connected = true;
Scan_b.Enabled = true;
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(0);
}
//MessageBox.Show(ReadEndpointID.Ep04.ToString());
reader = MyUsbDevice.OpenEndpointReader(ReadEndpointID.Ep01);
writer = MyUsbDevice.OpenEndpointWriter(WriteEndpointID.Ep01);
mode = 4;
backgroundWorker1.RunWorkerAsync();
}
}
catch (Exception ex)
{
MessageBox.Show((ec != ErrorCode.None ? ec + ":" : String.Empty) + ex.Message);
}
}
protected void OnOpen()
{
UsbDeviceFinder f = new UsbDeviceFinder(2334, 3);
_device = UsbDevice.OpenUsbDevice(f);
if (_device == null)
throw new Exception("Device not found");
IUsbDevice id = _device as IUsbDevice;
if (id == null)
throw new Exception("This is not a full usb device");
id.SetConfiguration(1);
id.ClaimInterface(0);
_irIN = _device.OpenEndpointReader(ReadEndpointID.Ep01);
_bulkOUT = _device.OpenEndpointWriter(WriteEndpointID.Ep02);
_bulkIN = _device.OpenEndpointReader(ReadEndpointID.Ep03);
}