最近做了个平板与单片机的项目，由于使用的平板不支持串口，所以中间借助了usb-串口转换器(PL2303)。

这方面的资料可以说少之又少，几乎没有，我唯一能找到的就是usb-serial-for-android，一个国外的开源项目。

实现了一些主要的转换器的驱动，但是国内一般用得最多的还是PL2303。

我将usb-serial-for-android的驱动简化了下，成功的与串口调试工具通信了，能读，能写。给大家分享下。

或者直接下载

驱动源码：package com.example.android_usb;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.lang.reflect.Method;

import android.app.PendingIntent;

import android.content.Context;

import android.content.Intent;

import android.hardware.usb.UsbConstants;

import android.hardware.usb.UsbDevice;

import android.hardware.usb.UsbDeviceConnection;

import android.hardware.usb.UsbEndpoint;

import android.hardware.usb.UsbInterface;

import android.hardware.usb.UsbManager;

import android.util.Log;

import android.widget.Toast;

/**

* PL2303串口驱动

* @author pc

*

*/

public class ProlificSerialDriver {

private static final int USB_READ_TIMEOUT_MILLIS = 5000;

private static final int USB_WRITE_TIMEOUT_MILLIS = 3000;

private final Object mReadBufferLock = new Object();

private final Object mWriteBufferLock = new Object();

private byte[] buffer = new byte[4096];

private ByteArrayOutputStream bufferOS = new ByteArrayOutputStream();

private Context context;

private UsbEndpoint mReadEndpoint;

private UsbEndpoint mWriteEndpoint;

private UsbDeviceConnection connection;

private UsbDevice usbDevice;

public ProlificSerialDriver(Context context, UsbDevice usbDevice){

this.context = context;

this.usbDevice = usbDevice;

}

/**

* 安装

* @param baudRate

* @throws IOException

*/

public void setup(int baudRate) throws IOException{

open();

initPL2303Chip();

ctrlOut(baudRate);

}

private void open() throws IOException{

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

//申请权限

PendingIntent mPermissionIntent = PendingIntent.getBroadcast(context, 0, new Intent("com.prolific.pl2303hxdsimpletest.USB_PERMISSION"), 0);

usbManager.requestPermission(usbDevice, mPermissionIntent);

UsbInterface usbInterface = usbDevice.getInterface(0);

for (int i = 0; i

UsbEndpoint currentEndpoint = usbInterface.getEndpoint(i);

switch (currentEndpoint.getAddress()) {

case 0x83:

mReadEndpoint = currentEndpoint;

break;

case 0x02:

mWriteEndpoint = currentEndpoint;

break;

}

}

connection = usbManager.openDevice(usbDevice);

connection.claimInterface(usbInterface, true);

}

private final void ctrlOut(int baudRate) throws IOException {

//设置传输控制

byte[] lineRequestData = new byte[7];

lineRequestData[0] = (byte) (baudRate & 0xff);

lineRequestData[1] = (byte) ((baudRate >> 8) & 0xff);

lineRequestData[2] = (byte) ((baudRate >> 16) & 0xff);

lineRequestData[3] = (byte) ((baudRate >> 24) & 0xff);

lineRequestData[4] = 0;

lineRequestData[5] = 0;

lineRequestData[6] = (byte) 8;

outControlTransfer(UsbConstants.USB_DIR_OUT | UsbConstants.USB_TYPE_CLASS | 0x01, 0x20, 0, 0, lineRequestData);

}

/**

* 初始化芯片

* @throws IOException

*/

private void initPL2303Chip() throws IOException{

int mDeviceType = getDeviceType();

vendorIn(0x8484, 0, 1);

vendorOut(0x0404, 0, null);

vendorIn(0x8484, 0, 1);

vendorIn(0x8383, 0, 1);

vendorIn(0x8484, 0, 1);

vendorOut(0x0404, 1, null);

vendorIn(0x8484, 0, 1);

vendorIn(0x8383, 0, 1);

vendorOut(0, 1, null);

vendorOut(1, 0, null);

vendorOut(2, (mDeviceType == 0) ? 0x44 : 0x24, null);

}

/**

* 获得设备类型

*/

private int getDeviceType(){

int mDeviceType = 0;

try {

if (usbDevice.getDeviceClass() == 0x02) {

mDeviceType = 1;

} else{

Method getRawDescriptorsMethod = connection.getClass().getMethod("getRawDescriptors");

byte[] rawDescriptors = (byte[]) getRawDescriptorsMethod.invoke(connection);

byte maxPacketSize0 = rawDescriptors[7];

if (maxPacketSize0 == 64) {

mDeviceType = 0;

} else if ((usbDevice.getDeviceClass() == 0x00) || (usbDevice.getDeviceClass() == 0xff)) {

mDeviceType = 2;

} else {

mDeviceType = 0;

}

}

}catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return mDeviceType;

}

/**

* 写

* @param buf

* @param wlength

* @return

*/

public int write(byte[] buf, int wlength) {

int offset = 0;

byte[] write_buf = new byte[4096];

synchronized (mWriteBufferLock) {

while (offset

int write_size = 4096;

if (offset + write_size > wlength) {

write_size = wlength - offset;

}

System.arraycopy(buf, offset, write_buf, 0, write_size);

int actual_length = this.connection.bulkTransfer(this.mWriteEndpoint, write_buf, write_size, USB_WRITE_TIMEOUT_MILLIS);

if (actual_length

return -1;

}

offset += actual_length;

}

}

return offset;

}

/**

* 读取

* @param timeoutMillis

* @throws IOException

*/

public byte[] read() throws IOException {

synchronized (mReadBufferLock) {

try {

bufferOS.reset();

int number = 0;

while(number != -1){

number = connection.bulkTransfer(mReadEndpoint, buffer, buffer.length, USB_READ_TIMEOUT_MILLIS);

MainActivity.showMessage("number:"+number);

bufferOS.write(buffer, 0, number);

}

} catch (Exception e) {

e.printStackTrace();

}

}

return bufferOS.toByteArray();

}

/**

* 关闭资源

*/

public void close(){

try {

if (connection == null) {

return ;

}

connection.releaseInterface(this.usbDevice.getInterface(0));

} catch (Exception e) {

e.printStackTrace();

}

}

/**

* 输出的传输

* @throws IOException

*/

private final void outControlTransfer(int requestType, int request, int value, int index, byte[] data) throws IOException {

int length = (data == null) ? 0 : data.length;

int result = connection.controlTransfer(requestType, request, value, index, data, length, USB_WRITE_TIMEOUT_MILLIS);

if (result != length) {

throw new IOException(String.format("ControlTransfer with value 0x%x failed: %d", value, result));

}

}

/**

* 输入的传输

* @throws IOException

*/

private final byte[] inControlTransfer(int requestType, int request, int value, int index, int length) throws IOException {

byte[] buffer = new byte[length];

int result = connection.controlTransfer(requestType, request, value, index, buffer, length, USB_READ_TIMEOUT_MILLIS);

if (result != length) {

throw new IOException(String.format("ControlTransfer with value 0x%x failed: %d", value, result));

}

return buffer;

}

/**

* 写设备控制

*/

private final byte[] vendorIn(int value, int index, int length)throws IOException {

return inControlTransfer(UsbConstants.USB_DIR_IN | UsbConstants.USB_TYPE_VENDOR, 0x01, value, index, length);

}

/**

* 读设备控制

*/

private final void vendorOut(int value, int index, byte[] data)throws IOException {

outControlTransfer(UsbConstants.USB_DIR_OUT | UsbConstants.USB_TYPE_VENDOR, 0x01, value, index, data);

}

}