关于Android串口通讯总结_android 串口打开后,长时间 app 会退出

前言

这几天完了串口，暂时还没搞懂这是啥玩意，因为目前底层到底如何通讯的我还不知道，不过这里先总结一下这两天的收获。

正文

现在我们开始我们最主要的问题，因为串口作为底层实现，linux把设备作为文件，并且串口文件在dev目录下的，并且现在都是通过c代码来打开的（貌似Java无法设置波特率啥的，这个东西c代码我暂时也搞不懂。并且我们cat这个文件的时候是得不到文件。以后我有机会研究研究，说不定可以实现呢。）。
这里我们关注两个问题。一个是路径，因为我们Android貌似好几个串口。所以你一定要知道你链接的串口的路径。第二波特率，这个是传输频率。非常重要，不然会出现乱码。一般如果我们可以收到消息，不能正常工作，大部分都是波特率不对。

对于不清楚如何使用jni的。我这里我推荐两个东西，Android Studio很强大，已经支持直接编译c/c++代码了，所以呢（Android studio 2.2+版本）。这里我就不再介绍之前用Javah的方法来编译jni的代码。具体教程在Android Studio 引入C/C++， 这里我还是不再详细介绍，后续我会给大家一个详细教程。

首先我们对于我们关注的串口我们会有两个操作，打开和关闭。

#include <jni.h>
#include <string>
#include <termios.h>
#include <unistd.h>
#include <fcntl.h>
#include <android/log.h>
//这里有没有简单的方法我也不知道啊。为啥这么怪的实现方法呢。大家可以给我指点。我只能这样搞了！！！
#define TAG "serial Port" // 这个是自定义的LOG的标识
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG,TAG ,__VA_ARGS__) // 定义LOGD类型
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,TAG ,__VA_ARGS__) // 定义LOGI类型
#define LOGW(...) __android_log_print(ANDROID_LOG_WARN,TAG ,__VA_ARGS__) // 定义LOGW类型
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,TAG ,__VA_ARGS__) // 定义LOGE类型
#define LOGF(...) __android_log_print(ANDROID_LOG_FATAL,TAG ,__VA_ARGS__) // 定义LOGF类型
static speed_t getBaudRate(jint baudRate) {
    switch (baudRate) {
        case 0: return B0;
        case 50: return B50;
        case 75: return B75;
        case 110: return B110;
        case 134: return B134;
        case 150: return B150;
        case 200: return B200;
        case 300: return B300;
        case 600: return B600;
        case 1200: return B1200;
        case 1800: return B1800;
        case 2400: return B2400;
        case 4800: return B4800;
        case 9600: return B9600;
        case 19200: return B19200;
        case 38400: return B38400;
        case 57600: return B57600;
        case 115200: return B115200;
        case 230400: return B230400;
        case 460800: return B460800;
        case 500000: return B500000;
        case 576000: return B576000;
        case 921600: return B921600;
        case 1000000: return B1000000;
        case 1152000: return B1152000;
        case 1500000: return B1500000;
        case 2000000: return B2000000;
        case 2500000: return B2500000;
        case 3000000: return B3000000;
        case 3500000: return B3500000;
        case 4000000: return B4000000;
        default:
            return -1;
    }
}

extern "C"
JNIEXPORT jobject JNICALL Java_zzxcomm_keylock_Util_SerialPort_open
        (JNIEnv *env, jobject obj, jstring devicePath, jint buaRate, jint flags) {
    int fd;
    speed_t speed;
    jobject mFd;
    speed   = getBaudRate(buaRate);
    if (buaRate == 115200){
        LOGE("Invalid buaR");
    }
    if (speed == -1) {
        LOGE("Invalid buaRate!!");
        return NULL;
    }
    LOGI("Right buaRate = %d.", buaRate);
    /** open device */
    jboolean isCopy;
    const char *utfPath = env->GetStringUTFChars(devicePath, &isCopy);
    fd  = open(utfPath, O_RDWR | flags);
    env->ReleaseStringUTFChars(devicePath, utfPath);
    if (fd == -1) {
        LOGE("Cannot open port");
    }
    LOGI("Open port Success!");
    /** Configure Device*/
    struct termios cfg;
    /** 获取与该终端描述符有关的参数,结果保存在termios结构体中.成功返回0
    c_iflag:输入模式标志,控制终端输入方式.
    c_oflag:输出模式标志.
    c_cflag:控制模式标志,指定终端硬件控制信息.
    c_lflag:本地模式标志,控制终端编辑功能.
    c_cc[NCCS]:控制字符,用于保存终端驱动程序中的特殊字符,如输入结束符.
    **/
    if (tcgetattr(fd, &cfg)) {
        LOGE("tcgetattr() failed");
        close(fd);
        return NULL;
    }
    LOGI("tcgetattr() Success");
    /** 设置终端属性为原始属性 **/
    cfmakeraw(&cfg);
    /** 设置输入波特率 */
    cfsetispeed(&cfg, speed);
    /** 设置输出波特率 */
    cfsetospeed(&cfg, speed);
    /** 设置属性
    第二个参数表示什么时候生效.
    TCSANOW:表明该设置立即生效
    TCSADRAIN:在所有写入fd的输出都输出后生效.此参数该在参数影响输出时使用
    TCSAFLUSH:清空输入输出缓冲区才改变属性.所有写入 fd 引用的对象的输出都被传输后生效，所有已接受但未读入的输入都在改变发生前丢弃.
    **/
    if (tcsetattr(fd, TCSANOW, &cfg)) {
        LOGE("tcsetattr() failed");
        close(fd);
        return NULL;
    }
    LOGI("tcsetattr() Success");
    /** Create a corresponding file descriptor */
    jclass cFileDescriptor  = env->FindClass("java/io/FileDescriptor");
    jmethodID iFileDescriptor   = env->GetMethodID(cFileDescriptor, "<init>", "()V");
    jfieldID descriptorID   = env->GetFieldID(cFileDescriptor, "descriptor", "I");
    mFd = env->NewObject(cFileDescriptor, iFileDescriptor);
    env->SetIntField(mFd, descriptorID, (jint) fd);
    LOGI("return mFd = %d.", fd);
    return mFd;
}

/*
 * Class:     com_zzx_port_SerialPort
 * Method:    close
 * Signature: ()V
 */
extern "C"
JNIEXPORT void JNICALL Java_zzxcomm_keylock_Util_SerialPort_close
        (JNIEnv *env, jobject obj) {
    jclass SerialPortClass = env->GetObjectClass(obj);
    jclass FileDescriptorClass = env->FindClass("java/io/FileDescriptor");
    jfieldID descriptorID = env->GetFieldID(FileDescriptorClass, "descriptor", "I");

    jfieldID mFDID = env->GetFieldID(SerialPortClass, "mFd", "Ljava/io/FileDescriptor;");
    jobject mFd = env->GetObjectField(obj, mFDID);

    jint descriptor = env->GetIntField(mFd, descriptorID);
    close(descriptor);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

这里的东西我也不太懂，总是就是获取了一个文件的操作指针，也是句柄。总之就是你获取了文件的操作方法。。然后我们看下Java代码

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;

/**
 * Created by Administrator on 2016/6/17.
 * 串口通信
 */
public class SerialPort {

    private FileInputStream mInput;
    private FileOutputStream mOutput;
    private FileDescriptor mFd;

    private native FileDescriptor open(String path, int baudRate, int flags);

    public native void close();

    static {
        System.loadLibrary("native-lib");
    }

    /**
     * 构造函数
     * @param portPath 串口路径.
     * @param baudRate 串口波特率.
     * @param flags    串口类型.一般为0.
     */
    public SerialPort(String portPath, int baudRate, int flags) throws SecurityException, IOException {
        File file = new File(portPath);
        if (!file.canRead() || !file.canWrite()) {
        //这里很重要，在Android 5.0 之后，这里无法获取root 权限，所以无法读取到我们串口的消息。所以呢，只能找底层人帮忙了。
            try {
                Process su;
                su = Runtime.getRuntime().exec("/system/xbin/su");
                String cmd = "chmod 666 " + portPath + "\n";
                su.getOutputStream().write(cmd.getBytes());
                if ((su.waitFor() != 0) || !file.canWrite() || !file.canRead()) {
                    throw new SecurityException();
                }
                su.destroy();
            } catch (Exception e) {
                e.printStackTrace();
                throw new SecurityException();
            }
        }
        try {
            mFd = open(portPath, baudRate, flags);
            if (mFd == null) {
                throw new IOException();
            }
        } catch (Exception e) {
            e.printStackTrace();
            LogUtil.loge("serial port","is failed");
            return;
        }
        mInput = new FileInputStream(mFd);
        mOutput = new FileOutputStream(mFd);
        LogUtil.loge("serial port","is open");
    }

    /**
     * 获取输入流
     */
    public InputStream getInputStream() {
        return mInput;
    }

    /**
     * 获取输出流
     */
    public OutputStream getOutputStream() {
        return mOutput;
    }

    public void doClose(){
        close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

这里打开文件。然后获取到io流，以便于在应用中读取，其实这里我们已经获取到我们该得到的东西了，不过我们还是注意一下，因为我们需要不停的读取这个串口，近似于监听效果，并且我们这里使用一个单例模式，以便于获取与不至于是程序混乱。代码如下

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

/**
 * 串口操作类
 *
 * @author Jerome
 *
 */
public class SerialPortUtil {
    private SerialPort mSerialPort;
    private OutputStream mOutputStream;
    private InputStream mInputStream;
    private ReadThread mReadThread;
    private String path = "/dev/ttyMT0";
    private int baudrate = 115200;
    private static SerialPortUtil portUtil;
    private OnDataReceiveListener onDataReceiveListener = null;
    private boolean isStop = false;

    public interface OnDataReceiveListener {
        void onSerialDataReceive(byte[] buffer, int size);
    }

    public void setOnDataReceiveListener(
            OnDataReceiveListener dataReceiveListener) {
        onDataReceiveListener = dataReceiveListener;
    }

    public static SerialPortUtil getInstance() {
        if (null == portUtil) {
            portUtil = new SerialPortUtil();
            portUtil.onCreate();
        }
        return portUtil;
    }

    /**
     * 初始化串口信息
     */
    public void onCreate() {
        try {
            mSerialPort = new SerialPort(path, baudrate,0);
            mOutputStream = mSerialPort.getOutputStream();
            mInputStream = mSerialPort.getInputStream();

            mReadThread = new ReadThread();
            isStop = false;
            mReadThread.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private boolean sendData(byte[] data){
        boolean result = true;
        try {
            if (mOutputStream != null) {
                mOutputStream.write(data);
                LogUtil.logd("发出",data);
            } else {
                result = false;
            }
        } catch (IOException e) {
            e.printStackTrace();
            result = false;
        }
        return result;
    }

    public void sendBuffer(byte[] mBuffer) {
        if (!sendData(mBuffer)){
            closeSerialPort();
            onCreate();
            sendBuffer(mBuffer);
        }
    }

    private class ReadThread extends Thread {

        @Override
        public void run() {
            super.run();
            while (!isStop && !isInterrupted()) {
                int size;
                try {
                    if (mInputStream == null)
                        return;
                    byte[] buffer = new byte[512];
                    size = mInputStream.read(buffer);
                    if (size > 0) {
                        if (null != onDataReceiveListener) {
                            onDataReceiveListener.onSerialDataReceive(buffer, size);
                        }
                    }
                    Thread.sleep(10);
                } catch (Exception e) {
                    e.printStackTrace();
                    return;
                }
            }
        }
    }

    /**
     * 关闭串口
     */
    public void closeSerialPort() {
        isStop = true;
        if (mReadThread != null) {
            mReadThread.interrupt();
        }
        if (mSerialPort != null) {
            try {
                mSerialPort.doClose();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

这里我们就已经获取了串口的读取与发送的代码控制了。基本算是整个个流程都完成了。不在详细介绍，对于接收数据后如何处理。这里本人也没找到好的办法，如果只在一个界面前面代码保留了一个监听接口，基本满足我们需求，但是如果要分发数据的话，这里就不太容易处理了，
这里提供几个思路

1. eventbus、或者广播。这东西确实对于解耦很有用，缺点：黑洞效应比较明显，对于简单应用，有点复杂。

2. 直接设置一个OnDataReceiveListener，用来分发消息。这里逻辑更加简单，可是遇到更加复杂的问题，很难解决

   这里具体如何选择我就不再详细介绍。对于选择困难综合症患者。建议eventbus。

注意事项

我们通过数组得到的一般是inputstreame，然后很容易转换成byte数组，这里我们很容易知道每个byte包含8个字节，可以存储256个字符，但是这些字符有些无法表示，所以呢在很多通讯协议中都是讲一个byte转换成两个十六进制的数字表示，这里我知道的大概有四五种解析方法，我这里不一一解释，这篇博客暂时只给出一个方法。以后我有空再给大家补充

final static String HEX = "0123456789ABCDEF";
private String getHexString(byte[] buffer) {
    StringBuilder sb = new StringBuilder(buffer.length * 2);
    for (int i=0;i<buffer.length;i++) {
    sb.append(HEX.charAt((buffer[i] >> 4) & 0x0f));
            //取出字节的低4位，然后与 0x0f与运算，得到0~15的数据，通过HEX.charAt(0~15)，即为十六进制数.
        sb.append(HEX.charAt(buffer[i] & 0x0f));
    }
    LogUntils.logv(this,sb.toString());
    return sb.toString();
}
1
2
3
4
5
6
7
8
9
10
11

具体我就不解释了，这里逻辑比较简单。小面我们稍微说点小技巧。其实很简单，但是我总是忘记，

---

因为byte是8位，理论是上无符号，但是假如最高位为1的时候，再向int型转换的时候，会变成有符号的数据，这里我们记住，byte是个八byt的二进制数值，强制转换成int的时候只取这个八位的数值，所以会出现负数，当我们使用int型时，在八byt的范围内永远不会有负值。
而int型向byte转换仅仅取第八位的数值，因为byte不关心正负号，他仅仅是一种编码符号。所以加入我们需要判断获取的一个byte和int型。一般是可以

byt buffer = a;
int code =  97;
if(（byte）code  == buffer){
}
1
2
3
4

或者：

byte buffer = a;
int code =  97;
if(code  == （byt）buffer&0xff){
}
1
2
3
4

这里byte如果简单的算法还是要知道Java的数据存储方式比较好。具体自己理解。

---

Android 5.0之后包括5.0，权限貌似有问题。具体如何读取串口。我暂时没找到好的方法

---

还有几个问题。关于消息的处理。当读取的消息不是一条，也就是在那个时间段内，读取的东西不是一条消息指令。我们需要截取指令长度，然后处理。这里可以结合自己code来处理

如果中间发错指令或者，或者需要重新发送。这里需要建立一个消息队列，这里的问题比较复杂，不在详细介绍，这种情况一般很少发生，基本可以不用考虑。

后记

总之这个算是写完了，遇到一些问题，希望大家指正.具体代码
一个版本的源码：这里写代码片