public boolean commitControl(int request) {
   if (request == UvcConstants.SET_CUR) {
     if (mDeviceConnection.controlTransfer(
             UvcConstants.CLASS_REQUEST_OUT,
             request,
             UvcConstants.COMMIT_CONTROL,
             UvcConstants.VIDEO_STREAMING_INTERFACE,
             streamingControls,
             streamingControls.length,
             0)
         > -1) {
       return true;
     } else return false;
   } else {
     if (mDeviceConnection.controlTransfer(
             UvcConstants.CLASS_REQUEST_IN,
             request,
             UvcConstants.COMMIT_CONTROL,
             UvcConstants.VIDEO_STREAMING_INTERFACE,
             streamingControls,
             streamingControls.length,
             0)
         > -1) {
       return true;
     } else return false;
   }
 }
Exemple #2
0
 @Override
 public synchronized void write(byte[] buffer, int offset, int count) throws IOException {
   if (count > (buffer.length - offset)) {
     throw new IOException("Count is too big");
   }
   while (count > 0) {
     if (offset == 0) {
       // This is an optimization: when the offset is 0, we can pass the original
       // buffer and avoid a copy.
       offset = connection_.bulkTransfer(ep_, buffer, count, TRANSFER_TIMEOUT_MILLIS);
       if (offset < 0) {
         throw new IOException("Couldn't write to USB");
       }
       count -= offset;
     } else {
       // We cannot write directly from the buffer, since the API won't let us use a
       // non-0 offset.
       // So we have to use an intermediate buffer and copy.
       int copied = Math.min(count, buffer_.length);
       System.arraycopy(buffer, offset, buffer_, 0, copied);
       int written = connection_.bulkTransfer(ep_, buffer_, copied, TRANSFER_TIMEOUT_MILLIS);
       if (written < 0) {
         throw new IOException("Couldn't write to USB");
       }
       offset += written;
       count -= written;
     }
   }
 }
  public void setDevice(UsbManager usbManager, UsbDevice usbDevice) {
    //		Log.d(TAG, "setDevice " + usbDevice);

    device = usbDevice;

    if (device != null) {
      usbDeviceDump(usbDevice);

      UsbInterface controlInterface = device.getInterface(1);

      endpoint = controlInterface.getEndpoint(0);

      UsbDeviceConnection connection = usbManager.openDevice(device);

      if (connection != null && connection.claimInterface(controlInterface, true)) {
        controlConnection = connection;
        serial = UsbSerialDevice.createUsbSerialDevice(device, controlConnection);
        boolean t = serial.open();
        Log.d("Set DEVICE : ", "" + t);
        serial.setBaudRate(9600);
        serial.setParity(UsbSerialInterface.PARITY_NONE);
        serial.setStopBits(UsbSerialInterface.STOP_BITS_1);
        serial.setDataBits(UsbSerialInterface.DATA_BITS_8);
      } else {
        Log.e(TAG, "open connection FAIL");
        controlConnection = null;
      }
    }
  }
 /* (non-Javadoc)
  * @see net.smartrover.skyrover2.roverlib.IUsbLink#sendBulkTransfer(byte[], byte[])
  */
 public int sendBulkTransfer(byte[] data, byte[] receiveData) {
   int returnCode = -1;
   if (mConnection != null) {
     mConnection.bulkTransfer(mEpOut, data, data.length, TRANSFER_TIMEOUT);
     returnCode =
         mConnection.bulkTransfer(mEpIn, receiveData, receiveData.length, TRANSFER_TIMEOUT);
   }
   return returnCode;
 }
  int waitForUSBPermission() {
    UsbManager manager = (UsbManager) getSystemService(Context.USB_SERVICE);

    if (usbListener == null) return -1;
    while (!usbListener.permissionGranted()) {
      SystemClock.sleep(100);
    }

    UsbDevice depthCamera = usbListener.getDevice();
    UsbDeviceConnection con = manager.openDevice(depthCamera);
    return con.getFileDescriptor();
  }
  private void setDevice(UsbDevice device) {
    usbInterfaceFound = null;
    endpointOut = null;
    endpointIn = null;

    for (int i = 0; i < device.getInterfaceCount(); i++) {
      UsbInterface usbif = device.getInterface(i);

      UsbEndpoint tOut = null;
      UsbEndpoint tIn = null;

      int tEndpointCnt = usbif.getEndpointCount();
      if (tEndpointCnt >= 2) {
        for (int j = 0; j < tEndpointCnt; j++) {
          if (usbif.getEndpoint(j).getType() == UsbConstants.USB_ENDPOINT_XFER_BULK) {
            if (usbif.getEndpoint(j).getDirection() == UsbConstants.USB_DIR_OUT) {
              tOut = usbif.getEndpoint(j);
            } else if (usbif.getEndpoint(j).getDirection() == UsbConstants.USB_DIR_IN) {
              tIn = usbif.getEndpoint(j);
            }
          }
        }

        if (tOut != null && tIn != null) {
          // This interface have both USB_DIR_OUT
          // and USB_DIR_IN of USB_ENDPOINT_XFER_BULK
          usbInterfaceFound = usbif;
          endpointOut = tOut;
          endpointIn = tIn;
        }
      }
    }

    if (usbInterfaceFound == null) {
      return;
    }

    deviceFound = device;

    if (device != null) {
      UsbDeviceConnection connection = usbManager.openDevice(device);
      if (connection != null && connection.claimInterface(usbInterfaceFound, true)) {
        usbDeviceConnection = connection;
        Thread thread = new Thread(this);
        thread.start();

      } else {
        usbDeviceConnection = null;
      }
    }
  }
Exemple #7
0
 @Override
 public synchronized int read(byte[] buffer, int offset, int length) throws IOException {
   if (offset == 0) {
     return connection_.bulkTransfer(ep_, buffer, length, TRANSFER_TIMEOUT_MILLIS);
   }
   // We have to go through an intermediate buffer and copy, since the API won't let us
   // write to a non-0
   // offset.
   int readAmount =
       connection_.bulkTransfer(
           ep_, buffer_, Math.min(length, buffer_.length), TRANSFER_TIMEOUT_MILLIS);
   System.arraycopy(buffer_, 0, buffer, offset, readAmount);
   return readAmount;
 }
 /* (non-Javadoc)
  * @see net.smartrover.skyrover2.roverlib.IUsbLink#releaseInterface()
  */
 public void releaseInterface() {
   if (mConnection != null && mIntf != null) {
     mConnection.releaseInterface(mIntf);
     mConnection = null;
     mIntf = null;
   }
 }
Exemple #9
0
  @Override
  public void run() {
    ByteBuffer buffer = ByteBuffer.allocate(1);
    UsbRequest request = new UsbRequest();
    request.initialize(usbDeviceConnection, endpointIn);

    while (true) {
      request.queue(buffer, 1);
      if (usbDeviceConnection.requestWait() == request) {
        byte rxCmd = buffer.get(0);

        if (rxCmd != 0) {
          muestra = "" + rxCmd;
          temperatura = (int) rxCmd;
        }

        try {
          Thread.sleep(1000);
        } catch (InterruptedException e) {
        }
      } else {

        break;
      }
    }
  }
Exemple #10
0
  /**
   * デバイスの利用開始。
   *
   * @return null=正常、null以外=エラーメッセージ
   */
  public String onStart(UsbDevice device) {
    Log.d(TAG, "onStart:" + device);
    if (!device.equals(usbDevice)) {
      return "No device attach.";
    }
    if (!usbManager.hasPermission(usbDevice)) {
      return "No device permission.";
    }

    usbConnection = usbManager.openDevice(usbDevice);
    // TODO:インターフェースの検出は端折ってます。
    UsbInterface usbIf = usbDevice.getInterface(INTERFACE_INDEX);

    // EndPointの検索。分かってる場合は直接取り出しても良い。
    for (int i = 0; i < usbIf.getEndpointCount(); i++) {
      UsbEndpoint ep = usbIf.getEndpoint(i);
      Log.d(TAG, "tye=" + ep.getType());
      if (ep.getType() == UsbConstants.USB_ENDPOINT_XFER_INT) {
        if (ep.getDirection() == UsbConstants.USB_DIR_IN) {
          endpointIn = ep;
        } else if (ep.getDirection() == UsbConstants.USB_DIR_OUT) {
          endpointOut = ep;
        }
      }
    }
    if (endpointIn == null || endpointOut == null) {
      Log.e(TAG, "Device has not IN/OUT Endpoint.");
      return "Device has not IN/OUT Endpoint.";
    }
    // デバイスの確保
    usbConnection.claimInterface(usbIf, true);
    isReady = true;
    return null;
  }
    @Override
    public void open(UsbDeviceConnection connection) throws IOException {
      if (mConnection != null) {
        throw new IOException("Already open");
      }
      mConnection = connection;

      boolean opened = false;
      try {
        for (int i = 0; i < mDevice.getInterfaceCount(); i++) {
          if (connection.claimInterface(mDevice.getInterface(i), true)) {
            Log.d(TAG, "claimInterface " + i + " SUCCESS");
          } else {
            throw new IOException("Error claiming interface " + i);
          }
        }
        reset();
        opened = true;
      } finally {
        if (!opened) {
          close();
          mConnection = null;
        }
      }
    }
 /* (non-Javadoc)
  * @see net.smartrover.skyrover2.roverlib.IUsbLink#sendControlTransfer(int, int, int, int, byte[])
  */
 public int sendControlTransfer(int requestType, int request, int value, int index, byte[] data) {
   if (mConnection != null) {
     int dataLength = (data == null) ? 0 : data.length;
     return mConnection.controlTransfer(
         requestType, request, value, index, data, dataLength, TRANSFER_TIMEOUT);
   }
   return -1;
 }
 private void sendCommand(int control) {
   synchronized (this) {
     if (usbDeviceConnection != null) {
       byte[] message = new byte[1];
       message[0] = (byte) control;
       usbDeviceConnection.bulkTransfer(endpointOut, message, message.length, 0);
     }
   }
 }
  /** Closes connections, releases resources, cleans up variables */
  private void destroy() {
    /* Release the interface that was previously claimed and close
     * the connection.
     */
    connection.releaseInterface(intf);
    connection.close();

    /* Clear up all of the locals */
    device = null;
    manager = null;
    handler = null;
    toggleLEDCount = 0;
    lastButtonState = false;
    buttonStatusInitialized = false;
    closeRequested = false;
    connection = null;
    intf = null;
  }
Exemple #15
0
  /**
   * デバイスの切断通知
   *
   * @return
   */
  public String onDetach(UsbDevice device) {
    Log.d(TAG, "onDetach:" + device);

    if (!device.equals(usbDevice)) {
      Log.d(TAG, "onDetach: Other device.");
      return "Other device";
    }

    if (usbConnection != null) {
      UsbInterface usbIf = usbDevice.getInterface(INTERFACE_INDEX);
      usbConnection.releaseInterface(usbIf);
      usbConnection.close();
    }
    usbConnection = null;
    usbDevice = null;
    isReady = false;
    return null;
  }
Exemple #16
0
  public void sendCommand(int command, int channel, int value) {
    Log.d(TAG, "sendCommand(" + command + ", " + channel + ", " + value + ")");

    if (device == null) {
      Log.e(TAG, "sendCommand(): device is NULL!");
      return;
    }

    controlConnection.controlTransfer(0x40, command, value, channel, null, 0, 5000);
  }
  // Sets the current USB device and interface
  private boolean setAdbInterface(UsbDevice device, UsbInterface intf) {
    if (mDeviceConnection != null) {
      if (mInterface != null) {
        mDeviceConnection.releaseInterface(mInterface);
        mInterface = null;
      }
      mDeviceConnection.close();
      mDevice = null;
      mDeviceConnection = null;
    }

    if (device != null && intf != null) {
      UsbDeviceConnection connection = mManager.openDevice(device);
      if (connection != null) {
        log("open succeeded");
        if (connection.claimInterface(intf, false)) {
          log("claim interface succeeded");
          mDevice = device;
          mDeviceConnection = connection;
          mInterface = intf;
          mAdbDevice = new AdbDevice(this, mDeviceConnection, intf);
          log("call start");
          mAdbDevice.start();
          return true;
        } else {
          log("claim interface failed");
          connection.close();
        }
      } else {
        log("open failed");
      }
    }

    if (mDeviceConnection == null && mAdbDevice != null) {
      mAdbDevice.stop();
      mAdbDevice = null;
    }
    return false;
  }
  /**
   * Initialize the USB device. Determines endpoints and prepares communication.
   *
   * @throws IOException if the device cannot be opened
   */
  private void initDevice() throws IOException {
    Log.d(LOG_TAG, "setDevice " + this.mUsbDevice);
    // find interface
    if (this.mUsbDevice.getInterfaceCount() != 1) {
      Log.e(LOG_TAG, "Could not find interface");
      return;
    }
    mIntf = this.mUsbDevice.getInterface(0);
    // device should have two endpoints
    if (mIntf.getEndpointCount() != 2) {
      Log.e(LOG_TAG, "Could not find endpoints");
      return;
    }
    // endpoints should be of type bulk
    UsbEndpoint ep = mIntf.getEndpoint(0);
    if (ep.getType() != UsbConstants.USB_ENDPOINT_XFER_BULK) {
      Log.e(LOG_TAG, "Endpoint is not of type bulk");
      return;
    }
    // check endpoint direction
    if (ep.getDirection() == UsbConstants.USB_DIR_IN) {
      mEpIn = mIntf.getEndpoint(0);
      mEpOut = mIntf.getEndpoint(1);
    } else {
      mEpIn = mIntf.getEndpoint(1);
      mEpOut = mIntf.getEndpoint(0);
    }

    UsbDeviceConnection connection = mUsbManager.openDevice(mUsbDevice);
    if (connection != null && connection.claimInterface(mIntf, true)) {
      Log.d(LOG_TAG, "open SUCCESS");
      mConnection = connection;
    } else {
      Log.d(LOG_TAG, "open FAIL");
      throw new IOException("could not open usb connection");
    }
  }
 public boolean startStreaming() {
   if (mDeviceConnection.controlTransfer(
           UvcConstants.STANDARD_REQUEST_OUT,
           UvcConstants.SET_INTERFACE,
           UvcConstants.OPERATIONAL,
           UvcConstants.VIDEO_STREAMING_INTERFACE,
           null,
           0,
           0)
       > -1) {
     return true;
   } else {
     return false;
   }
 }
  /**
   * Constructor - creates connection to device and launches the thread that runs the actual demo.
   *
   * @param context Context requesting to run the demo.
   * @param device The USB device to attach to.
   * @param handler The Handler where demo Messages should be sent.
   */
  DemoCustomHID(Context context, UsbDevice device, Handler handler) {
    /* Save the device and handler information for later use. */
    this.device = device;
    this.handler = handler;

    /* Get the USB manager from the requesting context */
    this.manager = (UsbManager) context.getSystemService(Context.USB_SERVICE);

    /*
     * Get the required interface from the USB device.  In this case
     * we are hard coding the interface number to 0.  In a dynamic example
     * the code could scan through the interfaces to find the right
     * interface.  In this case since we know the exact device we are connecting
     * to, we can hard code it.
     */
    intf = device.getInterface(0);

    /* Open a connection to the USB device */
    connection = manager.openDevice(device);

    if (connection == null) {
      return;
    }

    /* Claim the required interface to gain access to it */
    if (connection.claimInterface(intf, true) == true) {
      thread = new Thread(this);
      thread.start();
      connected = true;
    } else {
      /* if the interface claim failed, we should close the
       * connection and exit.
       */
      connection.close();
    }
  }
Exemple #21
0
  public ZBResult readEP1(int numBytes) {
    if (usbDeviceConnection == null) return null;

    ZBResult rdo = new ZBResult();
    rdo.setStatus(ZBResultStatus.TRANSFER_OK);

    UsbRequest request = new UsbRequest();
    request.initialize(usbDeviceConnection, endpointInt);
    ByteBuffer buffer = ByteBuffer.allocate(numBytes);
    request.queue(buffer, numBytes);
    usbDeviceConnection.requestWait();
    rdo.setLength(numBytes);
    rdo.data = buffer.array();
    for (int i = 0; i < numBytes; i++) Log.d("USB" + i, rdo.data[i] + "");

    return rdo;
  }
Exemple #22
0
  public boolean isHearbeatOk() {
    if (usbDeviceConnection == null) return false;

    byte[] buffer = {1};
    // USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN
    usbDeviceConnection.controlTransfer(
        UsbConstants.USB_TYPE_VENDOR
            | UsbConstants.USB_ENDPOINT_XFER_CONTROL
            | UsbConstants.USB_DIR_IN,
        130,
        1,
        0,
        buffer,
        1,
        1000);
    return buffer[0] == 2;
  }
  public int getScanMode() {
    byte[] mode = new byte[1];

    if (mDeviceConnection.controlTransfer(
            UvcConstants.CLASS_REQUEST_IN,
            UvcConstants.GET_CUR,
            UvcConstants.SCANNING_MODE_CONTROL,
            UvcConstants.CAMERA_SENSOR,
            mode,
            mode.length,
            0)
        > -1) {
      return 1;
    } else {
      return 0;
    }
  }
  public int getErrorCode() {
    byte[] code = new byte[1];

    if (mDeviceConnection.controlTransfer(
            UvcConstants.CLASS_REQUEST_IN,
            UvcConstants.GET_CUR,
            UvcConstants.STREAM_ERROR_CODE_CONTROL,
            UvcConstants.VIDEO_STREAMING_INTERFACE,
            code,
            code.length,
            0)
        > -1) {
      return (int) code[0];
    } else {
      return -1;
    }
  }
Exemple #25
0
  public ZBResult send(byte[] buffer) {
    if (usbDeviceConnection == null) return null;

    // USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_OUT
    int realNumBytes =
        usbDeviceConnection.controlTransfer(
            UsbConstants.USB_TYPE_VENDOR
                | UsbConstants.USB_ENDPOINT_XFER_CONTROL
                | UsbConstants.USB_DIR_OUT,
            132,
            0,
            0,
            buffer,
            buffer.length,
            1000);

    ZBResult rdo = new ZBResult();
    rdo.setLength(realNumBytes);
    rdo.data = new byte[realNumBytes];
    for (int i = 0; i < realNumBytes; i++) rdo.data[i] = buffer[i];
    if (realNumBytes < 0) rdo.setStatus(ZBResultStatus.TRANSFER_ERROR);
    else rdo.setStatus(ZBResultStatus.TRANSFER_OK);
    return rdo;
  }
    @Override
    public void open(UsbDeviceConnection connection) throws IOException {
      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.getEndpointCount(); ++i) {
          UsbEndpoint currentEndpoint = usbInterface.getEndpoint(i);

          switch (currentEndpoint.getAddress()) {
            case READ_ENDPOINT:
              mReadEndpoint = currentEndpoint;
              break;

            case WRITE_ENDPOINT:
              mWriteEndpoint = currentEndpoint;
              break;

            case INTERRUPT_ENDPOINT:
              mInterruptEndpoint = currentEndpoint;
              break;
          }
        }

        if (mDevice.getDeviceClass() == 0x02) {
          mDeviceType = DEVICE_TYPE_0;
        } else {
          try {
            Method getRawDescriptorsMethod = mConnection.getClass().getMethod("getRawDescriptors");
            byte[] rawDescriptors = (byte[]) getRawDescriptorsMethod.invoke(mConnection);
            byte maxPacketSize0 = rawDescriptors[7];
            if (maxPacketSize0 == 64) {
              mDeviceType = DEVICE_TYPE_HX;
            } else if ((mDevice.getDeviceClass() == 0x00) || (mDevice.getDeviceClass() == 0xff)) {
              mDeviceType = DEVICE_TYPE_1;
            } else {
              Log.w(TAG, "Could not detect PL2303 subtype, " + "Assuming that it is a HX device");
              mDeviceType = DEVICE_TYPE_HX;
            }
          } catch (NoSuchMethodException e) {
            Log.w(
                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.e(
                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);
        }
      }
    }
  /** The man thread for the demo */
  @Override
  public void run() {
    /* Get the OUT endpoint.  It is the second endpoint in the interface */
    UsbEndpoint endpointOUT = intf.getEndpoint(1);

    /* Get the IN endpoint.  It is the first endpoint in the interface */
    UsbEndpoint endpointIN = intf.getEndpoint(0);

    /* Create the packets that we are going to send to the attached USB
     * device.
     */
    byte[] getPushButtonStatusPacket = new byte[] {(byte) 0x81};
    byte[] toggleLEDsPacket = new byte[] {(byte) 0x80};
    byte[] getPotentiometerRequest = new byte[] {(byte) 0x37};

    byte[] getPotentiometerResults = new byte[64];
    byte[] getPushButtonStatusResults = new byte[64];
    int potentiometerLastResults = Integer.MAX_VALUE;
    int result = 0;
    boolean needToToggleLEDs = false;

    while (true) {
      /* If the connection was closed, destroy the connections and variables
       * and exit this thread.
       */
      if (wasCloseRequested() == true) {
        destroy();
        return;
      }

      /* Sleep the thread for a while */
      try {
        Thread.sleep(50);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }

      /* Send the request to get the push button status */
      do {
        result =
            connection.bulkTransfer(
                endpointOUT, getPushButtonStatusPacket, getPushButtonStatusPacket.length, 1000);
      } while ((result < 0) && (wasCloseRequested() == false));

      /* Read the push button status */
      do {
        result =
            connection.bulkTransfer(
                endpointIN, getPushButtonStatusResults, getPushButtonStatusResults.length, 1000);
      } while ((result < 0) && (wasCloseRequested() == false));

      /* If there was data successfully read,... */
      if (result > 0) {
        /* convert the byte data to a boolean representing the current button state */
        boolean currentButtonState =
            (getPushButtonStatusResults[1] == CUSTOM_HID_DEMO_BUTTON_PRESSED) ? true : false;

        /* We only need to send a message to the GUI if the current button state is different than
         * the old button state.
         */
        if ((currentButtonState != lastButtonState) || (buttonStatusInitialized == false)) {
          lastButtonState = currentButtonState;
          handler.obtainMessage(0, new MessageButton(lastButtonState)).sendToTarget();
        }
      }

      /* Check to see if we need to toggle the LEDs.  We are synchronizing on
       * The toggleLEDCount object here to insure that the user isn't changing
       * the value as we are checking it.
       */
      synchronized (toggleLEDCount) {
        if (toggleLEDCount > 0) {
          needToToggleLEDs = true;
          toggleLEDCount--;
        }
      }

      /* If we need to toggle the LEDs, send out the toggle LED command */
      if (needToToggleLEDs == true) {
        do {
          result =
              connection.bulkTransfer(endpointOUT, toggleLEDsPacket, toggleLEDsPacket.length, 1000);
        } while ((result < 0) && (wasCloseRequested() == false));
        needToToggleLEDs = false;
      }

      /* Send the request to read the Potentiometer */
      do {
        result =
            connection.bulkTransfer(
                endpointOUT, getPotentiometerRequest, getPotentiometerRequest.length, 1000);
      } while ((result < 0) && (wasCloseRequested() == false));

      /* Read the results of that request */
      do {
        result =
            connection.bulkTransfer(
                endpointIN, getPotentiometerResults, getPotentiometerResults.length, 1000);
      } while ((result < 0) && (wasCloseRequested() == false));

      /* Convert the resulting data to an int */
      byte[] potentiometerBuffer = new byte[] {0, 0, 0, 0};
      potentiometerBuffer[0] = getPotentiometerResults[1];
      potentiometerBuffer[1] = getPotentiometerResults[2];

      ByteBuffer buf = ByteBuffer.wrap(potentiometerBuffer);
      buf.order(ByteOrder.LITTLE_ENDIAN);
      int potentiometerResults = buf.getInt();

      /* If the new results are different from the previous results, then send
       * a message to the specified handler containing the new data.
       */

      // handler.obtainMessage(0,new MessagePotentiometer((potentiometerResults *
      // 100)/0x3FF)).sendToTarget();

      //	potentiometerLastResults = potentiometerResults;

    }
  }
 /* (non-Javadoc)
  * @see net.smartrover.skyrover2.roverlib.IUsbLink#getFirmwareVersion()
  */
 public float getFirmwareVersion() {
   byte[] rawDescs = mConnection.getRawDescriptors();
   return Float.parseFloat(
       Integer.toHexString(rawDescs[13]) + "." + Integer.toHexString(rawDescs[12]));
 }
 /* (non-Javadoc)
  * @see net.smartrover.skyrover2.roverlib.IUsbLink#getSerialNumber()
  */
 public String getSerialNumber() {
   return mConnection.getSerial();
 }
        public void run() {
          Log("USB Thread started");

          UsbEndpoint readEp = null;
          UsbDeviceConnection usbConnection = null;
          UsbInterface Intf = null;
          UsbInterface Intf0 = null;
          UsbEndpoint readEp0 = null;
          UsbEndpoint writeEp0 = null;
          byte[] readbuffer = new byte[64];

          Log("Entering Read loop");
          interfaceclaimed = false;
          while (!_shouldstop) {
            if (_usbDevice == null) {
              Log("No device. Open device and Recheck in 1 sec...");
              interfaceclaimed = false;
              FindDevice();
              Sleep(10000);
              continue;
            }
            if (!interfaceclaimed) {
              Log("Read loop Aquiring Interface 0 and Endpoint 1");
              Intf = _usbDevice.getInterface(1);
              readEp = Intf.getEndpoint(0);
              Log("Read loop Aquiring Interface 0 and Endpoint 0");
              Intf0 = _usbDevice.getInterface(0);
              readEp0 = Intf0.getEndpoint(0);
              writeEp0 = Intf0.getEndpoint(1);
              if (!_usbManager.getDeviceList().containsKey(_deviceName)) {
                Log("Failed to connect to the device. Retrying to acquire it.");
                FindDevice();
                if (!_usbManager.getDeviceList().containsKey(_deviceName)) {
                  Log("No device. Recheking in 10 sec...");
                  _connectionHandler.onDeviceNotFound();
                  Sleep(10000);
                  continue;
                }
              }

              try {

                usbConnection = _usbManager.openDevice(_usbDevice);

                if (usbConnection == null) {
                  Log(
                      "Cannot start reader because the user didn't gave me permissions or the device is not present. Retrying in 2 sec...");
                  _connectionHandler.onUSBPermissionError();
                  Sleep(2000);
                  continue;
                }

                Log("USB loop claiming interface");
                // Claim and lock the interface in the android system.
                if (usbConnection.claimInterface(Intf, true)
                    && usbConnection.claimInterface(Intf0, true)) {
                  Log("USB loop Interface claimed successful");
                  interfaceclaimed = true;
                  _connectionHandler.onUSBDeviceClaimed();
                }
              } catch (SecurityException e) {
                Log(
                    "Cannot start reader because the user didn't gave me permissions. Retrying in 2 sec...");
                interfaceclaimed = false;
                Sleep(2000);
                continue;
              }
            }
            /*
            int filed = readConnection.getFileDescriptor();
            int epaddress = readEp.getAddress();
            TeensyDeviceUsbNativeHelper nativehelper = new TeensyDeviceUsbNativeHelper(filed,64,epaddress);
            nativehelper.beginUrbReadLoop();
            byte[] buffer2 = new byte[64];
            nativehelper.readUrb(1000, buffer2);
            //_receivedQueue.add(buffer2);
              	Log(String.format("Message received of lengths %s and content: %s", 64, composeString(buffer2)));
            */
            synchronized (_writelocker) {
              // Queue a USBRequest to USB if any data is in queue
              if (_writeQueue.size() > 0) {
                byte[] writebuffer = _writeQueue.poll();
                Log(String.format("Writing to USB: %s", CAN_Frame.bytesToHexString(writebuffer)));
                // Log("USB loop sending bulk write request");
                if (usbConnection.bulkTransfer(writeEp0, writebuffer, 64, 100) < 0) {
                  // failed to transfer
                  Log("USB loop sending bulk write request FAILED");
                } // else Log("USB loop sending bulk write request SUCCEEDED");
              }
            }

            synchronized (_locker) {
              // Log("Read loop Waiting for requst to complete");
              if (usbConnection.bulkTransfer(readEp0, readbuffer, 64, 100) >= 0) {
                byte[] readbuffertrimmed = new byte[readbuffer[0]];
                System.arraycopy(readbuffer, 0, readbuffertrimmed, 0, readbuffer[0]);
                _receivedQueue.add(readbuffertrimmed);
                Log(String.format("Message received: %s", CAN_Frame.bytesToHexString(readbuffer)));
                _connectionHandler.onUSBRecieve();
              }
            }
            // Sleep for 10 ms to pause, so other thread can write data or anything.
            // As both read and write data methods lock each other - they cannot be run in parallel.
            // Looks like Android is not so smart in planning the threads, so we need to give it a
            // small time
            // to switch the thread context.
            // Sleep(10);
          }
          if (usbConnection != null) {
            usbConnection.releaseInterface(Intf);
            usbConnection.releaseInterface(Intf0);
            interfaceclaimed = false;
            usbConnection.close();
            _connectionHandler.onUsbStopped();
            Log("USB Thread ENDED!");
          }
        }