• Android系统开发-添加USB转串口设备驱动i.MX8M开发（android usb转串口驱动）
• 2000系统usb转串口驱动程序
• Android USB转串口通信开发实例详解
• Android之USB转串口通信-基本流程
• Android开发Usb转移

Android系统开发-添加USB转串口设备驱动i.MX8M开发（android usb转串口驱动）

2000系统usb转串口驱动程序

对于 windows 2000 系统的 usb 转串口设备，需要安装相应的驱动程序以进行通信。驱动程序安装步骤如下： 1. 下载制造商提供的驱动程序； 2. 运行安装程序并按照提示进行操作。常见问题： 1. 设备未识别时，可能需要安装驱动程序； 2. 正确驱动程序可在制造商网站或设备管理器中查找； 3. 安装后需重启计算机； 4. 设备端口号可在设备管理器“端口”选项卡中查看； 5. 无法安装时，请检查驱动程序正确性、重新安装或联系制造商。

2000系统usb转串口驱动程序

简介

USB转串口驱动程序是连接USB设备和串口设备之间的桥梁，使计算机能够与传统串口设备进行通信。對於Windows 2000系統，需要安裝適當的驅動程式才能使用USB轉串口設備。

安装驱动程序

1. 下载驱动程序：从制造商的网站下载正确的USB转串口驱动程序。
2. 运行安装程序：双击下载的驱动程序安装程序文件，然后按照屏幕上的说明进行操作。

常见问题

1. 如何知道我的USB转串口设备需要驱动程序？

如果您的设备未被计算机识别，则可能需要安装驱动程序。

2. 如何找到正确的驱动程序？

您通常可以在制造商的网站上找到正确的驱动程序。如果找不到，请尝试使用设备管理器更新驱动程序。

3. 安装驱动程序后，我需要做什么？

安装驱动程序后，应重新启动计算机以完成安装。

4. 我在哪里可以找到设备的端口号？

在设备管理器中，可以找到设备的端口号。右键单击设备，然后选择“属性”>“端口”选项卡。

5. 如果我无法安装驱动程序怎么办？

• 确认已下载正确的驱动程序。
• 尝试卸载并重新安装驱动程序。
• 检查设备管理器是否有任何错误消息。
• 联系制造商以获取帮助。

提示

• 确保您的USB转串口设备与您的计算机兼容。
• 如果您遇到任何问题，请参阅制造商的用户手册。
• 定期更新驱动程序以确保设备正常运行。

以上就是2000系统usb转串口驱动程序的详细内容，更多请关注php中文网其它相关文章！

Android USB转串口通信开发实例详解

 Android USB转串口通信开发实例详解

好久没有写文章了，年前公司新开了一个项目，是和usb转串口通信相关的，需求是用安卓平板通过usb转接后与好几个外设进行通信，一直忙到最近，才慢慢闲下来，趁着这个周末不忙，记录下usb转串口通信开发的基本流程。

我们开发使用的是usb主机模式，即：安卓平板作为主机，usb外设作为从机进行数据通信。整个开发流程可以总结为以下几点：

1.发现设备

UsbManager usbManager = (UsbManager) context.getSystemService(Context.USB_SERVICE);
Map<String,UsbDevice> usbList = usbManager.getDeviceList();

通过UsbManager这个系统提供的类，我们可以枚举出当前连接的所有usb设备，我们主要需要的是UsbDevice对象，关于UsbDevice这个类，官方是这样注释的：

This class represents a USB device attached to the android device with the android device
 acting as the USB host.

是的，这个类就代表了Android所连接的usb设备。

2.打开设备

接下来，我们需要打开刚刚搜索到的usb设备，我们可以将平板与usb外设之间的连接想象成一个通道，只有把通道的门打开后，两边才能进行通信。

一般来说，在没有定制的android设备上首次访问usb设备的时候，默认我们是没有访问权限的，因此我们首先要判断对当前要打开的usbDevice是否有访问权限：

if (!usbManager.hasPermission(usbDevice)) {
    usbPermissionReceiver = new UsbPermissionReceiver();
    //申请权限
    Intent intent = new Intent(ACTION_DEVICE_PERMISSION);
    PendingIntent mPermissionIntent = PendingIntent.getbroadcast(context,intent,0);
    IntentFilter permissionFilter = new IntentFilter(ACTION_DEVICE_PERMISSION);
    context.registerReceiver(usbPermissionReceiver,permissionFilter);
    usbManager.requestPermission(usbDevice,mPermissionIntent);
    }

这里我们声明一个广播UsbPermissionReceiver，当接受到授权成功的广播后做一些其他处理：

 private class UsbPermissionReceiver extends broadcastReceiver {
    public void onReceive(Context context,Intent intent) {
      String action = intent.getAction();
      if (ACTION_DEVICE_PERMISSION.equals(action)) {
        synchronized (this) {
          UsbDevice device = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
          if (device.getDeviceName().equals(usbDevice.getDeviceName()) {
            if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED,false)) {
             //授权成功,在这里进行打开设备操作
            } else {
             //授权失败
            }
          }
        }
      }
    }
  }

接下来，我们要找到具有数据传输功能的接口UsbInterface，从它里边儿找到数据输入和输出端口UsbEndpoint，一般情况下，一个usbDevice有多个UsbInterface，我们需要的一般是第一个，所以：

usbInterface=usbDevice.getInterface(0);

同样的，一个usbInterface有多个UsbEndpoint，有控制端口和数据端口等，因此我们需要根据类型和数据流向来找到我们需要的数据输入和输出两个端口：

for (int index = 0; index < usbInterface.getEndpointCount(); index++) {
        UsbEndpoint point = usbInterface.getEndpoint(index);
        if (point.getType() == UsbConstants.USB_ENDPOINT_XFER_BULK) {
          if (point.getDirection() == UsbConstants.USB_DIR_IN) {
            usbEndpointIn = point;
          } else if (point.getDirection() == UsbConstants.USB_DIR_OUT) {
            usbEndpointOut = point;
          }
        }
      }

最后，才是真正的打开usb设备，我们需要和usb外设建立一个UsbDeviceConnection，它的注释很简介的说明了它的用途：

This class is used for sending and receiving data and control messages to a USB device.

它的获取也很简单，就一句代码：

usbDeviceConnection = usbManager.openDevice(usbDevice);

到这里，理论上平板和usb外设之间的连接已经建立了，也可以首发数据了，但是，我们大部分情况下还需要对usb串口进行一些配置，比如波特率,停止位,数据控制等，不然两边配置不同，收到的数据会乱码。具体怎么配置，就看你使用的串口芯片是什么了，目前流行的有pl2303,ch340等，由于篇幅问题，需要具体配置串口代码的朋友私信我我发给你。

3.数据传输

到这里，我们已经可以与usb外设进行数据传输了，首先来看怎么向usb设备发送数据。

 1.向usb外设发送数据

在第二步中，我们已经获取了数据的输出端口usbEndpointIn，我们向外设发送数据就是通过这个端口来实现的。来看怎么用：

int ret = usbDeviceConnection.bulkTransfer(usbEndpointOut,data,data.length,DEFAULT_TIMEOUT);

bulkTransfer这个函数用于在给定的端口进行数据传输，第一个参数就是此次传输的端口，这里我们用的输出端口，第二个参数是要发送的数据，类型为字节数组，第三个参数代表要发送的数据长度，最后一个参数是超时，返回值代表发送成功的字节数，如果返回-1，那就是发送失败了。

2.接受usb外设发送来的数据

同理，我们已经找到了数据输入端口usbEndpointIn，因为数据的输入是不定时的，因此我们可以另开一个线程，来专门接受数据，接受数据的代码如下：

int inMax = inEndpoint.getMaxPacketSize(); 
ByteBuffer byteBuffer = ByteBuffer.allocate(inMax); 
UsbRequest usbRequest = new UsbRequest(); 
usbRequest.initialize(connection,inEndpoint); 
usbRequest.queue(byteBuffer,inMax); 
if(connection.requestWait() == usbRequest){ 
  byte[] retData = byteBuffer.array(); 
  for(Byte byte1 : retData){ 
    System.err.println(byte1); 
  } 
}

以上，就是usb转串口通信的基本流程，有些地方写的不是很全面，比如接收usb外设数据的方法应该还有别的，不足之处欢迎指正。

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！

Android之USB转串口通信-基本流程

背景：近期公司一个项目对接第三方支付设备（类似平板的设备外接usb转串口设备），需要使用usb转串口，实现通信和交互，今天记下过程。

有引用这个库 https://github.com/mik3y/usb-serial-for-android，感谢开源的大佬。

这个库已经集合了一般的芯片协议，就不需要自己再配置了。我们设备是用的ProlificSerialDriver.

唯一要注意的是配置设备的参数：波特率，数据位，体制位，奇偶校验等。其中我就在奇偶校验的参数配置上坑了一把。

只需要按照流程，注意些细节就能跑。

贴下核心的几段代码：

import android.hardware.usb.UsbDevice
import android.hardware.usb.UsbDeviceConnection
import android.hardware.usb.UsbManager
import com.hoho.android.usbserial.driver.UsbSerialPort
import com.hoho.android.usbserial.driver.UsbSerialProber

class ZYDataSource(){
    var mUsbSeriaPortManager: USBSerialPortManager? = null
    private var usbDeviceConnection: UsbDeviceConnection? = null
    private var mDevice: UsbDevice? = null
    private var mUsbSerialPort: UsbSerialPort? = null
    private var usbPermissionReceiver: UsbPermissionReceiver? = null

    private var mUsbManager: UsbManager? = null
    
    /**
    * 初始化
    */
    override fun initCompletable(context: Context): Completable {
        return Completable.create() {
            mUsbManager = context.getSystemService(Context.USB_SERVICE) as UsbManager
            //查找所有设备
            val driversList = UsbSerialProber.getDefaultProber().findAllDrivers(mUsbManager)
            if (driversList == null || driversList.size == 0) {
                throw Exception("未找到设备")
            }
            //直接取第一个.
            mDevice = driversList.first().device

            if (!mUsbManager?.hasPermission(mDevice)!!) {
                usbPermissionReceiver = UsbPermissionReceiver()
                //申请权限
                val intent = Intent(ACTION_DEVICE_PERMISSION)
                val mPermissionIntent = PendingIntent.getbroadcast(context, 0, intent, 0)
                val permissionFilter = IntentFilter(ACTION_DEVICE_PERMISSION)
                context.registerReceiver(usbPermissionReceiver, permissionFilter)
                mUsbManager?.requestPermission(mDevice, mPermissionIntent)
            } else {
                this.openDeviceConnection(device = mDevice!!)
            }

            it.onComplete()
        }
    }

    inner class UsbPermissionReceiver : broadcastReceiver() {
        override fun onReceive(p0: Context?, intent: Intent?) {
            val action = intent?.getAction()
            if (ACTION_DEVICE_PERMISSION.equals(action)) {
                synchronized(this) {
                    val device = intent.getParcelableExtra<UsbDevice>(UsbManager.EXTRA_DEVICE)
                    openDeviceConnection(device)
                }
            }
        }

    }
    
    /**
    * 打开连接
    */
    fun openDeviceConnection(device: UsbDevice) {
        synchronized(this) {
            //授权成功,在这里进行打开设备操作
            val availableDrivers = UsbSerialProber.getDefaultProber().findAllDrivers(mUsbManager)
            if (availableDrivers.isEmpty()) {
                return
            }

            // Open a connection to the first available driver.
            val driver = availableDrivers[0]
            // Read some data! Most have just one port (port 0).
            mUsbSerialPort = driver.ports[0]
            try {
                mUsbSeriaPortManager = USBSerialPortManager(mUsbSerialPort!!)
                usbDeviceConnection = mUsbManager?.openDevice(device)
                mUsbSerialPort?.open(usbDeviceConnection)
                mUsbSerialPort?.setParameters(9600, 8, UsbSerialPort.STOPBITS_1, UsbSerialPort.PARITY_EVEN)
            } catch (e: Exception) {
                XLog.tag(TAG).e(e.message)
                throw Exception("设备初始化失败")
            }

        }
    }

    /**
    * 实际通信调用方法-找卡
    */
    override fun searchCardSingle(requestData: ByteArray): Single<ByteArray>                     {
        return Single.just(requestData)
            .flatMap { data ->
                val command = USBSerialPortManager.Command(data, data.size)
                //通信
                mUsbSeriaPortManager!!.execute(command)
            }
            .flatMap {
                Single.just(it.rxBytes)
            }
    }
}

下面这个是USBSerialPortManager工具类

import com.hoho.android.usbserial.driver.UsbSerialPort
import io.reactivex.Single
import io.reactivex.schedulers.Schedulers


class USBSerialPortManager(private val usbSerialPort: UsbSerialPort,
                           private val writeTimeout: Int = 100,
                           private val readTimeout: Int = 50) {
    open class Command(val hex: String, var rxLength: Int = 0, var rx: String = "") {
        val bytes: ByteArray
            get() = hex.hexStringToByteArray()
        val rxBytes: ByteArray
            get() = rx.hexStringToByteArray()

        constructor(bytes: ByteArray, rxLength: Int) : this(bytes.toHex(), rxLength, "")
    }

    private fun runOnceSingle(command: Command, timeoutInMillis: Int = 2000): Single<Command> {
        return Single.create {
            XLog.tag(TAG).i("send data=${command.hex} to $usbSerialPort")
            val txBytes = command.hex.hexStringToByteArray()
            usbSerialPort.write(txBytes, writeTimeout)

            if (command.rxLength <= 0) {
                command.rx = ""
                it.onSuccess(command)
                return@create
            }

            var times = 0L
            val interval = 2L
            val bytes = ByteArray(command.rxLength)
            var totalLength = 0
            while (totalLength < command.rxLength) {
                val bytesToRead = ByteArray(command.rxLength - totalLength)
                val n = usbSerialPort.read(bytesToRead, readTimeout)
                if (n > 0) {
                    for (i in 0 until n) {
                        bytes[totalLength + i] = bytesToRead[i]
                    }
                    totalLength += n
                }
                Thread.sleep(interval)
                times += interval
                if (times > timeoutInMillis) {
                    XLog.tag(TAG).e("read data from $usbSerialPort timeout, expect ${command.rxLength} bytes")
                    it.onError(Exception("read data from $usbSerialPort timeout, expect ${command.rxLength} bytes"))
                    return@create
                }
            }
            command.rx = bytes.toHex()
            XLog.tag(TAG).i("recv data=${command.rx} from $usbSerialPort")
            it.onSuccess(command)
        }
    }

    fun execute(command: Command, retryTimes: Long = 0L): Single<Command> {
        return runOnceSingle(command).retry(retryTimes).subscribeOn(Schedulers.single())
    }

    companion object {
        const val TAG = "USBSerialPortManager"
    }
}

代码是kotlin语言，没有写注释，目前项目已上线。工具类基本可以通用。

Android开发Usb转移

我们今天的关于Android系统开发-添加USB转串口设备驱动i.MX8M开发和android usb转串口驱动的分享就到这里，谢谢您的阅读，如果想了解更多关于2000系统usb转串口驱动程序、Android USB转串口通信开发实例详解、Android之USB转串口通信-基本流程、Android开发Usb转移的相关信息，可以在本站进行搜索。