logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

Android串口通讯SerialPort(使用篇)...

 创始元灵6666 2022-08-16 发布于河北

1.什么是串口？

在不会使用串口通讯之前，暂且可以把它理解为“一个可通讯的口”；使用篇不深入探讨理论及原理。能理解串口如何使用之后，可以查看Android串口通讯SerialPort(浅谈原理)

2.添加依赖

1.）在 module 中的 build.gradle 中的 dependencies 中添加以下依赖：

  1. dependencies {
  2.     //串口
  3.     implementation 'com.github.licheedev:Android-SerialPort-API:2.0.0'
  4. }

2.）低版本的 gradle 在Project 中的 build.gradle 中的 allprojects 中添加以下 maven仓库 (不添加任然无法加载SerialPort)；

  1. allprojects {
  2.     repositories {
  3.         maven { url "https://" }//maven仓库
  4.     }
  5. }

高版本的 gradle 已经废弃了 allprojects 在 settings.gradle 中 repositories 添加以下maven仓库(不添加任然无法加载SerialPort)；

  1. dependencyResolutionManagement {
  2.     repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
  3.     repositories {
  4.         google()
  5.         mavenCentral()
  6.         jcenter() // Warning: this repository is going to shut down soon
  7.         maven { url "https://" }//maven仓库
  8.     }
  9. }

3.编写串口处理类

1.）串口处理类：SerialHandle ；简单概括这个类，就是通过串口对象去获取两个流(输入流、输出流)，通过者两个流来监听数据或者写入指令，硬件收到后执行。同时注意配置参数(只要支持串口通讯的硬件，一般说明书上都会有写)

  1. package com.chj233.serialmode.serialUtil;
  3. import android.serialport.SerialPort;
  4. import android.util.Log;
  6. import java.io.BufferedInputStream;
  7. import java.io.File;
  8. import java.io.IOException;
  9. import java.io.InputStream;
  10. import java.io.OutputStream;
  11. import java.util.concurrent.ScheduledFuture;
  12. import java.util.concurrent.TimeUnit;
  14. /**
  15.  * 串口实处理类
  16.  */
  17. public class SerialHandle implements Runnable {
  19.     private static final String TAG = "串口处理类";
  20.     private String path = "";//串口地址
  21.     private SerialPort mSerialPort;//串口对象
  22.     private InputStream mInputStream;//串口的输入流对象
  23.     private BufferedInputStream mBuffInputStream;//用于监听硬件返回的信息
  24.     private OutputStream mOutputStream;//串口的输出流对象 用于发送指令
  25.     private SerialInter serialInter;//串口回调接口
  26.     private ScheduledFuture readTask;//串口读取任务
  28.     /**
  29.      * 添加串口回调
  30.      *
  31.      * @param serialInter
  32.      */
  33.     public void addSerialInter(SerialInter serialInter) {
  34.         this.serialInter = serialInter;
  35.     }
  37.     /**
  38.      * 打开串口
  39.      *
  40.      * @param devicePath 串口地址(根据平板的说明说填写)
  41.      * @param baudrate   波特率(根据对接的硬件填写 - 硬件说明书上"通讯"中会有标注)
  42.      * @param isRead     是否持续监听串口返回的数据
  43.      * @return 是否打开成功
  44.      */
  45.     public boolean open(String devicePath, int baudrate, boolean isRead) {
  46.         return open(devicePath, baudrate, 7, 1, 2, isRead);
  47.     }
  49.     /**
  50.      * 打开串口
  51.      *
  52.      * @param devicePath 串口地址(根据平板的说明说填写)
  53.      * @param baudrate   波特率(根据对接的硬件填写 - 硬件说明书上"通讯"中会有标注)
  54.      * @param dataBits   数据位(根据对接的硬件填写 - 硬件说明书上"通讯"中会有标注)
  55.      * @param stopBits   停止位(根据对接的硬件填写 - 硬件说明书上"通讯"中会有标注)
  56.      * @param parity     校验位(根据对接的硬件填写 - 硬件说明书上"通讯"中会有标注)
  57.      * @param isRead     是否持续监听串口返回的数据
  58.      * @return 是否打开成功
  59.      */
  60.     public boolean open(String devicePath, int baudrate, int dataBits, int stopBits, int parity, boolean isRead) {
  61.         boolean isSucc = false;
  62.         try {
  63.             if (mSerialPort != null) close();
  64.             File device = new File(devicePath);
  65.             mSerialPort = SerialPort // 串口对象
  66.                     .newBuilder(device, baudrate) // 串口地址地址，波特率
  67.                     .dataBits(dataBits) // 数据位,默认8；可选值为5~8
  68.                     .stopBits(stopBits) // 停止位，默认1；1:1位停止位；2:2位停止位
  69.                     .parity(parity) // 校验位；0:无校验位(NONE，默认)；1:奇校验位(ODD);2:偶校验位(EVEN)
  70.                     .build(); // 打开串口并返回
  71.             mInputStream = mSerialPort.getInputStream();
  72.             mBuffInputStream = new BufferedInputStream(mInputStream);
  73.             mOutputStream = mSerialPort.getOutputStream();
  74.             isSucc = true;
  75.             path = devicePath;
  76.             if (isRead) readData();//开启识别
  77.         } catch (Throwable tr) {
  78.             close();
  79.             isSucc = false;
  80.         } finally {
  81.             return isSucc;
  82.         }
  83.     }
  85.     // 读取数据
  86.     private void readData() {
  87.         if (readTask != null) {
  88.             readTask.cancel(true);
  89.             try {
  90.                 Thread.sleep(160);
  91.             } catch (InterruptedException e) {
  92.                 e.printStackTrace();
  93.             }
  94.             //此处睡眠：当取消任务时 线程池已经执行任务，无法取消，所以等待线程池的任务执行完毕
  95.             readTask = null;
  96.         }
  97.         readTask = SerialManage
  98.                 .getInstance()
  99.                 .getScheduledExecutor()//获取线程池
  100.                 .scheduleAtFixedRate(this, 0, 150, TimeUnit.MILLISECONDS);//执行一个循环任务
  101.     }
  103.     @Override//每隔 150 毫秒会触发一次run
  104.     public void run() {
  105.         if (Thread.currentThread().isInterrupted()) return;
  106.         try {
  107.             int available = mBuffInputStream.available();
  108.             if (available == 0) return;
  109.             byte[] received = new byte[1024];
  110.             int size = mBuffInputStream.read(received);//读取以下串口是否有新的数据
  111.             if (size > 0 && serialInter != null) serialInter.readData(path, received, size);
  112.         } catch (IOException e) {
  113.             Log.e(TAG, "串口读取数据异常:" + e.toString());
  114.         }
  115.     }
  117.     /**
  118.      * 关闭串口
  119.      */
  120.     public void close(){
  121.         try{
  122.             if (mInputStream != null) mInputStream.close();
  123.         }catch (Exception e){
  124.             Log.e(TAG,"串口输入流对象关闭异常：" +e.toString());
  125.         }
  126.         try{
  127.             if (mOutputStream != null) mOutputStream.close();
  128.         }catch (Exception e){
  129.             Log.e(TAG,"串口输出流对象关闭异常：" +e.toString());
  130.         }
  131.         try{
  132.             if (mSerialPort != null) mSerialPort.close();
  133.             mSerialPort = null;
  134.         }catch (Exception e){
  135.             Log.e(TAG,"串口对象关闭异常：" +e.toString());
  136.         }
  137.     }
  139.     /**
  140.      * 向串口发送指令
  141.      */
  142.     public void send(final String msg) {
  143.         byte[] bytes = hexStr2bytes(msg);//字符转成byte数组
  144.         try {
  145.             mOutputStream.write(bytes);//通过输出流写入数据
  146.         } catch (Exception e) {
  147.             e.printStackTrace();
  148.         }
  149.     }
  151.     /**
  152.      * 把十六进制表示的字节数组字符串，转换成十六进制字节数组
  153.      *
  154.      * @param
  155.      * @return byte[]
  156.      */
  157.     private byte[] hexStr2bytes(String hex) {
  158.         int len = (hex.length() / 2);
  159.         byte[] result = new byte[len];
  160.         char[] achar = hex.toUpperCase().toCharArray();
  161.         for (int i = 0; i < len; i++) {
  162.             int pos = i * 2;
  163.             result[i] = (byte) (hexChar2byte(achar[pos]) << 4 | hexChar2byte(achar[pos + 1]));
  164.         }
  165.         return result;
  166.     }
  168.     /**
  169.      * 把16进制字符[0123456789abcde]（含大小写）转成字节
  170.      * @param c
  171.      * @return
  172.      */
  173.     private static int hexChar2byte(char c) {
  174.         switch (c) {
  175.             case '0':
  176.                 return 0;
  177.             case '1':
  178.                 return 1;
  179.             case '2':
  180.                 return 2;
  181.             case '3':
  182.                 return 3;
  183.             case '4':
  184.                 return 4;
  185.             case '5':
  186.                 return 5;
  187.             case '6':
  188.                 return 6;
  189.             case '7':
  190.                 return 7;
  191.             case '8':
  192.                 return 8;
  193.             case '9':
  194.                 return 9;
  195.             case 'a':
  196.             case 'A':
  197.                 return 10;
  198.             case 'b':
  199.             case 'B':
  200.                 return 11;
  201.             case 'c':
  202.             case 'C':
  203.                 return 12;
  204.             case 'd':
  205.             case 'D':
  206.                 return 13;
  207.             case 'e':
  208.             case 'E':
  209.                 return 14;
  210.             case 'f':
  211.             case 'F':
  212.                 return 15;
  213.             default:
  214.                 return -1;
  215.         }
  216.     }
  218. }

2.）串口回调SerialInter；简单概括一下这个类，就是将SerialHandle类中产生的结果，返回给上一层的业务代码，解偶合

  1. package com.chj233.serialmode.serialUtil;
  3. /**
  4.  * 串口回调
  5.  */
  6. public interface SerialInter {
  8.     /**
  9.      * 连接结果回调
  10.      * @param path 串口地址(当有多个串口需要统一处理时，可以用地址来区分)
  11.      * @param isSucc 连接是否成功
  12.      */
  13.     void connectMsg(String path,boolean isSucc);
  15.     /**
  16.      * 读取到的数据回调
  17.      * @param path 串口地址(当有多个串口需要统一处理时，可以用地址来区分)
  18.      * @param bytes 读取到的数据
  19.      * @param size 数据长度
  20.      */
  21.     void readData(String path,byte[] bytes,int size);
  23. }

 3.）串口统一管理SerialManage；简单概括一下这个类，用于管理串口的连接以及发送等功能，尤其是发送指令，极短时间内发送多个指令(例如：1毫秒内发送10个指令)，多个指令之间会相互干扰。可能执行了第一个指令，可能一个都没执行。这个类不是必须的，如果有更好的方法可以自己定义。

  1. package com.chj233.serialmode.serialUtil;
  3. import java.util.Queue;
  4. import java.util.concurrent.ConcurrentLinkedQueue;
  5. import java.util.concurrent.Executors;
  6. import java.util.concurrent.ScheduledExecutorService;
  7. import java.util.concurrent.ScheduledFuture;
  8. import java.util.concurrent.TimeUnit;
  10. /**
  11.  * 串口管理类
  12.  */
  13. public class SerialManage {
  15.     private static SerialManage instance;
  16.     private ScheduledExecutorService scheduledExecutor;//线程池 同一管理保证只有一个
  17.     private SerialHandle serialHandle;//串口连接 发送 读取处理对象
  18.     private Queue<String> queueMsg = new ConcurrentLinkedQueue<String>();//线程安全到队列
  19.     private ScheduledFuture sendStrTask;//循环发送任务
  20.     private boolean isConnect = false;//串口是否连接
  22.     private SerialManage() {
  23.         scheduledExecutor = Executors.newScheduledThreadPool(8);//初始化8个线程
  24.     }
  26.     public static SerialManage getInstance() {
  27.         if (instance == null) {
  28.             synchronized (SerialManage.class) {
  29.                 if (instance == null) {
  30.                     instance = new SerialManage();
  31.                 }
  32.             }
  33.         }
  34.         return instance;
  35.     }
  37.     /**
  38.      * 获取线程池
  39.      *
  40.      * @return
  41.      */
  42.     public ScheduledExecutorService getScheduledExecutor() {
  43.         return scheduledExecutor;
  44.     }
  46.     /**
  47.      * 串口初始化
  48.      *
  49.      * @param serialInter
  50.      */
  51.     public void init(SerialInter serialInter) {
  52.         if (serialHandle == null) {
  53.             serialHandle = new SerialHandle();
  54.             startSendTask();
  55.         }
  56.         serialHandle.addSerialInter(serialInter);
  58.     }
  60.     /**
  61.      * 打开串口
  62.      */
  63.     public void open() {
  64.         isConnect = serialHandle.open("/dev/ttyS1", 9600, true);//设置地址，波特率，开启读取串口数据
  65.     }
  67.     /**
  68.      * 发送指令
  69.      *
  70.      * @param msg
  71.      */
  72.     public void send(String msg) {
  73.         /*
  74.          此处没有直接使用 serialHandle.send(msg); 方法去发送指令
  75.          因为 某些硬件在极短时间内只能响应一个指令,232通讯一次发送多个指令会有物理干扰，
  76.          让硬件接收到指令不准确；所以 此处将指令添加到队列中，排队执行，确保每个指令一定执行.
  77.          若不相信可以试试用serialHandle.send(msg)方法循环发送10个不同的指令，看看10个指令
  78.          的执行结果。
  79.          */
  80.         queueMsg.offer(msg);//向队列添加指令
  81.     }
  83.     /**
  84.      * 关闭串口
  85.      */
  86.     public void colse() {
  87.         serialHandle.close();//关闭串口
  88.     }
  90.     //启动发送发送任务
  91.     private void startSendTask() {
  92.         cancelSendTask();//先检查是否已经启动了任务 ？ 若有则取消
  93.         //每隔100毫秒检查一次 队列中是否有新的指令需要执行
  94.         sendStrTask = scheduledExecutor.scheduleAtFixedRate(new Runnable() {
  95.             @Override
  96.             public void run() {
  97.                 if (!isConnect) return;//串口未连接 退出
  98.                 if (serialHandle == null) return;//串口未初始化 退出
  99.                 String msg = queueMsg.poll();//取出指令
  100.                 if (msg == null || "".equals(msg)) return;//无效指令 退出
  101.                 serialHandle.send(msg);//发送指令
  102.             }
  103.         }, 0, 100, TimeUnit.MILLISECONDS);
  104.     }
  106.     //取消发送任务
  107.     private void cancelSendTask() {
  108.         if (sendStrTask == null) return;
  109.         sendStrTask.cancel(true);
  110.         try {
  111.             Thread.sleep(100);
  112.         } catch (InterruptedException e) {
  113.             e.printStackTrace();
  114.         }
  115.         sendStrTask = null;
  116.     }
  118. }

4.使用串口

  1. package com.chj233.serialmode;
  3. import androidx.appcompat.app.AppCompatActivity;
  5. import android.os.Bundle;
  6. import android.util.Log;
  7. import android.view.View;
  9. import com.chj233.serialmode.serialUtil.SerialInter;
  10. import com.chj233.serialmode.serialUtil.SerialManage;
  12. public class MainActivity extends AppCompatActivity implements SerialInter {
  14.     @Override
  15.     protected void onCreate(Bundle savedInstanceState) {
  16.         super.onCreate(savedInstanceState);
  17.         setContentView(R.layout.activity_main);
  18.         SerialManage.getInstance().init(this);//串口初始化
  19.         SerialManage.getInstance().open();//打开串口
  20.         findViewById(R.id.send_but).setOnClickListener(new View.OnClickListener() {
  21.             @Override
  22.             public void onClick(View view) {
  23.                 SerialManage.getInstance().send("Z");//发送指令 Z 
  24.             }
  25.         });
  26.     }
  28.     @Override
  29.     public void connectMsg(String path, boolean isSucc) {
  30.         String msg = isSucc ? "成功" : "失败";
  31.         Log.e("串口连接回调", "串口 "+ path + " -连接" + msg);
  32.     }
  34.     @Override//若在串口开启的方法中 传入false 此处不会返回数据
  35.     public void readData(String path, byte[] bytes, int size) {
  36. //        Log.e("串口数据回调","串口 "+ path + " -获取数据" + bytes);
  37.     }
  38. }

5.总结

串口通讯对于Android开发者来说，仅需关注如何连接、操作(发送指令)、读取数据；无论是232、485还是422，对于开发者来说连接、操作、读取代码都是一样的

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： 创始元灵6666 > 《android》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多