Android串口通信之串口读写实例

在Android串口通信：基本知识梳理的基础上，我结合我项目中使用串口的实例，进行总结；

Android使用jni直接进行串口设备的读写网上已经有开源项目了，本文是基于网上的开源项目在实际项目中的使用做的调整和优化；
Google串口开源项目

下面是我项目中的相关代码及介绍：

1、SerialPort.cpp

/*
* Copyright 2009 Cedric Priscal
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#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 "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:  cedric_serial_SerialPort
* Method: open
* Signature: (Ljava/lang/String;)V
*/
JNIEXPORT jobject JNICALL native_open(JNIEnv *env, jobject thiz, jstring path,jint baudrate) {
int fd;
speed_t speed;
jobject mFileDescriptor;

LOGD("init native Check arguments");
/* Check arguments */
{
 speed = getBaudrate(baudrate);
 if (speed == -1) {
  /* TODO: throw an exception */
  LOGE("Invalid baudrate");
  return NULL;
 }
}

LOGD("init native Opening device!");
/* Opening device */
{
 jboolean iscopy;
 const char *path_utf = env->GetStringUTFChars(path, &iscopy);
 LOGD("Opening serial port ％s", path_utf);
//  fd = open(path_utf, O_RDWR | O_DIRECT | O_SYNC);
 fd = open(path_utf, O_RDWR | O_NOCTTY | O_NONBLOCK | O_NDELAY);
 LOGD("open() fd = ％d", fd);
 env->ReleaseStringUTFChars(path, path_utf);
 if (fd == -1) {
  /* Throw an exception */
  LOGE("Cannot open port ％d",baudrate);
  /* TODO: throw an exception */
  return NULL;
 }
}

LOGD("init native Configure device!");
/* Configure device */
{
 struct termios cfg;
 if (tcgetattr(fd, &cfg)) {
  LOGE("Configure device tcgetattr() failed 1");
  close(fd);
  return NULL;
 }

cfmakeraw(&cfg);
 cfsetispeed(&cfg, speed);
 cfsetospeed(&cfg, speed);

if (tcsetattr(fd, TCSANOW, &cfg)) {
  LOGE("Configure device tcsetattr() failed 2");
  close(fd);
  /* TODO: throw an exception */
  return NULL;
 }
}

/* 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");
 mFileDescriptor = env->NewObject(cFileDescriptor,iFileDescriptor);
 env->SetIntField(mFileDescriptor, descriptorID, (jint) fd);
}

return mFileDescriptor;
}

/*
* Class:  cedric_serial_SerialPort
* Method: close
* Signature: ()V
*/
JNIEXPORT jint JNICALL native_close(JNIEnv * env, jobject thiz)
{
jclass SerialPortClass = env->GetObjectClass(thiz);
jclass FileDescriptorClass = env->FindClass("java/io/FileDescriptor");

jfieldID mFdID = env->GetFieldID(SerialPortClass, "mFd", "Ljava/io/FileDescriptor;");
jfieldID descriptorID = env->GetFieldID(FileDescriptorClass, "descriptor", "I");

jobject mFd = env->GetObjectField(thiz, mFdID);
jint descriptor = env->GetIntField(mFd, descriptorID);

LOGD("close(fd = ％d)", descriptor);
close(descriptor);
return 1;
}

static JNINativeMethod gMethods[] = {
 { "open", "(Ljava/lang/String;I)Ljava/io/FileDescriptor;",(void*) native_open },
 { "close", "()I",(void*) native_close },
};

/*
* 为某一个类注册本地方法
*/
static int registerNativeMethods(JNIEnv* env, const char* className,
 JNINativeMethod* gMethods, int numMethods) {
jclass clazz;
clazz = env->FindClass(className);
if (clazz == NULL) {
 return JNI_FALSE;
}
if (env->RegisterNatives(clazz, gMethods, numMethods) < 0) {
 return JNI_FALSE;
}

return JNI_TRUE;
}

/*
* 为所有类注册本地方法
*/
static int registerNatives(JNIEnv* env) {
const char* kClassName = "com/jerome/serialport/SerialPort"; //指定要注册的类
return registerNativeMethods(env, kClassName, gMethods,
  sizeof(gMethods) / sizeof(gMethods[0]));
}

/*
* System.loadLibrary("lib")时调用
* 如果成功返回JNI版本, 失败返回-1
*/
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) {
JNIEnv* env = NULL;
jint result = -1;

if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
 return -1;
}
assert(env != NULL);

if (!registerNatives(env)) { //注册
 return -1;
}
//成功
result = JNI_VERSION_1_4;

return result;
}

在编译时注意修改const char* kClassName = "com/jerome/serialport/SerialPort";为你Java层与jni对应得包名；

2、Android.mk

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

TARGET_PLATFORM := android-3
LOCAL_MODULE := serial_port
LOCAL_SRC_FILES := SerialPort.cpp
LOCAL_LDLIBS := -llog

include $(BUILD_SHARED_LIBRARY)

如果要修改生成so文件的名称，请修改LOCAL_MODULE    := serial_port

3、SerialPort.java

package com.jerome.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 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) throws SecurityException, IOException {
 mFd = open(device.getAbsolutePath(), baudrate);
 if (mFd == null) {
  throw new IOException();
 }
 mFileInputStream = new FileInputStream(mFd);
 mFileOutputStream = new FileOutputStream(mFd);
}

public InputStream getInputStream() {
 return mFileInputStream;
}

public OutputStream getOutputStream() {
 return mFileOutputStream;
}

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

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

4、SerialPortUtil.java

package com.jerome.serialport;

import java.io.BufferedWriter;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

/**
* 串口操作类
*
* @author Jerome
*
*/
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/ttyMT1";
private int baudrate = 115200;
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);
  mOutputStream = mSerialPort.getOutputStream();
  mInputStream = mSerialPort.getInputStream();

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

/**
 * 发送指令到串口
 *
 * @param cmd
 * @return
 */
public boolean sendCmds(String cmd) {
 boolean result = true;
 byte[] mBuffer = (cmd+"\r\n").getBytes();
//注意：我得项目中需要在每次发送后面加\r\n，大家根据项目项目做修改，也可以去掉，直接发送mBuffer
 try {
  if (mOutputStream != null) {
   mOutputStream.write(mBuffer);
  } else {
   result = false;
  }
 } catch (IOException e) {
  e.printStackTrace();
  result = false;
 }
 return result;
}

public boolean sendBuffer(byte[] mBuffer) {
 boolean result = true;
 String tail = "\r\n";
 byte[] tailBuffer = tail.getBytes();
 byte[] mBufferTemp = new byte[mBuffer.length+tailBuffer.length];
 System.arraycopy(mBuffer, 0, mBufferTemp, 0, mBuffer.length);
 System.arraycopy(tailBuffer, 0, mBufferTemp, mBuffer.length, tailBuffer.length);
//注意：我得项目中需要在每次发送后面加\r\n，大家根据项目项目做修改，也可以去掉，直接发送mBuffer
 try {
  if (mOutputStream != null) {
   mOutputStream.write(mBufferTemp);
  } else {
   result = false;
  }
 } catch (IOException e) {
  e.printStackTrace();
  result = false;
 }
 return result;
}

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(MyLog.isDyeLevel()){
      MyLog.log(TAG, MyLog.DYE_LOG_LEVEL, "length is:"+size+",data is:"+new String(buffer, 0, size));
     }
     if (null != onDataReceiveListener) {
      onDataReceiveListener.onDataReceive(buffer, size);
     }
    }
    Thread.sleep(10);
   } catch (Exception e) {
    e.printStackTrace();
    return;
   }
  }
 }
}

/**
 * 关闭串口
 */
public void closeSerialPort() {
 sendShellCommond1();
 isStop = true;
 if (mReadThread != null) {
  mReadThread.interrupt();
 }
 if (mSerialPort != null) {
  mSerialPort.close();
 }
}

}

5、使用方法：

a、配置ndk开发环境，具体百度一下；
b、工程根目录下新建jni文件夹，将Android.mk和SerialPort.cpp放进去；
c、ndk中进入jni目录，编译生成so文件，默认so生成在libs/armeabi下；
d、新建com.jerom.serialport目录，将SerialPort和SerialPortUtil放进去；
 f、在你要使用的地方初始化SerialPortUtil，实现回调接口OnDataReceiveListener即可接受数据；

总结：

1、串口发送实质就是向串口设备（类似于文件操作）写入字节流，串口读取也是一样；
2、主要jni与Java native得对应；

来源：https://blog.csdn.net/Chen_xiaobao/article/details/76153900