Android USB转串口开发（hoho.android.usbserial串口库）

使用hoho.android.usbserial串口库开发串口
import android.app.Application
import android.app.PendingIntent
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.hardware.usb.UsbDevice
import android.hardware.usb.UsbManager
import android.util.Log
import android.widget.Toast
import com.cuifeipeng.unfix.raman.BaseActivity
import com.cuifeipeng.unfix.raman.model.LaserParameter
import com.hoho.android.usbserial.driver.UsbSerialProber
import java.util.concurrent.Semaphore
广播类
class DeviceBroadcastReceiver (var deviceContext: DeviceContext) : BroadcastReceiver() {

override fun onReceive(context: Context?, intent: Intent?) {
    val device1 = intent!!.getParcelableExtra<UsbDevice>(UsbManager.EXTRA_DEVICE)
    val action = intent!!.action
    when (action) {
        UsbManager.ACTION_USB_DEVICE_ATTACHED -> {
            val device = intent.getParcelableExtra<UsbDevice>(UsbManager.EXTRA_DEVICE)
            val mUsbManager = context!!.getSystemService(Context.USB_SERVICE) as UsbManager
            val mPermissionIntent = PendingIntent.getBroadcast(context, 0, Intent(DeviceContext.ACTION_USB_PERMISSION), 0)
            mUsbManager.requestPermission(device, mPermissionIntent)
        }
        UsbManager.ACTION_USB_DEVICE_DETACHED -> {
            val device = intent.getParcelableExtra<UsbDevice>(UsbManager.EXTRA_DEVICE)
            if (deviceContext.ccdAdapter?.usbDevice == device) {
                deviceContext.ccdAdapter = null
            } else if (deviceContext.laserAdapter?.usbDevice == device) {
                deviceContext.laserAdapter = null
            }
        }
        DeviceContext.ACTION_USB_PERMISSION -> {
            synchronized(this) {
                val device = intent.getParcelableExtra<UsbDevice>(UsbManager.EXTRA_DEVICE)
                if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
                    val mUsbManager = context!!.getSystemService(Context.USB_SERVICE) as UsbManager
                    connectDevice(mUsbManager, device, context)

                    if (deviceIterator!!.hasNext()) {
                        val nextDevice = deviceIterator!!.next()
                        mUsbManager.requestPermission(nextDevice, mPermissionIntent!!)
                    } else {

                    }
                } else {

                    Log.d("sss", "permission denied for device " + device)
                }
            }
        }
    }
}

private var deviceIterator: MutableIterator<UsbDevice>? = null
private var mPermissionIntent: PendingIntent? = null
private val semaphore : Semaphore = Semaphore(1)
private val semaphore2 : Semaphore = Semaphore(1)
fun requestPermission(context: Context) {
    mPermissionIntent = PendingIntent.getBroadcast(context, 0, Intent(DeviceContext.ACTION_USB_PERMISSION), 0)

    val mUsbManager = context.getSystemService(Context.USB_SERVICE) as UsbManager
    val deviceList = mUsbManager.deviceList

    deviceIterator = deviceList.values.iterator()
    if (deviceIterator!!.hasNext()) {
        val device = deviceIterator!!.next()
        mUsbManager.requestPermission(device, mPermissionIntent!!)
    }
}

private fun connectDevice(usbManager: UsbManager, usbDevice: UsbDevice?, context: Context) {
    try {
        if (usbDevice != null) {
            //context!!.getSystemService(Context.USB_SERVICE) as UsbManager
            val availableDriver = UsbSerialProber.getDefaultProber().probeDevice(usbDevice)
            if (availableDriver != null) {
                val connection = usbManager.openDevice(availableDriver.device) ?: return
                val port = availableDriver.ports[0]
                port.open(connection)
                if (deviceContext.ccdAdapter == null && CCDAdapter.isCCDDevice(port)) {
                    deviceContext.ccdAdapter = CCDAdapter(port, usbDevice)
                }else if(deviceContext.laserAdapter == null)
                {
                    if (LaserAdapter4.isLaserDevice(port)) {
                        val laserParameter = LaserParameter.fromSharedPreferences(context.getSharedPreferences(BaseActivity.preferenceName, Context.MODE_PRIVATE))
                        deviceContext.laserAdapter = LaserAdapter4(port, laserParameter, usbDevice)
                    }
                }
                else if (deviceContext.laserAdapter == null ) {
                    if (LaserAdapter3.isLaserDevice(port)) {
                        val laserParameter = LaserParameter.fromSharedPreferences(context.getSharedPreferences(BaseActivity.preferenceName, Context.MODE_PRIVATE))
                        deviceContext.laserAdapter = LaserAdapter3(port, laserParameter, usbDevice)
                    }
                } else if (deviceContext.laserAdapter == null) {
                    if (LaserAdapter2.isLaserDevice(port)) {
                        val laserParameter = LaserParameter.fromSharedPreferences(context.getSharedPreferences(BaseActivity.preferenceName, Context.MODE_PRIVATE))
                        deviceContext.laserAdapter = LaserAdapter2(port, laserParameter, usbDevice)
                    }
                } else if (deviceContext.laserAdapter == null ) {
                    if (LaserAdapter1.isLaserDevice(port)) {
                        val laserParameter = LaserParameter.fromSharedPreferences(context.getSharedPreferences(BaseActivity.preferenceName, Context.MODE_PRIVATE))
                        deviceContext.laserAdapter = LaserAdapter1(port, laserParameter, usbDevice)
                    }
                }
                else {
                    port.close()
                }
            } else {
            }
        } else {
        }
    } catch (e: Exception) {
        deviceContext.setError(e.message.toString() + e.stackTrace.joinToString("@"))
    }
}

}

硬件上下文类
class DeviceContext {

companion object {
    var ACTION_USB_PERMISSION = "com.android.example.USB_PERMISSION"
    private var instance: DeviceContext? = null
    fun setInstance(context: DeviceContext) {
        instance = context
    }

    fun getInstance(): DeviceContext? {
        return instance
    }
}

private var _ccdAdapter: CCDAdapter? = null;
private var _laserAdapter: LaserAdapter? = null;
var ccdAdapter: CCDAdapter?
    set(value) {
        if (_ccdAdapter == value) return
        _ccdAdapter = value;
        if (value != null)
            onConnectDevice("ccd")
        else onDisConnectDevice("ccd")
    }
    get() {
        return _ccdAdapter;
    }
var laserAdapter: LaserAdapter?
    set(value) {
        if (_laserAdapter == value) return
        _laserAdapter = value;
        if (value != null)
            onConnectDevice("laser")
        else onDisConnectDevice("laser")
    }
    get() {
        return _laserAdapter;
    }

var deviceConnected: IOnDeviceConnected? = null;

fun isAllConnected(): Boolean {
    //return ccdAdapter != null
    return ccdAdapter != null && laserAdapter != null;
}

private fun onConnectDevice(message:String) {
    deviceConnected?.onConnected(this,message)
}

private fun onDisConnectDevice(message:String) {
    deviceConnected?.onDisConnected(this,message)
}

fun dispose() {
    ccdAdapter?.dispose()
    ccdAdapter = null
    laserAdapter?.dispose()
    laserAdapter = null
}

fun setError(message: String) {
    deviceConnected?.onError(this, message)
}

fun setOnConnected(deviceConnected: IOnDeviceConnected) {
    this.deviceConnected = deviceConnected;
}

}
设备类
import android.hardware.usb.UsbDevice
import com.cuifeipeng.unfix.raman.model.LaserParameter
import com.cuifeipeng.unfix.raman.util.LogUtil
import com.hoho.android.usbserial.driver.UsbSerialPort

class LaserAdapter4 (port: UsbSerialPort, laserParameter: LaserParameter, usbDevice: UsbDevice):LaserAdapter(port,laserParameter,usbDevice) {
override fun dispose() {

    closeLaser()
    port.close()
}

override fun openLaser() {
    SetControlMode(0)//设置激光器工作模式
    SetLaserStatus(1)//设置激光器工作状态

}

override fun closeLaser() {

    SetLaserStatus(0)//设置激光器工作状态
    SetLaserCurrent(0)//设定电流


}

override fun setLaserPower(power: Double) {

    SetLaserCurrent(power.toInt())//设定激光器工作电流（mA)
}

//********************************************************************************************************************
private fun SetDeviceID(id:String): Boolean//设定序列号
{
    var tempStr= ":SN=" + id+";"
    var sendByte:ByteArray=tempStr.toByteArray(Charsets.US_ASCII)
    write(port, sendByte)
    var ReceiveBuffer = ByteArray(17)

    read(port, ReceiveBuffer)
    var resultStr:String = ReceiveBuffer.toString(Charsets.US_ASCII)
    var value:String= resultStr.substring(4,10)
    if(id== value)
    {
        return true;
    }
    else
    {
        return false;
    }

}
public fun GetDeviceID():String//获取序列号
{
   var tempStr= ":SN=?;"

    var sendByte:ByteArray = tempStr.toByteArray(Charsets.US_ASCII)
    write(port, sendByte)
    var ReceiveBuffer = ByteArray(17)
    read(port, ReceiveBuffer)
    var resultStr:String = ReceiveBuffer.toString(Charsets.US_ASCII)

    var value:String= resultStr.substring(4,10)
    return value
}

public fun GetRunTime():Int//获取运行时间
{
    var tempStr= ":WT=?;"

    var sendByte:ByteArray = tempStr.toByteArray(Charsets.US_ASCII)
    write(port, sendByte)
    var ReceiveBuffer = ByteArray(15)
    read(port, ReceiveBuffer)
    var resultStr:String = ReceiveBuffer.toString(Charsets.US_ASCII)

    var value:Int= resultStr.substring(4,5).toInt()
    return value
}

public fun SetControlMode(mode:Int):Boolean//设定控制模式:PCN=0;PCN=1;（PCN=1 切换到外部模拟量控制；PCN=0 使用USB设置）
{
    var sendStr:String = ""
    if (mode == 0)
    {
        sendStr = ":PCN=0;"
    }
    else if (mode == 1)
    {
        sendStr = ":PCN=1;"

    }

    var sendByte:ByteArray = sendStr.toByteArray(Charsets.US_ASCII)
    write(port, sendByte)
    return true
    var ReceiveBuffer = ByteArray(9)
    read(port, ReceiveBuffer)
    var resultStr:String = ReceiveBuffer.toString(Charsets.US_ASCII)

    var value:Int= resultStr.substring(5,1).toInt()
    if (value == mode)
    { return true }
    else
    {
        return false
    }
}

public fun GetModuleTemprature():Int//读取激光器模块温度
{
    var tempStr=":LDDT=?;"

    var sendByte:ByteArray = tempStr.toByteArray(Charsets.US_ASCII)
    write(port, sendByte)
    var ReceiveBuffer = ByteArray(14)
    read(port, ReceiveBuffer)
    var resultStr:String = ReceiveBuffer.toString(Charsets.US_ASCII)

    var value:Int= resultStr.substring(6,5).toInt()
    return value
}
public fun GetLaserCurrentTemprature():Int//读取激光器温度
{
    var tempStr=":LDT=?;"

    var sendByte:ByteArray = tempStr.toByteArray(Charsets.US_ASCII)
    write(port, sendByte)
    var ReceiveBuffer = ByteArray(15)
    read(port, ReceiveBuffer)
    var resultStr:String = ReceiveBuffer.toString(Charsets.US_ASCII)

    var value:Int= resultStr.substring(5,5).toInt()
    return value
}
public fun GetLaserCurrent():Int//读取激光器实际电流
{
    var tempStr= ":LDC=?;"

    var sendByte:ByteArray = tempStr.toByteArray(Charsets.US_ASCII)
    write(port, sendByte)
    var ReceiveBuffer = ByteArray(15)
    read(port, ReceiveBuffer)
    var resultStr:String = ReceiveBuffer.toString(Charsets.US_ASCII)

    var value:Int= resultStr.substring(5,5).toInt()
    return value
}
public fun GetTECCurrent():Int//读取TEC实际电流
{
    var tempStr= ":TECC=?;"

    var sendByte:ByteArray = tempStr.toByteArray(Charsets.US_ASCII)
    write(port, sendByte)
    var ReceiveBuffer = ByteArray(16)
    read(port, ReceiveBuffer)
    var resultStr:String = ReceiveBuffer.toString(Charsets.US_ASCII)

    var value:Int= resultStr.substring(6,5).toInt()
    return value
}

public fun SetLaserCurrent(current:Int):Boolean//设定激光器工作电流（mA)
{
    var tempValue=current.toString()
    while(tempValue.length<5)
    {
        tempValue = "0"+tempValue;
    }
    var tempStr = ":LDC=" + tempValue.toString() + ";"

    var sendByte: ByteArray = tempStr.toByteArray(Charsets.US_ASCII)
    write(port, sendByte)
    var ReceiveBuffer = ByteArray(13)
    return true
    read(port, ReceiveBuffer)
    var resultStr: String = ReceiveBuffer.toString(Charsets.US_ASCII)

    var value: Int = resultStr.substring(5, 5).toInt()
    if (current == value) {
        return true
    } else {
        return false
    }
}
    public fun SetLaserStatus(status:Int):Boolean//设置激光器工作状态
    {
        var sendStr = ""

        if (status == 0) {
            sendStr = ":LDON=0;";
        } else if (status == 1) {
            sendStr = ":LDON=1;";

        }

        var sendByte: ByteArray = sendStr.toByteArray(Charsets.US_ASCII)
        write(port, sendByte)
        var ReceiveBuffer = ByteArray(10)
        return true
        read(port, ReceiveBuffer)
        var resultStr: String = ReceiveBuffer.toString(Charsets.US_ASCII)

        var value: Int = resultStr.substring(6, 1).toInt()
        if (value == status) {
            return true
        } else {
            return false
        }
    }

        public fun SetTECTemprature(temprature:Int):Boolean//设TEC工作温度
        {
            var tempStr = ":LDT=" + temprature.toString() + ";";
            var sendByte: ByteArray = tempStr.toByteArray(Charsets.US_ASCII)
            write(port, sendByte)
            var ReceiveBuffer = ByteArray(13)
            read(port, ReceiveBuffer)
            var resultStr: String = ReceiveBuffer.toString(Charsets.US_ASCII)

            var value: Int = resultStr.substring(5, 5).toInt()
            if (value == temprature) {
                return true
            } else {
                return false
            }
        }


companion object {


    //**********************************************************************************************



    private fun write(port: UsbSerialPort, cmd: ByteArray) {

        LogUtil.debug("Laser4 write", cmd.joinToString(","))
        port.write(cmd, 1000)
    }

    private fun read(port: UsbSerialPort, resultByte: ByteArray) {
        val bufferArray = ByteArray(resultByte.size)
        var readCount = 0
        do {
            val count = port.read(bufferArray, 1000)
            for (i in 0..(count -1)) {
                if (readCount + i < resultByte.count())
                    resultByte[readCount + i] = bufferArray[i]
            }
            readCount += count
        } while (readCount < resultByte.count())

        //LogUtil.debug("Laser4 read", resultByte.joinToString(","))


    }
    private fun read2(port: UsbSerialPort, resultByte: ByteArray) {
        val bufferArray = ByteArray(resultByte.size)

            val count = port.read(bufferArray, 1000)

          var tempStr=bufferArray.toString(Charsets.US_ASCII)


        LogUtil.debug("Laser4 read", tempStr)


    }

    fun isLaserDevice(port: UsbSerialPort): Boolean {
        return try {

            port.setParameters(115200, 8, UsbSerialPort.STOPBITS_1, UsbSerialPort.PARITY_NONE)
            var tempStr=":SN=?;"
            val cmd =tempStr.toByteArray(Charsets.US_ASCII)

            write(port, cmd)

            val resultByte = ByteArray(15)
            return true
            read(port, resultByte)

            var resultStr: String = resultByte.toString(Charsets.US_ASCII)
           var value= resultStr.substring(4, 10)

            if (value!="0123456789") return false
            LogUtil.debug("Laser4 connected", ":true")

            true
        } catch (e: Exception) {
            false
        }
    }
}

}

在其他类调用
private var deviceContext = DeviceContext()
private var deviceBroadcastReceiver = DeviceBroadcastReceiver(deviceContext)