Seriport实现串口数据发送和接收

serialport是谷歌的一个关于串口通信的框架，它封装了方法，帮助我们更好的使用串口，进行软件和硬件之前的通信

效果图：手机效果图是大屏android，无截图按钮，图片可能和结果稍有出处

1.在app下的builder.gradle下面添加依赖：

  //gogle serialPort
    implementation 'com.aill:AndroidSerialPort:1.0.8'

2.封装一个串口传输类

package com.example.administrator.testz;


import java.io.InputStream;
import java.io.OutputStream;

/**
 * 串口传输类。在这个类里会启动两个线程分别对串口进行监听输入与数据输出。
 *
 * @author xxs
 */
public class SerialTransceiver {

    private InputStream inputStream;
    private OutputStream outputStream;
    private WriteRunnable write;
    private ReadRunnable read;
    private ReceiverListener listener;

    private byte[] writeBuffer;
    private int writeIn, writeOut;

    /**
     * 构造函数
     */
    public SerialTransceiver() {
        writeBuffer = new byte[1024];
        writeIn = 0;
        writeOut = 0;
    }

    /**
     * 启动线程
     */
    public void start() {
        write = new WriteRunnable();
        write.isRunnung = true;
        (new Thread(write)).start();

        read = new ReadRunnable();
        read.isRunnung = true;
        (new Thread(read)).start();
    }

    /**
     * 停止线程
     */
    public void stop() {
        if (write != null) {
            write.isRunnung = false;
            synchronized (writeBuffer) {
                writeBuffer.notifyAll();
            }
        }

        if (read != null)
            read.isRunnung = false;
    }

    /**
     * 写入数据。这个数据会先写入到一个缓存里，然后再通知输出线程将数据发送出去。
     *
     * @param data   数据
     * @param offset 有效偏移量
     * @param size   数据大小
     * @return 成功返回true，否则返回false
     */
    public boolean write(byte[] data, int offset, int size) {
        if (data == null)
            throw new NullPointerException("data = null");
        if (offset + size > data.length)
            throw new IndexOutOfBoundsException("offset + size > data.length");

        synchronized (writeBuffer) {
            if (size > 1024 - writeIn)
                return false;

            System.arraycopy(data, offset, writeBuffer, writeIn, size);
            writeIn += size;
            writeBuffer.notifyAll();
        }

        return true;
    }

    /**
     * 设置输入流。这个输入流应是串口输入流。监听线程就是监听这个输入流。
     *
     * @param inputStream 串口输入流。
     */
    public void setInputStream(InputStream inputStream) {
        this.inputStream = inputStream;
    }

    /**
     * 设置输出流。这个输出流应是串口输出流。发送线程会将数据从这个输出流发凌空出去。
     *
     * @param outputStream 串口输出流。
     */
    public void setOutputStream(OutputStream outputStream) {
        this.outputStream = outputStream;
    }

    /**
     * 设置接收监听器。当从输入流收到数据后会通过这个监听器通知设置监听器的类。
     *
     * @param listener
     */
    public void setListener(ReceiverListener listener) {
        this.listener = listener;
    }

    /**
     * 数据输出线程主体。
     *
     * @author Hong
     */
    private class WriteRunnable implements Runnable {

        private boolean isRunnung = false;

        @Override
        public void run() {
            System.out.println("Start WriteRunnable!");
            if (outputStream == null)
                isRunnung = false;

            try {
                while (isRunnung) {
                    synchronized (writeBuffer) {
                        // 当缓存为空时会阻塞
                        while (isRunnung && (writeIn == writeOut))
                            writeBuffer.wait();
                        if (!isRunnung)
                            break;

                        // 将数据写入输出流
                        int size = writeIn - writeOut;
                        outputStream.write(writeBuffer, writeOut, size);
                        writeOut += size;
                        if (writeIn == writeOut) {
                            writeIn = 0;
                            writeOut = 0;
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

            isRunnung = false;
            System.out.println("finish WriteRunnable!");
        }
    }

    /**
     * 监听输入线程主体。
     *
     * @author Hong
     */
    private class ReadRunnable implements Runnable {

        private boolean isRunnung = false;

        @Override
        public void run() {
            System.out.println("Start ReadRunnable!"