MTK 串口在应用中的应用

最新推荐文章于 2025-06-18 09:37:08 发布
最新推荐文章于 2025-06-18 09:37:08 发布
阅读量1.4k 收藏 29
点赞数 41
CC 4.0 BY-SA版权
分类专栏： Android应用 文章标签： 串口工具 串口工具类 串口封装 MTK串口
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ItJavawfc/article/details/146160018

作为一个工具篇，在后续工作中经常会用到串口测试工具，方便工作中作为测试工具使用。

文章目录

资料参考

串口的原理基本一致的，没有特别的东西，无论在哪里使用，顶多一层封装。
这里可以参考一下之前的笔记，framework层的应用
串口在framework层的应用

或者 网上太多的demo 封装，可参考下。

串口应用场景

  • 串口，作为一种协议，使用场景无处不在。
  • 我接触的在Android平台上外挂的各种模组通讯用到了串口：功放模组、物联网模组、话筒模组、语音模块模组、各种传感器模组、各种外围设备通讯…

代码分析

串口so文件的载入和配置

在这里插入图片描述

在 build.gradle 文件中配置 .so 库文件


        ndk {
            abiFilters 'armeabi','armeabi-v7a'
        }

本地native 方法

使用到串口，核心三个方法，如下

  • 加载.so 文件
  • 打开串口
  • 关闭串口
   static {
        System.loadLibrary("serial_port");
    }


    private native static FileDescriptor open(String path, int baudrate);

    private native void close();

SerialPort 流封装方法

本地方法，最终通过流来和串口进行通讯的，下面给出 open 的具体操作，方法如下

  public SerialPort(File device, int baudate) throws IOException {
        if (!device.canRead() || !device.canWrite()) {
            try {
                Process su = Runtime.getRuntime().exec("su");
                String cmd = "chmod 777 " + device.getAbsolutePath();
                su.getOutputStream().write(cmd.getBytes());
                su.getOutputStream().flush();
                int waitFor = su.waitFor();
                boolean canRead = device.canRead();
                boolean canWrite = device.canWrite();
                if (waitFor != 0 || !canRead || !canWrite) {
                    throw new SecurityException();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        mFd = open(device.getAbsolutePath(), baudate);
        if (mFd == null) {
            throw new IOException();
        }
        mFileInputStream = new FileInputStream(mFd);
        mFileOutputStream = new FileOutputStream(mFd);
    }

其中 open 是native 方法，拿到了文件描述符，就可以进行 流操作了。

完整的SerialPort 代码如下：


import java.io.File;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * 串口通信，打开串口，读写数据
 */
public class SerialPort {

    private FileDescriptor mFd;
    private FileInputStream mFileInputStream;
    private FileOutputStream mFileOutputStream;

    static {
        System.loadLibrary("serial_port");
    }

    /**
     * 打开串口
     * @param device
     * @param baudate
     */
    public SerialPort(File device, int baudate) throws IOException {
        if (!device.canRead() || !device.canWrite()) {
            try {
                Process su = Runtime.getRuntime().exec("su");
                String cmd = "chmod 777 " + device.getAbsolutePath();
                su.getOutputStream().write(cmd.getBytes());
                su.getOutputStream().flush();
                int waitFor = su.waitFor();
                boolean canRead = device.canRead();
                boolean canWrite = device.canWrite();
                if (waitFor != 0 || !canRead || !canWrite) {
                    throw new SecurityException();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        mFd = open(device.getAbsolutePath(), baudate);
        if (mFd == null) {
            throw new IOException();
        }
        mFileInputStream = new FileInputStream(mFd);
        mFileOutputStream = new FileOutputStream(mFd);
    }

    public boolean isOpened() {
        return mFd == null;
    }

    /**
     * 关闭串口
     */
    public void closePort() {
        if (this.mFd != null) {
            try {
                this.close();
                this.mFd = null;
                this.mFileInputStream = null;
                this.mFileOutputStream = null;
            } catch (Exception var2) {
                var2.printStackTrace();
            }
        }
    }

    public InputStream getInputStream() {
        return mFileInputStream;
    }

    public OutputStream getOutputStream() {
        return mFileOutputStream;
    }

    /**
     * JNI，设备地址和波特率
     */
    private native static FileDescriptor open(String path, int baudrate);

    private native void close();


}

PowerHelper 串口工具封装

这里举例使用一个工具类的封装
在上面已经对串口native 进行了一定的封装 SerialPort ，这里的PowerHelper 实际上是一个业务工具类的封装。 对外释放的方法或者接口类。

打开串口

    fun open() {
        Log.d(TAG," PowerHelper .open()")
        if (serialPort != null) {
            close();
        }
        try {
            serialPort = SerialPort(File("/dev/ttyS1"), 9600);
            Log.d(TAG," PowerHelper .startReadData()")
            startReadData();
        } catch (e: Exception) {
            e.printStackTrace();
            Log.e(TAG,"无法打开电池电量串口")
        }
    }

借助于SerialPort 的构造方法，传递串口的节点和波特率，在构造方法里面不就执行了open 方法，来打开串口的嘛。

读取数据

打开串口后，串口对应的流不就有了嘛，接下来要做的就是 对流的监听和读取了，如下读取串口数据

 private fun startReadData() {
        if (serialPort == null) {
            return;
        }
        isStop = false;
        DISK_IO.execute {
            while (!isStop) {
                val readData = ByteArray(1024)
                val size = serialPort!!.inputStream!!.read(readData)
                val byteList : List<Byte> = readData.slice(0 until size)
                val str = byteList.map { it.toInt().toChar() }.joinToString(separator = "")
                val temp : ByteArray = readData.slice(0 until size).toByteArray()
                if (size >= 18) {
                    val temp : ByteArray = readData.slice(0 until size).toByteArray()
                    val powerData=PowerDataBean(temp.contentToString(),readData[13].toInt(), readData[4].toInt())
                    Log.i(TAG, "result bytes=${temp.contentToString()}")
                    Log.d(TAG," powerLiveData.postValue(powerData) ")
                    powerLiveData.postValue(powerData)
                   /*  val powerData=PowerDataBean(str,readData[13].toInt(), readData[4].toInt())
                    Log.i(TAG, "result bytes=${temp.contentToString()}")
                    Log.d(TAG," powerLiveData.postValue(powerData) ")
                    powerLiveData.postValue(powerData)*/
                }/*else{
                    val powerData=PowerDataBean(str,0, 0)
                    Log.i(TAG, "result bytes=${temp.contentToString()}")
                    Log.i(TAG, "result 异常数据  =${str}")
                    Log.d(TAG," powerLiveData.postValue(powerData) ")
                    powerLiveData.postValue(powerData)
                }*/
                /* val temp : ByteArray = readData.slice(0 until size).toByteArray()
                 if (size >= 18) {
                     Log.d(TAG," temp:"+temp)
                     val powerData=PowerDataBean(temp.contentToString(),readData[13].toInt(), readData[4].toInt())
                     Log.i(TAG, "result bytes=${temp.contentToString()}")
                     Log.d(TAG," powerLiveData.postValue(powerData) ")
                     powerLiveData.postValue(powerData)
                 }else{
                     val powerData=PowerDataBean(temp.contentToString(),0, 0)
                     Log.i(TAG, "result bytes=${temp.contentToString()}")
                     Log.d(TAG," powerLiveData.postValue(powerData) ")
                     powerLiveData.postValue(powerData)
                 }*/
                //Thread.sleep(100)
            }
        }
    }

这里核心内容其实就只有一点，在死循环线程里面 读取 串口数据

 val size = serialPort!!.inputStream!!.read(readData)

拿到数据进行解析，然后针对自己的业务进行处理，比如封装自己数据，从数据里面根据对接的协议进行业务处理等。

停止读取串口数据-关闭串口

这里的逻辑就是关闭死循环读取数据和调用native 方法，关闭串口

private fun stopReadData() {
        isStop = true;
    }

    fun close() {
         powerLiveData.postValue(PowerDataBean());
        stopReadData();
        if (serialPort != null && serialPort!!.isOpened) {
            serialPort!!.closePort();
        }
        serialPort = null;
    }

工具类 如下


import android.serialport.SerialPort
import android.util.Log
import androidx.lifecycle.MutableLiveData
import com.fise.ttl.vo.PowerDataBean
import java.io.File
import java.util.concurrent.Executors
object PowerHelper {
    private   val TAG = "PowerHelper"
    var serialPort: SerialPort? = null;
    val powerLiveData = MutableLiveData<PowerDataBean>();
    private val DISK_IO = Executors.newSingleThreadExecutor();
    var isStop = false;
    fun open() {
        Log.d(TAG," PowerHelper .open()")
        if (serialPort != null) {
            close();
        }
        try {
            serialPort = SerialPort(File("/dev/ttyS1"), 9600);
            Log.d(TAG," PowerHelper .startReadData()")
            startReadData();
        } catch (e: Exception) {
            e.printStackTrace();
            Log.e(TAG,"无法打开电池电量串口")
        }
    }

    private fun startReadData() {
        if (serialPort == null) {
            return;
        }
        isStop = false;
        DISK_IO.execute {
            while (!isStop) {
                val readData = ByteArray(1024)
                val size = serialPort!!.inputStream!!.read(readData)
                val byteList : List<Byte> = readData.slice(0 until size)
                val str = byteList.map { it.toInt().toChar() }.joinToString(separator = "")
                val temp : ByteArray = readData.slice(0 until size).toByteArray()
                if (size >= 18) {
                    val temp : ByteArray = readData.slice(0 until size).toByteArray()
                    val powerData=PowerDataBean(temp.contentToString(),readData[13].toInt(), readData[4].toInt())
                    Log.i(TAG, "result bytes=${temp.contentToString()}")
                    Log.d(TAG," powerLiveData.postValue(powerData) ")
                    powerLiveData.postValue(powerData)
                   /*  val powerData=PowerDataBean(str,readData[13].toInt(), readData[4].toInt())
                    Log.i(TAG, "result bytes=${temp.contentToString()}")
                    Log.d(TAG," powerLiveData.postValue(powerData) ")
                    powerLiveData.postValue(powerData)*/
                }/*else{
                    val powerData=PowerDataBean(str,0, 0)
                    Log.i(TAG, "result bytes=${temp.contentToString()}")
                    Log.i(TAG, "result 异常数据  =${str}")
                    Log.d(TAG," powerLiveData.postValue(powerData) ")
                    powerLiveData.postValue(powerData)
                }*/
                /* val temp : ByteArray = readData.slice(0 until size).toByteArray()
                 if (size >= 18) {
                     Log.d(TAG," temp:"+temp)
                     val powerData=PowerDataBean(temp.contentToString(),readData[13].toInt(), readData[4].toInt())
                     Log.i(TAG, "result bytes=${temp.contentToString()}")
                     Log.d(TAG," powerLiveData.postValue(powerData) ")
                     powerLiveData.postValue(powerData)
                 }else{
                     val powerData=PowerDataBean(temp.contentToString(),0, 0)
                     Log.i(TAG, "result bytes=${temp.contentToString()}")
                     Log.d(TAG," powerLiveData.postValue(powerData) ")
                     powerLiveData.postValue(powerData)
                 }*/
                //Thread.sleep(100)
            }
        }
    }


    private fun stopReadData() {
        isStop = true;
    }

    fun close() {
         powerLiveData.postValue(PowerDataBean());
        stopReadData();
        if (serialPort != null && serialPort!!.isOpened) {
            serialPort!!.closePort();
        }
        serialPort = null;
    }

 }

串口工具使用

在上面已经对串口SerialPort 和 串口对外方法封装PowerHelper 进行了总结，剩下的就是在自己的业务中执行工具方法了。 比如在服务中直接打开串口 就可以了。

PowerHelper.open()

这里贴一个实际串口应用，显示串口电量数据，如下：
在这里插入图片描述

总结

  • 串口数据显示需求

上述分析，提供了两个工具类，就已经满足了绝大多数，通过串口获取数据，作为校验、显示的需求。适合所有平台的显示需求，快速接入验证。

  • 这里只有读取数据，为什么没有写入的总结
    本身串口是由读取和写入的，才能算一个完整的串口使用，实际上99% 的需求必须有读写操作才能叫串口通讯的， 这里应该写一个demo 来演示的。 但是通用的工具在MTK平台上是无法实现的，权限原因，无法写一个通用的write 工具方法。
【MT9669】USB OTG口配置ADB功能
阿xin*的嵌入式AI
06-17 723
MT9669 Android9启动USB ADB功能。
MTK Android 12修改默认权限以及添加XXX IoT应用默认权限
我其实什么都不会
07-15 1406
本文介绍，在MTK Android 12的系统定制过程中，项目需求需要为某些关键应用设置默认权限，以确保它们能够正常运行。这篇博客将详细介绍如何通过修改系统代码来为XXX IoT应用添加默认权限，同时对这些修改进行技术分析。
MTK平台 BootLoader lk部分串口驱动简析，以及客制化和外设通讯串口
杨涂涂的博客
07-02 1226
只分析主要代码，省略了不重要的代码： bootable/bootloader/lk/platform/mtxxxx/uart.c
MTK之UART串口收发数据
ivy_reny的专栏
04-19 8542
MTK之UART
安卓串口调试工具apk：轻松调试各类串口设备
gitblog_06726的博客
05-08 586
安卓串口调试工具apk：轻松调试各类串口设备 【下载地址】安卓串口调试工具apk 安卓串口调试工具是一款专为安卓设备开发的专业级串口测试应用，兼容平板、主板、盒子、手机及x86设备。它支持多种串口设备，如打印机、电子秤、投影机等，提供自定义串口、波特率设置，并能发送16进制指令和字符串，接收并显示设备返回的16进制信息。...
Android串口通讯SerialPort(使用篇)
热门推荐
qq_42111674的博客
03-22 5万+
1.什么是串口？ 在不会使用串口通讯之前，暂且可以把它理解为“一个可通讯的口”；使用篇不深入探讨理论及原理。 2.添加依赖 1.）在 module 中的 build.gradle 中的 dependencies 中添加以下依赖： dependencies { //串口 implementation 'com.github.licheedev:Android-SerialPort-API:2.0.0' } 2.）低版本的 gradle在Project 中的 build....
MTK6235芯片在手机硬件设计中的应用解析
weixin_42527589的博客
03-19 723
MTK6235是一款由联发科技（MediaTek Inc.）设计的移动通信芯片，广泛应用于早期的智能手机和平板电脑中。该芯片集成了多种移动通信技术，如GSM/GPRS/EDGE、WCDMA等，同时还支持多媒体和连接性功能，使得它在当时市场上颇受欢迎。原理图是一个符号化的电路图，它以图形化的方式展示电路的组成和连接关系，不涉及实际的物理尺寸或位置。它的主要功能包括：- 描述电路的功能和工作原理。- 作为电路板布线和组装的依据。- 进行电路仿真分析的基础。- 便于维护和故障诊断。
最新MTKUSB驱动安装与应用指南
weixin_42298778的博客
06-18 1005
MTKUSB驱动指的是专为联发科（MediaTek）芯片组的设备设计的USB通信驱动程序。它是一个软件组件，负责在计算机和联发科设备之间建立通信连接，使用户能够通过USB接口传输数据、进行调试或系统升级。当运行MTKUSB驱动的安装程序时，会弹出一个安装向导界面。向导会引导你完成安装的每一步骤，包括阅读和接受许可协议、选择安装类型（典型、自定义等）、指定安装位置等。请确保按照向导的指示操作，如果有疑问，可以参考驱动的官方文档或者社区论坛。
MTK Android串口权限配置
zmlovelx(帅得不敢出门 程序员群31843264)
03-14 1559
Android11设备中添加串口应用，遇到打开串口时报错问题： System.err: Caused by: java.io.IOException: error=13, Permission denied 系统级应用 AndroidManifest.xml添加android.uid.system 这里只介绍system应用配置，如果是普通应用，改法不一样。根据avc打印提示修改，不同的平台修改的地方不一样，这里介绍的是mtk平台 device/mediatek/sepolicy/basic/non_
win7可用抓MTK串口工具支持921600波特率
09-03
标题中的“win7可用抓MTK串口工具支持921600波特率”意味着这是一个专为Windows 7操作系统设计的串口通信工具，它主要用于监控和捕获使用MediaTek（MTK）芯片的设备的UART（通用异步接收发送器）通信日志。...
MTK 串口屏驱动跟接口
01-16
在实际应用中，开发者需要对MTK芯片的规格有深入理解，同时熟悉串口通信协议，以便正确编写和调试驱动。此外，了解Linux内核驱动开发、嵌入式系统以及可能涉及的图形库（如Linux Framebuffer或Android的...
MTK_USB_VCOM_mtk驱动_源码
10-02
MTK USB VCOM驱动需要在这个过程中正确响应，使得系统能够识别出这是一个虚拟串口设备。 4. **数据传输**：驱动需要实现USB端点的读写操作，确保数据能正确地在主机和设备之间传输。这通常涉及到中断（Interrupt）...
MTK6225手机串口驱动在电脑端的应用
MTK（MediaTek）是一家专业的集成电路设计公司，它所开发的芯片广泛应用于各类移动通信设备中，包括智能手机。MTK6255和MTK6225是该公司推出的两款手机芯片产品，它们具有串口通信功能，能够通过串口与电脑进行数据...
mavlink协议，c++语言版本，用于px4飞控通信
07-14
mavlink协议，c++语言版本，用于px4飞控通信
(完整word版)网上订餐系统软件测试总结报告.doc
07-14
(完整word版)网上订餐系统软件测试总结报告.doc
chromedriver-mac-x64-140.0.7295.0(Canary).zip
07-14
chromedriver-mac-x64-140.0.7295.0(Canary).zip
(完整版)基因工程药物干扰素的制备.ppt
最新发布
07-14
(完整版)基因工程药物干扰素的制备.ppt
用户完成登录后自动跳转至主界面
07-14
资源下载链接为： https://pan.quark.cn/s/9e7ef05254f8 Delphi 7 中做一个「登录→主界面」的完整流程： 建立登录窗体 File → New → VCL Forms Application，拖两个 TEdit（用户名、密码）、一个 TButton（登录）、一个 TLabel（提示）。把 Edit2 的 PasswordChar 设为 *，Button.Caption 设为“登录”。 写验证代码 Button 的 OnClick 里： 多窗体管理 Project → Options → Forms，把 Form1 设为主窗体，Form2 设为可用窗体。登录成功后创建并显示 Form2，隐藏 Form1；主界面退出时调用 Application.Terminate 结束程序。 错误提示 验证失败直接用 ShowMessage，也可把 Label 换成红色文字提示。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

野火少年

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值