说明：写该文章用的Android studio还是3.0之前的版本，因此3.0之后的版本，打包so文件，都不对了。因此本人做了更新，3.0之后的版本请看这篇博客： 【android 串口开发（二）】
说到串口开发，不得不先明确一下以下概念。
接口的定义：
- 接口泛指实体把自己提供给外界的一种抽象化物（可以为另一实体），用以由内部操作分离出外部沟通方法，使其能被修改内部而不影响外界其他实体与其交互的方式。
串行接口的定义：
- 串行接口简称 串口，也称 串行通信接口 或 串行通讯接口（通常指COM接口）。是指数据一位一位地顺序传送，其特点是通信线路简单，只要一对传输线就可以实现双向通信，从而大大降低了成本，特别适用于远距离通信，但传送速度较慢。
串口通信的定义：
- 串口按位（bit）发送和接收字节。
串口通讯的定义：
- 串口通讯(Serial Communication)， 是指外设和计算机间，通过数据信号线 、地线、控制线等，按位进行传输数据的一种通讯方式。一条信息的各位数据被逐位按顺序传送的通讯方式称为串行通讯。
明确了概念以后，那么我们就回归正题。android的串口开发，很自然的就是要用到JNI的相关知识，通过JNI调用底层C代码。其实使用JNI直接进行串口设备的读写操作，网上参考的资料还是有不少的，而且 google也有开源项目 ，本文也是整理一下网上的资源，做些优化，也方便以后查阅。
一：生成SO库
1. 生成 .h结尾文件
首现做一些准备工作，确保你的android studio已经下载了NDK。然后创建一个 SerialPort.java
如图：
注意：包名一旦写好，以后都不要变动了。
SerialPort.java具体代码：
import android.util.Log;
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 abc on 2017/2/21.
*/
public class SerialPort {
private static final String TAG = "SerialPort";
/*
* Do not remove or rename the field mFd: it is used by native method close();
*/
private FileDescriptor mFd;
private FileInputStream mFileInputStream;
private FileOutputStream mFileOutputStream;
public SerialPort(File device, int baudrate, int flags) throws SecurityException, IOException {
if (device == null) {
System.out.println("device is null");
return;
}
/* Check access permission */
if (!device.canRead() || !device.canWrite()) {
try {
/* Missing read/write permission, trying to chmod the file */
Process su;
su = Runtime.getRuntime().exec("/system/bin/su");
String cmd = "chmod 777 " + device.getAbsolutePath() + "\n" + "exit\n";
su.getOutputStream().write(cmd.getBytes());
if ((su.waitFor() != 0) || !device.canRead() || !device.canWrite()) {
throw new SecurityException();
}
} catch (Exception e) {
e.printStackTrace();
throw new SecurityException();
}
}
mFd = open(device.getAbsolutePath(), baudrate, flags);
if (mFd == null) {
Log.e(TAG, "native open returns null");
throw new IOException();
}
mFileInputStream = new FileInputStream(mFd);
mFileOutputStream = new FileOutputStream(mFd);
}
// Getters and setters
public InputStream getInputStream() {
return mFileInputStream;
}
public OutputStream getOutputStream() {
return mFileOutputStream;
}
// JNI
private native static FileDescriptor open(String path, int baudrate, int flags);
public native void close();
static {
System.loadLibrary("serial_port");
}
}
然后clean project 再rebuild project 生成class文件，
这时候打开如下图的文件夹看是否生成了classes文件夹，没有生成请重新来过。
再打开Terminal输入指令
cd app/build/intermediates/classes/debug
然后再输入指令
javah -jni com.everyoo.serialport.SerialPort
注意 这里javah -jni后面跟的是JniUtils类的全路径，如果javah报不存在之类的，是你的Java环境没有配置好。
这时候打开classes/debug下面的文件发现多了一个以 .h 结尾文件
2.编写C文件
添加jni文件夹：
然后，将之前生成的文件，复制到jni文件夹中。再创建一个 SerialPort.c 文件。如图：
至于为什么会有黄色箭头指向的类，可以参考这篇博客。如果不添加的话，很有可能会报如下错误：
java.lang.UnsatisfiedLinkError: dlopen failed: cannot locate symbol tcgetattr referenced by libserial_port.so…
下面贴出 SerialPort.c 具体代码：
#include <stdlib.h>
#include <stdio.h>
#include <jni.h>
#include <assert.h>
#include <termios.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <jni.h>
#include "com_everyoo_serialport_SerialPort.h"
#include "android/log.h"
static const char *TAG = "serial_port";
#define LOGI(fmt, args...) __android_log_print(ANDROID_LOG_INFO, TAG, fmt, ##args)
#define LOGD(fmt, args...) __android_log_print(ANDROID_LOG_DEBUG, TAG, fmt, ##args)
#define LOGE(fmt, args...) __android_log_print(ANDROID_LOG_ERROR, TAG, fmt, ##args)
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;
}
}
/*
* Class: android_serialport_SerialPort
* Method: open
* Signature: (Ljava/lang/String;II)Ljava/io/FileDescriptor;
*/
JNIEXPORT jobject JNICALL Java_com_everyoo_serialport_SerialPort_open
(JNIEnv *env, jclass thiz, jstring path, jint baudrate, jint flags)
{
int fd;
speed_t speed;
jobject mFileDescriptor;
/* Check arguments */
{
speed = getBaudrate(baudrate);
if (speed == -1) {
/* TODO: throw an exception */
LOGE("Invalid baudrate");
return NULL;
}
}
/* Opening device */
{
jboolean iscopy;
const char *path_utf = (*env)->GetStringUTFChars(env, path, &iscopy);
LOGD("Opening serial port %s with flags 0x%x", path_utf, O_RDWR | flags);
fd = open(path_utf, O_RDWR | flags);
LOGD("open() fd = %d", fd);
(*env)->ReleaseStringUTFChars(env, path, path_utf);
if (fd == -1)
{
/* Throw an exception */
LOGE("Cannot open port");
/* TODO: throw an exception */
return NULL;
}
}
/* Configure device */
{
struct termios cfg;
LOGD("Configuring serial port");
if (tcgetattr(fd, &cfg))
{
LOGE("tcgetattr() failed");
close(fd);
/* TODO: throw an exception */
return NULL;
}
cfmakeraw(&cfg);
cfsetispeed(&cfg, speed);
cfsetospeed(&cfg, speed);
if (tcsetattr(fd, TCSANOW, &cfg))
{
LOGE("tcsetattr() failed");
close(fd);
/* TODO: throw an exception */
return NULL;
}
}
/* Create a corresponding file descriptor */
{
jclass cFileDescriptor = (*env)->FindClass(env, "java/io/FileDescriptor");
jmethodID iFileDescriptor = (*env)->GetMethodID(env, cFileDescriptor, "<init>", "()V");
jfieldID descriptorID = (*env)->GetFieldID(env, cFileDescriptor, "descriptor", "I");
mFileDescriptor = (*env)->NewObject(env, cFileDescriptor, iFileDescriptor);
(*env)->SetIntField(env, mFileDescriptor, descriptorID, (jint)fd);
}
return mFileDescriptor;
}
/*
* Class: cedric_serial_SerialPort
* Method: close
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_com_everyoo_serialport_SerialPort_close
(JNIEnv *env, jobject thiz)
{
jclass SerialPortClass = (*env)->GetObjectClass(env, thiz);
jclass FileDescriptorClass = (*env)->FindClass(env, "java/io/FileDescriptor");
jfieldID mFdID = (*env)->GetFieldID(env, SerialPortClass, "mFd", "Ljava/io/FileDescriptor;");
jfieldID descriptorID = (*env)->GetFieldID(env, FileDescriptorClass, "descriptor", "I");
jobject mFd = (*env)->GetObjectField(env, thiz, mFdID);
jint descriptor = (*env)->GetIntField(env, mFd, descriptorID);
LOGD("close(fd = %d)", descriptor);
close(descriptor);
}
termios.h 具体代码:
/*
* Copyright (C) 2008 The Android Open Source Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#ifndef _TERMIOS_H_
#define _TERMIOS_H_
#include <sys/cdefs.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <stdint.h>
#include <linux/termios.h>
__BEGIN_DECLS
/* Redefine these to match their ioctl number */
#undef TCSANOW
#define TCSANOW TCSETS
#undef TCSADRAIN
#define TCSADRAIN TCSETSW
#undef TCSAFLUSH
#define TCSAFLUSH TCSETSF
static __inline__ int tcgetattr(int fd, struct termios *s)
{
return ioctl(fd, TCGETS, s);
}
static __inline__ int tcsetattr(int fd, int __opt, const struct termios *s)
{
return ioctl(fd, __opt, (void *)s);
}
static __inline__ int tcflow(int fd, int action)
{
return ioctl(fd, TCXONC, (void *)(intptr_t)action);
}
static __inline__ int tcflush(int fd, int __queue)
{
return ioctl(fd, TCFLSH, (void *)(intptr_t)__queue);
}
static __inline__ pid_t tcgetsid(int fd)
{
pid_t _pid;
return ioctl(fd, TIOCGSID, &_pid) ? (pid_t)-1 : _pid;
}
static __inline__ int tcsendbreak(int fd, int __duration)
{
return ioctl(fd, TCSBRKP, (void *)(uintptr_t)__duration);
}
static __inline__ speed_t cfgetospeed(const struct termios *s)
{
return (speed_t)(s->c_cflag & CBAUD);
}
static __inline__ int cfsetospeed(struct termios *s, speed_t speed)
{
s->c_cflag = (s->c_cflag & ~CBAUD) | (speed & CBAUD);
return 0;
}
static __inline__ speed_t cfgetispeed(const struct termios *s)
{
return (speed_t)(s->c_cflag & CBAUD);
}
static __inline__ int cfsetispeed(struct termios *s, speed_t speed)
{
s->c_cflag = (s->c_cflag & ~CBAUD) | (speed & CBAUD);
return 0;
}
static __inline__ void cfmakeraw(struct termios *s)
{
s->c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
s->c_oflag &= ~OPOST;
s->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
s->c_cflag &= ~(CSIZE|PARENB);
s->c_cflag |= CS8;
}
__END_DECLS
#endif /* _TERMIOS_H_ */
###3.配置参数
好了，到此基本上完成一大半，万事俱备只欠东风。我们还需要一些关键步骤：
在项目（app）的build.gradel中的defaultConfig下添加。没有下载NKD的，要下载ndk。
ndk{
moduleName "serial_port" //生成的so名字
ldLibs "log", "z", "m" //添加依赖库文件，因为有log打印等
abiFilters "arm64-v8a","armeabi", "armeabi-v7a","mips","mips64","x86_64", "x86"
//输出指定几种abi体系结构下的so库。
}
在gradle.properties文件中添加：
android.useDeprecatedNdk=true
到这里基本上ok啦。
你现在就可以组建apk或者运行代码啦，之后会在这里会生成so库：
新建libs文件夹把这三个文件夹放进去，或者这样：
不过你如果没有放到如上图一样到jniLibs文件夹中，而是放到了 libs文件夹下，最好要指定一下：
然后删除咱们的jni文件试试，是否工程还能运行？
答案当然是能运行的！
注意：生成SO库的时候，第一次运行有时候会出错，那你就关闭一下工程，再打开一下，就好了。
二：串口的读写操作
既然，我们的so已经生成了，那么接下来就是串口的读写操作啦。
下面贴出关键类的代码：
**
* 串口操作类
*/
public class SerialPortUtil {
private String TAG = SerialPortUtil.class.getSimpleName();
private SerialPort mSerialPort;
private OutputStream mOutputStream;
private InputStream mInputStream;
private ReadThread mReadThread;
private String path = "/dev/ttyS4"; //这个是我们要读取的串口路径，这个硬件开发人员会告诉我们的
private int baudrate = 9600;//这个参数，硬件开发人员也会告诉我们的
private static SerialPortUtil portUtil;
private OnDataReceiveListener onDataReceiveListener = null;
private boolean isStop = false;
public interface OnDataReceiveListener {
public void onDataReceive(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(new File(path), baudrate, 0);
mOutputStream = mSerialPort.getOutputStream();
mInputStream = mSerialPort.getInputStream();
mReadThread = new ReadThread();
isStop = false;
mReadThread.start();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 发送指令到串口
*
* @param cmd
* @return
*/
public boolean sendCmds(String cmd) {
boolean result = true;
String str = cmd;
str = str.replace(" ", "");
byte[] mBuffer = SerialDataUtils.HexToByteArr(str);
if (!isStop) {
try {
if (mOutputStream != null) {
mOutputStream.write(mBuffer);
} else {
result = false;
}
} catch (IOException e) {
e.printStackTrace();
result = false;
}
} else {
System.out.println("sendCmds serialPort isClose");
result = false;
}
return result;
}
private class ReadThread extends Thread {
@Override
public void run() {
super.run();
System.out.println("ReadThread.run isInterrupted()=" + isInterrupted());
while (!isStop && !isInterrupted()) {
System.out.println("ReadThread.run mInputStream=" + mInputStream);
int size;
try {
if (mInputStream == null){
System.out.println("ReadThread.run return");
return;
}
byte[] buffer = new byte[512];
System.out.println("ReadThread.run buffer");
size = mInputStream.read(buffer);//该方法读不到数据时，会阻塞在这里
System.out.println("ReadThread.run size=" + size);
if (size > 0) {
/* if(MyLog.isDyeLevel()){
MyLog.log(TAG, MyLog.DYE_LOG_LEVEL, "length is:"+size+",data is:"+new String(buffer, 0, size));
}*/
byte[] buffer2 = new byte[size];
for (int i = 0; i < size; i++) {
buffer2[i] = buffer[i];
}
if (onDataReceiveListener != null) {
onDataReceiveListener.onDataReceive(buffer2, size);
}
}
Thread.sleep(50);//延时 50 毫秒
} catch (Exception e) {
e.printStackTrace();
System.out.println("ReadThread.run e.printStackTrace() " + e);
return;
}
}
}
}
/**
* 关闭串口
*/
public void closeSerialPort() {
isStop = true;
if (mReadThread != null) {
mReadThread.interrupt();
}
if (mSerialPort != null) {
mSerialPort.close();
}
}
}
把这个进制转换的工具类也贴出一下：
package com.everyoo.serialportdaemon2;
/**
* 串口数据转换工具类
* Created by Administrator on 2016/6/2.
*/
public class SerialDataUtils {
//-------------------------------------------------------
// 判断奇数或偶数，位运算，最后一位是1则为奇数，为0是偶数
public static int isOdd(int num) {
return num & 1;
}
//-------------------------------------------------------
//Hex字符串转int
public static int HexToInt(String inHex) {
return Integer.parseInt(inHex, 16);
}
//-------------------------------------------------------
//Hex字符串转byte
public static byte HexToByte(String inHex) {
return (byte) Integer.parseInt(inHex, 16);
}
//-------------------------------------------------------
//1字节转2个Hex字符
public static String Byte2Hex(Byte inByte) {
return String.format("%02x", new Object[]{inByte}).toUpperCase();
}
//-------------------------------------------------------
//字节数组转转hex字符串
public static String ByteArrToHex(byte[] inBytArr) {
StringBuilder strBuilder = new StringBuilder();
for (byte valueOf : inBytArr) {
strBuilder.append(Byte2Hex(Byte.valueOf(valueOf)));
strBuilder.append(" ");
}
return strBuilder.toString();
}
//-------------------------------------------------------
//字节数组转转hex字符串，可选长度
public static String ByteArrToHex(byte[] inBytArr, int offset, int byteCount) {
StringBuilder strBuilder = new StringBuilder();
int j = byteCount;
for (int i = offset; i < j; i++) {
strBuilder.append(Byte2Hex(Byte.valueOf(inBytArr[i])));
}
return strBuilder.toString();
}
//-------------------------------------------------------
//转hex字符串转字节数组
public static byte[] HexToByteArr(String inHex) {
byte[] result;
int hexlen = inHex.length();
if (isOdd(hexlen) == 1) {
hexlen++;
result = new byte[(hexlen / 2)];
inHex = "0" + inHex;
} else {
result = new byte[(hexlen / 2)];
}
int j = 0;
for (int i = 0; i < hexlen; i += 2) {
result[j] = HexToByte(inHex.substring(i, i + 2));
j++;
}
return result;
}
}
最后你在你的MainActivity中，直接调用 serialPort.sendCmds(“7e01010d”) 方法即可，需要注意一点的就是：像7e01010d 是十六进制的字符：
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ButterKnife.inject(this);
initEvent();
SerialPortUtil serialPort = SerialPortUtil.getInstance();
//该方法是读取数据的回调监听，一旦读取到数据，就立马回调
serialPort.setOnDataReceiveListener(new SerialPortUtil.OnDataReceiveListener() {
@Override
public void onDataReceive(byte[] buffer, int size) {
receiveString = SerialDataUtils.ByteArrToHex(buffer).trim();
System.out.println("MainActivity2.onDataReceive receiveString= " + receiveString);
runOnUiThread(new Runnable() {
@Override
public void run() {
result.append(receiveString + "\r\n");
}
});
}
});
}
##源码下载
参考博客：
https://github.com/cepr/android-serialport-api
528
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
