ARM Tiny210v2開發板Android系統讀寫串口設備

之前買了塊Tiny210v2開發板，需要在Android系統下讀寫串口，於是自己在JNI層封裝了下串口讀寫，PS：友善官方也提供了底層硬件的讀寫庫，這個純粹是自己寫了玩的。

代碼主要分爲5個部分，ReadWriteSerialPortLib.c+stty.h+Android.mk+accessarmborddevlib.java+MainActivity.java

stty.h主要是對於串口設備/dev/s3c2410_serial3的讀寫，參考常見的linux系統串口讀寫代碼編寫

ReadWriteSerialPortLib.c是JNI的C語言層封裝代碼

Android.mk是Android NDK編譯腳本

accessarmborddevlib.java是JNI的Java語言層封裝代碼

MainActivity.java是Android最上層的調用代碼

stty.h代碼如下：

//filename:stty.h 
#ifndef __STTY_H__ 
#define __STTY_H__ 

//包含頭文件
#include <stdio.h> 
#include <stdlib.h> 
#include <unistd.h> 
#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
#include <termios.h> 
#include <errno.h> 
#include <pthread.h> 
#include <sys/ioctl.h> 
#include<string.h>
#include<time.h>

#define DEVPATHLEN 40
// 串口設備信息結構 
typedef struct tty_info_t 
{ 
	int fd; // 串口設備ID 
	pthread_mutex_t mt; // 線程同步互斥對象 
	char name[DEVPATHLEN]; // 串口設備名稱，例："/dev/ttyS0" 
	struct termios ntm; // 新的串口設備選項 
	struct termios otm; // 舊的串口設備選項 
} TTY_INFO; 

// 串口操作函數 
TTY_INFO *readyTTY(char* devname); 
int setTTYSpeed(TTY_INFO *ptty, int speed); 
int setTTYParity(TTY_INFO *ptty,int databits,char parity,int stopbits); 
int cleanTTY(TTY_INFO *ptty); 
int sendnTTY(TTY_INFO *ptty,char *pbuf,int size); 
int recvnTTY(TTY_INFO *ptty,char *pbuf,int size); 
int lockTTY(TTY_INFO *ptty); 
int unlockTTY(TTY_INFO *ptty); 
void thread_receive(TTY_INFO *ptty);
void thread_send(TTY_INFO *ptty);

#endif 

/*
從頭文件中的函數定義不難看出，函數的功能，使用過程如下： 
（1） 打開串口設備，調用函數setTTYSpeed（）； 
（2） 設置串口讀寫的波特率，調用函數setTTYSpeed（）； 
（3） 設置串口的屬性，包括停止位、校驗位、數據位等，調用函數setTTYParity（）； 
（4） 向串口寫入數據，調用函數sendnTTY（）； 
（5） 從串口讀出數據，調用函數recvnTTY（）； 
（6） 操作完成後，需要調用函數cleanTTY（）來釋放申請的串口信息接口； 
其中，lockTTY（）和unlockTTY（）是爲了能夠在多線程中使用。在讀寫操作的前後，需要鎖定和釋放串口資源。 
具體的使用方法，在代碼實現的原文件中，main（）函數中進行了演示。下面就是源代碼文件： 
*/

// 初始化串口設備並進行原有設置的保存
TTY_INFO *readyTTY(char* DevName)
{ 
	TTY_INFO *ptty; 
	
	ptty = (TTY_INFO *)malloc(sizeof(TTY_INFO)); 
	if(ptty == NULL) 
		return NULL; 
	memset(ptty,0,sizeof(TTY_INFO)); 
	pthread_mutex_init(&ptty->mt,NULL);
	memset(ptty->name,0,DEVPATHLEN);
	strcat(ptty->name,"/dev/");
	strcat(ptty->name,DevName); //填充字符串數組內存

	// 打開並且設置串口 
	ptty->fd = open(ptty->name, O_RDWR | O_NOCTTY |O_NDELAY); 
	if (ptty->fd <0) 
	{ 
		free(ptty); 
		return NULL; 
	} 
	
	// 取得並且保存原來的設置 
	tcgetattr(ptty->fd,&ptty->otm);
	return ptty; 
} 

// 清理串口設備資源 
int cleanTTY(TTY_INFO *ptty) 
{ 
	// 
	// 關閉打開的串口設備 
	if(ptty->fd>0) 
	{ 
		tcsetattr(ptty->fd,TCSANOW,&ptty->otm); 
		close(ptty->fd); 
		ptty->fd = -1; 
		free(ptty); 
		ptty = NULL; 
	} 
	
	return 0; 
} 


// 設置串口通信速率 
// ptty 參數類型(TTY_INFO *),已經初始化的串口設備信息結構指針 
// speed 參數類型(int),用來設置串口的波特率 
// return 返回值類型(int),函數執行成功返回零值，否則返回大於零的值 
int setTTYSpeed(TTY_INFO *ptty, int speed) 
{ 
	int i; 
	// 
	// 進行新的串口設置,數據位爲8位 
	bzero(&ptty->ntm, sizeof(ptty->ntm)); 
	tcgetattr(ptty->fd,&ptty->ntm); 
	ptty->ntm.c_cflag = /*CS8 |*/ CLOCAL | CREAD; 
	
	switch(speed) 
	{ 
	case 300: 
		ptty->ntm.c_cflag |= B300; 
		break; 
	case 1200: 
		ptty->ntm.c_cflag |= B1200; 
		break; 
	case 2400: 
		ptty->ntm.c_cflag |= B2400; 
		break; 
	case 4800: 
		ptty->ntm.c_cflag |= B4800; 
		break; 
	case 9600: 
		ptty->ntm.c_cflag |= B9600; 
		break; 
	case 19200: 
		ptty->ntm.c_cflag |= B19200; 
		break; 
	case 38400: 
		ptty->ntm.c_cflag |= B38400; 
		break; 
	case 115200: 
		ptty->ntm.c_cflag |= B115200; 
		break; 
	} 
	ptty->ntm.c_iflag = IGNPAR; 
	ptty->ntm.c_oflag = 0; 
 
	tcflush(ptty->fd, TCIFLUSH); 
	tcsetattr(ptty->fd,TCSANOW,&ptty->ntm); 
	return 0; 
}

// 設置串口數據位，停止位和效驗位 
// ptty 參數類型(TTY_INFO *),已經初始化的串口設備信息結構指針 
// databits 參數類型(int), 數據位,取值爲7或者8 
// stopbits 參數類型(int),停止位,取值爲1或者2 
// parity 參數類型(int),效驗類型 取值爲N,E,O,,S 
// return 返回值類型(int),函數執行成功返回零值，否則返回大於零的值 
int setTTYParity(TTY_INFO *ptty,int databits,char parity,int stopbits) 
{ 
	// 取得串口設置 
	if( tcgetattr(ptty->fd,&ptty->ntm) != 0) 
	{ 
		printf("SetupSerial [%s]\n",ptty->name); 
		return 1; 
	} 
	
	bzero(&ptty->ntm, sizeof(ptty->ntm)); 
	ptty->ntm.c_cflag = CS8 | CLOCAL | CREAD; 
	ptty->ntm.c_iflag = IGNPAR; 
	ptty->ntm.c_oflag = 0; 

	// 設置串口的各種參數 
	ptty->ntm.c_cflag &= ~CSIZE; 
	switch (databits) 
	{ 
		//設置數據位數 
	case 7: 
		ptty->ntm.c_cflag |= CS7; 
		break; 
	case 8: 
		ptty->ntm.c_cflag |= CS8; 
		break; 
	default: 
		printf("Unsupported data size\n"); 
		return 5; 
	} 

	switch (parity) 
	{ 
		// 設置奇偶校驗位數 
	case 'n': 
	case 'N': 
		ptty->ntm.c_cflag &= ~PARENB; /* Clear parity enable */ 
		ptty->ntm.c_iflag &= ~INPCK; /* Enable parity checking */ 
		break; 
	case 'o': 
	case 'O': 
		ptty->ntm.c_cflag |= (PARODD|PARENB); /* 設置爲奇效驗*/ 
		ptty->ntm.c_iflag |= INPCK; /* Disnable parity checking */ 
		break; 
	case 'e': 
	case 'E': 
		ptty->ntm.c_cflag |= PARENB; /* Enable parity */ 
		ptty->ntm.c_cflag &= ~PARODD; /* 轉換爲偶效驗*/ 
		ptty->ntm.c_iflag |= INPCK; /* Disnable parity checking */ 
		break; 
	case 'S': 
	case 's': /*as no parity*/ 
		ptty->ntm.c_cflag &= ~PARENB; 
		ptty->ntm.c_cflag &= ~CSTOPB; 
		break; 
	default: 
		printf("Unsupported parity\n"); 
		return 2; 
	} 

	// 設置停止位 
	switch (stopbits) 
	{ 
	case 1: 
		ptty->ntm.c_cflag &= ~CSTOPB; 
		break; 
	case 2: 
		ptty->ntm.c_cflag |= CSTOPB; 
		break; 
	default: 
		printf("Unsupported stop bits\n"); 
		return 3; 
	} 
 
	ptty->ntm.c_lflag = 0; 
	ptty->ntm.c_cc[VTIME] = 0; // inter-character timer unused 
	ptty->ntm.c_cc[VMIN] = 1; // blocking read until 1 chars received 
	tcflush(ptty->fd, TCIFLUSH); 
	if (tcsetattr(ptty->fd,TCSANOW,&ptty->ntm) != 0) 
	{ 
		printf("SetupSerial \n"); 
		return 4; 
	} 
	
	return 0; 
} 

int recvnTTY(TTY_INFO *ptty,char *pbuf,int size) 
{ 
	int ret,left,bytes; 
	
	left = size; 
	
	while(left>0) 
	{ 
		ret = 0; 
		bytes = 0; 
		
		pthread_mutex_lock(&ptty->mt); 
		ioctl(ptty->fd, FIONREAD, &bytes); 
		if(bytes>0) 
		{ 
			ret = read(ptty->fd,pbuf,left); 
		} 
		pthread_mutex_unlock(&ptty->mt); 
		if(ret >0) 
		{ 
			left -= ret; 
			pbuf += ret; 
		} 
		usleep(100); 
	} 
	
	return size - left; 
} 

int sendnTTY(TTY_INFO *ptty,char *pbuf,int size) 
{ 
	int ret,nleft; 
	char *ptmp; 
	
	ret = 0; 
	nleft = size; 
	ptmp = pbuf; 
	
	while(nleft>0) 
	{ 
		pthread_mutex_lock(&ptty->mt); 
		ret = write(ptty->fd,ptmp,nleft); 
		pthread_mutex_unlock(&ptty->mt); 
		
		if(ret >0) 
		{ 
			nleft -= ret; 
			ptmp += ret; 
		} 
		//usleep(100); 
	} 
	
	return size - nleft; 
} 

int lockTTY(TTY_INFO *ptty) 
{ 
	if(ptty->fd < 0) 
	{ 
		return 1; 
	} 
	
	return flock(ptty->fd,LOCK_EX); 
} 
int unlockTTY(TTY_INFO *ptty) 
{ 
	if(ptty->fd < 0) 
	{ 
		return 1; 
	} 
	
	return flock(ptty->fd,LOCK_UN); 
} 

//多線程讀寫相關函數
//ptty作爲參數傳入兩個線程處理函數
//data->8 bits
void thread_receive(TTY_INFO *ptty)
{
	int nbyte,idx=0; 
	unsigned char data[16]; 
	
	while(1)
	{
		nbyte = recvnTTY(ptty,data,1);
		printf("Receive Data %d:%02X\n",idx++,data[0]); 
	}

	pthread_exit(0);
}

void thread_send(TTY_INFO *ptty)
{
	unsigned char data; 

	while(1)
	{
		//printf("Please input the data(HEX:such as 0x00) you want to send:\n");
		//scanf("%x",&data) ;
		//sendnTTY(ptty,&data,1); 
	}

	pthread_exit(0);
}

ReadWriteSerialPortLib.c代碼如下：

// Serial Port接口
#include <string.h>
#include <jni.h>
#include <stdio.h>
#include <stdlib.h>

#include "stty.h"

#include <android/log.h>
#define TAG "ReadWriteSerialPortLib"
#define  LOGI(...)  __android_log_print(ANDROID_LOG_INFO,TAG,__VA_ARGS__)
#define  LOGE(...)  __android_log_print(ANDROID_LOG_ERROR,TAG,__VA_ARGS__)

//#define DEVNAMELEN 35
TTY_INFO *ptty;

jint Java_org_echo_prox_accessarmborddevlib_openserialdev(JNIEnv* env, jobject thiz, jstring devname, jint baudrate)
{
	const jbyte *DevNameStr;
	char DevNameStrArray[DEVPATHLEN-5];

	pthread_t id_rec,id_send;
	int ret;

	DevNameStr = (*env)->GetStringUTFChars(env, devname, NULL);
	if (DevNameStr == NULL) 
	{
		return -1;
	}
	memset(DevNameStrArray,0,DEVPATHLEN-5);
	strcpy(DevNameStrArray,DevNameStr);

	LOGE("devname:%s",DevNameStrArray);

	ptty = readyTTY(DevNameStrArray);
	if(ptty == NULL) 
	{ 
		LOGE("readyTTY error"); 
		return -1;
	}

	lockTTY(ptty);
	if(setTTYSpeed(ptty,baudrate)>0) 
	{ 
		LOGE("setTTYSpeed() error"); 
		return -1; 
	} 
	if(setTTYParity(ptty,8,'N',1)>0) 
	{ 
		LOGE("setTTYParity() error"); 
		return -1; 
	}
	LOGE("readyTTY OK");
	return 0;
}

jint Java_org_echo_prox_accessarmborddevlib_writedata(JNIEnv* env, jobject thiz, jbyteArray dataarray, jint datalen)
{
	jbyte * dataarraybuf = (jbyte*)(*env)->GetByteArrayElements(env, dataarray, 0);
	int ret=-1;
	ret=sendnTTY(ptty,dataarraybuf,datalen);
	(*env)->ReleaseByteArrayElements(env, dataarray, dataarraybuf, 0);
	return ret;
}

jint Java_org_echo_prox_accessarmborddevlib_closeserialdev(JNIEnv* env, jobject thiz)
{
	unlockTTY(ptty);
	cleanTTY(ptty);
	LOGE("cleanTTY OK");
	return 0;
}

Android.mk代碼如下：

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_LDLIBS += -llog

LOCAL_MODULE    := AccessARMBordDevLib
LOCAL_SRC_FILES := ReadWriteSerialPortLib.c

include $(BUILD_SHARED_LIBRARY)

accessarmborddevlib.java代碼如下：

package org.echo.prox;

import android.util.Log;

public class accessarmborddevlib
{
	static public native int openserialdev(String DevName,int BaudRate);
	static public native int writedata(byte[] SendDataArray,int SendDataLen);
	static public native int closeserialdev();
	
	static {
		try {
			System.loadLibrary("AccessARMBordDevLib");
		} catch (UnsatisfiedLinkError e) {
			Log.d("readwriteserialportlib","ReadWriteSerialPortLib library not found!");
		}
	}
}

MainActivity.java核心代碼如下：

        org.echo.prox.accessarmborddevlib AccessDev =new org.echo.prox.accessarmborddevlib();
        AccessDev.openserialdev("s3c2410_serial3", 9600);
        byte[] data=new byte[4];
        data[0]='p';
        data[1]='r';
        data[2]='o';
        data[3]='x';
        AccessDev.writedata(data, data.length);
        AccessDev.closeserialdev();

要注意修改串口設備/dev/s3c2410_serial3的讀寫權限，至於如何修改可以參考這篇http://blog.csdn.net/chenxupro/article/details/8746544