Android USB主机从设备读取

Question

我试图从主机模式下连接到我的Android手机的USB设备中获取一些数据。我能够将数据发送给它，但读取失败。

我已经看过severalexamples尽我所能，但我没有任何USB通信的经验，虽然现在我知道了一点，而且我一直在坚持这一点，我不想承认。

我对端点配置不是很熟悉，但我知道我的设备使用CDC类型的通信方法，并且输出（从电话到设备）和输入都被注册。

下面是整个班级管理与连接到手机的唯一设备的USB连接，但没有完成任何手段，但我希望在进一步学习之前让阅读部分工作。

public class UsbCommunicationManager 
{ 
    static final String ACTION_USB_PERMISSION = "com.android.example.USB_PERMISSION"; 

    UsbManager usbManager; 
    UsbDevice usbDevice; 
    UsbInterface intf = null; 
    UsbEndpoint input, output; 
    UsbDeviceConnection connection; 

    PendingIntent permissionIntent; 

    Context context; 

    byte[] readBytes = new byte[64]; 

    public UsbCommunicationManager(Context context) 
    { 
     this.context = context; 
     usbManager = (UsbManager) context.getSystemService(Context.USB_SERVICE); 

     // ask permission from user to use the usb device 
     permissionIntent = PendingIntent.getBroadcast(context, 0, new Intent(ACTION_USB_PERMISSION), 0); 
     IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION); 
     context.registerReceiver(usbReceiver, filter); 
    } 

    public void connect() 
    { 
     // check if there's a connected usb device 
     if(usbManager.getDeviceList().isEmpty()) 
     { 
      Log.d("trebla", "No connected devices"); 
      return; 
     } 

     // get the first (only) connected device 
     usbDevice = usbManager.getDeviceList().values().iterator().next(); 

     // user must approve of connection 
     usbManager.requestPermission(usbDevice, permissionIntent); 
    } 

    public void stop() 
    { 
     context.unregisterReceiver(usbReceiver); 
    } 

    public String send(String data) 
    { 
     if(usbDevice == null) 
     { 
      return "no usb device selected"; 
     } 

     int sentBytes = 0; 
     if(!data.equals("")) 
     { 
      synchronized(this) 
      { 
       // send data to usb device 
       byte[] bytes = data.getBytes(); 
       sentBytes = connection.bulkTransfer(output, bytes, bytes.length, 1000); 
      } 
     } 

     return Integer.toString(sentBytes); 
    } 

    public String read() 
    { 
     // reinitialize read value byte array 
     Arrays.fill(readBytes, (byte) 0); 

     // wait for some data from the mcu 
     int recvBytes = connection.bulkTransfer(input, readBytes, readBytes.length, 3000); 

     if(recvBytes > 0) 
     { 
      Log.d("trebla", "Got some data: " + new String(readBytes)); 
     } 
     else 
     { 
      Log.d("trebla", "Did not get any data: " + recvBytes); 
     } 

     return Integer.toString(recvBytes); 
    } 

    public String listUsbDevices() 
    { 
     HashMap<String, UsbDevice> deviceList = usbManager.getDeviceList(); 

     if(deviceList.size() == 0) 
     { 
      return "no usb devices found"; 
     } 

     Iterator<UsbDevice> deviceIterator = deviceList.values().iterator(); 
     String returnValue = ""; 
     UsbInterface usbInterface; 

     while(deviceIterator.hasNext()) 
     { 
      UsbDevice device = deviceIterator.next(); 
      returnValue += "Name: " + device.getDeviceName(); 
      returnValue += "\nID: " + device.getDeviceId(); 
      returnValue += "\nProtocol: " + device.getDeviceProtocol(); 
      returnValue += "\nClass: " + device.getDeviceClass(); 
      returnValue += "\nSubclass: " + device.getDeviceSubclass(); 
      returnValue += "\nProduct ID: " + device.getProductId(); 
      returnValue += "\nVendor ID: " + device.getVendorId(); 
      returnValue += "\nInterface count: " + device.getInterfaceCount(); 

      for(int i = 0; i < device.getInterfaceCount(); i++) 
      { 
       usbInterface = device.getInterface(i); 
       returnValue += "\n Interface " + i; 
       returnValue += "\n\tInterface ID: " + usbInterface.getId(); 
       returnValue += "\n\tClass: " + usbInterface.getInterfaceClass(); 
       returnValue += "\n\tProtocol: " + usbInterface.getInterfaceProtocol(); 
       returnValue += "\n\tSubclass: " + usbInterface.getInterfaceSubclass(); 
       returnValue += "\n\tEndpoint count: " + usbInterface.getEndpointCount(); 

       for(int j = 0; j < usbInterface.getEndpointCount(); j++) 
       { 
        returnValue += "\n\t Endpoint " + j; 
        returnValue += "\n\t\tAddress: " + usbInterface.getEndpoint(j).getAddress(); 
        returnValue += "\n\t\tAttributes: " + usbInterface.getEndpoint(j).getAttributes(); 
        returnValue += "\n\t\tDirection: " + usbInterface.getEndpoint(j).getDirection(); 
        returnValue += "\n\t\tNumber: " + usbInterface.getEndpoint(j).getEndpointNumber(); 
        returnValue += "\n\t\tInterval: " + usbInterface.getEndpoint(j).getInterval(); 
        returnValue += "\n\t\tType: " + usbInterface.getEndpoint(j).getType(); 
        returnValue += "\n\t\tMax packet size: " + usbInterface.getEndpoint(j).getMaxPacketSize(); 
       } 
      } 
     } 

     return returnValue; 
    } 

    private void setupConnection() 
    { 
     // find the right interface 
     for(int i = 0; i < usbDevice.getInterfaceCount(); i++) 
     { 
      // communications device class (CDC) type device 
      if(usbDevice.getInterface(i).getInterfaceClass() == UsbConstants.USB_CLASS_CDC_DATA) 
      { 
       intf = usbDevice.getInterface(i); 

       // find the endpoints 
       for(int j = 0; j < intf.getEndpointCount(); j++) 
       { 
        if(intf.getEndpoint(j).getDirection() == UsbConstants.USB_DIR_OUT && intf.getEndpoint(j).getType() == UsbConstants.USB_ENDPOINT_XFER_BULK) 
        { 
         // from android to device 
         output = intf.getEndpoint(j); 
        } 

        if(intf.getEndpoint(j).getDirection() == UsbConstants.USB_DIR_IN && intf.getEndpoint(j).getType() == UsbConstants.USB_ENDPOINT_XFER_BULK) 
        { 
         // from device to android 
         input = intf.getEndpoint(j); 
        } 
       } 
      } 
     } 
    } 

    private final BroadcastReceiver usbReceiver = new BroadcastReceiver() 
    { 
     public void onReceive(Context context, Intent intent) 
     { 
      String action = intent.getAction(); 
      if(ACTION_USB_PERMISSION.equals(action)) 
      { 
       // broadcast is like an interrupt and works asynchronously with the class, it must be synced just in case 
       synchronized(this) 
       { 
        if(intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) 
        { 
         setupConnection(); 

         connection = usbManager.openDevice(usbDevice); 
         connection.claimInterface(intf, true); 

         // set flow control to 8N1 at 9600 baud 
         int baudRate = 9600; 
         byte stopBitsByte = 1; 
         byte parityBitesByte = 0; 
         byte dataBits = 8; 
         byte[] msg = { 
          (byte) (baudRate & 0xff), 
          (byte) ((baudRate >> 8) & 0xff), 
          (byte) ((baudRate >> 16) & 0xff), 
          (byte) ((baudRate >> 24) & 0xff), 
          stopBitsByte, 
          parityBitesByte, 
          (byte) dataBits 
         }; 

         connection.controlTransfer(UsbConstants.USB_TYPE_CLASS | 0x01, 0x20, 0, 0, msg, msg.length, 5000); 
        } 
        else 
        { 
         Log.d("trebla", "Permission denied for USB device"); 
        } 
       } 
      } 
      else if(UsbManager.ACTION_USB_DEVICE_DETACHED.equals(action)) 
      { 
       Log.d("trebla", "USB device detached"); 
      } 
     } 
    }; 
} 

我一直从read()方法，它表明了某种错误，它总是超时越来越-1。也许问题来自连接配置，我试了几次（阅读：试用和错误），没有工作，令人惊讶的是我不需要任何配置发送数据到设备。

---

编辑

还必须指出的是，我使用的电缆微型USB到微型USB，它只有一条出路的作品，这是我的设备是由我的动力手机只有当插头A连接到手机和插头B连接到设备，而不是反过来......这似乎很奇怪。事实上，我能够发送数据，但没有收到时插入正确的方式仍然存在。

---

EDIT 2

我发现somebody else had the same problem但他似乎没能解决这个问题。

---

EDIT 3

我终于找到上this page溶液：

另一个主要的监督是，没有机制为主机，以通知该设备有一个数据在主机侧的接收器准备接受数据。这意味着设备可能会尝试在主机未侦听时发送数据，从而导致传输例程中的冗长阻塞超时。因此强烈建议在可能的情况下使用虚拟串行线路DTR（数据终端就绪）信号来确定主机应用程序是否准备好数据。

所以DTR信号是强制性的，所有我所要做的就是把它添加到接口配置：

connection.controlTransfer(0x21, 0x22, 0x1, 0, null, 0, 0); 

---

EDIT 4

如果有人有兴趣我完成了这个项目，它是open source and published on my GitHub account。但它始终不稳定（请参阅notes），我不打算继续使用它，但它很有用。随意使用它为您自己的项目。

Answer 1

您可以从https://github.com/mik3y/usb-serial-for-android

我的示例代码中使用UsbSerial库的：

UsbManager usbManager = null; 
    UsbDeviceConnection connection = null; 
    UsbSerialDriver driver = null; 
    UsbSerialPort port = null; 

    usbManager = (UsbManager) context.getSystemService(Context.USB_SERVICE); 

    List<UsbSerialDriver> availableDrivers = UsbSerialProber.getDefaultProber().findAllDrivers(manager); 
    // Open a connection to the first available driver. 

    for (UsbSerialDriver usd : availableDrivers) { 
     UsbDevice udv = usd.getDevice(); 
     if (udv.getVendorId()==0x067B || udv.getProductId()==2303){ 
      driver = usd; 
      break; 
     } 
    } 
     connection = usbManager.openDevice(driver.getDevice()); 

     port = driver.getPorts().get(0); 

     driver.getDevice(). 

    } 

     if (connection == null) return; 

     try{ 

      port.open(connection); 
      port.setParameters(4800, UsbSerialPort.DATABITS_8, UsbSerialPort.STOPBITS_1, UsbSerialPort.PARITY_NONE); 

       try{ 

        byte buffer[] = new byte[250]; 
        //Log.d("GPS_REQ", "->"); 
        int numBytesRead = port.read(buffer, 500); //5000; 

       }catch (Exception e) { 
        Log.d("GPS_ERR", e.getLocalizedMessage()); 
       }