USB 串口通信

val usbManager = context.getSystemService(Context.USB_SERVICE) as UsbManager?
// 遍历 usb 设备
val devices = usbManager?.deviceList?.values?.toList()
devices?.forEach { usbDevice ->
    println("--> usbDevice.deviceName: ${usbDevice.deviceName}")
    println("--> usbDevice.vendorId: ${usbDevice.vendorId}")
    println("--> usbDevice.productId: ${usbDevice.productId}")
}

var usbDeviceConnection: UsbDeviceConnection? = null
var mReadEndpoint: UsbEndpoint? = null
var mWriteEndpoint: UsbEndpoint? = null
var mDevice: UsbDevice? = null

// 请求连接 ch340 设备
devices?.find { it.vendorId == 6790 && it.productId == 29987 }?.let { device ->
    mDevice = device

    if (!usbManager.hasPermission(device)) {
        // 没有访问设备的权限，先申请访问 USB 设备权限
        val usbPermissionIntent = PendingIntent.getBroadcast(
            context,
            0,
            Intent("${context.packageName}.USB_PERMISSION"),
            PendingIntent.FLAG_IMMUTABLE
        )
        usbManager.requestPermission(device, usbPermissionIntent)
        return
    }

    try {
        // 连接设备
        usbDeviceConnection = usbManager.openDevice(device)
        // 选择一个设备接口 UsbInterface, 此设备只有一个接口
        println("--> device.interfaceCount = ${device.interfaceCount}")
        val dataInterface: UsbInterface = device.getInterface(device.interfaceCount - 1)
        // 声明对设备接口的独占访问权，必须在设备端点 UsbEndpoints 上发送或接收数据之前完成
        usbDeviceConnection?.claimInterface(dataInterface, true)

        // 获取此接口的读写端点
        for (i in 0 until dataInterface.endpointCount) {
            val ep = dataInterface.getEndpoint(i)
            // 使用 bulk endpoint 批量传输端口
            if (ep.type == UsbConstants.USB_ENDPOINT_XFER_BULK) {
                if (ep.direction == UsbConstants.USB_DIR_IN) {
                    // 数据方向是 IN（设备到主机）
                    mReadEndpoint = ep
                } else {
                    // 数据方向是 OUT（主机到设备）
                    mWriteEndpoint = ep
                }
            }
        }
    } catch (e: Exception) {
        e.printStackTrace()
    }
}

/**
* Performs a control transaction on endpoint zero for this device.
* The direction of the transfer is determined by the request type.
* If requestType & {@link UsbConstants#USB_ENDPOINT_DIR_MASK} is
* {@link UsbConstants#USB_DIR_OUT}, then the transfer is a write,
* and if it is {@link UsbConstants#USB_DIR_IN}, then the transfer
* is a read.
* <p>
* This method transfers data starting from index 0 in the buffer.
* To specify a different offset, use
* {@link #controlTransfer(int, int, int, int, byte[], int, int, int)}.
* </p>
*
* @param requestType request type for this transaction
* @param request request ID for this transaction
* @param value value field for this transaction
* @param index index field for this transaction
* @param buffer buffer for data portion of transaction,
* or null if no data needs to be sent or received
* @param length the length of the data to send or receive
* @param timeout in milliseconds
* @return length of data transferred (or zero) for success,
* or negative value for failure
*/
public int controlTransfer(int requestType, int request, int value, int index, byte[] buffer, int length, int timeout) {
    return controlTransfer(requestType, request, value, index, buffer, 0, length, timeout);
}

/**
 * 串口通信配置
 * @param baud - 波特率
 * @param dataBits - 数据位 - 取值 5，6，7，8
 * @param stopBits - 停止位 - 取值 1，2
 * @param parity - 校验类型 - 取值 0 (无校验)，1 (奇校验)，2 (偶校验)，3 (1校验-校验位始终为1)，4 (0校验-校验位始终为0)
 */
private fun setConfig(baud: Int = 9600, dataBits: Int = 8, stopBits: Int = 1, parity: Int = 0) {
    val baudPair = splitBaudRate(baud)
    var regValue: Int = 0
    var value: Int = 0
    var index: Int = 0

    // 停止位
    if (stopBits == 2) regValue = regValue or 0x04 // CH341_L_SB
    // 校验类型
    regValue = when(parity) {
        1 -> regValue or 0x08 // CH341_L_PO
        2 -> regValue or 0x18 // CH341_L_PE
        3 -> regValue or 0x28 // CH341_L_PM
        4 -> regValue or 0x38 // CH341_L_PS
        else -> regValue
    }
    // 数据位
    regValue = when(dataBits) {
        5 -> regValue or 0x00 // CH341_L_D5
        6 -> regValue or 0x01 // CH341_L_D6
        7 -> regValue or 0x02 // CH341_L_D7
        else -> regValue or 0x03 // CH341_L_D8
    }

    regValue = regValue or 0xc0
    value = value or 0x9c
    value = value or (regValue shl 8)

    index = index or (0x80 or baudPair.second)
    index = index or (baudPair.first shl 8)

    println(String.format("--> baud rate=%d, factor=0x%04x, divisor=0x%04x", baud, baudPair.first, baudPair.second))
    println(String.format("--> request = 0xA1, value=0x%04x, index=0x%04x", value, index))
    usbDeviceConnection?.controlTransfer(
        UsbConstants.USB_TYPE_VENDOR or UsbConstants.USB_DIR_OUT,
        0xA1,
        value, index, null, 0, 2000
    )
}

/**
 * 拆分波特率
 * @param baud - 波特率
 * @return Pari<Int, Int> - factor to divisor
 */
private fun splitBaudRate(baud: Int): Pair<Int, Int> {
    var a = 0x0
    var b = 0x0
    var c = 0x0
    when(baud) {
        921600 -> {
            a = 0xf3
            b = 0x07
        }
        307200 -> {
            a = 0xd9
            b = 0x07
        }
        else -> {
            if (baud > 6000000 / 255) {
                b = 0x03
                c = 6000000
            } else if (baud > 750000 / 255) {
                b = 0x02
                c = 750000
            } else if (baud > 93750 / 255) {
                b = 0x01
                c = 93750
            } else {
                b = 0x0
                c = 11719
            }
            a = c / baud
            if (a == 0 || a == 0xff) throw Exception("baud rate error")
            if ((c / a - baud) > (baud - c / (a + 1))) a++
            a = 256 - a
        }
    }
    return a to b
}

private fun send(content: String) {
    val bytes = content.toByteArray()
    val length = usbDeviceConnection?.bulkTransfer(mWriteEndpoint, bytes, bytes.size, 2000)
    println("--> 发送成功: length =$length")
}

private fun receive() {
    readThread = Thread {
        val readBuffer = ByteBuffer.allocate(mReadEndpoint?.maxPacketSize ?: 1024)
        val buffer: ByteArray = readBuffer.array()
        while (readThreadState == 1) {
            val len = usbDeviceConnection?.bulkTransfer(mReadEndpoint, buffer, buffer.size, 2000)
            len?.takeIf { it > 0 }?.let {
                val data = ByteArray(len)
                System.arraycopy(buffer, 0, data, 0, len)
                val content = data.toString(Charset.defaultCharset())
                println("--> received data: length = $len, content = $content")
            }
        }
    }
    readThread?.start()
}

private fun disconnect() {
    readThreadState = 0
    try {
        mDevice?.let {
            usbDeviceConnection?.releaseInterface(it.getInterface(it.interfaceCount - 1))
        }
    } catch (e: Exception) {
        e.printStackTrace()
    } finally {
        mDevice = null
    }
    try {
        usbDeviceConnection?.close()
    } catch (e: Exception) {
        e.printStackTrace()
    } finally {
        usbDeviceConnection = null
        mReadEndpoint = null
        mWriteEndpoint = null
    }
}