zoukankan      html  css  js  c++  java

  • Android Studio的串口通讯开发

    基于android-serialport-api实现

    前言
    RS232标准接口
    UART
    RS232与UART转接
    下载 NDK 和构建工具
    创建支持 C/C++ 的新项目
    编译C/C++代码
    串口通讯原理
    关于校验位
    HexString与Bytes的转换
    参考

    前言

    软件代码写久了，总会对嵌入式开发感兴趣，因为软件的东西写来写去看不见摸不着，而嵌入式硬件开发，可以捣鼓一些机械设备玩，电子感应灯，遥控车啥的，这也就是传说中的创客啊！后面索性买了一套单片机教程《手把手教你学51单片机》和板子学习，作为入门书来说，确实挺不错，配合上官方的板子，把单片机的基础原理都将的挺透彻，其中还包括了C语言的讲解，为嵌入式开发打下基础。

    共花了2个月把单片机学了一遍，最后觉得也没有想象中的难，因为其实到头来还是像在使用工具，只是知识体系会有些不一样，主要就是基于C/汇编语言通过单片机对寄存器、定时器、每个引脚的高低电平的使用，然后参考硬件手册，对每个硬件进行操作，以达到想要实现的效果。而如果想要实现自己的最小系统，或者弄出一些好玩的东西，还要自己根据物力电气原理选原件、画PCB板子，这就是硬件工程师要干的事情了。

    刚好公司项目里基于Android板子开发了一些串口通讯的应用，得益于之前单片机的学习，没有遇到太多困难，记录分享一下。

    RS232标准接口

    也就是PC电脑上所说的COM口，RS232是负逻辑电平，它定义+5~+12V为低电平，而-12~-5V为高电平。

    正常情况下，PC台式主机机箱都会有一个RS232的通讯接口（别和VGI的口搞错啦！），而目前笔记本几乎不会带有了，所以都是用USB转接口。

    UART

    及Universal Asynchronous Receiver Transmitter：通用异步收发器，通常ARM嵌入式板子都会集成此接口

    UART有4个pin（VCC, GND, RX, TX）, 用的TTL电平, 低电平为0(0V)，高电平为1（3.3V或以上）。

    RS232与UART转接

    通常嵌入式里所说的串口，是指UART口，但硬件众多，大多数都是基于RS232和UART，有时候这两种口之间需要通讯，最主要不同的其实也就是电平不一样，所以需要转接口，某宝上MAX3232种类繁多。

    下载 NDK 和构建工具

    由于是使用JNI直接进行串口设备的读写，所以需要下载工具。android studio版本务必要2.2以上
    运行SDK Manager，下载3个工具，CMake、LLDB、NDK
    PS：如果下载进度很慢，请使用国内镜像

    创建支持 C/C++ 的新项目



    在 Customize C++ Support 选项卡中。你有下面几种方式来自定义你的项目：

    1. C++ Standard：点击下拉框，可以选择标准 C++，或者选择默认 CMake 设置的 Toolchain Default 选项。
    2. Exceptions Support：如果你想使用有关 C++ 异常处理的支持，就勾选它。勾选之后，Android Studio 会在 module 层的 build.gradle 文件中的 cppFlags 中添加 -fexcetions 标志。
    3. Runtime Type Information Support：如果你想支持 RTTI，那么就勾选它。勾选之后，Android Studio 会在 module 层的 build.gradle 文件中的 cppFlags 中添加 -frtti 标志。


    新建成功之后，相对于以前的项目目录，多了几个地方。

    1. cpp 目录存放你所有 native code 的地方，包括源码，头文件，预编译项目等。对于新项目，Android Studio 创建了一个 C++ 模板文件：native-lib.cpp，并且将该文件放到了你的 app 模块的 src/main/cpp/ 目录下。这份模板代码提供了一个简答的 C++ 函数：stringFromJNI()，该函数返回一个字符串：”Hello from C++”。
    2. External Build Files 目录是存放 CMake 或 ndk-build 构建脚本的地方。有点类似于 build.gradle 文件告诉 Gradle 如何编译你的 APP 一样，CMake 和 ndk-build 也需要一个脚本来告知如何编译你的 native library。对于一个新的项目，Android Studio 创建了一个 CMake 脚本：CMakeLists.txt，并且将其放到了你的 module 的根目录下。
    3. gradle的脚本下也加入了externalNativeBuild字段来显示指定CMake。

    PS：如果现有项目需要添加C/C++ 代码，则参考项目模板添加相应文件即可。

    编译C/C++代码

    CMakeLists.txt

    1. # Sets the minimum version of CMake required to build the native
    2. # library. You should either keep the default value or only pass a
    3. # value of 3.4.0 or lower.
    5. cmake_minimum_required(VERSION 3.4.1)
    7. # Creates and names a library, sets it as either STATIC
    8. # or SHARED, and provides the relative paths to its source code.
    9. # You can define multiple libraries, and CMake builds it for you.
    10. # Gradle automatically packages shared libraries with your APK.
    12. add_library( # Sets the name of the library.
    13.              serial_port
    15.              # Sets the library as a shared library.
    16.              SHARED
    18.              # Provides a relative path to your source file(s).
    19.              # Associated headers in the same location as their source
    20.              # file are automatically included.
    21.              src/main/cpp/SerialPort.c )
    23. # Searches for a specified prebuilt library and stores the path as a
    24. # variable. Because system libraries are included in the search path by
    25. # default, you only need to specify the name of the public NDK library
    26. # you want to add. CMake verifies that the library exists before
    27. # completing its build.
    29. find_library( # Sets the name of the path variable.
    30.               log-lib
    32.               # Specifies the name of the NDK library that
    33.               # you want CMake to locate.
    34.               log )
    36. # Specifies libraries CMake should link to your target library. You
    37. # can link multiple libraries, such as libraries you define in the
    38. # build script, prebuilt third-party libraries, or system libraries.
    40. target_link_libraries( # Specifies the target library.
    41.                        serial_port
    43.                        # Links the target library to the log library
    44.                        # included in the NDK.
    45.                        ${log-lib} )

    SerialPort.h

    1. /* DO NOT EDIT THIS FILE - it is machine generated */
    2. #include <jni.h>
    3. /* Header for class android_serialport_api_SerialPort */
    5. #ifndef _Included_android_serialport_api_SerialPort
    6. #define _Included_android_serialport_api_SerialPort
    7. #ifdef __cplusplus
    8. extern "C" {
    9. #endif
    10. /*
    11.  * Class:     android_serialport_api_SerialPort
    12.  * Method:    open
    13.  * Signature: (Ljava/lang/String;II)Ljava/io/FileDescriptor;
    14.  */
    15. JNIEXPORT jobject JNICALL Java_android_1serialport_1api_SerialPort_open
    16.   (JNIEnv *, jclass, jstring, jint, jint);
    18. /*
    19.  * Class:     android_serialport_api_SerialPort
    20.  * Method:    close
    21.  * Signature: ()V
    22.  */
    23. JNIEXPORT void JNICALL Java_android_1serialport_1api_SerialPort_close
    24.   (JNIEnv *, jobject);
    26. #ifdef __cplusplus
    27. }
    28. #endif
    29. #endif

    SerialPort.c

    1. /*
    2. * Copyright 2009-2011 Cedric Priscal
    3. *
    4. * Licensed under the Apache License, Version 2.0 (the "License");
    5. * you may not use this file except in compliance with the License.
    6. * You may obtain a copy of the License at
    7. *
    8. * http://www.apache.org/licenses/LICENSE-2.0
    9. *
    10. * Unless required by applicable law or agreed to in writing, software
    11. * distributed under the License is distributed on an "AS IS" BASIS,
    12. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13. * See the License for the specific language governing permissions and
    14. * limitations under the License.
    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 "SerialPort.h"
    27. #include "android/log.h"
    28. static const char *TAG="serial_port";
    29. #define LOGI(fmt, args...) __android_log_print(ANDROID_LOG_INFO,  TAG, fmt, ##args)
    30. #define LOGD(fmt, args...) __android_log_print(ANDROID_LOG_DEBUG, TAG, fmt, ##args)
    31. #define LOGE(fmt, args...) __android_log_print(ANDROID_LOG_ERROR, TAG, fmt, ##args)
    33. static speed_t getBaudrate(jint baudrate)
    34. {
    35.     switch(baudrate) {
    36.     case 0: return B0;
    37.     case 50: return B50;
    38.     case 75: return B75;
    39.     case 110: return B110;
    40.     case 134: return B134;
    41.     case 150: return B150;
    42.     case 200: return B200;
    43.     case 300: return B300;
    44.     case 600: return B600;
    45.     case 1200: return B1200;
    46.     case 1800: return B1800;
    47.     case 2400: return B2400;
    48.     case 4800: return B4800;
    49.     case 9600: return B9600;
    50.     case 19200: return B19200;
    51.     case 38400: return B38400;
    52.     case 57600: return B57600;
    53.     case 115200: return B115200;
    54.     case 230400: return B230400;
    55.     case 460800: return B460800;
    56.     case 500000: return B500000;
    57.     case 576000: return B576000;
    58.     case 921600: return B921600;
    59.     case 1000000: return B1000000;
    60.     case 1152000: return B1152000;
    61.     case 1500000: return B1500000;
    62.     case 2000000: return B2000000;
    63.     case 2500000: return B2500000;
    64.     case 3000000: return B3000000;
    65.     case 3500000: return B3500000;
    66.     case 4000000: return B4000000;
    67.     default: return -1;
    68.     }
    69. }
    71. /*
    72.  * Class:     android_serialport_SerialPort
    73.  * Method:    open
    74. * Signature: (Ljava/lang/String;II)Ljava/io/FileDescriptor;
    75. */
    76. JNIEXPORT jobject JNICALL Java_android_1serialport_1api_SerialPort_open
    77.   (JNIEnv *env, jclass thiz, jstring path, jint baudrate, jint flags)
    78. {
    79.     int fd;
    80.     speed_t speed;
    81.     jobject mFileDescriptor;
    83.     /* Check arguments */
    84.     {
    85.         speed = getBaudrate(baudrate);
    86.         if (speed == -1) {
    87.             /* TODO: throw an exception */
    88.             LOGE("Invalid baudrate");
    89.             return NULL;
    90.         }
    91.     }
    93.     /* Opening device */
    94.     {
    95.         jboolean iscopy;
    96.         const char *path_utf = (*env)->GetStringUTFChars(env, path, &iscopy);
    97.         LOGD("Opening serial port %s with flags 0x%x", path_utf, O_RDWR | flags);
    98.         fd = open(path_utf, O_RDWR | flags);
    99.         LOGD("open() fd = %d", fd);
    100.         (*env)->ReleaseStringUTFChars(env, path, path_utf);
    101.         if (fd == -1)
    102.         {
    103.             /* Throw an exception */
    104.             LOGE("Cannot open port");
    105.             /* TODO: throw an exception */
    106.             return NULL;
    107.         }
    108.     }
    110.     /* Configure device */
    111.     {
    112.         struct termios cfg;
    113.         LOGD("Configuring serial port");
    114.         if (tcgetattr(fd, &cfg))
    115.         {
    116.             LOGE("tcgetattr() failed");
    117.             close(fd);
    118.             /* TODO: throw an exception */
    119.             return NULL;
    120.         }
    122.         cfmakeraw(&cfg);
    123.         cfsetispeed(&cfg, speed);
    124.         cfsetospeed(&cfg, speed);
    126.         //此处设置校验位
    127.         //cfg.c_cflag……
    129.         if (tcsetattr(fd, TCSANOW, &cfg))
    130.         {
    131.             LOGE("tcsetattr() failed");
    132.             close(fd);
    133.             /* TODO: throw an exception */
    134.             return NULL;
    135.         }
    136.     }
    138.     /* Create a corresponding file descriptor */
    139.     {
    140.         jclass cFileDescriptor = (*env)->FindClass(env, "java/io/FileDescriptor");
    141.         jmethodID iFileDescriptor = (*env)->GetMethodID(env, cFileDescriptor, "<init>", "()V");
    142.         jfieldID descriptorID = (*env)->GetFieldID(env, cFileDescriptor, "descriptor", "I");
    143.         mFileDescriptor = (*env)->NewObject(env, cFileDescriptor, iFileDescriptor);
    144.         (*env)->SetIntField(env, mFileDescriptor, descriptorID, (jint)fd);
    145.     }
    147.     return mFileDescriptor;
    148. }
    150. /*
    151.  * Class:     cedric_serial_SerialPort
    152.  * Method:    close
    153. * Signature: ()V
    154. */
    155. JNIEXPORT void JNICALL Java_android_1serialport_1api_SerialPort_close
    156.   (JNIEnv *env, jobject thiz)
    157. {
    158.     jclass SerialPortClass = (*env)->GetObjectClass(env, thiz);
    159.     jclass FileDescriptorClass = (*env)->FindClass(env, "java/io/FileDescriptor");
    161.     jfieldID mFdID = (*env)->GetFieldID(env, SerialPortClass, "mFd", "Ljava/io/FileDescriptor;");
    162.     jfieldID descriptorID = (*env)->GetFieldID(env, FileDescriptorClass, "descriptor", "I");
    164.     jobject mFd = (*env)->GetObjectField(env, thiz, mFdID);
    165.     jint descriptor = (*env)->GetIntField(env, mFd, descriptorID);
    167.     LOGD("close(fd = %d)", descriptor);
    168.     close(descriptor);
    169. }

    最后java在需要的地方调用

    1.     // JNI
    2.     private native static FileDescriptor open(String path, int baudrate, int flags);
    3.     public native void close();
    4.     static {
    5.         Log.i(TAG, "loadLibrary..............");
    6.         System.loadLibrary("serial_port");
    7.     }

    串口通讯原理

    使用到了linux系统函数，是相对底层的开发，所以一大堆标志位，位运算，看着有些晕，函数的具体使用方法需要查询手册
    1、打开串口

    1. fd = open(path_utf, O_RDWR | flags);

    其中
    O_RDWR 读写方式打开
    O_NOCTTY 不允许进程管理串口
    O_NDELAY 非阻塞

    2、写串口

    1. n = write(fd, "ATZ ", 4);

    n实际写入个数

    3、设置串口为非阻塞方式

    1. fcntl(fd, F_SETFL, FNDELAY);

    4、设置串口为阻塞方式：

    1. fcntl(fd, F_SETFL, 0);

    5、读串口：

    1. res = read(fd,buf,len);

    6、关闭串口

    1.  Close(fd);

    注：示例代码中通过JAVA的FileDescriptor类包装了数据流，所以读写操作是在上层完成的。

    1.     /* Create a corresponding file descriptor */
    2.     {
    3.         jclass cFileDescriptor = (*env)->FindClass(env, "java/io/FileDescriptor");
    4.         jmethodID iFileDescriptor = (*env)->GetMethodID(env, cFileDescriptor, "<init>", "()V");
    5.         jfieldID descriptorID = (*env)->GetFieldID(env, cFileDescriptor, "descriptor", "I");
    6.         mFileDescriptor = (*env)->NewObject(env, cFileDescriptor, iFileDescriptor);
    7.         (*env)->SetIntField(env, mFileDescriptor, descriptorID, (jint)fd);
    8.     }
    9.         return mFileDescriptor;

    关于校验位

    示例代码默认是没有添加任何校验位的，一般情况设备的基础通讯协议都是
    波特率：9600
    校验位：无
    数据位：8
    停止位：1位
    至于具体的指令协议，根据设备提供商文档自行写控制代码即可。
    校验位设置代码如下：
    No parity (8N1):

    1. cfg.c_cflag &= ~PARENB
    2. cfg.c_cflag &= ~CSTOPB
    3. cfg.c_cflag &= ~CSIZE;
    4. cfg.c_cflag |= CS8;

    Even parity (7E1):

    1. cfg.c_cflag |= PARENB
    2. cfg.c_cflag &= ~PARODD
    3. cfg.c_cflag &= ~CSTOPB
    4. cfg.c_cflag &= ~CSIZE;
    5. cfg.c_cflag |= CS7;

    Odd parity (7O1):

    1. cfg.c_cflag |= PARENB
    2. cfg.c_cflag |= PARODD
    3. cfg.c_cflag &= ~CSTOPB        
    4. cfg.c_cflag &= ~CSIZE;
    5. cfg.c_cflag |= CS7;

    Space parity is setup the same as no parity (7S1):

    1. cfg.c_cflag &= ~PARENB
    2. cfg.c_cflag &= ~CSTOPB
    3. cfg.c_cflag &= ~CSIZE;                     
    4. cfg.c_cflag |= CS8;
    5. //cfg.c_cflag |= PARENB | CS8 | CMSPAR;

    Mark parity is simulated by using 2 stop bits (7M1):

    1. cfg.c_cflag &= ~PARENB;
    2. cfg.c_cflag |= CSTOPB;
    3. cfg.c_cflag &= ~CSIZE;
    4. cfg.c_cflag |= CS7;
    5. //cfg.c_cflag |= PARENB | CS8 | CMSPAR |PARODD;

    1.even 每个字节传送整个过程中bit为1的个数是偶数个（校验位调整个数）
    2.odd 每个字节穿送整个过程中bit为1的个数是奇数个（校验位调整个数）
    3.noparity没有校验位
    4.space 校验位总为0
    5.mark 校验位总为1；

    HexString与Bytes的转换

    默认情况下串口读出来的数据是byte[]，有时候需要转换16进制的字符串进行指令识别

    1. /**
    2.  * Created by lixin(178078114@qq.com) on 2016/12/17.
    3.  */
    5. public class HexUtils {
    7.     /**
    8.      * 把字节数组转换成16进制字符串
    9.      *
    10.      * @param bArray
    11.      * @return
    12.      */
    13.     public static String bytesToHexString(byte[] src) {
    14.         StringBuilder stringBuilder = new StringBuilder("");
    15.         if (src == null || src.length <= 0) {
    16.             return null;
    17.         }
    18.         for (int i = 0; i < src.length; i++) {
    19.             int v = src[i] & 0xFF;
    20.             String hv = Integer.toHexString(v);
    21.             if (hv.length() < 2) {
    22.                 stringBuilder.append(0);
    23.             }
    24.             stringBuilder.append(hv);
    25.         }
    26.         return stringBuilder.toString().toUpperCase();
    27.     }
    29.     /**
    30.      * 把16进制字符串转换成字节数组
    31.      *
    32.      * @param hex
    33.      * @return
    34.      */
    35.     public static byte[] hexStringToByte(String hex) {
    36.         int len = (hex.length() / 2);
    37.         byte[] result = new byte[len];
    38.         char[] achar = hex.toCharArray();
    39.         for (int i = 0; i < len; i++) {
    40.             int pos = i * 2;
    41.             result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1]));
    42.         }
    43.         return result;
    44.     }
    46.     private static byte toByte(char c) {
    47.         byte b = (byte) "0123456789ABCDEF".indexOf(c);
    48.         return b;
    49.     }
    50. }

    最终的demo如图，选择对了参数和串口设备，即可调试了！

    参考

    http://gqdy365.iteye.com/blog/2188906
    http://wl9739.github.io/2016/09/21/%E5%9C%A8-Android-Studio-2-2-%E4%B8%AD%E6%84%89%E5%BF%AB%E5%9C%B0%E4%BD%BF%E7%94%A8-C-C-md/

    demo示例：
    链接：http://pan.baidu.com/s/1pLc1JVt 密码：h1zt
  • 相关阅读:
    Annotation
    GIT的作用以及Versioncontrol为什么要用GIT
    Http协议
    人工智能的可怕与不可怕
    Makefile简易教程
    Node.js 学习笔记之一：学习规划 & 认知 Node.js
    《大教堂与集市》的启示 — 软件工程的另一种选择
    Git简易教程
    谈谈买书与读书
    clang编译器简介
  • 原文地址：https://www.cnblogs.com/leestar54/p/6604636.html
Copyright © 2011-2022 走看看