首页 > 编程开发 > Android

Android实现读写USB串口数据

来自：网络
时间：2022-12-26
阅读：

本文实例为大家分享了Android实现读写USB串口数据的具体代码，供大家参考，具体内容如下

最近在研究USB方面的内容；先后做了关于Android读写HID、串口设备的DEMO。本文比较简单，主要介绍的是Android实现读取串口数据的功能

废话不多说，先看一下业务层是如何调用的；如图：

Android实现读写USB串口数据

首先，监听USB连接状况，当USB 进行请求USB权限，当USB权限申请成功，进行调用打开Usb设备的方法；当监听到USB断开，进行关闭连接；

Android实现读写USB串口数据

这是向串口写入数据的方法；

本DEMO主要使用Handle进行数据各个线程之间的数据传到，以及USB连接读写情况的反馈；

下面直接上代码：
连接USB设备的代码

public void openCDC(UsbDevice usbDevice, UsbDeviceConnection usbDeviceConnection)
    {
        this.usbDeviceConnection = usbDeviceConnection;
        usbInterface = usbDevice.getInterface(findCDC(usbDevice)); //获取USB设备接口
        if (usbDeviceConnection == null) //判断USB设备链路是否为空
        {
            myHandler.sendEmptyMessage(MyHandler.USB_CONNECT_FAILED);
            return;
        }
        if (!usbDeviceConnection.claimInterface(usbInterface,true)) //USB设备链路绑定获取到的接口
        {
            myHandler.sendEmptyMessage(MyHandler.USB_CONNECT_FAILED);
            return;
        }
        int numberEndpoints = usbInterface.getEndpointCount(); //获取USB设备接口的数据传输通道数量
        for (int num = 0; num <= numberEndpoints-1; num++)
        {
            UsbEndpoint usbEndpoint = usbInterface.getEndpoint(num);

            switch (usbEndpoint.getType())
            {
                //USB控制传输模式通道
                case UsbConstants.USB_ENDPOINT_XFER_CONTROL:
                    controlUsbEndpoint = usbEndpoint;
                    break;
                //USB块传输模式通道
                case UsbConstants.USB_ENDPOINT_XFER_BULK:
                    switch (usbEndpoint.getDirection())
                    {
                        case UsbConstants.USB_DIR_OUT:
                            bulkOutUsbEndpoint = usbEndpoint; //USB块传输模式输出通道
                            break;
                        case UsbConstants.USB_DIR_IN:
                            bulkInUsbEndpoint = usbEndpoint; //USB块传输模式输入通道
                            break;
                    }
                    break;
                //USB中断传输模式通道
                case UsbConstants.USB_ENDPOINT_XFER_INT:
                    switch (usbEndpoint.getDirection())
                    {
                        case UsbConstants.USB_DIR_OUT:
                            intOutUsbEndpoint = usbEndpoint;
                            break;
                        case UsbConstants.USB_DIR_IN:
                            intInUsbEndpoint = usbEndpoint;
                            break;
                    }
                    break;
            }
        }
        if (bulkOutUsbEndpoint != null && bulkInUsbEndpoint != null) //如果USB块传输模式输入输通道都不为空出
        {
            //USB连接成功
            connect = true;
            //获取到USB设备的ID、VID、PID
            String usbData = "Name:"+usbDevice.getDeviceName()+"\nID:"+usbDevice.getDeviceId()+"    VID:"+usbDevice.getVendorId()+"    PID:"+usbDevice.getProductId();
            mes = new Message();
            mes.obj = usbData;
            mes.what = MyHandler.USB_CONNECT_SUCCESS;
            myHandler.sendMessage(mes);
            threadReadData.start(); //开启接收数据线程
        }
        else
        {
            //USB连接失败
            connect = false;
            myHandler.sendEmptyMessage(MyHandler.USB_CONNECT_FAILED);
        }
    }

这个代码有点多，可能看的不太清楚，我删减一下，是这样的

public void openCDC(UsbDevice usbDevice, UsbDeviceConnection usbDeviceConnection)
    {
        this.usbDeviceConnection = usbDeviceConnection;
        usbInterface = usbDevice.getInterface(findCDC(usbDevice)); //获取USB设备接口
      
        int numberEndpoints = usbInterface.getEndpointCount(); //获取USB设备接口的数据传输通道数量
        for (int num = 0; num <= numberEndpoints-1; num++)
        {
            UsbEndpoint usbEndpoint = usbInterface.getEndpoint(num);

            switch (usbEndpoint.getType())
            {
                //USB控制传输模式通道
                case UsbConstants.USB_ENDPOINT_XFER_CONTROL:
                    controlUsbEndpoint = usbEndpoint;
                    break;
                //USB块传输模式通道
                case UsbConstants.USB_ENDPOINT_XFER_BULK:
                    switch (usbEndpoint.getDirection())
                    {
                        case UsbConstants.USB_DIR_OUT:
                            bulkOutUsbEndpoint = usbEndpoint; //USB块传输模式输出通道
                            break;
                        case UsbConstants.USB_DIR_IN:
                            bulkInUsbEndpoint = usbEndpoint; //USB块传输模式输入通道
                            break;
                    }
                    break;
                //USB中断传输模式通道
                case UsbConstants.USB_ENDPOINT_XFER_INT:
                    switch (usbEndpoint.getDirection())
                    {
                        case UsbConstants.USB_DIR_OUT:
                            intOutUsbEndpoint = usbEndpoint;
                            break;
                        case UsbConstants.USB_DIR_IN:
                            intInUsbEndpoint = usbEndpoint;
                            break;
                    }
                    break;
            }
        }
       
    }

设备打开之后，就可以进行读写了；

Android 读取串口数据

public String readData()
    {
        byte[] tempByte = new byte[4096];
       
        int i = usbDeviceConnection.bulkTransfer(bulkInUsbEndpoint,tempByte,tempByte.length,100);//读取数据，100为超时时间，接收的数据为数组类型
   
        //将接收的数组转为字符串并返回
        byte[] messageByte = new byte[i];
        System.arraycopy(tempByte,0, messageByte,0, i);
        return new String(messageByte);
    }

这里主要通过调用谷歌提供的bulkTransfer方法进行的，传递的参数分别有endpoint,要读取的数据长度，和放要读取的数据的数组，超时时间

Android实现读写USB串口数据

有了读，当然也需要写，向串口写入数据；代码如下：

public boolean send(String message)
    {
      
        byte[] messageBytes = message.getBytes(); //字符串转为数组
        int result = usbDeviceConnection.bulkTransfer(bulkOutUsbEndpoint,messageBytes,messageBytes.length,100);//发送数据，发送转换为数组后的数据，超时时间为100毫秒
        if ((result >= 0)) //发送数据返回值大于等于0代表发送成功
        {
            //向信息处理中心发送“发送成功”的信息，并将信息内容传递过去
           
            return true;
        }
        else
        {
            //发送失败
            connect = false;
            return false;
        }
    }

传输数据的方式是用Handler；以下是Handler类的写法

public void handleMessage(@NonNull Message msg)
    {
        switch (msg.what)
        {
            case USB_CONNECT_SUCCESS:  //USB设备连接成功
                MyHandler.USB_CONNECT_STATE  = true; //连接状态改变为true
                bt_send.setEnabled(true); //发送控件可以使用
                bt_sendTiming.setEnabled(true);
                bt_send.setTextColor(Color.BLACK); //定时发送控件可以使用
                bt_sendTiming.setTextColor(Color.BLACK); 
                tv_usbDataShow.setText(msg.obj.toString()); //填充意图发送过来的信息
                Toast.makeText(context,"连接成功",Toast.LENGTH_LONG).show();
                break;
            case USB_CONNECT_FAILED: //USB设备连接失败
                MyHandler.USB_CONNECT_STATE  = false;
                bt_send.setEnabled(false);
                bt_sendTiming.setEnabled(false);
                bt_send.setTextColor(Color.GRAY);
                bt_sendTiming.setTextColor(Color.GRAY);
                bt_sendTiming.setText("定时发送");
                tv_usbDataShow.setText("未连接设备");
                mainActivity.closeAll(); //连接断开或连接失败，执行关闭所有连接和对象的方法
                Toast.makeText(context,"断开连接",Toast.LENGTH_LONG).show();
                break;
            case OUTPUT:  //发送消息
                if (messageShowNeedRoll(tv_sendMessageShow) != 0) tv_sendMessageShow.scrollTo(0, messageShowNeedRoll(tv_sendMessageShow));//如果TextView填充满可使用高度就滚动到最新更新处
                tv_sendMessageShow.append("[TX]"+gteNowDate()+": "+msg.obj.toString()+"\n"); //给控件填充意图发送来的信息
                break;
            case INPUT:  //接收消息
                if (messageShowNeedRoll(tv_receiveMessageShow) != 0) tv_receiveMessageShow.scrollTo(0, messageShowNeedRoll(tv_receiveMessageShow));
                tv_receiveMessageShow.append("[RX]"+gteNowDate()+": "+msg.obj.toString()+"\n");
                break;
        }
    }

主要代码已展示完毕，接下来展示具体代码

先看USB类，如下：

public class UsbCDC
{
    private boolean connect; //USB连接状态
    private UsbInterface usbInterface; //USB设备的物理接口

    //控制传输模式通道
    private UsbEndpoint controlUsbEndpoint;
    //块传输模式通道
    private UsbEndpoint bulkInUsbEndpoint;
    private UsbEndpoint bulkOutUsbEndpoint;
    //中断传输模式通道
    private UsbEndpoint intInUsbEndpoint;
    private UsbEndpoint intOutUsbEndpoint;

    private UsbDeviceConnection usbDeviceConnection; //USB设备连接链路，用来进行设备通讯

    private Message mes; //信息包

    private MyHandler myHandler;//信息处理中心对象
    UsbCDC(MyHandler myHandler)
    {
        this.myHandler = myHandler;
    }

    /**
     * 向USB设备发送数据
     * @param message 要发送的数据，字符串类型
     * @return 数据发送结果，true代表发送成功
     */
    public boolean send(String message)
    {
        if (this.usbDeviceConnection == null) //判断USB链路是否获取到，不为空才能进行数据发送
        {
            //如果USB链路为空，执行该作用域代码
            connect = false;
            myHandler.sendEmptyMessage(MyHandler.USB_CONNECT_FAILED);
            return false;
        }
        byte[] messageBytes = message.getBytes(); //字符串转为数组
        int result = usbDeviceConnection.bulkTransfer(bulkOutUsbEndpoint,messageBytes,messageBytes.length,100);//发送数据，发送转换为数组后的数据，超时时间为100毫秒
        if ((result >= 0)) //发送数据返回值大于等于0代表发送成功
        {
            //向信息处理中心发送“发送成功”的信息，并将信息内容传递过去
            mes = new Message();
            mes.obj = new String(messageBytes);
            mes.what = MyHandler.OUTPUT;
            myHandler.sendMessage(mes);
            return true;
        }
        else
        {
            //发送失败
            connect = false;
            myHandler.sendEmptyMessage(MyHandler.USB_CONNECT_FAILED);
            return false;
        }
    }

    /**
     * 接收数据
     * @return 接收的数据内容
     */
    public String readData()
    {
        byte[] tempByte = new byte[4096];
        if (usbDeviceConnection == null) //判断USB连接链路是否为空，不为空才能进行数据接收
        {
            connect = false;
            myHandler.sendEmptyMessage(MyHandler.USB_CONNECT_FAILED);
            return null;
        }
        int i = usbDeviceConnection.bulkTransfer(bulkInUsbEndpoint,tempByte,tempByte.length,100);//读取数据，100为超时时间，接收的数据为数组类型
        if (i < 0) //小于0代表接收失败或未接收到数据，接收结果也受USB设备的影响
        {
            return null;
        }
        //将接收的数组转为字符串并返回
        byte[] messageByte = new byte[i];
        System.arraycopy(tempByte,0, messageByte,0, i);
        return new String(messageByte);
    }

    /**
     * 设置USB设备的波特率，方法内涉及算法等；
     * @param paramInt 要设置波特率的数值
     * @return 设置结果，true代表设置成功
     */
    public boolean configUsb(int paramInt)
    {
        if (usbDeviceConnection != null)
        {
            byte[] arrayOfByte = new byte[8];
            usbDeviceConnection.controlTransfer(192, 95, 0, 0, arrayOfByte, 8, 1000);
            usbDeviceConnection.controlTransfer(64, 161, 0, 0, null, 0, 1000);
            long l1 = 1532620800 / paramInt;
            for (int i = 3; ; i--)
            {
                if ((l1 <= 65520L) || (i <= 0))
                {
                    long l2 = 65536L - l1;
                    int j = (short) (int) (0xFF00 & l2 | i);
                    int k = (short) (int) (0xFF & l2);
                    usbDeviceConnection.controlTransfer(64, 154, 4882, j, null, 0, 1000);
                    usbDeviceConnection.controlTransfer(64, 154, 3884, k, null, 0, 1000);
                    usbDeviceConnection.controlTransfer(192, 149, 9496, 0, arrayOfByte, 8, 1000);
                    usbDeviceConnection.controlTransfer(64, 154, 1304, 80, null, 0, 1000);
                    usbDeviceConnection.controlTransfer(64, 161, 20511, 55562, null, 0, 1000);
                    usbDeviceConnection.controlTransfer(64, 154, 4882, j, null, 0, 1000);
                    usbDeviceConnection.controlTransfer(64, 154, 3884, k, null, 0, 1000);
                    usbDeviceConnection.controlTransfer(64, 164, 0, 0, null, 0, 1000);
                    return true;
                }
                l1 >>= 3;
            }
        }
        else  return false;
    }

    /**
     * 获取收发数据的通道
     * @param usbDevice USB设备
     * @param usbDeviceConnection USB连接链路
     */
    public void openCDC(UsbDevice usbDevice, UsbDeviceConnection usbDeviceConnection)
    {
        this.usbDeviceConnection = usbDeviceConnection;
        usbInterface = usbDevice.getInterface(findCDC(usbDevice)); //获取USB设备接口
        if (usbDeviceConnection == null) //判断USB设备链路是否为空
        {
            myHandler.sendEmptyMessage(MyHandler.USB_CONNECT_FAILED);
            return;
        }
        if (!usbDeviceConnection.claimInterface(usbInterface,true)) //USB设备链路绑定获取到的接口
        {
            myHandler.sendEmptyMessage(MyHandler.USB_CONNECT_FAILED);
            return;
        }
        int numberEndpoints = usbInterface.getEndpointCount(); //获取USB设备接口的数据传输通道数量
        for (int num = 0; num <= numberEndpoints-1; num++)
        {
            UsbEndpoint usbEndpoint = usbInterface.getEndpoint(num);

            switch (usbEndpoint.getType())
            {
                //USB控制传输模式通道
                case UsbConstants.USB_ENDPOINT_XFER_CONTROL:
                    controlUsbEndpoint = usbEndpoint;
                    break;
                //USB块传输模式通道
                case UsbConstants.USB_ENDPOINT_XFER_BULK:
                    switch (usbEndpoint.getDirection())
                    {
                        case UsbConstants.USB_DIR_OUT:
                            bulkOutUsbEndpoint = usbEndpoint; //USB块传输模式输出通道
                            break;
                        case UsbConstants.USB_DIR_IN:
                            bulkInUsbEndpoint = usbEndpoint; //USB块传输模式输入通道
                            break;
                    }
                    break;
                //USB中断传输模式通道
                case UsbConstants.USB_ENDPOINT_XFER_INT:
                    switch (usbEndpoint.getDirection())
                    {
                        case UsbConstants.USB_DIR_OUT:
                            intOutUsbEndpoint = usbEndpoint;
                            break;
                        case UsbConstants.USB_DIR_IN:
                            intInUsbEndpoint = usbEndpoint;
                            break;
                    }
                    break;
            }
        }
        if (bulkOutUsbEndpoint != null && bulkInUsbEndpoint != null) //如果USB块传输模式输入输通道都不为空出
        {
            //USB连接成功
            connect = true;
            //获取到USB设备的ID、VID、PID
            String usbData = "Name:"+usbDevice.getDeviceName()+"\nID:"+usbDevice.getDeviceId()+"    VID:"+usbDevice.getVendorId()+"    PID:"+usbDevice.getProductId();
            mes = new Message();
            mes.obj = usbData;
            mes.what = MyHandler.USB_CONNECT_SUCCESS;
            myHandler.sendMessage(mes);
            threadReadData.start(); //开启接收数据线程
        }
        else
        {
            //USB连接失败
            connect = false;
            myHandler.sendEmptyMessage(MyHandler.USB_CONNECT_FAILED);
        }
    }

    /**
     * USB接收数据线程
     */
    private Thread threadReadData = new Thread(new Runnable()
    {
        String message = "";
        @Override
        public void run()
        {
            while (connect) //USB处于连接状态就循环执行
            {
                String temMes = readData(); //获取到接收到的字符串
                if (temMes != null) 
                {
                    //如果接收到的数据不为空，就一直拼接，因为这些可能属于同一组数据（除非USB设备发送频率小于我们设置的超时时间100毫秒）
                    message = message+temMes;
                    continue;
                }
                else
                {
                    //接收到的数据为空了，表示该组数据接收完整了，就可以发送给消息处理中心进行处理了
                    if (!message.equals("")) //接收到的数据要不为空，不然没意义
                    {
                        mes = new Message();
                        mes.obj = message;
                        mes.what = MyHandler.INPUT;
                        myHandler.sendMessage(mes);
                        message = "";
                    }
                }
            }
        }
    });

    /**
     * 获取USB可以收发数据的接口号
     * @param usbDevice USB设备
     * @return USB可以收发数据的接口号
     */
    private int findCDC(UsbDevice usbDevice)
    {
        int interfaceCount = usbDevice.getInterfaceCount(); //获取USB设备接口数量
        for (int count = 0; count < interfaceCount; ++count)
        {
            //遍历获取到的接口进行判断是否为收发数据的接口，是就返回该接口号
            if (usbDevice.getInterface(count).getInterfaceClass() == UsbConstants.USB_CLASS_CDC_DATA)
            {
                return count;
            }
        }
        // 如果获取到的所有接口没有我们需要的就返回-1
        return -1;
    }

     /**
     * 关闭USB连接、链路、数据通道等
     */
    public void close()
    {
        connect = false; //连接状态为false
        usbDeviceConnection.releaseInterface(usbInterface); //USB设备链路解绑接口
        usbDeviceConnection.close(); //关闭USB设备链路
        usbDeviceConnection = null; //USB设备链路赋值为空
        bulkOutUsbEndpoint = null; //输出通道赋值为空
        bulkInUsbEndpoint = null; //输入通道赋值为空
    }

}

接下来是连接USB类与业务层的中枢，HANDLER类：

package com.jlkj.lsk.usb_host;

import android.content.Context;
import android.graphics.Color;
import android.os.Handler;
import android.os.Message;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;
import androidx.annotation.NonNull;
import java.text.SimpleDateFormat;
import java.util.Date;

public class MyHandler extends Handler
{

    public static final int OUTPUT = 0; //发送消息
    public static final int INPUT = 1; //接收消息

    public static final int USB_CONNECT_SUCCESS = 2; //USB设备连接成功
    public static final int USB_CONNECT_FAILED = 3; //USB设备连接失败或断开连接

    public static boolean USB_CONNECT_STATE = false; //当前USB设备连接状态

    private Button bt_send,bt_sendTiming; 
    private TextView tv_sendMessageShow,tv_receiveMessageShow,tv_usbDataShow;
    private Context context; //上下文
    private MainActivity mainActivity;
    MyHandler(TextView tv_sendMessageShow, TextView tv_receiveMessageShow, TextView tv_usbDataShow, Button bt_send, Button bt_sendTiming, Context context,MainActivity mainActivity)
    {
        this.bt_send = bt_send;
        this.tv_sendMessageShow = tv_sendMessageShow;
        this.tv_receiveMessageShow = tv_receiveMessageShow;
        this.tv_usbDataShow = tv_usbDataShow;
        this.bt_sendTiming = bt_sendTiming;
        this.context = context;
        this.mainActivity = mainActivity;
    }

    @Override
    public void handleMessage(@NonNull Message msg)
    {
        switch (msg.what)
        {
            case USB_CONNECT_SUCCESS:  //USB设备连接成功
                MyHandler.USB_CONNECT_STATE  = true; //连接状态改变为true
                bt_send.setEnabled(true); //发送控件可以使用
                bt_sendTiming.setEnabled(true);
                bt_send.setTextColor(Color.BLACK); //定时发送控件可以使用
                bt_sendTiming.setTextColor(Color.BLACK); 
                tv_usbDataShow.setText(msg.obj.toString()); //填充意图发送过来的信息
                Toast.makeText(context,"连接成功",Toast.LENGTH_LONG).show();
                break;
            case USB_CONNECT_FAILED: //USB设备连接失败
                MyHandler.USB_CONNECT_STATE  = false;
                bt_send.setEnabled(false);
                bt_sendTiming.setEnabled(false);
                bt_send.setTextColor(Color.GRAY);
                bt_sendTiming.setTextColor(Color.GRAY);
                bt_sendTiming.setText("定时发送");
                tv_usbDataShow.setText("未连接设备");
                mainActivity.closeAll(); //连接断开或连接失败，执行关闭所有连接和对象的方法
                Toast.makeText(context,"断开连接",Toast.LENGTH_LONG).show();
                break;
            case OUTPUT:  //发送消息
                if (messageShowNeedRoll(tv_sendMessageShow) != 0) tv_sendMessageShow.scrollTo(0, messageShowNeedRoll(tv_sendMessageShow));//如果TextView填充满可使用高度就滚动到最新更新处
                tv_sendMessageShow.append("[TX]"+gteNowDate()+": "+msg.obj.toString()+"\n"); //给控件填充意图发送来的信息
                break;
            case INPUT:  //接收消息
                if (messageShowNeedRoll(tv_receiveMessageShow) != 0) tv_receiveMessageShow.scrollTo(0, messageShowNeedRoll(tv_receiveMessageShow));
                tv_receiveMessageShow.append("[RX]"+gteNowDate()+": "+msg.obj.toString()+"\n");
                break;
        }
    }

    /**
     * 返回格式化后的当前时间
     * @return 当前时间字符串形式
     */
    private String gteNowDate()
    {
        SimpleDateFormat sdf = new SimpleDateFormat();// 格式化时间
        sdf.applyPattern("HH:mm:ss");// 时：分：秒
        Date date = new Date();// 获取当前时间戳
        return sdf.format(date); //返回格式化后的时间戳
    }

    /**
     * 判断当前TextView是否已经填充满控件可使用高度，如果高度已满就滚动需要的距离高度
     * @param textView 需要判断的TextView控件
     * @return 已满就返回对应高度，否则就返回0
     */
    private int messageShowNeedRoll(TextView textView)
    {
        int offset = textView.getLineCount() * textView.getLineHeight(); //添加的textview数量 x 字体高度
        if (offset > textView.getHeight()) return offset - tv_receiveMessageShow.getHeight(); //如果乘积大于控件高度就返回需要滚动的距离
        else return 0; //小于就返回0
    }

}

监听USB连接状况的广播类，如下：

package com.jlkj.lsk.usb_host;

import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.hardware.usb.UsbDevice;
import android.hardware.usb.UsbManager;
import android.widget.TextView;
import android.widget.Toast;
import java.util.HashMap;

public class UsbMonitor extends BroadcastReceiver //继承USB广播对象
{

    private static final String ACTION_USB_PERMISSION = "com.spark.teaching.answertool.USB_PERMISSION"; //USB设备的操作权限，可自定义
    //private static final String ACTION_USB_PERMISSION = "android.USB"; //USB设备的操作权限，可自定义
    private int VID = 1155; //USB设备生产厂商ID，用来区分选择目标USB设备，如果不是该ID的USB设备，不对其进行操作
    private int PID = 1155; //USB设备生产厂商ID，用来区分选择目标USB设备，如果不是该ID的USB设备，不对其进行操作
    private UsbController usbController; //USB动作管理接口
    private UsbManager usbManager; //USB状态、管理对象
    private UsbDevice usbDevice; //USB设备
    private Context context; //上下文
    private TextView tv_usbDeviceDataShow; //USB信息数据展示控件

    /**
     * 数据初始化
     * @param usbController usb控制器接口
     * @param context 上下文
     * @param tv_usbDeviceDataShow USB信息数据展示控件
     */
    UsbMonitor(UsbController usbController,Context context,TextView tv_usbDeviceDataShow)
    {
        this.usbController = usbController;
        this.context = context;
        this.tv_usbDeviceDataShow = tv_usbDeviceDataShow;
    }

    /**
     * 注册USB广播监听、USB权限
     */
    public void register()
    {
        if (this.context != null)
        {
            IntentFilter intentFilter = new IntentFilter(); //意图过滤器
            intentFilter.addAction(ACTION_USB_PERMISSION); //添加USB设备的操作权限意图
            intentFilter.addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED); //添加设备接入意图
            intentFilter.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED); //添加设备拔出意图
            this.context.registerReceiver(this, intentFilter); //注册添加的意图
            usbManager = (UsbManager)this.context.getSystemService(Context.USB_SERVICE); //获取USB设备管理

            if (usbManager != null)
            {
                HashMap<String,UsbDevice> list = usbManager.getDeviceList(); //获取USB设备，返回的是 UsbDevice 的Hash列表，里面是所有当前连接主机的USB设备
                for (UsbDevice usbDevice : list.values()) //遍历获取到的UsbDevice
                {
                    if ((usbDevice.getVendorId() == VID)&&(usbDevice.getProductId() == PID)) //找到目标USB设备
                    {
                        this.usbDevice = usbDevice;
                        usbController.onDeviceInsert(this, usbManager,usbDevice); //执行USB接入时接口
                        break;
                    }
                }
                tv_usbDeviceDataShow.setText("不支持该设备"); //如果列表里面没有目标USB设备，执行该操作
            }
            tv_usbDeviceDataShow.setText("未连接设备"); //如果没有USB设备接入，执行该操作
        }
    }

    /**
     * 请求打开此USB设备的权限
     * @param usbDevice usb设备
     */
    public void requestOpenDevice(UsbDevice usbDevice)
    {
        if (usbManager != null)
        {
            if (usbManager.hasPermission(usbDevice))//如果有该USB设备的操作权限
            {
                usbController.onDeviceOpen(this,usbManager,usbDevice);//连接USB设备（打开USB设备）
            }
            else
            {
                usbManager.requestPermission(usbDevice,PendingIntent.getBroadcast(context, 666, new Intent(ACTION_USB_PERMISSION), 0));//如果没有USB操作权限则请求权限
            }
        }
    }

    /**
     * 注销USB广播监听
     */
    public void unregister()
    {
        if (context != null)
        {
            context.unregisterReceiver(this); //注销USB设备广播监听
            context = null;
            usbManager = null;
            usbController = null;
        }
    }

    /**
     * 广播事务处理中心
     * @param context 上下文
     * @param intent 意图
     */
    @Override
    public void onReceive(Context context, Intent intent)
    {
        if (intent.getExtras() != null && !intent.getExtras().isEmpty())
        {
            usbDevice = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE); //获取意图中的USB设备
            switch(intent.getAction())
            {
                case UsbManager.ACTION_USB_DEVICE_ATTACHED: //USB设备接入
                    Toast.makeText(context, "设备接入", Toast.LENGTH_LONG).show();
                    if ((usbDevice.getVendorId() == VID)&&(usbDevice.getProductId() == PID)) usbController.onDeviceInsert(this, usbManager,usbDevice); //找到目标USB设备，执行USB设备接入时接口
                    else tv_usbDeviceDataShow.setText("不支持该设备"); //未找到目标USB设备
                    break;
                case UsbManager.ACTION_USB_DEVICE_DETACHED: //USB设备拔出
                    Toast.makeText(context, "设备断开", Toast.LENGTH_LONG).show();
                    usbController.onDevicePullOut(this,usbManager,usbDevice); //执行USB设备拔出时接口
                    break;
                case UsbMonitor.ACTION_USB_PERMISSION: //请求USB设备操作权限
                    if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false))
                    {
                        //同意USB权限
                        usbController.onDeviceOpen(this,usbManager,usbDevice); //执行连接USB设备接口
                    }
                    else
                    {
                        //拒绝USB权限
                        Toast.makeText(context, "拒绝USB权限！", Toast.LENGTH_LONG).show();
                    }
                    break;
            }
        }
        else
        {
            Toast.makeText(this.context,"请检查USB设备！",Toast.LENGTH_LONG).show();
        }
    }

}

接口类 UsbController

public interface UsbController
{

     /**
     * USB设备接入时的接口
     * @param usbMonitor USB监听广播对象
     * @param usbManager USB状态、管理对象
     * @param usbDevice USB设备对象
     */
    void onDeviceInsert(UsbMonitor usbMonitor, UsbManager usbManager, UsbDevice usbDevice);

    //USB设备拔出时的接口
    void onDevicePullOut(UsbMonitor usbMonitor, UsbManager usbManager, UsbDevice usbDevice);

    //连接USB设备（打开USB设备）的接口
    void onDeviceOpen(UsbMonitor usbMonitor, UsbManager usbManager, UsbDevice usbDevice);
    
}

activity类

package com.jlkj.lsk.usb_host;

import android.app.AlertDialog;
import android.content.DialogInterface;
import android.graphics.Color;
import android.hardware.usb.UsbDevice;
import android.hardware.usb.UsbDeviceConnection;
import android.hardware.usb.UsbManager;
import android.os.Bundle;
import android.text.method.ScrollingMovementMethod;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;
import androidx.appcompat.app.AppCompatActivity;
import java.util.Timer;
import java.util.TimerTask;

public class MainActivity extends AppCompatActivity implements UsbController
{
    private Timer timer; //计时器对象
    private TimerTask timerTask; //计时器任务对象

    private UsbCDC usbCDC; //当前连接的USB设备对象
    private MyHandler myHandler; //消息处理中心对象
    private UsbMonitor usbMonitor; //USB监听广播对象
    private TextView m_tv_sendMessageShow,m_tv_receiveMessageShow,m_tv_usbDataShow,m_tv_porterShow;
    private EditText m_et_messageText,m_et_time;
    private Button m_bt_send,m_bt_sendTiming,m_bt_clean,m_tv_porterSet;

    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView(); //实例化当前页面控件
        initData(); //加载初始数据

        m_bt_send.setOnClickListener(new View.OnClickListener()
        {
            @Override
            public void onClick(View v)
            {
                //开启新线程进行数据发送
                new Thread(new Runnable()
                {
                    @Override
                    public void run()
                    {
                        usbCDC.send(m_et_messageText.getText().toString()); //向当前连接的USB设备发送消息
                    }
                }).start();
            }
        });

        m_bt_clean.setOnClickListener(new View.OnClickListener()
        {
            @Override
            public void onClick(View v)
            {
                m_tv_sendMessageShow.setText(""); //清除发送的消息文本
                m_tv_receiveMessageShow.setText(""); //清除接收的消息文本
                m_tv_sendMessageShow.scrollTo(0, 0); //发送的消息文本回滚到最顶部
                m_tv_receiveMessageShow.scrollTo(0, 0); //接收的消息文本回滚到最顶部
            }
        });

        m_bt_sendTiming.setOnClickListener(new View.OnClickListener()
        {
            @Override
            public void onClick(View v)
            {
                //判断计时器是否为空，不为就代表正在执行计时任务，就停止当前任务
                if (timer != null)
                {
                    timer.cancel(); //停止计时器
                    timer = null; //计时器设为空
                    m_bt_sendTiming.setTextColor(Color.BLACK); //改变定时发送控件的颜色
                    m_bt_sendTiming.setText("定时发送"); //控件 恢复为“定时发送”
                }
                else
                {
                    //如果为空，就开始定时发送任务
                    if (!m_et_time.getText().toString().equals("")) //获取定时任务的时间间隔
                    {
                        timer = new Timer(); //创建定时器
                        timerTask = new TimerTask() //创建定时任务
                        {
                            @Override
                            public void run()
                            {   
                                //定时任务要执行的内容
                                usbCDC.send(m_et_messageText.getText().toString());
                            }
                        };
                        new Thread(new Runnable() //开启新线程执行 开启计时器
                        {
                            @Override
                            public void run()
                            {
                                //开启计时器
                                timer.schedule(timerTask,0,Integer.parseInt(m_et_time.getText().toString()));
                            }
                        }).start();
                        m_bt_sendTiming.setTextColor(Color.RED);
                        m_bt_sendTiming.setText("停止"); //计时器开始后“定时发送”控件就改变颜色和字体
                    }
                    else
                    {
                        //判断计时器是否为空，如果为空，就执行该作用域内容
                        Toast.makeText(MainActivity.this,"定时不能为空",Toast.LENGTH_LONG).show();
                    }
                }
            }
        });

        m_tv_porterSet.setOnClickListener(new View.OnClickListener()
        {
            @Override
            public void onClick(View v)
            {
                //展示设置波特率的diaog对象
                setPorter();
            }
        });
    }

    @Override
    public void onDeviceInsert(UsbMonitor usbMonitor, UsbManager usbManager, UsbDevice usbDevice)
    {
        usbMonitor.requestOpenDevice(usbDevice); //请求USB连接权限
    }

    @Override
    public void onDevicePullOut(UsbMonitor usbMonitor, UsbManager usbManager, UsbDevice usbDevice)
    {
       closeAll(); //执行关闭所有连接的方法
       myHandler.sendEmptyMessage(MyHandler.USB_CONNECT_FAILED); //向消息中心发送 断开连接 信息
    }

    @Override
    public void onDeviceOpen(UsbMonitor usbMonitor, UsbManager usbManager, UsbDevice usbDevice)
    {
        usbCDC = new UsbCDC(myHandler); //创建USB连接的对象
        UsbDeviceConnection connection = usbManager.openDevice(usbDevice); //获取此USB链路
        usbCDC.openCDC(usbDevice, connection); //连接USB设备（打开USB设备）
    }

    @Override
    protected void onDestroy()
    {
        super.onDestroy();
        closeAll();//执行关闭所有连接的方法
        myHandler.sendEmptyMessage(MyHandler.USB_CONNECT_FAILED);//向消息中心发送 断开连接 信息
    }

    //关闭所有连接
    public void closeAll()
    {
        if (usbCDC != null)
        {
            usbCDC.close();
            usbCDC = null;
        }
        if (timer != null)
        {
            timer.cancel();
            timer = null;
        }
    }

    //展示设置波特率dialog的对象，用一个AlertDialog让用户进行选择比特率
    private void setPorter()
    {
        final String[] items = {"2400","4800","9600","19200","38400","57600","115200","230400","460800","1700000","2300000","3400000"};
        AlertDialog.Builder listDialog = new AlertDialog.Builder(MainActivity.this);
        listDialog.setTitle("设置波特率");
        listDialog.setItems(items, new DialogInterface.OnClickListener()
        {
            @Override
            public void onClick(DialogInterface dialog, int which)
            {
                //判断当前USB设备是否连接，连接之后才可以设置波特率
               if (usbCDC != null)
               {
                   boolean porter = usbCDC.configUsb(Integer.parseInt(items[which])); //执行设置波特率的对象，返回true代表设置成功
                   m_tv_porterShow.setText(porter ? "波特率："+items[which]:"波特率：9600"); //设置波特率对象返回true才改变控件字体，否则设置失败，不改变控件字体
               }
               else
               {
                    //判断当前USB设备是否连接，未连接则提示 设备未连接
                   Toast.makeText(MainActivity.this,"设备未连接",Toast.LENGTH_LONG).show();
               }
            }
        });
        listDialog.show(); //展示dialog
    }

    //加载数据
    private void initData()
    {
        myHandler = new MyHandler(m_tv_sendMessageShow,m_tv_receiveMessageShow,m_tv_usbDataShow,m_bt_send,m_bt_sendTiming,this,MainActivity.this); //实例化消息处理中心
        usbMonitor = new UsbMonitor(this,this,m_tv_usbDataShow); //实例化USB广播监听
        usbMonitor.register(); //注册USB广播监听，注册之后，才可以正常监听USB设备
    }

    //实例化控件
    private void initView()
    {
        m_tv_receiveMessageShow = (TextView)findViewById(R.id.m_tv_receiveMessageShow);
        m_tv_receiveMessageShow.setMovementMethod(ScrollingMovementMethod.getInstance());
        m_tv_sendMessageShow = (TextView)findViewById(R.id.m_tv_sendMessageShow);
        m_tv_sendMessageShow.setMovementMethod(ScrollingMovementMethod.getInstance());
        m_tv_usbDataShow = (TextView)findViewById(R.id.m_tv_usbDataShow);
        m_et_messageText = (EditText)findViewById(R.id.m_et_messageText);
        m_et_time = (EditText)findViewById(R.id.m_et_time);
        m_bt_sendTiming = (Button)findViewById(R.id.m_bt_sendTiming);
        m_bt_clean = (Button)findViewById(R.id.m_bt_clean);
        m_bt_send = (Button)findViewById(R.id.m_bt_send);
        m_tv_porterShow = (TextView)findViewById(R.id.m_tv_porterShow);
        m_tv_porterSet = (Button)findViewById(R.id.m_bt_porterSet);
    }

}

这个比较初级，接下来，我会再出一个精简版本；详细探讨Android读取USB串口、HID设备的实现；我把这两个集成在了一起，并打包成了arr文件，这个库可以自动识别USB 串口或USB hid ,当连接成功，就可以自动读写；代码比这个更为精简；接下来我会慢慢的记录下来。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。

最新文章 相关文章

adb push命令向设备传输文件的操作步骤

目录一、向设备传输文件命令二、操作步骤2.1 连接设备2.2 启动windows的cmd2.3 输入adb push指令三、总结一、向设备传输文件命令用于在windows系统下，向设备传输文件。二、

2024-06-09 01:14:15

Android自定义实现转盘菜单

目录一、前言二、绘制原理三、总结一、前言旋转菜单是一种占用空间较大，实用性稍弱的UI，一方面由于展示空间的问题，其展示的数据有限，但另一方面真由于这个原因，对用户而言趣味性

2024-06-09 01:14:12

Android使用SqLite实现登录注册功能流程详解

目录一、了解什么是Android Studio二、了解什么是sqlite三、创建项目文件四、创建活动文件和布局文件五、创建数据库连接数据库六、创建实体类实现注册功能七、实现登录功能

2024-06-09 01:14:09

Android大图监测系统的三种实现方式

目录原理解析主动监测被动监测在第三方图片加载库回调中进行大图监测在网络加载图片时进行大图监测使用ASM插桩进行大图监控注意事项与优化技巧总结原理解析内存占用计算首

2024-06-09 01:14:05

详细讲解AsyncTask使用说明(值得收藏)

目录概念类简介简单例子执行流程一、在执行完 AsyncTask.excute() 后二、方法分析源码分析一、主分支二、次分支主分支部分一、分析mWorker二、分析mFuture三、回过头来看一

2024-06-09 01:14:03

Kotlin 协程的异常处理准则

目录Kotlin 协程的异常处理概述异常处理六大准则准则一：协程的取消需要内部配合问题：cancel不被响应解决：使用 isActive 判断是否处于活跃状态准则二：不要打破协程的父子结构问

2024-06-09 01:14:00

Android 双屏异显自适应Dialog的实现

目录一、前言需求问题二、方案方案：自定义Presentation原理WindowType问题解决WindowManagerImpl 问题方案：Delagate方式：兼容总结一、前言Android 多屏互联的时代，必然会出现多

2024-06-09 01:13:57

Android实现录音监听动画的示例代码

目录一、前言二、实现方法三、全部代码四、总结一、前言在很多app种内置了语音助手，也存在各种动画，主要原因是处理2个阶段问题，第一个是监听声音的等待效果，第二个是语意解析存

2024-06-09 01:13:55

Flutter路由的几种用法小结

目录Flutter路由跳转基本路由跳转 返回上一页路由基本路由跳转传参命名路由跳转命名路由跳转需要先配置路由命名路由跳转传参命名路由替换跳转移除所有页面返回到根页面Flut

2024-06-09 01:13:52

Android图片描边效果的实现

目录前言提取蒙版蒙版绘制扩大蒙版（影子）闪烁效果总结全部代码前言先看下我们阔爱滴海绵宝宝，其原图是一张PNG图片，我们给宝宝加上描边效果，今天我们使用的是图片蒙版技术。说到

2024-06-09 01:13:50

Android EditText设置边框的操作方法

目录Android EditText设置边框简介快速开始Android EditText设置边框简介Android应用程序中给EditText设置边框。效果图：快速开始1.在res/drawable目录下新建样式文件 edit_b

2024-06-09 01:13:47

Qt6.5.3 Android环境配置的实现

目录前言安装Qt安装JDK配置环境问题解决SDK配置报错：&times; Android SDK Command-line Tools runsQt版本出现错误：无法检测 Qt 版本所使用的 ABI。安卓构建套件警告：no device

2024-06-09 01:13:44

Flutter使用stack实现悬浮UI的示例代码

目录stack特性示例stack特性在Flutter中，你可以使用Stack和Positioned来创建悬浮 UI。Stack允许你将多个小部件叠放在一起，而Positioned则用于定位小部件在Stack中的位置。示

2024-06-09 01:13:42

OkHttp原理分析小结

目录Okhttp 介绍Okhttp 中几个重要类的介绍OkHttpClientOkHttpClient使用注意OkHttpClient的创建不需要了可以关闭Call 类Request 类RequestBody总结一下OKHTTP架构图OKHttp

2024-06-09 01:13:39

Android车载空调系统（HVAC）开发方法分析

目录1. HVAC 功能介绍1.1 双区温度调节1.2 空调开关1.3 内/外循环1.4 风量调节1.5 风向调节1.6 A/C开关1.7 主副驾座椅加热1.8 除霜1.9 自动模式2. HVAC 源码结构3. HVAC 核

2024-06-09 01:13:36

基于Android实现自动滚动布局

目录前言1. 布局自动滚动的思路2. 最终效果3. 代码实现4. 总结前言在平时的开发中，有时会碰到这样的场景，设计上布局的内容会比较紧凑，导致部分机型上某些布局中的内容显示不完

2024-06-09 01:13:34

Flutter BuildContext功能使用详解

目录BuildContext 简介BuildContext的主要作用BuildContext 简介BuildContext是Flutter中的一个重要概念，表示当前Widget在树中的位置上下文。它是一个对Widget树的一个位置

2024-06-09 01:13:26

Android apk完整性检测的实现思路和代码实现

目录需求和背景实现安全管理类相关工具类需求和背景行业相关，对安全性较高的程序一般都需要添加完整性检测的功能，以防止程序被篡改，从而导致安全问题的发生。
相关的支付应用

2024-06-09 01:13:24

Android Studio开发中Gradle各种常见报错问题解决方案

目录Android开发各种Gradle错误缺少依赖项版本冲突配置错误Android开发各种Gradle错误在开发Android应用程序时，我们可能会遇到各种Gradle错误。这些错误可能来自不同的原因，

2024-06-09 01:13:22

Flutter框架实现Android拖动到垃圾桶删除效果

目录Draggable介绍构造函数参数说明使用示例DragTarget介绍构造函数参数说明使用示例DragTarget如何接收Draggable传递过来的数据结束语Draggable介绍Draggable是Flutter框

2024-06-09 01:13:20

Android 中的 XRecyclerview的使用案例

目录前言：步骤：引用库实战过程我的案例前言：我们在上一篇文章中学到了Recyclerview但是在现实中往往需求不是那么的简单，可能需要多种需求合并起来，例如常见的上下拉刷新，删除 ite

2024-06-09 01:13:18

Android滑动冲突的解决技巧

目录滑动冲突的原理解决方法外部拦截法内部拦截法注意事项和优化技巧总结滑动冲突的原理Android的事件分发机制是基于ViewGroup的。当用户在屏幕上触摸时，事件会首先传递给最

2024-06-09 01:13:16

Android自定义View实现两种二维码的扫描效果

目录背景横线效果网格效果基础属性绘制背景色绘制边框线绘制四个边角线扫描线绘制及移动特点背景最近在开发新项目时，使用了扫描二维码的功能，一般扫描二维码的效果是一条横线

2024-06-09 01:12:49

Android中的HTextView库实现TextView动画效果

目录HTextView前言HTextView的简单使用方法HTextView引入line使用以及效果fade使用以及效果typer使用以及效果rainbow使用以及效果scale使用以及效果evaporate使用以及效果f

2024-06-09 01:12:45

Android应用设置独立的多语言实战技巧详解

目录应用设置一个不同于全局的多语言系统设置中支持为应用设置单独多语言入口在哪里自动添加手动添加在应用内部设置多语言应用设置一个不同于全局的多语言通常情况下多语言

2024-06-09 01:12:43

Flutter fluro时报错type &apos;String&apos; is not a subtype of type &ap

目录报错错误原因解决方法序列化和反序列化结语报错使用fluro时报错type &lsquo;String&rsquo; is not a subtype of type &lsquo;Queue<Task>&rsquo;报错如下：错误原因在使

2024-06-09 01:12:41

Kotlin 协程 supervisorScope {} 运行崩溃解决方法

目录Kotlin 协程 supervisorScope {} 运行崩溃解决前言解决方法kotlin 协程异常处理Kotlin 协程 supervisorScope {} 运行崩溃解决前言简单介绍supervisorScope函数，它用于创

2024-06-09 01:12:38

Android ADB简介、安装及使用详解

目录一、ADB简介1、什么是adb2、为什么要用adb二、准备工具1、下载adb2、配置环境变量3、连接 4、电脑打开cmd窗口三、ADB命令详解1、基本命令2、权限命令 3、建立连接4、ap

2024-06-09 01:12:36

解决Android SELinux权限问题记录分析

目录引言解决上下文问题上下文类型引言我在恢复安卓Termux数据时遇到了权限问题，我将数据恢复到/data/data目录中，并用chown设置了正确的用户和组，但是Termux在访问时还是遇到

2024-06-09 01:12:32

Android中注解处理器APT用法示例

目录APT作用Android基本编译流程APT基本使用1、 自定义注解2、注解处理器注解处理器注解处理器注册java代码生成3. 对外调用4. 调用总结APT，Annotation Processing Tool，即注

2024-06-09 01:12:30

热点内容

Flutter项目在 iOS14 启动崩溃的解决方法
2020-09-23
Android解决getExternalStorageDirectory在29后废弃问题(推荐)
2021-02-18
Android Studio连接MySql实现登录注册(附源代码)
2021-05-16
Android串口通信apk源码详解(附完整源码)
2021-01-19
解决flutter 错误: 程序包androidx.lifecycle不存在问题
2020-10-14
Flutter 实现进度条效果
2020-05-18
解决Android调用系统分享给微信,出现分享失败,分享多文件必须为图片格式的问题
2020-10-14
Android Tablayout 自定义Tab布局的使用案例
2020-10-14
Android studio listview实现列表数据显示 数据循环显示效果
2020-10-14
关于android studio升级4.1 某些插件使用不了的问题(Mac)
2020-10-23
返回顶部
顶部