mirror of
https://github.com/mik3y/usb-serial-for-android.git
synced 2026-08-12 00:42:54 +00:00
Initial commit.
This commit is contained in:
mike wakerly
@@ -0,0 +1,376 @@
|
||||
/* Copyright 2011 Google Inc.
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
|
||||
* USA.
|
||||
*
|
||||
* Project home page: http://code.google.com/p/usb-serial-for-android/
|
||||
*/
|
||||
|
||||
package com.hoho.android.usbserial.driver;
|
||||
|
||||
import android.hardware.usb.UsbConstants;
|
||||
import android.hardware.usb.UsbDevice;
|
||||
import android.hardware.usb.UsbDeviceConnection;
|
||||
import android.hardware.usb.UsbEndpoint;
|
||||
import android.util.Log;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.util.Arrays;
|
||||
|
||||
/**
|
||||
* A {@link UsbSerialDriver} implementation for a variety of FTDI devices
|
||||
* <p>
|
||||
* This driver is based on <a
|
||||
* href="http://www.intra2net.com/en/developer/libftdi">libftdi</a>, and is
|
||||
* copyright and subject to the following terms:
|
||||
*
|
||||
* <pre>
|
||||
* Copyright (C) 2003 by Intra2net AG
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Lesser General Public License
|
||||
* version 2.1 as published by the Free Software Foundation;
|
||||
*
|
||||
* opensource@intra2net.com
|
||||
* http://www.intra2net.com/en/developer/libftdi
|
||||
* </pre>
|
||||
*
|
||||
* </p>
|
||||
* <p>
|
||||
* Some FTDI devices have not been tested; see later listing of supported and
|
||||
* unsupported devices. Devices listed as "supported" support the following
|
||||
* features:
|
||||
* <ul>
|
||||
* <li>Read and write of serial data (see {@link #read(byte[], int)} and
|
||||
* {@link #write(byte[], int)}.
|
||||
* <li>Setting baud rate (see {@link #setBaudRate(int)}).
|
||||
* </ul>
|
||||
* </p>
|
||||
* <p>
|
||||
* Supported and tested devices:
|
||||
* <ul>
|
||||
* <li>{@value DeviceType#TYPE_R}</li>
|
||||
* </ul>
|
||||
* </p>
|
||||
* <p>
|
||||
* Unsupported but possibly working devices (please contact the author with
|
||||
* feedback or patches):
|
||||
* <ul>
|
||||
* <li>{@value DeviceType#TYPE_2232C}</li>
|
||||
* <li>{@value DeviceType#TYPE_2232H}</li>
|
||||
* <li>{@value DeviceType#TYPE_4232H}</li>
|
||||
* <li>{@value DeviceType#TYPE_AM}</li>
|
||||
* <li>{@value DeviceType#TYPE_BM}</li>
|
||||
* </ul>
|
||||
* </p>
|
||||
*
|
||||
* @author mike wakerly (opensource@hoho.com)
|
||||
* @see <a href="http://code.google.com/p/usb-serial-for-android/">USB Serial
|
||||
* for Android project page</a>
|
||||
* @see <a href="http://www.ftdichip.com/">FTDI Homepage</a>
|
||||
* @see <a href="http://www.intra2net.com/en/developer/libftdi">libftdi</a>
|
||||
*/
|
||||
public class FtdiSerialDriver implements UsbSerialDriver {
|
||||
|
||||
private static final int DEFAULT_BAUD_RATE = 115200;
|
||||
|
||||
public static final int USB_TYPE_STANDARD = 0x00 << 5;
|
||||
public static final int USB_TYPE_CLASS = 0x00 << 5;
|
||||
public static final int USB_TYPE_VENDOR = 0x00 << 5;
|
||||
public static final int USB_TYPE_RESERVED = 0x00 << 5;
|
||||
|
||||
public static final int USB_RECIP_DEVICE = 0x00;
|
||||
public static final int USB_RECIP_INTERFACE = 0x01;
|
||||
public static final int USB_RECIP_ENDPOINT = 0x02;
|
||||
public static final int USB_RECIP_OTHER = 0x03;
|
||||
|
||||
public static final int USB_ENDPOINT_IN = 0x80;
|
||||
public static final int USB_ENDPOINT_OUT = 0x00;
|
||||
|
||||
public static final int USB_WRITE_TIMEOUT_MILLIS = 5000;
|
||||
public static final int USB_READ_TIMEOUT_MILLIS = 5000;
|
||||
|
||||
// From ftdi.h
|
||||
/**
|
||||
* Reset the port.
|
||||
*/
|
||||
private static final int SIO_RESET_REQUEST = 0;
|
||||
|
||||
/**
|
||||
* Set the modem control register.
|
||||
*/
|
||||
private static final int SIO_MODEM_CTRL_REQUEST = 1;
|
||||
|
||||
/**
|
||||
* Set flow control register.
|
||||
*/
|
||||
private static final int SIO_SET_FLOW_CTRL_REQUEST = 2;
|
||||
|
||||
/**
|
||||
* Set baud rate.
|
||||
*/
|
||||
private static final int SIO_SET_BAUD_RATE_REQUEST = 3;
|
||||
|
||||
/**
|
||||
* Set the data characteristics of the port.
|
||||
*/
|
||||
private static final int SIO_SET_DATA_REQUEST = 4;
|
||||
|
||||
private static final int SIO_RESET_SIO = 0;
|
||||
|
||||
public static final int FTDI_DEVICE_OUT_REQTYPE =
|
||||
UsbConstants.USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_OUT;
|
||||
|
||||
public static final int FTDI_DEVICE_IN_REQTYPE =
|
||||
UsbConstants.USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN;
|
||||
|
||||
/**
|
||||
* Size of chunks, used in {@link #write(byte[], int)}.
|
||||
*/
|
||||
private static final int WRITE_CHUNKSIZE = 4096;
|
||||
|
||||
/**
|
||||
* Length of the modem status header, transmitted with every read.
|
||||
*/
|
||||
private static final int MODEM_STATUS_HEADER_LENGTH = 2;
|
||||
|
||||
private final String TAG = FtdiSerialDriver.class.getSimpleName();
|
||||
|
||||
private UsbDevice mDevice;
|
||||
private UsbDeviceConnection mConnection;
|
||||
private DeviceType mType;
|
||||
|
||||
private final byte[] mReadBuffer = new byte[4096];
|
||||
|
||||
/**
|
||||
* FTDI chip types.
|
||||
*/
|
||||
private static enum DeviceType {
|
||||
TYPE_BM, TYPE_AM, TYPE_2232C, TYPE_R, TYPE_2232H, TYPE_4232H;
|
||||
}
|
||||
|
||||
private int mInterface = 0; /* INTERFACE_ANY */
|
||||
|
||||
private int mMaxPacketSize = 64; // TODO(mikey): detect
|
||||
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* @param usbDevice the {@link UsbDevice} to use
|
||||
* @param usbConnection the {@link UsbDeviceConnection} to use
|
||||
* @throws UsbSerialRuntimeException if the given device is incompatible
|
||||
* with this driver
|
||||
*/
|
||||
public FtdiSerialDriver(UsbDevice usbDevice, UsbDeviceConnection usbConnection) {
|
||||
if (!probe(usbDevice)) {
|
||||
throw new UsbSerialRuntimeException("Device type not supported.");
|
||||
}
|
||||
mConnection = usbConnection;
|
||||
mDevice = usbDevice;
|
||||
mType = null;
|
||||
}
|
||||
|
||||
public void reset() throws IOException {
|
||||
int result = mConnection.controlTransfer(FTDI_DEVICE_OUT_REQTYPE, SIO_RESET_REQUEST,
|
||||
SIO_RESET_SIO, 0 /* index */, null, 0, USB_WRITE_TIMEOUT_MILLIS);
|
||||
if (result != 0) {
|
||||
throw new IOException("Reset failed: result=" + result);
|
||||
}
|
||||
|
||||
// TODO(mikey): autodetect.
|
||||
mType = DeviceType.TYPE_R;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void open() throws IOException {
|
||||
boolean opened = false;
|
||||
try {
|
||||
for (int i = 0; i < mDevice.getInterfaceCount(); i++) {
|
||||
if (mConnection.claimInterface(mDevice.getInterface(i), true)) {
|
||||
Log.d(TAG, "claimInterface " + i + " SUCCESS");
|
||||
} else {
|
||||
Log.d(TAG, "claimInterface " + i + " FAIL");
|
||||
}
|
||||
}
|
||||
reset();
|
||||
setBaudRate(DEFAULT_BAUD_RATE);
|
||||
opened = true;
|
||||
} finally {
|
||||
if (!opened) {
|
||||
close();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void close() {
|
||||
mConnection.close();
|
||||
}
|
||||
|
||||
@Override
|
||||
public int read(byte[] dest, int timeoutMillis) throws IOException {
|
||||
final int readAmt = Math.min(dest.length, mReadBuffer.length);
|
||||
final UsbEndpoint endpoint = mDevice.getInterface(0).getEndpoint(0);
|
||||
|
||||
final int transferred = mConnection.bulkTransfer(endpoint, mReadBuffer, readAmt,
|
||||
timeoutMillis);
|
||||
if (transferred < MODEM_STATUS_HEADER_LENGTH) {
|
||||
throw new IOException("Expected at least " + MODEM_STATUS_HEADER_LENGTH + " bytes");
|
||||
}
|
||||
|
||||
final int nread = transferred - MODEM_STATUS_HEADER_LENGTH;
|
||||
if (nread > 0) {
|
||||
System.arraycopy(mReadBuffer, MODEM_STATUS_HEADER_LENGTH, dest, 0, nread);
|
||||
}
|
||||
return nread;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int write(byte[] src, int timeoutMillis) throws IOException {
|
||||
final UsbEndpoint endpoint = mDevice.getInterface(0).getEndpoint(0);
|
||||
int offset = 0;
|
||||
|
||||
while (offset < src.length) {
|
||||
final byte[] writeBuffer;
|
||||
final int writeLength;
|
||||
|
||||
// bulkTransfer does not support offsets; make a copy if necessary.
|
||||
writeLength = Math.min(src.length - offset, WRITE_CHUNKSIZE);
|
||||
if (offset == 0) {
|
||||
writeBuffer = src;
|
||||
} else {
|
||||
writeBuffer = Arrays.copyOfRange(src, offset, offset + writeLength);
|
||||
}
|
||||
|
||||
final int amt = mConnection.bulkTransfer(endpoint, writeBuffer, writeLength,
|
||||
timeoutMillis);
|
||||
if (amt <= 0) {
|
||||
throw new IOException("Error writing " + writeLength
|
||||
+ " bytes at offset " + offset);
|
||||
}
|
||||
offset += amt;
|
||||
}
|
||||
return offset;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int setBaudRate(int baudRate) throws IOException {
|
||||
long[] vals = convertBaudrate(baudRate);
|
||||
long actualBaudrate = vals[0];
|
||||
long index = vals[1];
|
||||
long value = vals[2];
|
||||
Log.i(TAG, "Requested baudrate=" + baudRate + ", actual=" + actualBaudrate);
|
||||
|
||||
int result = mConnection.controlTransfer(FTDI_DEVICE_OUT_REQTYPE,
|
||||
SIO_SET_BAUD_RATE_REQUEST, (int) value, (int) index,
|
||||
null, 0, USB_WRITE_TIMEOUT_MILLIS);
|
||||
if (result != 0) {
|
||||
throw new IOException("Setting baudrate failed: result=" + result);
|
||||
}
|
||||
return (int) actualBaudrate;
|
||||
}
|
||||
|
||||
private long[] convertBaudrate(int baudrate) {
|
||||
// TODO(mikey): Braindead transcription of libfti method. Clean up,
|
||||
// using more idiomatic Java where possible.
|
||||
int divisor = 24000000 / baudrate;
|
||||
int bestDivisor = 0;
|
||||
int bestBaud = 0;
|
||||
int bestBaudDiff = 0;
|
||||
int fracCode[] = {
|
||||
0, 3, 2, 4, 1, 5, 6, 7
|
||||
};
|
||||
|
||||
for (int i = 0; i < 2; i++) {
|
||||
int tryDivisor = divisor + i;
|
||||
int baudEstimate;
|
||||
int baudDiff;
|
||||
|
||||
if (tryDivisor <= 8) {
|
||||
// Round up to minimum supported divisor
|
||||
tryDivisor = 8;
|
||||
} else if (mType != DeviceType.TYPE_AM && tryDivisor < 12) {
|
||||
// BM doesn't support divisors 9 through 11 inclusive
|
||||
tryDivisor = 12;
|
||||
} else if (divisor < 16) {
|
||||
// AM doesn't support divisors 9 through 15 inclusive
|
||||
tryDivisor = 16;
|
||||
} else {
|
||||
if (mType == DeviceType.TYPE_AM) {
|
||||
// TODO
|
||||
} else {
|
||||
if (tryDivisor > 0x1FFFF) {
|
||||
// Round down to maximum supported divisor value (for
|
||||
// BM)
|
||||
tryDivisor = 0x1FFFF;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Get estimated baud rate (to nearest integer)
|
||||
baudEstimate = (24000000 + (tryDivisor / 2)) / tryDivisor;
|
||||
|
||||
// Get absolute difference from requested baud rate
|
||||
if (baudEstimate < baudrate) {
|
||||
baudDiff = baudrate - baudEstimate;
|
||||
} else {
|
||||
baudDiff = baudEstimate - baudrate;
|
||||
}
|
||||
|
||||
if (i == 0 || baudDiff < bestBaudDiff) {
|
||||
// Closest to requested baud rate so far
|
||||
bestDivisor = tryDivisor;
|
||||
bestBaud = baudEstimate;
|
||||
bestBaudDiff = baudDiff;
|
||||
if (baudDiff == 0) {
|
||||
// Spot on! No point trying
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Encode the best divisor value
|
||||
long encodedDivisor = (bestDivisor >> 3) | (fracCode[bestDivisor & 7] << 14);
|
||||
// Deal with special cases for encoded value
|
||||
if (encodedDivisor == 1) {
|
||||
encodedDivisor = 0; // 3000000 baud
|
||||
} else if (encodedDivisor == 0x4001) {
|
||||
encodedDivisor = 1; // 2000000 baud (BM only)
|
||||
}
|
||||
|
||||
// Split into "value" and "index" values
|
||||
long value = encodedDivisor & 0xFFFF;
|
||||
long index;
|
||||
if (mType == DeviceType.TYPE_2232C || mType == DeviceType.TYPE_2232H
|
||||
|| mType == DeviceType.TYPE_4232H) {
|
||||
index = (encodedDivisor >> 8) & 0xffff;
|
||||
index &= 0xFF00;
|
||||
index |= 0 /* TODO mIndex */;
|
||||
} else {
|
||||
index = (encodedDivisor >> 16) & 0xffff;
|
||||
}
|
||||
|
||||
// Return the nearest baud rate
|
||||
return new long[] {
|
||||
bestBaud, index, value
|
||||
};
|
||||
}
|
||||
|
||||
public static boolean probe(UsbDevice usbDevice) {
|
||||
// TODO(mikey): Support other devices.
|
||||
return usbDevice.getVendorId() == 0x0403 && usbDevice.getProductId() == 0x6001;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,76 @@
|
||||
/* Copyright 2011 Google Inc.
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
|
||||
* USA.
|
||||
*
|
||||
* Project home page: http://code.google.com/p/usb-serial-for-android/
|
||||
*/
|
||||
|
||||
package com.hoho.android.usbserial.driver;
|
||||
|
||||
import java.io.IOException;
|
||||
|
||||
/**
|
||||
* Driver interface for a supported USB serial device.
|
||||
*
|
||||
* @author mike wakerly (opensource@hoho.com)
|
||||
*/
|
||||
public interface UsbSerialDriver {
|
||||
|
||||
/**
|
||||
* Opens and initializes the device as a USB serial device. Upon success,
|
||||
* caller must ensure that {@link #close()} is eventually called.
|
||||
*
|
||||
* @throws IOException on error opening or initializing the device.
|
||||
*/
|
||||
public void open() throws IOException;
|
||||
|
||||
/**
|
||||
* Closes the serial device.
|
||||
*
|
||||
* @throws IOException on error closing the device.
|
||||
*/
|
||||
public void close() throws IOException;
|
||||
|
||||
/**
|
||||
* Reads as many bytes as possible into the destination buffer.
|
||||
*
|
||||
* @param dest the destination byte buffer
|
||||
* @param timeoutMillis the timeout for reading
|
||||
* @return the actual number of bytes read
|
||||
* @throws IOException if an error occurred during reading
|
||||
*/
|
||||
public int read(final byte[] dest, final int timeoutMillis) throws IOException;
|
||||
|
||||
/**
|
||||
* Writes as many bytes as possible from the source buffer.
|
||||
*
|
||||
* @param src the source byte buffer
|
||||
* @param timeoutMillis the timeout for writing
|
||||
* @return the actual number of bytes written
|
||||
* @throws IOException if an error occurred during writing
|
||||
*/
|
||||
public int write(final byte[] src, final int timeoutMillis) throws IOException;
|
||||
|
||||
/**
|
||||
* Sets the baud rate of the serial device.
|
||||
*
|
||||
* @param baudRate the desired baud rate, in bits per second
|
||||
* @return the actual rate set
|
||||
* @throws IOException on error setting the baud rate
|
||||
*/
|
||||
public int setBaudRate(final int baudRate) throws IOException;
|
||||
|
||||
}
|
||||
@@ -0,0 +1,105 @@
|
||||
/* Copyright 2011 Google Inc.
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
|
||||
* USA.
|
||||
*
|
||||
* Project home page: http://code.google.com/p/usb-serial-for-android/
|
||||
*/
|
||||
|
||||
package com.hoho.android.usbserial.driver;
|
||||
|
||||
import android.hardware.usb.UsbDevice;
|
||||
import android.hardware.usb.UsbDeviceConnection;
|
||||
import android.hardware.usb.UsbManager;
|
||||
|
||||
/**
|
||||
* Helper class to assist in detecting and building {@link UsbSerialDriver}
|
||||
* instances from available hardware.
|
||||
*
|
||||
* @author mike wakerly (opensource@hoho.com)
|
||||
*/
|
||||
public enum UsbSerialProber {
|
||||
|
||||
/**
|
||||
* Prober for {@link FtdiSerialDriver}.
|
||||
*
|
||||
* @see FtdiSerialDriver
|
||||
*/
|
||||
FTDI_SERIAL {
|
||||
@Override
|
||||
public UsbSerialDriver getDevice(final UsbManager manager, final UsbDevice usbDevice) {
|
||||
if (!FtdiSerialDriver.probe(usbDevice)) {
|
||||
return null;
|
||||
}
|
||||
final UsbDeviceConnection connection = manager.openDevice(usbDevice);
|
||||
if (connection == null) {
|
||||
return null;
|
||||
}
|
||||
return new FtdiSerialDriver(usbDevice, connection);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Builds a new {@link UsbSerialDriver} instance from the raw device, or
|
||||
* returns <code>null</code> if it could not be built (for example, if the
|
||||
* probe failed).
|
||||
*
|
||||
* @param manager the {@link UsbManager} to use
|
||||
* @param usbDevice the raw {@link UsbDevice} to use
|
||||
* @return the first available {@link UsbSerialDriver}, or {@code null} if
|
||||
* no devices could be acquired
|
||||
*/
|
||||
public abstract UsbSerialDriver getDevice(final UsbManager manager, final UsbDevice usbDevice);
|
||||
|
||||
/**
|
||||
* Acquires and returns the first available serial device among all
|
||||
* available {@link UsbDevice}s, or returns {@code null} if no device could
|
||||
* be acquired.
|
||||
*
|
||||
* @param usbManager the {@link UsbManager} to use
|
||||
* @return the first available {@link UsbSerialDriver}, or {@code null} if
|
||||
* no devices could be acquired
|
||||
*/
|
||||
public static UsbSerialDriver acquire(final UsbManager usbManager) {
|
||||
for (final UsbDevice usbDevice : usbManager.getDeviceList().values()) {
|
||||
final UsbSerialDriver probedDevice = acquire(usbManager, usbDevice);
|
||||
if (probedDevice != null) {
|
||||
return probedDevice;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Builds and returns a new {@link UsbSerialDriver} from the given
|
||||
* {@link UsbDevice}, or returns {@code null} if no drivers supported this
|
||||
* device.
|
||||
*
|
||||
* @param usbManager the {@link UsbManager} to use
|
||||
* @param usbDevice the {@link UsbDevice} to use
|
||||
* @return a new {@link UsbSerialDriver}, or {@code null} if no devices
|
||||
* could be acquired
|
||||
*/
|
||||
public static UsbSerialDriver acquire(final UsbManager usbManager, final UsbDevice usbDevice) {
|
||||
for (final UsbSerialProber prober : values()) {
|
||||
final UsbSerialDriver probedDevice = prober.getDevice(usbManager, usbDevice);
|
||||
if (probedDevice != null) {
|
||||
return probedDevice;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,46 @@
|
||||
/*
|
||||
* Copyright 2011 Google Inc.
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
|
||||
* USA.
|
||||
*/
|
||||
|
||||
package com.hoho.android.usbserial.driver;
|
||||
|
||||
/**
|
||||
* Generic unchecked exception for the usbserial package.
|
||||
*
|
||||
* @author mike wakerly (opensource@hoho.com)
|
||||
*/
|
||||
@SuppressWarnings("serial")
|
||||
public class UsbSerialRuntimeException extends RuntimeException {
|
||||
|
||||
public UsbSerialRuntimeException() {
|
||||
super();
|
||||
}
|
||||
|
||||
public UsbSerialRuntimeException(String detailMessage, Throwable throwable) {
|
||||
super(detailMessage, throwable);
|
||||
}
|
||||
|
||||
public UsbSerialRuntimeException(String detailMessage) {
|
||||
super(detailMessage);
|
||||
}
|
||||
|
||||
public UsbSerialRuntimeException(Throwable throwable) {
|
||||
super(throwable);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,149 @@
|
||||
/*
|
||||
* Copyright (C) 2006 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package com.hoho.android.usbserial.util;
|
||||
|
||||
/**
|
||||
* Clone of Android's HexDump class, for use in debugging. Cosmetic changes
|
||||
* only.
|
||||
*/
|
||||
public class HexDump {
|
||||
private final static char[] HEX_DIGITS = {
|
||||
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
|
||||
};
|
||||
|
||||
public static String dumpHexString(byte[] array) {
|
||||
return dumpHexString(array, 0, array.length);
|
||||
}
|
||||
|
||||
public static String dumpHexString(byte[] array, int offset, int length) {
|
||||
StringBuilder result = new StringBuilder();
|
||||
|
||||
byte[] line = new byte[16];
|
||||
int lineIndex = 0;
|
||||
|
||||
result.append("\n0x");
|
||||
result.append(toHexString(offset));
|
||||
|
||||
for (int i = offset; i < offset + length; i++) {
|
||||
if (lineIndex == 16) {
|
||||
result.append(" ");
|
||||
|
||||
for (int j = 0; j < 16; j++) {
|
||||
if (line[j] > ' ' && line[j] < '~') {
|
||||
result.append(new String(line, j, 1));
|
||||
} else {
|
||||
result.append(".");
|
||||
}
|
||||
}
|
||||
|
||||
result.append("\n0x");
|
||||
result.append(toHexString(i));
|
||||
lineIndex = 0;
|
||||
}
|
||||
|
||||
byte b = array[i];
|
||||
result.append(" ");
|
||||
result.append(HEX_DIGITS[(b >>> 4) & 0x0F]);
|
||||
result.append(HEX_DIGITS[b & 0x0F]);
|
||||
|
||||
line[lineIndex++] = b;
|
||||
}
|
||||
|
||||
if (lineIndex != 16) {
|
||||
int count = (16 - lineIndex) * 3;
|
||||
count++;
|
||||
for (int i = 0; i < count; i++) {
|
||||
result.append(" ");
|
||||
}
|
||||
|
||||
for (int i = 0; i < lineIndex; i++) {
|
||||
if (line[i] > ' ' && line[i] < '~') {
|
||||
result.append(new String(line, i, 1));
|
||||
} else {
|
||||
result.append(".");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return result.toString();
|
||||
}
|
||||
|
||||
public static String toHexString(byte b) {
|
||||
return toHexString(toByteArray(b));
|
||||
}
|
||||
|
||||
public static String toHexString(byte[] array) {
|
||||
return toHexString(array, 0, array.length);
|
||||
}
|
||||
|
||||
public static String toHexString(byte[] array, int offset, int length) {
|
||||
char[] buf = new char[length * 2];
|
||||
|
||||
int bufIndex = 0;
|
||||
for (int i = offset; i < offset + length; i++) {
|
||||
byte b = array[i];
|
||||
buf[bufIndex++] = HEX_DIGITS[(b >>> 4) & 0x0F];
|
||||
buf[bufIndex++] = HEX_DIGITS[b & 0x0F];
|
||||
}
|
||||
|
||||
return new String(buf);
|
||||
}
|
||||
|
||||
public static String toHexString(int i) {
|
||||
return toHexString(toByteArray(i));
|
||||
}
|
||||
|
||||
public static byte[] toByteArray(byte b) {
|
||||
byte[] array = new byte[1];
|
||||
array[0] = b;
|
||||
return array;
|
||||
}
|
||||
|
||||
public static byte[] toByteArray(int i) {
|
||||
byte[] array = new byte[4];
|
||||
|
||||
array[3] = (byte) (i & 0xFF);
|
||||
array[2] = (byte) ((i >> 8) & 0xFF);
|
||||
array[1] = (byte) ((i >> 16) & 0xFF);
|
||||
array[0] = (byte) ((i >> 24) & 0xFF);
|
||||
|
||||
return array;
|
||||
}
|
||||
|
||||
private static int toByte(char c) {
|
||||
if (c >= '0' && c <= '9')
|
||||
return (c - '0');
|
||||
if (c >= 'A' && c <= 'F')
|
||||
return (c - 'A' + 10);
|
||||
if (c >= 'a' && c <= 'f')
|
||||
return (c - 'a' + 10);
|
||||
|
||||
throw new RuntimeException("Invalid hex char '" + c + "'");
|
||||
}
|
||||
|
||||
public static byte[] hexStringToByteArray(String hexString) {
|
||||
int length = hexString.length();
|
||||
byte[] buffer = new byte[length / 2];
|
||||
|
||||
for (int i = 0; i < length; i += 2) {
|
||||
buffer[i / 2] = (byte) ((toByte(hexString.charAt(i)) << 4) | toByte(hexString
|
||||
.charAt(i + 1)));
|
||||
}
|
||||
|
||||
return buffer;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,181 @@
|
||||
/* Copyright 2011 Google Inc.
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
|
||||
* USA.
|
||||
*
|
||||
* Project home page: http://code.google.com/p/usb-serial-for-android/
|
||||
*/
|
||||
|
||||
package com.hoho.android.usbserial.util;
|
||||
|
||||
import android.hardware.usb.UsbRequest;
|
||||
import android.util.Log;
|
||||
|
||||
import com.hoho.android.usbserial.driver.UsbSerialDriver;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.nio.ByteBuffer;
|
||||
|
||||
/**
|
||||
* Utility class which services a {@link UsbSerialDriver} in its {@link #run()}
|
||||
* method.
|
||||
*
|
||||
* @author opensource@hoho.com (mike wakerly)
|
||||
*/
|
||||
public class SerialInputOutputManager implements Runnable {
|
||||
|
||||
private static final String TAG = SerialInputOutputManager.class.getSimpleName();
|
||||
private static final boolean DEBUG = true;
|
||||
|
||||
private static final int READ_WAIT_MILLIS = 200;
|
||||
private static final int BUFSIZ = 4096;
|
||||
|
||||
private final UsbSerialDriver mDriver;
|
||||
|
||||
private final ByteBuffer mReadBuffer = ByteBuffer.allocate(BUFSIZ);
|
||||
private final ByteBuffer mWriteBuffer = ByteBuffer.allocate(BUFSIZ);
|
||||
|
||||
private enum State {
|
||||
STOPPED,
|
||||
RUNNING,
|
||||
STOPPING
|
||||
}
|
||||
|
||||
// Synchronized by 'this'
|
||||
private State mState = State.STOPPED;
|
||||
|
||||
// Synchronized by 'this'
|
||||
private Listener mListener;
|
||||
|
||||
public interface Listener {
|
||||
/**
|
||||
* Called when new incoming data is available.
|
||||
*/
|
||||
public void onNewData(byte[] data);
|
||||
|
||||
/**
|
||||
* Called when {@link SerialInputOutputManager#run()} aborts due to an
|
||||
* error.
|
||||
*/
|
||||
public void onRunError(Exception e);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new instance with no listener.
|
||||
*/
|
||||
public SerialInputOutputManager(UsbSerialDriver driver) {
|
||||
this(driver, null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new instance with the provided listener.
|
||||
*/
|
||||
public SerialInputOutputManager(UsbSerialDriver driver, Listener listener) {
|
||||
mDriver = driver;
|
||||
mListener = listener;
|
||||
}
|
||||
|
||||
public synchronized void setListener(Listener listener) {
|
||||
mListener = listener;
|
||||
}
|
||||
|
||||
public synchronized Listener getListener() {
|
||||
return mListener;
|
||||
}
|
||||
|
||||
public void writeAsync(byte[] data) {
|
||||
mWriteBuffer.put(data);
|
||||
}
|
||||
|
||||
public synchronized void stop() {
|
||||
if (getState() == State.RUNNING) {
|
||||
Log.i(TAG, "Stop requested");
|
||||
mState = State.STOPPING;
|
||||
}
|
||||
}
|
||||
|
||||
private synchronized State getState() {
|
||||
return mState;
|
||||
}
|
||||
|
||||
/**
|
||||
* Continuously services the read and write buffers until {@link #stop()} is
|
||||
* called, or until a driver exception is raised.
|
||||
*
|
||||
* NOTE(mikey): Uses inefficient read/write-with-timeout.
|
||||
* TODO(mikey): Read asynchronously with {@link UsbRequest#queue(ByteBuffer, int)}
|
||||
*/
|
||||
@Override
|
||||
public void run() {
|
||||
synchronized (this) {
|
||||
if (getState() != State.STOPPED) {
|
||||
throw new IllegalStateException("Already running.");
|
||||
}
|
||||
mState = State.RUNNING;
|
||||
}
|
||||
|
||||
Log.i(TAG, "Running ..");
|
||||
try {
|
||||
while (true) {
|
||||
if (getState() != State.RUNNING) {
|
||||
Log.i(TAG, "Stopping mState=" + getState());
|
||||
break;
|
||||
}
|
||||
step();
|
||||
}
|
||||
} catch (Exception e) {
|
||||
Log.w(TAG, "Run ending due to exception: " + e.getMessage(), e);
|
||||
final Listener listener = getListener();
|
||||
if (listener != null) {
|
||||
listener.onRunError(e);
|
||||
}
|
||||
} finally {
|
||||
synchronized (this) {
|
||||
mState = State.STOPPED;
|
||||
Log.i(TAG, "Stopped.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void step() throws IOException {
|
||||
// Handle incoming data.
|
||||
int len = mDriver.read(mReadBuffer.array(), READ_WAIT_MILLIS);
|
||||
if (len > 0) {
|
||||
if (DEBUG) Log.d(TAG, "Read data len=" + len);
|
||||
final Listener listener = getListener();
|
||||
if (listener != null) {
|
||||
final byte[] data = new byte[len];
|
||||
mReadBuffer.get(data, 0, len);
|
||||
listener.onNewData(data);
|
||||
}
|
||||
mReadBuffer.clear();
|
||||
}
|
||||
|
||||
// Handle outgoing data.
|
||||
if (mWriteBuffer.position() > 0) {
|
||||
final byte[] outBuff;
|
||||
synchronized (mWriteBuffer) {
|
||||
len = mWriteBuffer.position();
|
||||
outBuff = new byte[len];
|
||||
mWriteBuffer.get(outBuff, 0, len);
|
||||
mWriteBuffer.clear();
|
||||
}
|
||||
if (DEBUG)
|
||||
Log.d(TAG, "Writing data len=" + len);
|
||||
mDriver.write(outBuff, READ_WAIT_MILLIS);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user