void Setup()
{
if (UsbDev != null)
{
return;
}
UsbDev = FindDevice();
if (!UsbDev.SetConfiguration(1))
{
throw new M4ATXException("Failed to set device config");
}
if (!UsbDev.ClaimInterface(0))
{
throw new M4ATXException("Failed to claim interface #0");
}
if (!UsbDev.SetAltInterface(0))
{
throw new M4ATXException("Failed to set alternate interface to 0");
}
Writer = UsbDev.OpenEndpointWriter(WriteEndpointID.Ep01);
Reader = UsbDev.OpenEndpointReader(ReadEndpointID.Ep01);
}
void trinket_OnConnect(object sender, EventArgs e)
{
notifyIcon.ShowBalloonTip(1000, "Trinket Fake USB Serial", "USB Device Connected", ToolTipIcon.Info);
if (trinket.TryConnect())
{
try
{
if (trinket.MyUsbDevice.IsOpen == false)
{
if (trinket.MyUsbDevice.Open() == false)
{
throw new Exception("Can't Open USB Device");
}
}
trinketReader = trinket.MyUsbDevice.OpenEndpointReader(LibUsbDotNet.Main.ReadEndpointID.Ep01);
trinketReader.DataReceived += new EventHandler <LibUsbDotNet.Main.EndpointDataEventArgs>(trinket_DataReceived);
trinketReader.DataReceivedEnabled = true;
}
catch (Exception ex)
{
notifyIcon.ShowBalloonTip(1000, "Trinket Fake USB Serial", "Trinket Connecting Error: " + ex.Message, ToolTipIcon.Error);
}
}
}
internal void ClosePort()
{
lock (lock_access)
{
if (Is_opened)
{
oldDevice.Enqueue(srb_reader);
srb_reader.Flush();
srb_reader.Dispose();
srb_reader = null;
oldDevice.Enqueue(srb_writer);
srb_writer.Flush();
srb_writer.Dispose();
srb_writer = null;
IUsbDevice wholeUsbDevice = selected_device as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
// Release interface #0.
wholeUsbDevice.ReleaseInterface(0);
wholeUsbDevice.ReleaseInterface((1 | 0x80));
wholeUsbDevice.ReleaseInterface(2);
wholeUsbDevice.Close();
oldDevice.Enqueue(selected_device);
selected_device.Close();
selected_device = null;
}
}
}
}
private void CloseDevice()
{
if (_sensorRead != null)
{
_sensorRead.DataReceivedEnabled = false;
_sensorRead.DataReceived -= SensorRead;
_sensorRead.Device.Close();
_sensorRead.Dispose();
}
_sensorRead = null;
if (_controlRead != null)
{
_controlRead.DataReceivedEnabled = false;
_controlRead.DataReceived -= ControlRead;
_controlRead.Dispose();
}
_controlRead = null;
if (_controlWrite != null)
{
_controlWrite.Dispose();
_controlWrite.Device.Close();
}
_controlWrite = null;
UsbDevice.Exit();
PostActions.Clear();
}
private void ButtonEp03Int_Click(object sender, EventArgs e)
{
try
{
if (!_ep3InterupEnable)
{
_epReader = _device.OpenEndpointReader(ReadEndpointID.Ep03, 256, EndpointType.Interrupt);
_epReader.DataReceived += EndpointReader_DataReceived;
_epReader.DataReceivedEnabled = true;
//var data = Encoding.ASCII.GetBytes("Test String");
//var lenTransfer = 0;
//_epWriter = MyUsbDevice.OpenEndpointWriter(WriteEndpointID.Ep03, EndpointType.Interrupt);
//_epWriter.Write(data, 500, out lenTransfer);
_ep3InterupEnable = true;
AppendEventLog("End Point 03 Interupt Enable");
}
else
{
_ep3InterupEnable = false;
_epReader.DataReceivedEnabled = false;
_epReader.DataReceived -= EndpointReader_DataReceived;
_epReader.Abort();
AppendEventLog("End Point 03 Interupt Disable");
}
}
catch (Exception ex)
{
PopupException(ex.Message);
}
}
public bool Connect()
{
bool rv = false;
rv = false;
Disconnect();
MyUSBDeviceFinder = new UsbDeviceFinder(DevVID, DevPID, DevRevision, DevSerialNumber, DevGUID);
MyUSBDevice = UsbDevice.OpenUsbDevice(MyUSBDeviceFinder);
if (MyUSBDevice != null)
{
WholeUSBDevice = MyUSBDevice as IUsbDevice;
if (!ReferenceEquals(WholeUSBDevice, null))
{
WholeUSBDevice.SetConfiguration(1);
WholeUSBDevice.ClaimInterface(0);
}
MyUSBWriter = MyUSBDevice.OpenEndpointWriter(WriteEndpointID.Ep01);
MyUSBReader = MyUSBDevice.OpenEndpointReader(ReadEndpointID.Ep01, 4096);
MyUSBReader.DataReceived += MyUSBReader_DataReceived;
MyUSBReader.DataReceivedEnabled = true;
MyUSBSetupPacket.RequestType = (byte)(UsbCtrlFlags.RequestType_Vendor | UsbCtrlFlags.Recipient_Interface | UsbCtrlFlags.Direction_In);
MyUSBSetupPacket.Request = 1;
MyUSBSetupPacket.Value = 0;
MyUSBSetupPacket.Length = 4;
bkThread = new System.Threading.Thread(this.Th_DoWork);
bkThExit = false;
bkThread.Start();
rv = true;
}
return(rv);
}
public void CloseDevice()
{
if (_usbDevice == null || !_usbDevice.IsOpen)
{
return;
}
if (_epReader != null)
{
_epReader.Dispose();
_epReader = null;
}
if (_epWriter != null)
{
_epWriter.Abort();
_epWriter.Dispose();
_epWriter = null;
}
// 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))
{
wholeUsbDevice.ReleaseInterface(0); // Release interface #0.
}
_usbDevice.Close();
_usbDevice = null;
}
public static void Update(Record Record)
{
if (MyUsbDevice == null)
{
/* we failed to connect to M4ATX device, nothing to do here */
return;
}
UsbEndpointWriter writer = MyUsbDevice.OpenEndpointWriter(WriteEndpointID.Ep01);
// specify data to send
ec = writer.Write(new byte[] { 0x81, 0x00 }, 5000, out bytesWritten);
if (ec != ErrorCode.None)
{
throw new Exception("M4ATX: Error sending command: " + ec);
}
// open read endpoint 1.
UsbEndpointReader reader = MyUsbDevice.OpenEndpointReader(ReadEndpointID.Ep01);
// If the device hasn't sent data in the last 5 seconds,
// a timeout error (ec = IoTimedOut) will occur.
reader.Read(readBuffer, 3000, out bytesRead);
if (ec != ErrorCode.None || bytesRead != readBuffer.Length)
{
var msg = string.Format("M4ATX: Error reading result, error {0}, got {1} bytes",
ec, bytesRead);
throw new Exception(msg);
}
Record.Set(Record.DataPoint.M4ATXTemperature, readBuffer[12]);
Record.Set(Record.DataPoint.M4ATXVoltageIn, readBuffer[2]);
}
public override bool Open()
{
try
{
UsbDeviceFinder MyUsbFinder = new UsbDeviceFinder(((UsbConfigModel)Configuration).PID, ((UsbConfigModel)Configuration).VID);
UsbRegistry myUsbRegistry = UsbDevice.AllWinUsbDevices.Find(MyUsbFinder);
if (myUsbRegistry is null)
{
return(false);
}
// Open this usb device.
_dev = UsbDevice.OpenUsbDevice(MyUsbFinder) as IUsbDevice;
_dev.SetConfiguration(1);
_dev.ClaimInterface(0);
_writer = _dev.OpenEndpointWriter(WriteEndpointID.Ep01);
_reader = _dev.OpenEndpointReader(ReadEndpointID.Ep01);
}
catch (Exception exp)
{
throw new Exception(exp.ToString());
}
return(true);
}
/// <summary>
/// Initializes the device via LibUSB, and sets the refresh interval of the controller data
/// </summary>
/// <param name="Interval">The interval that the device is polled for information.</param>
public void Init(int Interval)
{
//ErrorCode ec = ErrorCode.None;
// Find and open the usb device.
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);
}
reader = MyUsbDevice.OpenEndpointReader(ReadEndpointID.Ep02);
writer = MyUsbDevice.OpenEndpointWriter(WriteEndpointID.Ep01);
ButtonMasks.InitializeMasks();
SetPollingInterval(Interval);
pollTimer.Elapsed += new ElapsedEventHandler(pollTimer_Elapsed);
pollTimer.Start();
TestLEDs();
RefreshLEDState();
}
private void closeTestDevice(object state)
{
if (!ReferenceEquals(mUsbDevice, null))
{
if (mUsbDevice.IsOpen)
{
mEP1Reader.DataReceived -= OnDataReceived;
stopReadWrite();
mUsbDevice.ActiveEndpoints.Clear();
UsbDevice.UsbErrorEvent -= OnUsbError;
// 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))
{
// Release interface #0.
wholeUsbDevice.ReleaseInterface(0);
}
mUsbDevice.Close();
}
mUsbDevice = null;
mEP1Reader = null;
mEP1Writer = null;
}
cmdOpenClose.Text = "Open";
panDevice.Enabled = false;
}
public override void Close()
{
try {
write_lock.WaitOne();
if (ep_reader != null)
{
// detach read event
ep_reader.DataReceivedEnabled = false;
ep_reader.DataReceived -= (read_usb);
}
ep_reader = null;
ep_writer = null;
if (IsOpen())
{
// close devices
usb_device.Close();
wholeUsbDevice.ReleaseInterface(1);
wholeUsbDevice.Close();
}
// release devices
usb_device = null;
wholeUsbDevice = null;
UsbDevice.Exit();
} catch (Exception) {
// Ignore everything
} finally {
write_lock.ReleaseMutex();
}
}
public override void Close()
{
if (_reader != null)
{
_reader.Abort();
_reader = null;
}
if (_writer != null)
{
_writer.Abort();
_writer = null;
}
if (_usbDevice != null)
{
if (_usbDevice.IsOpen)
{
_usbDevice.Close();
}
_usbDevice = null;
UsbDevice.Exit();
}
}
public void closeDevice()
{
if (mUsbDevice != null)
{
if (mUsbDevice.IsOpen)
{
if (mEpReader != null)
{
mEpReader.DataReceivedEnabled = false;
mEpReader.DataReceived -= mEp_DataReceived;
mEpReader.Dispose();
mEpReader = null;
}
if (mEpWriter != null)
{
mEpWriter.Abort();
mEpWriter.Dispose();
mEpWriter = null;
}
// 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))
{
// Release interface #0.
wholeUsbDevice.ReleaseInterface(0);
}
mUsbDevice.Close();
mUsbDevice = null;
}
}
}
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 async Task <bool> GetDevice(UsbContext context)
{
Console.WriteLine("Looking for device ...");
// Dump all devices and descriptor information to console output.
foreach (var usbDevice in context.List())
{
if (usbDevice.TryOpen())
{
if (usbDevice.Info.Manufacturer == mfrName)
{
device = usbDevice;
if (usbDevice.ClaimInterface(interfaceID))
{
monitorBuddyDevice = usbDevice;
// Console.WriteLine($"Device open, interface 0 claimed: {device.ToString()}");
endpointReader = monitorBuddyDevice.OpenEndpointReader(ReadEndpointID.Ep01, endpointBufferSize, EndpointType.Interrupt);
return(true);
}
}
}
}
await Task.Delay(2000);
return(false);
}
public static void InitializeUSBDevice()
{
// Use the USB device finder to find our Gamecube adapter
_usbDevice = UsbDevice.OpenUsbDevice(_usbDeviceFinder);
if (_usbDevice == null)
{
// If the gamecube adapter isn't plugged in OR is being used by another application, throw an exception.
// Is there even a way to take control over the adapter from another device?
throw new Exception(Strings.ERROR_ADAPTERNOTFOUND);
}
IUsbDevice wholeUsbDevice = _usbDevice as IUsbDevice;
if (!ReferenceEquals(wholeUsbDevice, null))
{
wholeUsbDevice.SetConfiguration(1); // Set the adapter to use config one
wholeUsbDevice.ClaimInterface(0); // Claim interface zero
}
// Set reader to read from endpoint 1 (apparently GCN adapters use endpoint 0x81, but this works?)
_controllerReader = _usbDevice.OpenEndpointReader(ReadEndpointID.Ep01);
// Write to endpoint 2
_controllerWriter = _usbDevice.OpenEndpointWriter(WriteEndpointID.Ep02);
// begin polling command - https://gbatemp.net/threads/wii-u-gamecube-adapter-reverse-engineering-cont.388169/
_controllerWriter.Write(Convert.ToByte(0x13), 5000, out int transferLength);
}
/// <summary>
/// Initializes a new instance of the <see cref="LCTFDevice"/> class.
/// </summary>
/// <param name="underlyingWinUsbDevice">The underlying <see cref="UsbDevice"/>.</param>
public LCTFDevice(UsbDevice underlyingWinUsbDevice)
{
this.usbDevice = underlyingWinUsbDevice ?? throw new ArgumentNullException(nameof(underlyingWinUsbDevice));
this.InstanceId = underlyingWinUsbDevice.DevicePath;
this.DeviceInfo = this.GetDeviceInfo();
if (this.DeviceInfo.FirmwareVersion < 107)
{
throw new NotSupportedException("This library only supports LCTF firmware v1.07 or newer and cannot be used with older versions.");
}
this.WavelengthMin = (int)(this.GetFloat((byte)CommandIndices.WavelengthMin) + 0.5f);
this.WavelengthMax = (int)(this.GetFloat((byte)CommandIndices.WavelengthMax) + 0.5f);
this.WavelengthStep = (int)(this.GetFloat((byte)CommandIndices.WavelengthStep) + 0.5f);
UsbDevice.UsbErrorEvent += this.UsbDevice_UsbErrorEvent;
// Set up reader for interrupts
this.interruptReader = this.usbDevice.OpenEndpointReader(ReadEndpointID.Ep02);
this.interruptReader.DataReceivedEnabled = true;
this.interruptReader.DataReceived += this.Reader_DataReceived;
// Turn on all the normal features
this.SetFilterEnable(true);
this.SetAutotune(true);
this.SetOUStatus(true);
}
public void Disconnect()
{
if (bkThread != null)
{
bkThExit = true;
bkThInterrupt.Set();
if (bkThread.ThreadState == System.Threading.ThreadState.Running)
{
bkThread.Join();
}
}
bkThread = null;
if (MyUSBDevice != null)
{
if (MyUSBDevice.IsOpen)
{
WholeUSBDevice = MyUSBDevice as IUsbDevice;
if (!ReferenceEquals(WholeUSBDevice, null))
{
WholeUSBDevice.ReleaseInterface(0);
}
MyUSBReader.DataReceivedEnabled = false;
MyUSBReader.DataReceived -= MyUSBReader_DataReceived;
MyUSBDevice.Close();
}
MyUSBDevice = null;
WholeUSBDevice = null;
MyUSBDeviceFinder = null;
MyUSBReader = null;
MyUSBWriter = null;
}
}
private static void InitalizeAndVerify()
{
bool Success = false;
while (Success == false)
{
Writer = DI_2008.OpenEndpointWriter(WriteEndpointID.Ep01);
Reader = DI_2008.OpenEndpointReader(ReadEndpointID.Ep01);
//No clue what these do but they keep the device from hanging on program restarts #TrialAndError
Writer.Abort();
Writer.Reset();
Writer.Flush();
Reader.Abort();
Reader.ReadFlush();
Reader.Flush();
Reader.Reset();
InternalFunctions.Write("stop"); //Make sure the device wasnt left in a scan state
try
{
var DeviceResponding = InternalFunctions.Write("info 0");
Success = DeviceResponding.Contains("DATAQ");
}
catch { }
}
}
private void Start()
{
var USBFinder = new UsbDeviceFinder(0x057E, 0x0337);
GCNAdapter = UsbDevice.OpenUsbDevice(USBFinder);
if (GCNAdapter != null)
{
reader = GCNAdapter.OpenEndpointReader(ReadEndpointID.Ep01);
writer = GCNAdapter.OpenEndpointWriter(WriteEndpointID.Ep02);
//prompt controller to start sending
writer.Write(Convert.ToByte((char)19), 10, out transferLength);
// PORT 1: bytes 02-09
// PORT 2: bytes 11-17
// PORT 3: bytes 20-27
// PORT 4: bytes 29-36l
ReadBuffer = new byte[37]; // 32 (4 players x 8) bytes for input, 5 bytes for formatting
//WriteBuffer = new byte[5]; // 1 for command, 4 for rumble state
//WriteBuffer[0] = 0x11;
//WriteBuffer[1] = 0;
reader.ReadThreadPriority = System.Threading.ThreadPriority.Highest;
reader.Flush();
gcThread = new Thread(() => inputUpdate(ref ReadBuffer));
gcThread.Start();
}
else
{
UnityEngine.Debug.Log("ERROR: Could not detect device WUP-028 Gamecube Controller Adapter.");
}
}
public bool OpenDevice()
{
MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder);
if (MyUsbDevice == null)
{
return(false);
}
#region 当设备是一个 "whole" 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 = 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);
}
#endregion
reader = MyUsbDevice.OpenEndpointReader(ReadEndpointID.Ep02);
reader.ReadBufferSize = nReadBufSize;
writer = MyUsbDevice.OpenEndpointWriter(WriteEndpointID.Ep01);
return(true);
}
public async Task InitializeAsync()
{
if (disposed)
{
throw new Exception(DeviceBase.DeviceDisposedErrorMessage);
}
await Task.Run(() =>
{
//TODO: Error handling etc.
UsbDevice.Open();
//TODO: This is far beyond not cool.
if (UsbDevice is MonoUsbDevice monoUsbDevice)
{
monoUsbDevice.ClaimInterface(0);
}
else if (UsbDevice is WinUsbDevice winUsbDevice)
{
//Doesn't seem necessary in this case...
}
else
{
((IUsbDevice)UsbDevice).ClaimInterface(0);
}
_UsbEndpointWriter = UsbDevice.OpenEndpointWriter(WriteEndpointID.Ep01);
_UsbEndpointReader = UsbDevice.OpenEndpointReader(ReadEndpointID.Ep01);
ReadPacketSize = _UsbEndpointReader.EndpointInfo.Descriptor.MaxPacketSize;
IsInitialized = true;
});
}
private bool OpenCustomDevice(out WinUsbDevice usb, out UsbEndpointReader reader, out UsbEndpointWriter writer)
{
usb = null;
reader = null;
writer = null;
var device = UsbDevice.AllWinUsbDevices.FirstOrDefault(d => d.Vid == 0x1974 && d.Pid == 0x0001) as WinUsbRegistry;
if (device != null)
{
if (device.Open(out usb))
{
writer = usb.OpenEndpointWriter(WriteEndpointID.Ep01);
writer.Reset();
writer.Flush();
reader = usb.OpenEndpointReader(ReadEndpointID.Ep01);
reader.Reset();
reader.Flush();
reader.ReadBufferSize = 32;
reader.DataReceived += CustomDataReceived;
reader.DataReceivedEnabled = true;
return(true);
}
}
return(false);
}
private void HeadsetReader_DataReceived(object sender, EndpointDataEventArgs e)
{
var buffer = new byte[e.Count];
Array.Copy(e.Buffer, 0, buffer, 0, buffer.Length);
UsbEndpointReader reader = sender as UsbEndpointReader;
if (reader != null)
{
//Find the slot this belongs to
int?index = null;
foreach (var slot in _slots)
{
if (slot.Value.DataReader == reader)
{
index = slot.Key;
break;
}
}
if (index.HasValue)
{
if (HeadsetDataReceived != null)
{
HeadsetDataReceived(this, new DataReceivedEventArgs(index.Value, buffer));
}
}
}
}
/// <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);
// create the otp reader object
this.myOTPreader = new OTPreader(this);
// create a saved track reader to get a list of saved tracks
this.trackReader = new SavedTrackReader(this);
this.trackList = trackReader.trackList;
// get the record table data
tableReader = new RecordTableReader(this);
tableReader.readRecordTable();
this.recordTableList = tableReader.recordTable;
}
/// <summary>
/// Open connection to the device
/// </summary>
public void OpenDevice()
{
MyUsbDevice = UsbDevice.OpenUsbDevice(MyUsbFinder);
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.
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 1.
writer = MyUsbDevice.OpenEndpointWriter(WriteEndpointID.Ep02);
}
private void USB_init()
{
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);
}
reader1 = MyUsbDevice.OpenEndpointReader(ReadEndpointID.Ep01);
writer1 = MyUsbDevice.OpenEndpointWriter(WriteEndpointID.Ep01);
// Setup trigger
USB_receive = new Thread(USBReceive);
// open read endpoint 1.
USB_receive.Start();
button1Enable(true);
}
public bool Reset()
{
bool ret = true;
Close();
//Start message thread
_messageThread = new Thread(new ThreadStart(_SendMessages));
_messageThread.IsBackground = true;
_messageThread.Start();
//Find device
_device = UsbDevice.OpenUsbDevice(new UsbDeviceFinder(_VENDOR_ID, _PRODUCT_ID)) as IUsbDevice;
if (_device != null)
{
//Set up the incoming and outgoing endpoints
_reader = _device.OpenEndpointReader(LibUsbDotNet.Main.ReadEndpointID.Ep03);
_reader.DataReceived += _reader_DataReceived;
_reader.DataReceivedEnabled = true;
lock (_writerLock)
{
_writer = _device.OpenEndpointWriter(LibUsbDotNet.Main.WriteEndpointID.Ep02);
}
}
else
{
ret = false;
}
return(ret);
}
public bool Open()
{
if (IsOpen)
{
return(false);
}
if (!_Device.Open())
{
return(false);
}
IUsbDevice whole = _Device as IUsbDevice;
if (!ReferenceEquals(whole, null))
{
if (!whole.SetConfiguration(ConfigurationID) || !whole.ClaimInterface(InterfaceID))
{
_Device.Close();
throw new PTPException("could not set USB device configuration and interface to " + ConfigurationID + " and " + InterfaceID + ", respectively");
}
}
Writer = _Device.OpenEndpointWriter(WriterEndpointID);
Reader = _Device.OpenEndpointReader(ReaderEndpointID);
return(true);
}
