Android,Kotlin串口通讯类，支持设置串口读取超时间

引用第三方库

libs.versions.toml添加配置

[versions]
androidSerialportVersion = "2.1.3"

[libraries]
licheedev-android-serialport = { module = "com.licheedev:android-serialport", version.ref = "androidSerialportVersion" }

build.gradle.kts添加配置

dependencies {

    implementation(libs.licheedev.android.serialport)
}

类代码

package com.luofenming.khpec.utility

import android.os.Build
import android.serialport.SerialPort
import androidx.annotation.RequiresApi
import java.io.File
import java.io.IOException
import java.time.Instant


class SerialPortManager {

    private var serialPort: SerialPort? = null

    private var readThread: Thread? = null

    /**
     * 打开串口    lqwvje:2024-13
     * @param port 串口设备文件
     * @param baudRate 波特率
     * @param parity 奇偶校验；0:无校验位(NONE，默认)；1:奇校验位(ODD);2:偶校验位(EVEN)
     * */
    fun open(port: String, baudRate: Int, parity: Int): Boolean {
        try {
            serialPort = SerialPort(File(port), baudRate, 8, parity, 1)

            println("lqwvje,打开串口，$port ,$baudRate ,$parity")
            return true
        } catch (e: ArithmeticException) {
            println("lqwvje,串口打开异常" + e.message)
            return false
        } catch (e: Exception) {
            println("lqwvje,串口打开异常" + e.message)
            return false
        }
    }

    fun isOpen(): Boolean {
        return this.serialPort != null
    }

    fun close() {
        // 实现关闭串口的逻辑
        try {
            serialPort?.close()
        } catch (e: IOException) {
            e.printStackTrace()
        } finally {
            serialPort = null
        }
    }

    fun write(data: ByteArray) {
        try {
            serialPort?.outputStream?.write(data)
        } catch (e: Exception) {
            println("lqwvje,串口发送异常" + e.message)
        }
    }


    /**
     * 读取串口数据  lqwvje:2024-12-18
     * @param timeoutMillis 超时时间（单位：毫秒）
     * @return 返回读取到ByteArray
     * */
    @RequiresApi(Build.VERSION_CODES.O)
    fun read(timeoutMillis: Long = 1000): ByteArray? {
        var len: Int = -1
        val buffer = ByteArray(1024) // 增大缓存区大小
        if (readThread == null || (!readThread!!.isAlive)) {
            readThread = Thread {
                try {
                    len = serialPort?.inputStream?.read(buffer) ?: -1
                } catch (e: Exception) {
                    println("lqwvje,串口读取异常" + e.message)
                }
            }
            readThread!!.start()
        }

        val now = Instant.now().toEpochMilli() + timeoutMillis
        while (true) {
            if (len > 0) {
                return buffer.copyOf(len)
            }
            if (now < Instant.now().toEpochMilli()) {
                break
            }
            Thread.sleep(5)
        }
        return null
    }
}

读写方法调用

var serialPortManager = SerialPortManager()
if (!serialPortManager.isOpen()) {
    if (!serialPortManager.open("/dev/ttyS0", 2400, 2)) {
        println("lqwvje,串口打开失败")
        return@setOnClickListener
    }
}
val bytes = byteArrayOf(
    0x68,
    0xAA.toByte(),
    0xAA.toByte(),
    0xAA.toByte(),
    0xAA.toByte(),
    0xAA.toByte(),
    0xAA.toByte(),
    0x68,
    0x13,
    0x00,
    0xDF.toByte(),
    0x16
)
serialPortManager.write(bytes)
println("lqwvje,发送的数据" + bytes.toHexString().chunked(2).joinToString(" "))
val dataBytes = serialPortManager.read(buffer,5000)//读取超时时间5秒
if (dataBytes != null) {
    println("lqwvje,读取到的数据" + dataBytes.toHexString().chunked(2).joinToString(" "))
}

本文来自 www.LuoFenMing.com