public override void Open(UsbDeviceConnection connection) { _connection = connection; _controlInterface = Device.GetInterface(0); if (!connection.ClaimInterface(_controlInterface, true)) { throw new Exception("Could not claim control interface."); } _controlEndpoint = _controlInterface.GetEndpoint(0); _dataInterface = Device.GetInterface(1); if (!connection.ClaimInterface(_dataInterface, true)) { throw new Exception("Could not claim data interface."); } if (Device.VendorId == 0x1cbe) { _writeEndpoint = _dataInterface.GetEndpoint(1); _readEndpoint = _dataInterface.GetEndpoint(0); } else { _writeEndpoint = _dataInterface.GetEndpoint(0); _readEndpoint = _dataInterface.GetEndpoint(1); } Init(); var buadSet = SetBaudrate(960000); }
internal virtual void OpenInterface() { Log.Debug(nameof(CdcAcmSerialDriver), "claiming interfaces, count=" + _driver.Device.InterfaceCount); _controlInterface = _driver.Device.GetInterface(0); Log.Debug(nameof(CdcAcmSerialDriver), "Control iface=" + _controlInterface); if (!_connection.ClaimInterface(_controlInterface, true)) { throw new UsbSerialException("Could not claim control interface."); } _controlEndpoint = _controlInterface.GetEndpoint(0); Log.Debug(nameof(CdcAcmSerialDriver), "Control endpoint direction: " + _controlEndpoint.Direction); Log.Debug(nameof(CdcAcmSerialDriver), "Claiming data interface."); _dataInterface = _driver.Device.GetInterface(1); Log.Debug(nameof(CdcAcmSerialDriver), "data iface=" + _dataInterface); if (!_connection.ClaimInterface(_dataInterface, true)) { throw new UsbSerialException("Could not claim data interface."); } _readEndpoint = _dataInterface.GetEndpoint(1); Log.Debug(nameof(CdcAcmSerialDriver), "Read endpoint direction: " + _readEndpoint.Direction); _writeEndpoint = _dataInterface.GetEndpoint(0); Log.Debug(nameof(CdcAcmSerialDriver), "Write endpoint direction: " + _writeEndpoint.Direction); }
private void openInterface() { Log.Debug(TAG, "claiming interfaces, count=" + mDevice.InterfaceCount); mControlInterface = mDevice.GetInterface(0); Log.Debug(TAG, "Control iface=" + mControlInterface); // class should be USB_CLASS_COMM if (!mConnection.ClaimInterface(mControlInterface, true)) { throw new IOException("Could not claim control interface."); } mControlEndpoint = mControlInterface.GetEndpoint(0); Log.Debug(TAG, "Control endpoint direction: " + mControlEndpoint.Direction); Log.Debug(TAG, "Claiming data interface."); mDataInterface = mDevice.GetInterface(1); Log.Debug(TAG, "data iface=" + mDataInterface); // class should be USB_CLASS_CDC_DATA if (!mConnection.ClaimInterface(mDataInterface, true)) { throw new IOException("Could not claim data interface."); } mReadEndpoint = mDataInterface.GetEndpoint(1); Log.Debug(TAG, "Read endpoint direction: " + mReadEndpoint.Direction); mWriteEndpoint = mDataInterface.GetEndpoint(0); Log.Debug(TAG, "Write endpoint direction: " + mWriteEndpoint.Direction); }
public override void Open(UsbDeviceConnection connection) { if (mConnection != null) { throw new IOException("Already opened."); } mConnection = connection; bool opened = false; bool controlInterfaceFound = false; try { for (var i = 0; i < mDevice.InterfaceCount; i++) { mControlInterface = mDevice.GetInterface(i); if (mControlInterface.InterfaceClass == UsbClass.Comm) { if (!mConnection.ClaimInterface(mControlInterface, true)) { throw new IOException("Could not claim control interface"); } (Driver as STM32SerialDriver).mCtrlInterf = i; controlInterfaceFound = true; break; } } if (!controlInterfaceFound) { throw new IOException("Could not claim control interface"); } for (var i = 0; i < mDevice.InterfaceCount; i++) { mDataInterface = mDevice.GetInterface(i); if (mDataInterface.InterfaceClass == UsbClass.CdcData) { if (!mConnection.ClaimInterface(mDataInterface, true)) { throw new IOException("Could not claim data interface"); } mReadEndpoint = mDataInterface.GetEndpoint(1); mWriteEndpoint = mDataInterface.GetEndpoint(0); opened = true; break; } } if (!opened) { throw new IOException("Could not claim data interface."); } } finally { if (!opened) { mConnection = null; } } }
private void getEndpoint(UsbDeviceConnection connection, UsbInterface intf) { if (intf.GetEndpoint(1) != null) { epOut = intf.GetEndpoint(1); } if (intf.GetEndpoint(0) != null) { epIn = intf.GetEndpoint(0); } }
/** * 分配端点,IN | OUT,即输入输出;此处我直接用1为OUT端点,0为IN,当然你也可以通过判断 */ private void assignEndpoint() { if (myInterface.GetEndpoint(1) != null) { epOut = myInterface.GetEndpoint(1); } if (myInterface.GetEndpoint(0) != null) { epIn = myInterface.GetEndpoint(0); } //Log.Debug(TAG, getString(R.string.text)); }
public CardReader(UsbDevice device) { _device = device; _interface = device.GetInterface(0); for (var i = 0; i < _interface.EndpointCount; i++) { var endpoint = _interface.GetEndpoint(i); switch (endpoint.Direction) { case UsbAddressing.In when endpoint.Type == UsbAddressing.XferInterrupt: _interruptPipe = endpoint; break; case UsbAddressing.In when endpoint.Type == UsbAddressing.XferBulk: _bulkInPipe = endpoint; _receiveBuffer = new byte[_bulkInPipe.MaxPacketSize]; break; case UsbAddressing.Out when endpoint.Type == UsbAddressing.XferBulk: _bulkOutPipe = endpoint; break; } } SupportsInterrupt = _interruptPipe != null; }
/// <summary> /// Retreive bulk Enpoints from the interface /// </summary> /// <param name="usbIface"></param> /// <param name="epIn"></param> /// <param name="epOut"></param> /// <returns></returns> protected int InterfaceGetBulkEndpoints(UsbInterface usbIface, ref UsbEndpoint epIn, ref UsbEndpoint epOut) { int i; int ret; // We iterate over over the interface endpoint to find bulk in and out for (i = 0, ret = 0; (i < usbIface.EndpointCount) && (ret < 2); i++) { UsbEndpoint ep = usbIface.GetEndpoint(i); if (ep.Type == UsbAddressing.XferBulk) { if (ep.Direction == UsbAddressing.In) { epIn = ep; ret++; } else if (ep.Direction == UsbAddressing.Out) { epOut = ep; ret++; } } } // Did we find the two needed endpoints ? return((ret == 2) ? 0 : -1); }
private bool openCP2130() { if (connection.ClaimInterface(mInterface, true)) { Log.Info(CLASS_ID, "Interface succesfully claimed"); } else { Log.Info(CLASS_ID, "Interface could not be claimed"); return(false); } // Assign endpoints int numberEndpoints = mInterface.EndpointCount; for (int i = 0; i <= numberEndpoints - 1; i++) { UsbEndpoint endpoint = mInterface.GetEndpoint(i); if (endpoint.Type == UsbAddressing.XferBulk && endpoint.Direction == UsbAddressing.In) { inEndpoint = endpoint; } else { outEndpoint = endpoint; } } return(true); }
public async Task <bool> OpenAsync() { if (connected) { return(false); } //usbManager.RequestPermission(usbDevice, PendingIntent.GetBroadcast(ConnectionService.Instance.Context, 0, new Intent(ConnectionService.Instance.ActionUsbPermission), PendingIntentFlags.CancelCurrent)); UsbInterface intf = usbDevice.GetInterface(0); pinReportEndpoint = intf.GetEndpoint(0); peripheralResponseEndpoint = intf.GetEndpoint(1); pinConfigEndpoint = intf.GetEndpoint(2); peripheralConfigEndpoint = intf.GetEndpoint(3); connection = usbManager.OpenDevice(usbDevice); if (connection != null) { bool intfClaimed = connection.ClaimInterface(intf, true); if (intfClaimed) { connected = true; pinListenerThread = new Thread( () => { byte[] data = new byte[64]; pinListenerThreadRunning = true; while (pinListenerThreadRunning) { int res = connection.BulkTransfer(pinReportEndpoint, data, 41, 100); // pin reports are 41 bytes long now if (res > 0) { this.PinEventDataReceived?.Invoke(data); } } }); pinListenerThread.Start(); return(true); } } return(false); }
public override void Open(UsbDeviceConnection connection) { if (_connection != null) { throw new UsbSerialException("Already opened."); } _connection = connection; bool opened = false; try { for (int i = 0; i < _driver.Device.InterfaceCount; i++) { UsbInterface usbIface = _driver.Device.GetInterface(i); Log.Debug(nameof(Ch34xSerialDriver), _connection.ClaimInterface(usbIface, true) ? $"claimInterface {i} SUCCESS" : $"claimInterface {i} FAIL"); } UsbInterface dataIface = _driver.Device.GetInterface(_driver.Device.InterfaceCount - 1); for (int i = 0; i < dataIface.EndpointCount; i++) { UsbEndpoint ep = dataIface.GetEndpoint(i); if (ep.Type.IsEqualTo(ExtendedUsbConstants.USB_ENDPOINT_XFER_BULK)) { if (ep.Direction.IsEqualTo(ExtendedUsbConstants.USB_DIR_IN)) { _readEndpoint = ep; } else { _writeEndpoint = ep; } } } Initialize(); BaudRate = DEFAULT_BAUD_RATE; opened = true; } finally { if (!opened) { try { Close(); } catch (UsbSerialException) { //Swallowing this exception for now } } } }
public override void Open(UsbDeviceConnection connection) { if (_connection != null) { throw new UsbSerialException("Already opened."); } _connection = connection; bool opened = false; try { for (int i = 0; i < _driver.Device.InterfaceCount; i++) { UsbInterface usbIface = _driver.Device.GetInterface(i); Log.Debug(nameof(Cp21xxSerialDriver), _connection.ClaimInterface(usbIface, true) ? $"claimInterface {i} SUCCESS" : $"claimInterface {i} FAIL"); } UsbInterface dataIface = _driver.Device.GetInterface(_driver.Device.InterfaceCount - 1); for (int i = 0; i < dataIface.EndpointCount; i++) { UsbEndpoint ep = dataIface.GetEndpoint(i); if (ep.Type.IsEqualTo(ExtendedUsbConstants.USB_ENDPOINT_XFER_BULK)) { if (ep.Direction.IsEqualTo(ExtendedUsbConstants.USB_DIR_IN)) { _readEndpoint = ep; } else { _writeEndpoint = ep; } } } SetConfigSingle(SILABSER_IFC_ENABLE_REQUEST_CODE, UART_ENABLE); SetConfigSingle(SILABSER_SET_MHS_REQUEST_CODE, MCR_ALL | CONTROL_WRITE_DTR | CONTROL_WRITE_RTS); SetConfigSingle(SILABSER_SET_BAUDDIV_REQUEST_CODE, BAUD_RATE_GEN_FREQ / DEFAULT_BAUD_RATE); opened = true; } finally { if (!opened) { try { Close(); } catch (UsbSerialException) { //Swallowing this exception for now } } } }
public override void Open() { bool openedSuccessfully = false; try { CreateConnection(); for (int i = 0; i < UsbDevice.InterfaceCount; i++) { UsbInterface usbIface = UsbDevice.GetInterface(i); if (Connection.ClaimInterface(usbIface, true)) { Log.Debug(TAG, "ClaimInterface " + i + " SUCCESS"); } else { Log.Debug(TAG, "ClaimInterface " + i + " FAIL"); } } UsbInterface dataIface = UsbDevice.GetInterface(UsbDevice.InterfaceCount - 1); for (int i = 0; i < dataIface.EndpointCount; i++) { UsbEndpoint ep = dataIface.GetEndpoint(i); if (ep.Type == UsbAddressing.XferBulk) { // UsbConstants.USB_ENDPOINT_XFER_BULK if (ep.Direction == UsbAddressing.In) { // UsbConstants.USB_DIR_IN ReadEndpoint = ep; } else { WriteEndpoint = ep; } } } setConfigSingle(SILABSER_IFC_ENABLE_REQUEST_CODE, UART_ENABLE); setConfigSingle(SILABSER_SET_MHS_REQUEST_CODE, MCR_ALL | CONTROL_WRITE_DTR | CONTROL_WRITE_RTS); setConfigSingle(SILABSER_SET_BAUDDIV_REQUEST_CODE, BAUD_RATE_GEN_FREQ / DEFAULT_BAUD_RATE); ResetParameters(); openedSuccessfully = true; } finally { if (openedSuccessfully) { IsOpened = true; StartUpdating(); } else { CloseConnection(); } } }
internal virtual void OpenSingleInterface() { _controlInterface = _driver.Device.GetInterface(0); Log.Debug(nameof(CdcAcmSerialDriver), "Control iface=" + _controlInterface); _dataInterface = _driver.Device.GetInterface(0); Log.Debug(nameof(CdcAcmSerialDriver), "data iface=" + _dataInterface); if (!_connection.ClaimInterface(_controlInterface, true)) { throw new UsbSerialException("Could not claim shared control/data interface."); } int endCount = _controlInterface.EndpointCount; if (endCount < 3) { Log.Debug(nameof(CdcAcmSerialDriver), "not enough endpoints - need 3. count=" + _controlInterface.EndpointCount); throw new UsbSerialException("Insufficient number of endpoints(" + _controlInterface.EndpointCount + ")"); } _controlEndpoint = null; _readEndpoint = null; _writeEndpoint = null; for (int i = 0; i < endCount; ++i) { UsbEndpoint ep = _controlInterface.GetEndpoint(i); if ((ep.Direction.IsEqualTo(ExtendedUsbConstants.USB_DIR_IN)) && (ep.Type.IsEqualTo(ExtendedUsbConstants.USB_ENDPOINT_XFER_INT))) { Log.Debug(nameof(CdcAcmSerialDriver), "Found controlling endpoint"); _controlEndpoint = ep; } else if ((ep.Direction.IsEqualTo(ExtendedUsbConstants.USB_DIR_IN)) && (ep.Type.IsEqualTo(ExtendedUsbConstants.USB_ENDPOINT_XFER_BULK))) { Log.Debug(nameof(CdcAcmSerialDriver), "Found reading endpoint"); _readEndpoint = ep; } else if ((ep.Direction.IsEqualTo(ExtendedUsbConstants.USB_DIR_OUT)) && (ep.Type.IsEqualTo(ExtendedUsbConstants.USB_ENDPOINT_XFER_BULK))) { Log.Debug(nameof(CdcAcmSerialDriver), "Found writing endpoint"); _writeEndpoint = ep; } if ((_controlEndpoint != null) && (_readEndpoint != null) && (_writeEndpoint != null)) { Log.Debug(nameof(CdcAcmSerialDriver), "Found all required endpoints"); break; } } if ((_controlEndpoint == null) || (_readEndpoint == null) || (_writeEndpoint == null)) { Log.Debug(nameof(CdcAcmSerialDriver), "Could not establish all endpoints"); throw new UsbSerialException("Could not establish all endpoints"); } }
public UsbDataBinder(UsbManager manager, UsbDevice device) { // TODO Auto-generated constructor stub mUsbManager = manager; mDevice = device; mIntf = mDevice.GetInterface(0); mEndpoint = mIntf.GetEndpoint(0); mConnection = mUsbManager.OpenDevice(mDevice); }
private bool OpenCP2102() { if (connection.ClaimInterface(mInterface, true)) { Log.Info(CLASS_ID, "Interface succesfully claimed"); } else { Log.Info(CLASS_ID, "Interface could not be claimed"); return(false); } // Assign endpoints int numberEndpoints = mInterface.EndpointCount; for (int i = 0; i <= numberEndpoints - 1; i++) { UsbEndpoint endpoint = mInterface.GetEndpoint(i); if (endpoint.Type == UsbAddressing.XferBulk && endpoint.Direction == UsbAddressing.In) { inEndpoint = endpoint; } else { outEndpoint = endpoint; } } // Default Setup if (SetControlCommand(CP210x_IFC_ENABLE, CP210x_UART_ENABLE, null) < 0) { return(false); } SetControlCommand(CP210x_SET_BAUDDIV, BAUD_RATE_GEN_FREQ / DEFAULT_BAUDRATE, null); //SetBaudRate(DEFAULT_BAUDRATE); //if (SetControlCommand(CP210x_SET_LINE_CTL, CP210x_LINE_CTL_DEFAULT, null) < 0) //{ // return false; //} SetFlowControl(UsbSerialInterface.FLOW_CONTROL_OFF); //SetControlCommand(CP210x_SET_MHS, MCR_ALL | CP210x_MHS_DTR_OFF | CP210x_MHS_RTS_OFF, null); if (SetControlCommand(CP210x_SET_MHS, CP210x_MHS_DEFAULT, null) < 0) { return(false); } PurgeHwBuffers(true, true); return(true); }
private void openInterface() { Log.Debug(TAG, "claiming interfaces, count=" + mDevice.InterfaceCount); mControlInterface = mDevice.GetInterface(0); Log.Debug(TAG, "Control iface=" + mControlInterface); // class should be USB_CLASS_COMM if (!mConnection.ClaimInterface(mControlInterface, true)) { throw new IOException("Could not claim control interface."); } mControlEndpoint = mControlInterface.GetEndpoint(0); Log.Debug(TAG, "Control endpoint direction: " + mControlEndpoint.Direction); Log.Debug(TAG, "Claiming data interface."); mDataInterface = mDevice.GetInterface(1); Log.Debug(TAG, "data iface=" + mDataInterface); // class should be USB_CLASS_CDC_DATA if (!mConnection.ClaimInterface(mDataInterface, true)) { throw new IOException("Could not claim data interface."); } for (int i = 0; i < mDataInterface.EndpointCount; ++i) { UsbEndpoint ep = mDataInterface.GetEndpoint(i); if ((ep.Direction == UsbAddressing.In) && (ep.Type == UsbAddressing.XferBulk)) { Log.Debug(TAG, "Found reading endpoint"); mReadEndpoint = ep; } else if ((ep.Direction == UsbAddressing.Out) && (ep.Type == UsbAddressing.XferBulk)) { Log.Debug(TAG, "Found writing endpoint"); mWriteEndpoint = ep; } } //mReadEndpoint = mDataInterface.GetEndpoint(1); //Log.Debug(TAG, "Read endpoint direction: " + mReadEndpoint.Direction); //mWriteEndpoint = mDataInterface.GetEndpoint(0); //Log.Debug(TAG, "Write endpoint direction: " + mWriteEndpoint.Direction); //mReadEndpoint = mDataInterface.GetEndpoint(0); //Log.Debug(TAG, "Read endpoint direction: " + mReadEndpoint.Direction); //mWriteEndpoint = mDataInterface.GetEndpoint(1); //Log.Debug(TAG, "Write endpoint direction: " + mWriteEndpoint.Direction); }
public void Start() { _usbConnection = _usbManager.OpenDevice(_usbDevice); if (_usbConnection == null) { throw new NullReferenceException("connection"); } _usbInterface = _usbDevice.GetInterface(1); if (!_usbConnection.ClaimInterface(_usbInterface, true)) { throw new Exception("claim interface"); } _usbWriteEndpoint = _usbInterface.GetEndpoint(0); _usbReadEndpoint = _usbInterface.GetEndpoint(1); ScanNetworks(); }
public SmartScopeUsbInterfaceXamarin(Context context, UsbManager usbManager, UsbDevice device) { Destroyed = false; if (!usbManager.HasPermission(device)) { Logger.Error("Permission denied"); throw new Exception("Device permission not obtained"); } UsbInterface interf = device.GetInterface(0); for (int i = 0; i < interf.EndpointCount; i++) { if (interf.GetEndpoint(i).EndpointNumber == 1) { dataEndpoint = interf.GetEndpoint(i); } else if (interf.GetEndpoint(i).EndpointNumber == 2) { commandWriteEndpoint = interf.GetEndpoint(i); } else if (interf.GetEndpoint(i).EndpointNumber == 3) { commandReadEndpoint = interf.GetEndpoint(i); } } usbConnection = usbManager.OpenDevice(device); usbConnection.ClaimInterface(interf, true); }
private UsbEndpoint GetEndpoint(UsbInterface interf, UsbAddressing direction) { for (var i = 0; i < interf.EndpointCount; i++) { var endpoint = interf.GetEndpoint(i); if (endpoint.Direction.HasFlag(direction)) { return(endpoint); } } return(null); }
private bool OpenCDC() { if (connection.ClaimInterface(mInterface, true)) { Log.Info(CLASS_ID, "Interface succesfully claimed"); } else { Log.Info(CLASS_ID, "Interface could not be claimed"); return(false); } // Assign endpoints int numberEndpoints = mInterface.EndpointCount; for (int i = 0; i <= numberEndpoints - 1; i++) { UsbEndpoint endpoint = mInterface.GetEndpoint(i); if (endpoint.Type == UsbAddressing.XferBulk && endpoint.Direction == UsbAddressing.In) { inEndpoint = endpoint; } else if (endpoint.Type == UsbAddressing.XferBulk && endpoint.Direction == UsbAddressing.Out) { outEndpoint = endpoint; } } if (outEndpoint == null || inEndpoint == null) { Log.Info(CLASS_ID, "Interface does not have an IN or OUT interface"); return(false); } // Default Setup SetControlCommand(CDC_SET_LINE_CODING, 0, GetInitialLineCoding()); SetControlCommand(CDC_SET_CONTROL_LINE_STATE, CDC_CONTROL_LINE_ON, null); return(true); }
/** * 分配端点,IN | OUT,即输入输出;此处我直接用1为OUT端点,0为IN,当然你也可以通过判断 */ private void assignEndpoint() { /* * string mess = "1111111111111111111111111111111111"; * byte[] OutBuffer;//数据 * int BufferSize; * Encoding targetEncoding; * //将[UNICODE编码]转换为[GB码],仅使用于简体中文版mobile * targetEncoding = Encoding.GetEncoding(0); //得到简体中文字码页的编码方式,因为是简体中文操作系统,参数用0就可以,用936也行。 * BufferSize = targetEncoding.GetByteCount(mess); //计算对指定字符数组中的所有字符进行编码所产生的字节数 * OutBuffer = new byte[BufferSize]; * OutBuffer = targetEncoding.GetBytes(mess); //将指定字符数组中的所有字符编码为一个字节序列,完成后outbufer里面即为简体中文编码 */ try { for (int i = 0; i < myInterface.EndpointCount; i++) { try { UsbEndpoint point = myInterface.GetEndpoint(i); //int res = myDeviceConnection.BulkTransfer(point, OutBuffer, BufferSize, 10000); if (point.Direction == UsbAddressing.Out) { epOut = point; } else //if (point.Direction == UsbAddressing.In) { epIn = point; } } catch (Exception ex) { } } } catch (Exception ex) { // throw ex; } }
public override void Open(UsbDeviceConnection connection) { if (mConnection != null) { throw new IOException("Already opened."); } mConnection = connection; Boolean opened = false; try { for (int i = 0; i < mDevice.InterfaceCount; i++) { UsbInterface usbIface = mDevice.GetInterface(i); if (mConnection.ClaimInterface(usbIface, true)) { Log.Debug(TAG, $"claimInterface {i} SUCCESS"); } else { Log.Debug(TAG, $"claimInterface {i} FAIL"); } } UsbInterface dataIface = mDevice.GetInterface(mDevice.InterfaceCount - 1); for (int i = 0; i < dataIface.EndpointCount; i++) { UsbEndpoint ep = dataIface.GetEndpoint(i); if (ep.Type == (UsbAddressing)UsbSupport.UsbEndpointXferBulk) { if (ep.Direction == (UsbAddressing)UsbSupport.UsbDirIn) { mReadEndpoint = ep; } else { mWriteEndpoint = ep; } } } SetConfigSingle(SILABSER_IFC_ENABLE_REQUEST_CODE, UART_ENABLE); SetConfigSingle(SILABSER_SET_MHS_REQUEST_CODE, MCR_ALL | CONTROL_WRITE_DTR | CONTROL_WRITE_RTS); SetConfigSingle(SILABSER_SET_BAUDDIV_REQUEST_CODE, BAUD_RATE_GEN_FREQ / DEFAULT_BAUD_RATE); // setParameters(DEFAULT_BAUD_RATE, DEFAULT_DATA_BITS, DEFAULT_STOP_BITS, DEFAULT_PARITY); opened = true; } finally { if (!opened) { try { Close(); } catch (IOException e) { // Ignore IOExceptions during close() } } } }
private void OpenSingleInterface() { // the following code is inspired by the cdc-acm driver // in the linux kernel mControlInterface = mDevice.GetInterface(0); Log.Debug(TAG, "Control iface=" + mControlInterface); mDataInterface = mDevice.GetInterface(0); Log.Debug(TAG, "data iface=" + mDataInterface); if (!mConnection.ClaimInterface(mControlInterface, true)) { throw new IOException("Could not claim shared control/data interface."); } int endCount = mControlInterface.EndpointCount; if (endCount < 3) { Log.Debug(TAG, "not enough endpoints - need 3. count=" + endCount); throw new IOException("Insufficient number of endpoints(" + endCount + ")"); } // Analyse endpoints for their properties mControlEndpoint = null; mReadEndpoint = null; mWriteEndpoint = null; for (int i = 0; i < endCount; ++i) { UsbEndpoint ep = mControlInterface.GetEndpoint(i); if ((ep.Direction == UsbAddressing.In) && (ep.Type == UsbAddressing.XferInterrupt)) { Log.Debug(TAG, "Found controlling endpoint"); mControlEndpoint = ep; } else if ((ep.Direction == UsbAddressing.In) && (ep.Type == UsbAddressing.XferBulk)) { Log.Debug(TAG, "Found reading endpoint"); mReadEndpoint = ep; } else if ((ep.Direction == UsbAddressing.Out) && (ep.Type == UsbAddressing.XferBulk)) { Log.Debug(TAG, "Found writing endpoint"); mWriteEndpoint = ep; } if ((mControlEndpoint != null) && (mReadEndpoint != null) && (mWriteEndpoint != null)) { Log.Debug(TAG, "Found all required endpoints"); break; } } if ((mControlEndpoint == null) || (mReadEndpoint == null) || (mWriteEndpoint == null)) { Log.Debug(TAG, "Could not establish all endpoints"); throw new IOException("Could not establish all endpoints"); } }
public override void Open(UsbDeviceConnection connection) { if (_connection != null) { throw new UsbSerialException("Already open"); } UsbInterface usbInterface = _driver.Device.GetInterface(0); if (!connection.ClaimInterface(usbInterface, true)) { throw new UsbSerialException("Error claiming Prolific interface 0"); } _connection = connection; bool opened = false; try { for (int i = 0; i < usbInterface.EndpointCount; ++i) { UsbEndpoint currentEndpoint = usbInterface.GetEndpoint(i); if (currentEndpoint.Address.IsEqualTo(READ_ENDPOINT)) { _readEndpoint = currentEndpoint; } else if (currentEndpoint.Address.IsEqualTo(WRITE_ENDPOINT)) { _writeEndpoint = currentEndpoint; } else if (currentEndpoint.Address.IsEqualTo(INTERRUPT_ENDPOINT)) { _interruptEndpoint = currentEndpoint; } } if ((int)_driver.Device.DeviceClass == 0x02) { _deviceType = DEVICE_TYPE_0; } else { try { byte[] rawDescriptors = _connection.GetRawDescriptors(); byte maxPacketSize0 = rawDescriptors[7]; if (maxPacketSize0 == 64) { _deviceType = DEVICE_TYPE_HX; } else if ((_driver.Device.DeviceClass == 0x00) || ((int)_driver.Device.DeviceClass == 0xff)) { _deviceType = DEVICE_TYPE_1; } else { Log.Warn(nameof(ProlificSerialDriver), "Could not detect PL2303 subtype, " + "Assuming that it is a HX device"); _deviceType = DEVICE_TYPE_HX; } } catch (NoSuchMethodException) { Log.Warn(nameof(ProlificSerialDriver), "Method UsbDeviceConnection.getRawDescriptors, " + "required for PL2303 subtype detection, not " + "available! Assuming that it is a HX device"); _deviceType = DEVICE_TYPE_HX; } catch (Exception e) { Log.Warn(nameof(ProlificSerialDriver), "An unexpected exception occured while trying " + "to detect PL2303 subtype", e); } } ControlLines = _controlLinesValue; ResetDevice(); PerformInitializationSequence(); opened = true; } finally { if (!opened) { _connection = null; connection.ReleaseInterface(usbInterface); } } }
public override void Open(UsbDeviceConnection connection) { if (mConnection != null) { throw new IOException("Already opened."); } mConnection = connection; Boolean opened = false; try { for (int i = 0; i < mDevice.InterfaceCount; i++) { UsbInterface usbIface = mDevice.GetInterface(i); if (mConnection.ClaimInterface(usbIface, true)) { Log.Debug(TAG, "claimInterface " + i + " SUCCESS"); } else { Log.Debug(TAG, "claimInterface " + i + " FAIL"); } } UsbInterface dataIface = mDevice.GetInterface(mDevice.InterfaceCount - 1); for (int i = 0; i < dataIface.EndpointCount; i++) { UsbEndpoint ep = dataIface.GetEndpoint(i); if (ep.Type == (UsbAddressing)UsbSupport.UsbEndpointXferBulk) { if (ep.Direction == (UsbAddressing)UsbSupport.UsbDirIn) { mReadEndpoint = ep; } else { mWriteEndpoint = ep; } } } Initialize(); SetBaudRate(DEFAULT_BAUD_RATE); opened = true; } finally { if (!opened) { try { Close(); } catch (IOException e) { // Ignore IOExceptions during close() } } } }
public override void Open() { bool openedSuccessfully = false; try { CreateConnection(); UsbInterface usbInterface = UsbDevice.GetInterface(0); if (!Connection.ClaimInterface(usbInterface, true)) { throw new IOException("Error claiming Prolific interface 0"); } for (int i = 0; i < usbInterface.EndpointCount; ++i) { UsbEndpoint currentEndpoint = usbInterface.GetEndpoint(i); switch ((int)currentEndpoint.Address) { case READ_ENDPOINT: ReadEndpoint = currentEndpoint; break; case WRITE_ENDPOINT: WriteEndpoint = currentEndpoint; break; case INTERRUPT_ENDPOINT: InterruptEndpoint = currentEndpoint; break; } } if (UsbDevice.DeviceClass == UsbClass.Comm) { DeviceType = DEVICE_TYPE_0; } else { try { byte[] rawDescriptors = Connection.GetRawDescriptors(); byte maxPacketSize0 = rawDescriptors[7]; if (maxPacketSize0 == 64) { DeviceType = DEVICE_TYPE_HX; } else if ((UsbDevice.DeviceClass == UsbClass.PerInterface) || (UsbDevice.DeviceClass == UsbClass.VendorSpec)) { DeviceType = DEVICE_TYPE_1; } else { Log.Warn(TAG, "Could not detect PL2303 subtype, " + "Assuming that it is a HX device"); DeviceType = DEVICE_TYPE_HX; } } catch (Exception e) { DeviceType = DEVICE_TYPE_HX; Log.Error(TAG, "An unexpected exception occured while trying " + "to detect PL2303 subtype", e); } } SetControlLines(ControlLinesValue); ResetDevice(); DoBlackMagic(); ResetParameters(); // byte[] buffer = new byte[STATUS_BUFFER_SIZE]; int readBytes = Connection.BulkTransfer(InterruptEndpoint, buffer, STATUS_BUFFER_SIZE, 100); if (readBytes != STATUS_BUFFER_SIZE) { Log.Warn(TAG, "Could not read initial CTS / DSR / CD / RI status"); } else { StatusBuffer = buffer[STATUS_BYTE_IDX] & 0xff; } #if UseSmartThreadPool if (ThreadPool != null) { ThreadPool.QueueWorkItem(o => ReadStatusThreadFunction()); } else { System.Threading.ThreadPool.QueueUserWorkItem(o => ReadStatusThreadFunction()); } #else ThreadPool.QueueUserWorkItem(o => ReadStatusThreadFunction()); #endif Dtr = true; openedSuccessfully = true; } finally { if (openedSuccessfully) { IsOpened = true; StartUpdating(); } else { CloseConnection(); } } }
public override void Open(UsbDeviceConnection connection) { if (mConnection != null) { throw new IOException("Already open"); } UsbInterface usbInterface = mDevice.GetInterface(0); if (!connection.ClaimInterface(usbInterface, true)) { throw new IOException("Error claiming Prolific interface 0"); } mConnection = connection; Boolean opened = false; try { for (int i = 0; i < usbInterface.EndpointCount; ++i) { UsbEndpoint currentEndpoint = usbInterface.GetEndpoint(i); switch (currentEndpoint.Address) { case (UsbAddressing)READ_ENDPOINT: mReadEndpoint = currentEndpoint; break; case (UsbAddressing)WRITE_ENDPOINT: mWriteEndpoint = currentEndpoint; break; case (UsbAddressing)INTERRUPT_ENDPOINT: mInterruptEndpoint = currentEndpoint; break; } } if (mDevice.DeviceClass == (UsbClass)0x02) { mDeviceType = DEVICE_TYPE_0; } else { try { //Method getRawDescriptorsMethod // = mConnection.getClass().getMethod("getRawDescriptors"); //byte[] rawDescriptors // = (byte[])getRawDescriptorsMethod.invoke(mConnection); byte[] rawDescriptors = mConnection.GetRawDescriptors(); byte maxPacketSize0 = rawDescriptors[7]; if (maxPacketSize0 == 64) { mDeviceType = DEVICE_TYPE_HX; } else if ((mDevice.DeviceClass == 0x00) || (mDevice.DeviceClass == (UsbClass)0xff)) { mDeviceType = DEVICE_TYPE_1; } else { Log.Warn(TAG, "Could not detect PL2303 subtype, " + "Assuming that it is a HX device"); mDeviceType = DEVICE_TYPE_HX; } } catch (NoSuchMethodException e) { Log.Warn(TAG, "Method UsbDeviceConnection.getRawDescriptors, " + "required for PL2303 subtype detection, not " + "available! Assuming that it is a HX device"); mDeviceType = DEVICE_TYPE_HX; } catch (Exception e) { Log.Error(TAG, "An unexpected exception occured while trying " + "to detect PL2303 subtype", e); } } SetControlLines(mControlLinesValue); ResetDevice(); DoBlackMagic(); opened = true; } finally { if (!opened) { mConnection = null; connection.ReleaseInterface(usbInterface); } } }
public override void Open() { if (IsOpened) { return; } bool openedSuccessfully = false; try { CreateConnection(); Log.Debug(Tag, "claiming interfaces, count=" + UsbDevice.InterfaceCount); mControlInterface = UsbDevice.GetInterface(0); Log.Debug(Tag, "Control iface=" + mControlInterface); // class should be USB_CLASS_COMM if (!Connection.ClaimInterface(mControlInterface, true)) { throw new IOException("Could not claim control interface."); } mControlEndpoint = mControlInterface.GetEndpoint(0); Log.Debug(Tag, "Control endpoint direction: " + mControlEndpoint.Direction); Log.Debug(Tag, "Claiming data interface."); mDataInterface = UsbDevice.GetInterface(1); Log.Debug(Tag, "data iface=" + mDataInterface); // class should be USB_CLASS_CDC_DATA if (!Connection.ClaimInterface(mDataInterface, true)) { throw new IOException("Could not claim data interface."); } mReadEndpoint = mDataInterface.GetEndpoint(1); Log.Debug(Tag, "Read endpoint direction: " + mReadEndpoint.Direction); mWriteEndpoint = mDataInterface.GetEndpoint(0); Log.Debug(Tag, "Write endpoint direction: " + mWriteEndpoint.Direction); if (mEnableAsyncReads) { Log.Debug(Tag, "Async reads enabled"); } else { Log.Debug(Tag, "Async reads disabled."); } ResetParameters(); openedSuccessfully = true; } finally { if (openedSuccessfully) { IsOpened = true; StartUpdating(); } else { CloseConnection(); } } }
private bool OpenPL2303() { if (connection.ClaimInterface(mInterface, true)) { Log.Info(CLASS_ID, "Interface succesfully claimed"); } else { Log.Info(CLASS_ID, "Interface could not be claimed"); return(false); } // Assign endpoints int numberEndpoints = mInterface.EndpointCount; for (int i = 0; i <= numberEndpoints - 1; i++) { UsbEndpoint endpoint = mInterface.GetEndpoint(i); if (endpoint.Type == UsbAddressing.XferBulk && endpoint.Direction == UsbAddressing.In) { inEndpoint = endpoint; } else if (endpoint.Type == UsbAddressing.XferBulk && endpoint.Direction == UsbAddressing.Out) { outEndpoint = endpoint; } } if (device.DeviceClass == (UsbClass)0x02) { mDeviceType = DEVICE_TYPE_0; } else { try { //Method getRawDescriptorsMethod // = mConnection.getClass().getMethod("getRawDescriptors"); //byte[] rawDescriptors // = (byte[])getRawDescriptorsMethod.invoke(mConnection); byte[] rawDescriptors = connection.GetRawDescriptors(); byte maxPacketSize0 = rawDescriptors[7]; if (maxPacketSize0 == 64) { mDeviceType = DEVICE_TYPE_HX; } else if ((device.DeviceClass == 0x00) || (device.DeviceClass == (UsbClass)0xff)) { mDeviceType = DEVICE_TYPE_1; } else { Log.Warn("com.felhr.usbserial.PL2303SerialDevice.OpenPL2303", "Could not detect PL2303 subtype, " + "Assuming that it is a HX device"); mDeviceType = DEVICE_TYPE_HX; } } catch (Java.Lang.NoSuchMethodException) { Log.Warn("com.felhr.usbserial.PL2303SerialDevice.OpenPL2303", "Method UsbDeviceConnection.getRawDescriptors, " + "required for PL2303 subtype detection, not " + "available! Assuming that it is a HX device"); mDeviceType = DEVICE_TYPE_HX; } catch (Exception e) { Log.Error("com.felhr.usbserial.PL2303SerialDevice.OpenPL2303", "An unexpected exception occured while trying " + "to detect PL2303 subtype", e); } } //Default Setup byte[] buf = new byte[1]; //Specific vendor stuff that I barely understand but It is on linux drivers, So I trust :) if (SetControlCommand(PL2303_REQTYPE_DEVICE2HOST_VENDOR, PL2303_VENDOR_WRITE_REQUEST, 0x8484, 0, buf) < 0) { return(false); } if (SetControlCommand(PL2303_REQTYPE_HOST2DEVICE_VENDOR, PL2303_VENDOR_WRITE_REQUEST, 0x0404, 0, null) < 0) { return(false); } if (SetControlCommand(PL2303_REQTYPE_DEVICE2HOST_VENDOR, PL2303_VENDOR_WRITE_REQUEST, 0x8484, 0, buf) < 0) { return(false); } if (SetControlCommand(PL2303_REQTYPE_DEVICE2HOST_VENDOR, PL2303_VENDOR_WRITE_REQUEST, 0x8383, 0, buf) < 0) { return(false); } if (SetControlCommand(PL2303_REQTYPE_DEVICE2HOST_VENDOR, PL2303_VENDOR_WRITE_REQUEST, 0x8484, 0, buf) < 0) { return(false); } if (SetControlCommand(PL2303_REQTYPE_HOST2DEVICE_VENDOR, PL2303_VENDOR_WRITE_REQUEST, 0x0404, 1, null) < 0) { return(false); } if (SetControlCommand(PL2303_REQTYPE_DEVICE2HOST_VENDOR, PL2303_VENDOR_WRITE_REQUEST, 0x8484, 0, buf) < 0) { return(false); } if (SetControlCommand(PL2303_REQTYPE_DEVICE2HOST_VENDOR, PL2303_VENDOR_WRITE_REQUEST, 0x8383, 0, buf) < 0) { return(false); } if (SetControlCommand(PL2303_REQTYPE_HOST2DEVICE_VENDOR, PL2303_VENDOR_WRITE_REQUEST, 0x0000, 1, null) < 0) { return(false); } if (SetControlCommand(PL2303_REQTYPE_HOST2DEVICE_VENDOR, PL2303_VENDOR_WRITE_REQUEST, 0x0001, 0, null) < 0) { return(false); } if (SetControlCommand(PL2303_REQTYPE_HOST2DEVICE_VENDOR, PL2303_VENDOR_WRITE_REQUEST, 0x0002, (mDeviceType == DEVICE_TYPE_HX) ? 0x0044 : 0x0024, null) < 0) { return(false); } // End of specific vendor stuff if (SetControlCommand(PL2303_REQTYPE_HOST2DEVICE, PL2303_SET_CONTROL_REQUEST, 0x0003, 0, null) < 0) { return(false); } if (SetControlCommand(PL2303_REQTYPE_HOST2DEVICE, PL2303_SET_LINE_CODING, 0x0000, 0, defaultSetLine) < 0) { return(false); } if (SetControlCommand(PL2303_REQTYPE_HOST2DEVICE_VENDOR, PL2303_VENDOR_WRITE_REQUEST, 0x0505, 0x1311, null) < 0) { return(false); } PurgeHwBuffers(true, true); return(true); }