Android USB host cihazı cihazdan okundu

Question

Android telefonuma bağlı, ana bilgisayar modundaki bir USB cihazından veri almaya çalışıyorum. Veri gönderebiliyorum, ancak okuma başarısız oluyor.

severalexamples'a baktım ve yapabildiğim herşeyi denedim ama USB iletişiminde herhangi bir deneyimim yok, ancak şimdi biraz biliyorum ve daha fazla takıldım. .

Son nokta yapılandırmasına çok aşina değilim, ancak aygıtımın CDC tipi bir iletişim yöntemi kullandığını ve hem çıkışın (telefondan cihaza) hem de girişin kayıtlı olduğunu biliyorum.

USB bağlantısını telefona bağlanan tek cihazla yöneten tüm sınıf, hiçbir şekilde tamamlanmadı, ancak daha fazla gitmeden önce bu okuma parçasını çalışmaya başlamak istiyorum.

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"); 
      } 
     } 
    }; 
} 

ben, her zaman kere hata çeşit gösterir read() yönteminden -1 almaya devam. Belki de sorun bağlantı konfigürasyonundan geliyor, birkaç deneme yaptım (okuma: deneme ve hata) ve hiç çalışmadım, şaşırtıcı bir şekilde, cihaza veri göndermek için herhangi bir konfigürasyona ihtiyacım yok.

---

Düzenleme

Ayrıca kullanıyorum kablo mikro USB mikro USB olduğunu kaydetti olmalı ve yalnızca bir şekilde çalışır

, bu benim cihaz tarafından desteklenmektedir olduğunu benim telefonu yalnızca fiş A bağlıyken telefona ve B fişini cihaza bağlıyken, başka bir şekilde değil ... çok garip görünüyor. doğru yoldan takıldığında veri gönderebiliyorum ve doğru değil kalıyorum.

---

DÜZENLEME 2

Ben somebody else had the same problem bulundu ama o bunu çözmek mümkün değildi görünüyor.

---

DÜZENLEME 3

sonunda bulunan this page üzerine çözelti:

Bir diğer önemli denetim ana veri olduğu cihazı bildirmek için bir mekanizma olmasıdır Verileri kabul etmeye hazır olarak ana bilgisayar tarafındaki lavabo. Bu, aygıtın ana bilgisayar dinlenmediği sırada veri göndermeye çalışabileceği ve iletim yordamlarında uzun süre engelleme zaman aşımlarına neden olabileceği anlamına gelir. Bu nedenle, bir host uygulamasının veri için hazır olup olmadığını belirlemek için mümkün olduğunda sanal seri hat DTR (Data Terminal Ready) sinyalinin kullanılması şiddetle tavsiye edilir.

Yani DTR sinyali zorunlu olduğunu ve tüm yapmak zorunda arayüz yapılandırmasına bu eklemek oldu: anybody ilgileniyorsa

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

---

DÜZENLEME 4

projeyi bitirdi ve open source and published on my GitHub account. Her zaman istikrarlı değil (bkz. notes) ve artık üzerinde çalışmayı planlamıyorum, ama işe yarıyor. Kendi projeleriniz için kullanmaktan çekinmeyin.

Answer 1

Sen https://github.com/mik3y/usb-serial-for-android

Benim örnek koddan arasında UsbSerial Lib kullanabilirsiniz: kullanıyorsunuz ne usb Aygıt

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()); 
       }