最近在做android串口的开发，找到一个开源的串口类android-serialport-api。其主页在这里http://code.google.com/p/android-serialport-api/ ，这里可以下到APK及对源码。

但是下载源码之后发现源码不能直接使用，而且源码结构较为复杂。关于串口的操作不外乎几步：

1.打开串口（及配置串口）；

2.读串口；

3.写串口；

4.关闭串口。

android-serialport-api的代码使用了继承等复杂的行为，不容易使初学者很快掌握关于串口的上述4步，所以我特别自己写了一个demo，只有一个activity，其中包含了打开串口，写串口，读串口的操作，对于关闭串口，大家一开就会不明白怎么写了。

这篇文章主要参考http://blog.csdn.net/tangcheng_ok/article/details/7021470

还有http://blog.csdn.net/jerome_home/article/details/8452305

下面言归正传：

第一：

说道android 串口，就不得不提JNI技术，它使得java中可以调用c语言写成的库。为可在android中使用串口，android-serialport-api的作者自己写了一个c语言的动态链接库serial_port.so(自动命名成libserial_port.so），并把它放在了libs/aemeabi 里，其c源文件在JNI中，大家在下载了android-serialport-api的源代码后，将这两个文件夹copy到自己新建的工程中即可。

第二：

然后将调用c语言写成的动态链接库的java类放入到src文件夹下的android.serialport包下，这里一定要将包名命名成这个，因为对JNI有一定了解的人就会知道，在写c语言链接库时候，函数的命名是和调用它的类所在的包名相关的，一旦包名与链接库中函数的命名不相符，就不能调用链接库的函数。这里可以打开jni中的.c文件（他就是动态链接库的源文件），可以看到源码：

[cpp] view plain copy

[cpp] view plain copy

1. /*
2. *Copyright2009CedricPriscal
3. *
4. *LicensedundertheApacheLicense,Version2.0(the"License");
5. *youmaynotusethisfileexceptincompliancewiththeLicense.
6. *YoumayobtainacopyoftheLicenseat
7. *
8. *http://www.apache.org/licenses/LICENSE-2.0
9. *
10. *Unlessrequiredbyapplicablelaworagreedtoinwriting,software
11. *distributedundertheLicenseisdistributedonan"ASIS"BASIS,
12. *WITHOUTWARRANTIESORCONDITIONSOFANYKIND,eitherexpressorimplied.
13. *SeetheLicenseforthespecificlanguagegoverningpermissionsand
14. *limitationsundertheLicense.
15. */
17. #include<termios.h>
18. #include<unistd.h>
19. #include<sys/types.h>
20. #include<sys/stat.h>
21. #include<fcntl.h>
22. #include<string.h>
23. #include<jni.h>
25. #include"android/log.h"
26. staticconstchar*TAG="serial_port";
27. #defineLOGI(fmt,args...)__android_log_print(ANDROID_LOG_INFO,TAG,fmt,##args)
28. #defineLOGD(fmt,args...)__android_log_print(ANDROID_LOG_DEBUG,TAG,fmt,##args)
29. #defineLOGE(fmt,args...)__android_log_print(ANDROID_LOG_ERROR,TAG,fmt,##args)
31. staticspeed_tgetBaudrate(jintbaudrate)
32. {
33. switch(baudrate){
34. case0:returnB0;
35. case50:returnB50;
36. case75:returnB75;
37. case110:returnB110;
38. case134:returnB134;
39. case150:returnB150;
40. case200:returnB200;
41. case300:returnB300;
42. case600:returnB600;
43. case1200:returnB1200;
44. case1800:returnB1800;
45. case2400:returnB2400;
46. case4800:returnB4800;
47. case9600:returnB9600;
48. case19200:returnB19200;
49. case38400:returnB38400;
50. case57600:returnB57600;
51. case115200:returnB115200;
52. case230400:returnB230400;
53. case460800:returnB460800;
54. case500000:returnB500000;
55. case576000:returnB576000;
56. case921600:returnB921600;
57. case1000000:returnB1000000;
58. case1152000:returnB1152000;
59. case1500000:returnB1500000;
60. case2000000:returnB2000000;
61. case2500000:returnB2500000;
62. case3000000:returnB3000000;
63. case3500000:returnB3500000;
64. case4000000:returnB4000000;
65. default:return-1;
66. }
67. }
69. /*
70. *Class:cedric_serial_SerialPort
71. *Method:open
72. *Signature:(Ljava/lang/String;)V
73. */
74. JNIEXPORTjobjectJNICALLJava_android_serialport_SerialPort_open
75. (JNIEnv*env,jobjectthiz,jstringpath,jintbaudrate)
76. {
77. intfd;
78. speed_tspeed;
79. jobjectmFileDescriptor;
81. /*Checkarguments*/
82. {
83. speed=getBaudrate(baudrate);
84. if(speed==-1){
85. /*TODO:throwanexception*/
86. LOGE("Invalidbaudrate");
87. returnNULL;
88. }
89. }
91. /*Openingdevice*/
92. {
93. jbooleaniscopy;
94. constchar*path_utf=(*env)->GetStringUTFChars(env,path,&iscopy);
95. LOGD("Openingserialport%s",path_utf);
96. fd=open(path_utf,O_RDWR|O_DIRECT|O_SYNC);
97. LOGD("open()fd=%d",fd);
98. (*env)->ReleaseStringUTFChars(env,path,path_utf);
99. if(fd==-1)
100. {
101. /*Throwanexception*/
102. LOGE("Cannotopenport");
103. /*TODO:throwanexception*/
104. returnNULL;
105. }
106. }
108. /*Configuredevice*/
109. {
110. structtermioscfg;
111. LOGD("Configuringserialport");
112. if(tcgetattr(fd,&cfg))
113. {
114. LOGE("tcgetattr()failed");
115. close(fd);
116. /*TODO:throwanexception*/
117. returnNULL;
118. }
120. cfmakeraw(&cfg);
121. cfsetispeed(&cfg,speed);
122. cfsetospeed(&cfg,speed);
124. if(tcsetattr(fd,TCSANOW,&cfg))
125. {
126. LOGE("tcsetattr()failed");
127. close(fd);
128. /*TODO:throwanexception*/
129. returnNULL;
130. }
131. }
133. /*Createacorrespondingfiledescriptor*/
134. {
135. jclasscFileDescriptor=(*env)->FindClass(env,"java/io/FileDescriptor");
136. jmethodIDiFileDescriptor=(*env)->GetMethodID(env,cFileDescriptor,"<init>","()V");
137. jfieldIDdescriptorID=(*env)->GetFieldID(env,cFileDescriptor,"descriptor","I");
138. mFileDescriptor=(*env)->NewObject(env,cFileDescriptor,iFileDescriptor);
139. (*env)->SetIntField(env,mFileDescriptor,descriptorID,(jint)fd);
140. }
142. returnmFileDescriptor;
143. }
145. /*
146. *Class:cedric_serial_SerialPort
147. *Method:close
148. *Signature:()V
149. */
150. JNIEXPORTvoidJNICALLJava_android_serialport_SerialPort_close
151. (JNIEnv*env,jobjectthiz)
152. {
153. jclassSerialPortClass=(*env)->GetObjectClass(env,thiz);
154. jclassFileDescriptorClass=(*env)->FindClass(env,"java/io/FileDescriptor");
156. jfieldIDmFdID=(*env)->GetFieldID(env,SerialPortClass,"mFd","Ljava/io/FileDescriptor;");
157. jfieldIDdescriptorID=(*env)->GetFieldID(env,FileDescriptorClass,"descriptor","I");
159. jobjectmFd=(*env)->GetObjectField(env,thiz,mFdID);
160. jintdescriptor=(*env)->GetIntField(env,mFd,descriptorID);
162. LOGD("close(fd=%d)",descriptor);
163. close(descriptor);
164. }

可以看到，函数的命名规则直接和包名有关。

第三：

android.serialport包下，有两个类，分别是SerialPort.java 和SerialPortFinder.java。

其中，SerialPort.java，这个类主要用来加载SO文件，通过JNI的方式打开关闭串口。

[java] view plain copy

1. /*
2. *Copyright2009CedricPriscal
3. *
4. *LicensedundertheApacheLicense,Version2.0(the"License");
5. *youmaynotusethisfileexceptincompliancewiththeLicense.
6. *YoumayobtainacopyoftheLicenseat
7. *
8. *http://www.apache.org/licenses/LICENSE-2.0
9. *
10. *Unlessrequiredbyapplicablelaworagreedtoinwriting,software
11. *distributedundertheLicenseisdistributedonan"ASIS"BASIS,
12. *WITHOUTWARRANTIESORCONDITIONSOFANYKIND,eitherexpressorimplied.
13. *SeetheLicenseforthespecificlanguagegoverningpermissionsand
14. *limitationsundertheLicense.
15. */
17. packageandroid.serialport;
19. importjava.io.File;
20. importjava.io.FileDescriptor;
21. importjava.io.FileInputStream;
22. importjava.io.FileOutputStream;
23. importjava.io.IOException;
24. importjava.io.InputStream;
25. importjava.io.OutputStream;
27. importandroid.util.Log;
29. publicclassSerialPort{
31. privatestaticfinalStringTAG="SerialPort";
33. /*
34. *DonotremoveorrenamethefieldmFd:itisusedbynativemethodclose();
35. */
36. privateFileDescriptormFd;
37. privateFileInputStreammFileInputStream;
38. privateFileOutputStreammFileOutputStream;
40. publicSerialPort(Filedevice,intbaudrate)throwsSecurityException,IOException{
42. /*Checkaccesspermission*/
43. if(!device.canRead()||!device.canWrite()){
44. try{
45. /*Missingread/writepermission,tryingtochmodthefile*/
46. Processsu;
47. su=Runtime.getRuntime().exec("/system/bin/su");
48. Stringcmd="chmod777"+device.getAbsolutePath()+"\n"
49. +"exit\n";
50. /*Stringcmd="chmod777/dev/s3c_serial0"+"\n"
51. +"exit\n";*/
52. su.getOutputStream().write(cmd.getBytes());
53. if((su.waitFor()!=0)||!device.canRead()
54. ||!device.canWrite()){
55. thrownewSecurityException();
56. }
57. }catch(Exceptione){
58. e.printStackTrace();
59. thrownewSecurityException();
60. }
61. }
63. mFd=open(device.getAbsolutePath(),baudrate);
64. if(mFd==null){
65. Log.e(TAG,"nativeopenreturnsnull");
66. thrownewIOException();
67. }
68. mFileInputStream=newFileInputStream(mFd);
69. mFileOutputStream=newFileOutputStream(mFd);
70. }
72. //Gettersandsetters
73. publicInputStreamgetInputStream(){
74. returnmFileInputStream;
75. }
77. publicOutputStreamgetOutputStream(){
78. returnmFileOutputStream;
79. }
81. //JNI
82. privatenativestaticFileDescriptoropen(Stringpath,intbaudrate);
83. publicnativevoidclose();
84. static{
85. System.loadLibrary("serial_port");
86. }
87. }

可以看到System.loadLibrary("serial_port");一句，这一句就是用来加载动态链接库。我们的串口操作就是要给予这个类来实现。

含有一个类SerialPortFinder.java，这个类是用来找到系统中可以用的串口的，如果你知道的android设备有什么串口，就不必使用这个类来查找串口了，一次简化我们的demo。

第四：加入我们自己的Activity类

为了方便我记在android.serialport包下加入了我自己的MyserialActivity.java,大家从上面的图中也可以看见。

代码如下：

[java] view plain copy

1. packageandroid.serialport;
4. importjava.io.File;
5. importjava.io.FileInputStream;
6. importjava.io.FileOutputStream;
7. importjava.io.IOException;
9. importandroid.app.Activity;
11. importandroid.os.Bundle;
15. //importandroid.serialport.sample.R;
16. importandroid.serialport.R;
18. importandroid.view.View;
19. importandroid.widget.Button;
20. importandroid.widget.EditText;
21. importandroid.widget.Toast;
23. publicclassMyserialActivityextendsActivity{
24. /**Calledwhentheactivityisfirstcreated.*/
27. EditTextmReception;
28. FileOutputStreammOutputStream;
29. FileInputStreammInputStream;
30. SerialPortsp;
32. @Override
34. publicvoidonCreate(BundlesavedInstanceState){
35. super.onCreate(savedInstanceState);
36. setContentView(R.layout.main);
39. finalButtonbuttonSetup=(Button)findViewById(R.id.ButtonSetup);
40. buttonSetup.setOnClickListener(newView.OnClickListener(){
41. publicvoidonClick(Viewv){
42. mReception=(EditText)findViewById(R.id.EditTextRec);
44. try{
45. sp=newSerialPort(newFile("/dev/ttyS2"),9600);
46. }catch(SecurityExceptione){
47. //TODOAuto-generatedcatchblock
48. e.printStackTrace();
49. }catch(IOExceptione){
50. //TODOAuto-generatedcatchblock
51. e.printStackTrace();
52. }
55. mOutputStream=(FileOutputStream)sp.getOutputStream();
56. mInputStream=(FileInputStream)sp.getInputStream();
58. Toast.makeText(getApplicationContext(),"open",
59. Toast.LENGTH_SHORT).show();
61. }
62. });
66. finalButtonbuttonsend=(Button)findViewById(R.id.ButtonSent1);
67. buttonsend.setOnClickListener(newView.OnClickListener(){
68. publicvoidonClick(Viewv){
70. try{
71. mOutputStream.write(newString("send").getBytes());
72. mOutputStream.write('\n');
73. }catch(IOExceptione){
74. e.printStackTrace();
75. }
78. Toast.makeText(getApplicationContext(),"send",
79. Toast.LENGTH_SHORT).show();
81. }
82. });
85. finalButtonbuttonrec=(Button)findViewById(R.id.ButtonRec);
86. buttonrec.setOnClickListener(newView.OnClickListener(){
87. publicvoidonClick(Viewv){
88. intsize;
90. try{
91. byte[]buffer=newbyte[64];
92. if(mInputStream==null)return;
93. size=mInputStream.read(buffer);
94. if(size>0){
95. onDataReceived(buffer,size);
97. }
98. }catch(IOExceptione){
99. e.printStackTrace();
100. return;
101. }
103. }
104. });
105. }
106. voidonDataReceived(finalbyte[]buffer,finalintsize){
107. runOnUiThread(newRunnable(){
108. publicvoidrun(){
109. if(mReception!=null){
110. mReception.append(newString(buffer,0,size));
111. }
112. }
113. });
114. }
117. }

可以看见，功能比较简单，只有三个按钮，分别用来打开串口（buttonsetup），写串口（buttonsend），读串口（buttonrec），一个文本框用来显示串口接收到的信息。功能已经简化到了最简。

下面先说说在模拟器中使用串口的方法：

应先使用-serial选项打开你的模拟器，如图（修改你模拟器的名字）

然后进入adb shell

cd /dev

chmod 777 ttyS2

运行后结果：

相比大家都懂得，我们的串口就是ttyS2，使用chmod命令来获取对它的操作，否则之后你的应用可能没有串口的操作权限。

然后运行程序：

其中Console就是打开串口（原谅我偷懒，忘改名字了）。

你可以把你的电脑的COM1连接到另一台电脑的串口上，并在那台电脑上打开你的串口助手之类的软件，配置好串口（参数不难从源代码里看出来）。按下模拟器中的send键，就能在那台电脑的串口助手中看到:

同样，从那台电脑向这台电脑发送数据也可以显示

至此，这个小demo就完毕了。

我的源码在这里： http://download.csdn.net/detail/akunainiannian/5202173

更多相关文章

1. Android(安卓)SharedPreferences总结及优化
2. Android开发，ArcGis for Android的一些常见操作
3. 【源码分享下载】每日更新之Android应用源码比较不错的新闻客户
4. 【Android(安卓)界面效果9】9patch图片
5. Android(安卓)创建及调用自己的 ContentProvider
6. Android(安卓)Jetpack系列——ViewModel源码分析
7. Android应用程序启动过程——Launcher源码分析
8. Android中AIDL实现进程通信（附源码下载）
9. Android(安卓)网络图片加载

随机推荐

1. HttpURLConnection类的保持session会话
2. Android(安卓)MediaStore检索视频并播放
3. MULTI-INTERFACE CONNECTIVITY ON ANDROI
4. android 自定义PickerView 日期滑动选择
5. 对android:textAlignmentStyle 属性参数
6. Android(安卓)Material Design初步认识
7. MediaPlayer的使用 带有seekBar
8. Android(安卓)Studio忽略文件配置
9. android Watchdog 实现剖析
10. ADT 0.9下载