Android——串口开发

最新推荐文章于 2024-08-16 14:57:15 发布
最新推荐文章于 2024-08-16 14:57:15 发布
阅读量859 收藏
点赞数
分类专栏： android jni 串口 文章标签： android ndk cmake android studio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Grandaunt/article/details/54579946
版权
android 同时被 3 个专栏收录
117 篇文章 2 订阅
订阅专栏
jni
3 篇文章 0 订阅
订阅专栏
串口
1 篇文章 0 订阅
订阅专栏

android studio更新换代后2.2后开发后开发ndk方便了很多。接下来以串口为例做一发ndk开发

1.集成ndk环境：
这里写图片描述

重点是C++呢里打勾，然后一路Next到finsh

这里写图片描述

然后Android studio就自动集成好了ndk，就这么简单
这里写图片描述

这是新增的CMake生成的ndk环境目录
这里只讲使用 不讲原理，所以想知道原理的话可自行百度CMake，有很全的介绍

MyApplication.class



import android.app.Application;

import com.example.sjs.vendingmachine.SerialUtil.SerialPort;
import com.example.sjs.vendingmachine.SerialUtil.SerialPortFinder;

import java.io.File;
import java.io.IOException;
import java.security.InvalidParameterException;


/**
 * Created by kqw on 2016/10/26.
 * MyApplication
 */

public class MyApplication extends Application {

    private static final String TAG = "MyApplication";
    public SerialPortFinder mSerialPortFinder = new SerialPortFinder();
    private SerialPort mSerialPort = null;

    public SerialPort getSerialPort() throws SecurityException, IOException, InvalidParameterException {
        if (mSerialPort == null) {
            mSerialPort = new SerialPort(new File("/dev/ttyUSB0"),9600 , 0);
        }
        return mSerialPort;
    }

    public void closeSerialPort() {
        if (mSerialPort != null) {
            mSerialPort.close();
            mSerialPort = null;
        }
    }
}

在Manifest.xml里，添加权限，添加MyApplication声明
这里写图片描述


    <!-- 往sdcard中写入数据的权限 -->
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <!-- 在sdcard中创建/删除文件的权限 -->
    <uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS" />
    android:name=".Application.MyApplication"

SerialPort.class


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;

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 {

        /* 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/xbin/su");
                String cmd = "chmod 666 " + 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("native-lib");
//        System.loadLibrary("serial_port");
    }
}

open,close方法标红时右键 空格，自动生成相关联的c++方法

SerialPortActivity.class


import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Message;

import com.example.sjs.vendingmachine.Application.MyApplication;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.security.InvalidParameterException;


public abstract class SerialPortActivity extends Activity {

    protected MyApplication mApplication;
    protected SerialPort mSerialPort;
    protected OutputStream mOutputStream;
    private InputStream mInputStream;
    private ReadThread mReadThread;

    HandlerThread sendingHandlerThread = new HandlerThread("sendingHandlerThread");

    {
        sendingHandlerThread.start();
    }

    protected Handler sendingHandler = new Handler(sendingHandlerThread.getLooper()) {
        @Override
        public void handleMessage(Message msg) {
            if (mOutputStream != null) {
                try {
                    mOutputStream.write((byte[]) msg.obj);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    };

    private class ReadThread extends Thread {

        @Override
        public void run() {
            super.run();
            while (!isInterrupted()) {
                int size;
                try {
                    byte[] buffer = new byte[64];
                    if (mInputStream == null) return;
                    size = mInputStream.read(buffer);
                    if (size > 0) {
                        onDataReceived(buffer, size);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                    return;
                }
            }
        }
    }

    private void DisplayError(String resourceId) {
        AlertDialog.Builder b = new AlertDialog.Builder(this);
        b.setTitle("Error");
        b.setMessage(resourceId);
        b.setPositiveButton("OK", new OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
                SerialPortActivity.this.finish();
            }
        });
        b.show();
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mApplication = (MyApplication) getApplication();
        try {
            mSerialPort = mApplication.getSerialPort();
            mOutputStream = mSerialPort.getOutputStream();
            mInputStream = mSerialPort.getInputStream();

            /* Create a receiving thread */
            mReadThread = new ReadThread();
            mReadThread.start();
        } catch (SecurityException e) {
            // You do not have read/write permission to the serial port.
            DisplayError("You do not have read/write permission to the serial port.");
        } catch (IOException e) {
            // The serial port can not be opened for an unknown reason.
            DisplayError("The serial port can not be opened for an unknown reason.");
        } catch (InvalidParameterException e) {
            // Please configure your serial port first.
            DisplayError("Please configure your serial port first.");
        }
    }

    protected abstract void onDataReceived(final byte[] buffer, final int size);

    @Override
    protected void onDestroy() {
        if (mReadThread != null)
            mReadThread.interrupt();
        mApplication.closeSerialPort();
        mSerialPort = null;
        if (null != sendingHandlerThread) {
            sendingHandlerThread.quit();
        }
        super.onDestroy();
    }
}

SerialPortFinder.class


import android.util.Log;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;
import java.util.Iterator;
import java.util.Vector;

public class SerialPortFinder {

    public class Driver {
        public Driver(String name, String root) {
            mDriverName = name;
            mDeviceRoot = root;
        }
        private String mDriverName;
        private String mDeviceRoot;
        Vector<File> mDevices = null;
        public Vector<File> getDevices() {
            if (mDevices == null) {
                mDevices = new Vector<File>();
                File dev = new File("/dev");
                File[] files = dev.listFiles();
                int i;
                for (i=0; i<files.length; i++) {
                    if (files[i].getAbsolutePath().startsWith(mDeviceRoot)) {
                        Log.d(TAG, "Found new device: " + files[i]);
                        mDevices.add(files[i]);
                    }
                }
            }
            return mDevices;
        }
        public String getName() {
            return mDriverName;
        }
    }

    private static final String TAG = "SerialPort";

    private Vector<Driver> mDrivers = null;

    Vector<Driver> getDrivers() throws IOException {
        if (mDrivers == null) {
            mDrivers = new Vector<Driver>();
            LineNumberReader r = new LineNumberReader(new FileReader("/proc/tty/drivers"));
            String l;
            while((l = r.readLine()) != null) {
                // Issue 3:
                // Since driver name may contain spaces, we do not extract driver name with split()
                String drivername = l.substring(0, 0x15).trim();
                String[] w = l.split(" +");
                if ((w.length >= 5) && (w[w.length-1].equals("serial"))) {
                    Log.d(TAG, "Found new driver " + drivername + " on " + w[w.length-4]);
                    mDrivers.add(new Driver(drivername, w[w.length-4]));
                }
            }
            r.close();
        }
        return mDrivers;
    }

    public String[] getAllDevices() {
        Vector<String> devices = new Vector<String>();
        // Parse each driver
        Iterator<Driver> itdriv;
        try {
            itdriv = getDrivers().iterator();
            while(itdriv.hasNext()) {
                Driver driver = itdriv.next();
                Iterator<File> itdev = driver.getDevices().iterator();
                while(itdev.hasNext()) {
                    String device = itdev.next().getName();
                    String value = String.format("%s (%s)", device, driver.getName());
                    devices.add(value);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return devices.toArray(new String[devices.size()]);
    }

    public String[] getAllDevicesPath() {
        Vector<String> devices = new Vector<String>();
        // Parse each driver
        Iterator<Driver> itdriv;
        try {
            itdriv = getDrivers().iterator();
            while(itdriv.hasNext()) {
                Driver driver = itdriv.next();
                Iterator<File> itdev = driver.getDevices().iterator();
                while(itdev.hasNext()) {
                    String device = itdev.next().getAbsolutePath();
                    devices.add(device);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return devices.toArray(new String[devices.size()]);
    }
}

最后调用的activity


import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

import com.example.sjs.vendingmachine.SerialUtil.SerialPortActivity;

public class OpenDoorActivity extends SerialPortActivity  {

    private  static  String TAG = "MainActivity";
    //    private EditText mEditTextEmission;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_open_door);
    }

    public void send(int open_num) {
//        参数是字符串
//        String text = mEditTextEmission.getText().toString();
//        if (TextUtils.isEmpty(text )) {
//            return;
//        }
//          Message message = Message.obtain();
//        message.obj = text .getBytes();
//        Log.i(TAG,HxStr+"send已发送");
//       sendingHandler.sendMessage(message);



        //收到参数已被封装
        Log.i(TAG,open_num+"send已发送open_num");
        byte [] HxStr =hex2byte(open_numarr[open_num]);
        Message message = Message.obtain();
        message.obj =  HxStr;
        Log.i(TAG,HxStr+"send已发送");
        sendingHandler.sendMessage(message);


    }

    @Override
    protected void onDataReceived(final byte[] buffer, final int size) {
        runOnUiThread(new Runnable() {
            @Override
            public void run() {

                Toast.makeText(mApplication, "收到消息：" + new String(buffer) + "  size = " + size, Toast.LENGTH_SHORT).show();

            }
        });
    }


    }
    /**
     * @Title:hex2byte
     * @Description:字符串转16进制
     * @param hex
     *           字符串
     * @return 16进制字符串
     * @throws
     */
    public static byte[] hex2byte(String hex) {
        String digital = "0123456789ABCDEF";
        String hex1 = hex.replace(" ", "");
        char[] hex2char = hex1.toCharArray();
        byte[] bytes = new byte[hex1.length()/2];
        byte temp;
        for (int p = 0; p < bytes.length; p++) {
            temp = (byte) (digital.indexOf(hex2char[2 * p]) * 16);
            temp += digital.indexOf(hex2char[2 * p + 1]);
            bytes[p] = (byte) (temp & 0xff);
        }
        return bytes;
    }

    /**
     * 数组转换成十六进制字符串
     *
     * @return HexString
     */
    public static final String bytesToHexString(byte[] bArray) {
        StringBuffer sb = new StringBuffer(bArray.length);
        String sTemp;
        for (int i = 0; i < bArray.length; i++) {
            sTemp = Integer.toHexString(0xFF & bArray[i]);
            if (sTemp.length() < 2)
                sb.append(0);
            sb.append(sTemp.toUpperCase());
        }
        return sb.toString();
    }
    /**
     * @Title:bytes2HexString
     * @Description:字节数组转16进制字符串
     * @param b
     *            字节数组
     * @return 16进制字符串
     * @throws
     */
    public static String bytes2HexString(byte[] b) {
        StringBuffer result = new StringBuffer();
        String hex;
        for (int i = 0; i < b.length; i++) {
            hex = Integer.toHexString(b[i] & 0xFF);
            if (hex.length() == 1) {
                hex = '0' + hex;
            }
            result.append(hex.toUpperCase());
        }
        return result.toString();
    }
}

native-lib.cpp

#include <jni.h>
#include <string>
extern "C" {

#include <termios.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.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;
    }
}


JNIEXPORT jobject JNICALL
Java_com_example_sjs_vendingmachine_SerialUtil_SerialPort_open(JNIEnv *env, jclass type,
                                                               jstring path, jint baudrate,
                                                               jint flags) {
//    const char *path = env->GetStringUTFChars(path_, 0);
//
//    // TODO
//
//    env->ReleaseStringUTFChars(path_, path);
    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(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(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("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;
}

JNIEXPORT void JNICALL
Java_com_example_sjs_vendingmachine_SerialUtil_SerialPort_close(JNIEnv *env, jobject instance) {

    // TODO

}

extern "C"
jstring
Java_com_example_sjs_vendingmachine_MainActivity_stringFromJNI(
        JNIEnv *env,
        jobject thiz) {
    // TODO
    jclass SerialPortClass = env->GetObjectClass(thiz);
    jclass FileDescriptorClass = env->FindClass((char *) "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);
}
}

哦了

misolamiso
关注
专栏目录
android 串口测试demo 代码简单 无bug 完美运行
04-25
android 串口测试demo 代码简单 无bug 完美运行 android 串口测试demo 代码简单 无bug 完美运行 android 串口测试demo 代码简单 无bug 完美运行 android 串口测试demo 代码简单 无bug 完美运行 android 串口测试demo 代码简单 无bug 完美运行 android 串口测试demo 代码简单 无bug 完美运行 android 串口测试demo 代码简单 无bug 完美运行 android 串口测试demo 代码简单 无bug 完美运行 android 串口测试demo 代码简单 无bug 完美运行 android 串口测试demo 代码简单 无bug 完美运行 android 串口测试demo 代码简单 无bug 完美运行 android 串口测试demo 代码简单 无bug 完美运行 android 串口测试demo 代码简单 无bug 完美运行 android 串口测试demo 代码简单 无bug 完美运行
Android串口使用方法
qaz96801的博客
04-28 6017
串口是一种用于android对硬件设备通信的一种协议，可以发送某种指令控制硬件设备,也可以接受传感器发送过来的数据，比如IC/ID卡，雷达，传感器等。下面介绍串口在android开发中的2使用方式Android系统版本:Android 7.1 Android 12jdk-18.0.2PCWindows11串口调试工具sscom(或者其他串口调试工具也可以)使用ARMT自带的串口api SerialPort.java。
Android串口开发：Serialport（如何进行串口开发，数据发送，TX和RX，A和B，粘包）
最新发布
qq_40853919的博客
08-16 2147
我们简单来看看他的协议，以及我们应该如何发送数据和接收数据。（1）需要厂家提供通讯参数（2）通讯文档，比如，查询下位机状态，还有很多协议内容，这里就讲一个：有了这些信息，先不着急写代码，先使用串口工具测试一下收发数据是否正常。打开串口通讯工具，设置通讯参数，然后发送数据就可以了。/*** 原始命令*//*** 帧开始*//*** 帧结束*//*** CMD指令：查询设备ID*//*** 命令帧*//*** 开始字符*//*** 字节长度*/
Android串口开发
Android之旅
01-07 6774
1.开发工具：Android Studio 2.所用资源： 3.
Android-SerialPort-Tool实践运行
Owen_Suen的博客
07-02 2582
需要在讯为4412开发板（核心板为Exynos4412）实现安卓的串口通信 在github（https://github.com/licheedev/Android-SerialPort-Tool）下载项目文件后 【问题一】 有Android3.4.0运行会失败，无法通过Syc： 原因在于MainActivity中需要 import android.serialport...
Android串口开发之使用JNI实现ANDROID和串口通信
故事不长丨的博客
10-16 1496
Android串口通信在物联网、智能家居等领域具有广泛的应用。本文将详细介绍如何使用JNI技术实现Android设备与串口的通信，包括串口的打开、设置参数和读写数据等过程。
安卓Android源码——串口开发的demo，里面包含JNI文件.zip
10-11
串口通信是一种数据传输方式，通过串行接口发送和接收数据。在Android系统中，串口主要用于设备调试、数据采集或与外部硬件设备如传感器、微控制器等进行通信。常见的串口包括UART（通用异步收发传输器）和USB转串口...
安卓Android源码——串口编程资料.rar
10-10
本资源"安卓Android源码——串口编程资料.rar"聚焦于Android系统中的串口通信编程，这对于那些需要在移动设备上进行硬件交互或者嵌入式系统开发的工程师来说，是极具价值的学习材料。以下是对这些内容的详细解析： ...
安卓Android源码——串口通信(JNI)例子.zip
10-14
在安卓（Android）开发中，有时我们需要实现与硬件设备的直接通信，比如通过串口（Serial Port）连接Arduino或其他嵌入式系统。本压缩包提供了一个使用JNI（Java Native Interface）进行串口通信的示例代码，帮助...
安卓Andriod源码——串口开发的demo，里面包含JNI文件.zip
10-13
总结来说，这个`安卓Andriod源码——串口开发的demo，里面包含JNI文件.zip`的项目，提供了一个基于Android的串口通信实例，涵盖了串口配置、JNI调用、数据传输等核心环节。开发者可以通过学习和分析这个示例，掌握在...
安卓Android源码——安卓Android系统访问串口设备源码.zip
10-10
这个压缩包“安卓Android源码——安卓Android系统访问串口设备源码.zip”包含了实现这一功能的源代码，可以帮助开发者深入理解如何在Android平台上操作串行端口。 串口通信是一种古老的通信方式，但因其简单可靠，...
Android Studio下的串口程序开发实战
热门推荐
船头灯
06-09 2万+
简介 公司最近正好有个关于Android串口通信的项目，所以我花了一段时间学习并总结了一下，以便大家学习以及自己日后回顾。 话不多说，直接进入正题。我们都知道，Android串口通信要使用到JNI以及NDK的内容，但这一块的内容网上资源一抓一大把，这里就不加以赘述了。不了解的可以先去百度了解一下再来。 项目的配置 首先，关于JNI方面以及SO库的编译这方面的内容不包括在本文中，本文直接使用...
安卓APP：利用AndroidStudio开发usb串口通信软件【第1步】
mm13420109325的博客
12-02 3228
一、搭建开发环境 （1）安装JDK，配置环境变量；（详略） （2）下载AndroidStudio并双击打开安装； 下载地址：https://developer.android.google.cn/studio/ 其他教程：https://developer.android.google.cn/studio/intro/ 二、具体开发过程 （第一步的效果图） （1）查找参考资料 ...
Android 串口通信 原来如此简单
weixin_45379305的博客
11-06 7742
Android串口通信，Android SerialPort，安卓串口通信框架，Android串口通信SDK，Android串口通信开源库，实现串口快速通信，无需在乎串口实现；适用于Kotlin项目；
Android Studio的串口通讯开发
weixin_33777877的博客
03-23 983
基于android-serialport-api实现 前言RS232标准接口UARTRS232与UART转接下载 NDK 和构建工具创建支持 C/C++ 的新项目编译C/C++代码串口通讯原理关于校验位HexString与Bytes的转换参考 前言 软件代码写久了，总会对嵌入式开发感兴趣，因为软件的东西写来写去看不见摸不着，而嵌入式硬件开发，可以捣鼓一些机械设备玩，电子感应灯，遥控...
快速开发和使用Android串口
走马川行雪的博客
06-02 7442
串口叫做串行接口，也称串行通信接口，也可以叫做COM口，按电气标准及协议来分包括RS-232-C、RS-422、RS485、USB等。串行接口是指数据一位一位地顺序传送，其特点是通信线路简单，只要一对传输线就可以实现双向通信，从而大大降低了成本，特别适用于远距离通信，但传送速度较慢。
Android串口开发基于ndk简书,使用Android Studio进行NDK开发
weixin_36296864的博客
05-27 136
第一，创建一个新项目，并且新建一个类FirstJNI定义两个native接口getStringFromNative和getIntFromNative。public class FirstJNI {static{System.loadLibrary("firstjni");//so 名称}public static native String getStringFromNative();public...
Android 手把手教你接入串口功能
z842463468的博客
11-24 6317
手把手教你实现 Android 串口
Android串口通信开发
Mr_Tony的专栏
07-14 2502
文章目录一、前言三、线圈、寄存器四、第三方开发资源五、参考链接： 一、前言 ​ 串口通信主要用于物联网设备中，采用的协议一般为ModBus协议，这是一种悠久的通信技术。在Android中的使用的通信协议如果是自己编译的话大多数会采用09年google提供的一个串口的源码(源码为C语言版本,需要自己编译成.so)。源码如下: https://github.com/cepr/android-serialport-api 这里提供一个将源码编译成.so的参考示例(这个参考示例中java代码只有几个，使用很简单，但
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值