Android USB转串口编程

最新推荐文章于 2024-09-05 16:23:39 发布
最新推荐文章于 2024-09-05 16:23:39 发布
阅读量2.6k 收藏 8
点赞数
分类专栏： 嵌入式
资料名称：CH341SER_ANDROID.ZIP 资料类型：驱动&工具 资料大小：1891KB 资料版本：1.4 更新时间：2017-07-05 软件简介：CH340/CH341的USB转串口安卓免驱应用库，用于Android操作系统3.1及以上版本的USB Host模式，无需加载Android内核驱动，无需root权限操作。包含apk安装程序，lib库文件（Java Driver），App Demo例程(USB转UART Demo工程SDK)。
适用范围：

CH340G，CH340C，CH340B，CH340E，CH340T，CH340R，CH341A，CH341T，CH341H下载


 安卓手机的对外通信接口就只有USB跟音频口，我们可采用其进行与外设进行通信。今天，我们来讲讲安卓手机利用USB接口与外设进行通信。此时，有两种情况。

第一：USB（手机）<--->USB（外设），就是手机与外设直接通过USB线进行通讯。

第二：USB（手机）<--->UART（外设），即手机与外设通过USB转接成串口，再与外设通信。

外设，说白了就是单片机，单片机端直接通过USB接口跟其他设备通讯，这种情况还是比较少见的。（另外，单片机是否具备驱动USB的能力，这个也值得质疑。我不是做下位机的，这些问题不太了解，只是说理论上这种方式是可行的而已。）一般来说，我们的单片机是通过串口跟其他设备进行通信的。所以，本文就自第二种情况进行阐述。他们的关系如下图所示。


在此，转接芯片承担着一个USB--UART转接的作用，CH34X是指具体一系列型号的芯片，包括CH340和CH341，此次我选择的是CH340，之前曾用过PL2303HA芯片作为转接芯片，但是手机端并不能很好地识别到USB设备，所以后来选择了CH340。MCU设备端的编程，是单片机工程师的串口编程，这个我们不太管，本文中我们更关注的是Android端的USB Host编程。

说到安卓USBHost编程，其实就是安卓的USB HOST编程。这部分网上资料很多，在此我大概用阐述一下。

Android下的USB Host介绍和开发

          一、USB Host介绍
USB Host,中文意思是USB主模式，是相对于USB Accessory(USB副模式)来说的。如果Android工作在USB Host模式下，则连接到Android上的USB设备把Android类似的看作是一台PC机，PC机能干的事儿，Android也能干，例如将鼠标、键盘插入则可以使用键盘、鼠标来操作Android系统，如果插入U盘则，通过Android可以读写U盘上的数据。而USB Accessory模式表示将Android设备类似当作一个USB的键盘、鼠标、U盘插入到电脑主机上一样使用，这两种模式在Android API level-12以上才支持，即Android3.1及更高的版本支持这两种模式。

在我们这里，Android端当然是主模式。 

要实现安卓USB HOST编程，系统版本只是他的软件要求，除此之外，当然还需要硬件要求。那就是手机必须支持OTG功能。不知道什么是OTG的朋友，请自行百度。

二、USB HOST开发

 关于Android USB HOST编程，网上这方面的例子也是不少的，大致可以实现从发现设备到打开连接设备并进行数据双向传输的功能。但这些例子只是单纯的进行USB通信，对于我们本文中的例子，是不够的。我们这里，USB设备之外是一个UART串口设备。虽然所对于我们的安卓端来说，转接芯片已经帮我们屏蔽了串口，已转接成USB，貌似已不用关心串口。但是，实际上，串口的 一些参数配置我们还是需要的。举个例子：如果MCU端以9600bps的波特率发送数据过来，转接芯片又如何知道应该以怎样的波特率进行接收并转换成USB数据呢？倘若转接芯片不是以相应的波特率接收数据，手机端必定接收到的是错误的数据。即使转接芯片默认的波特率是9600，得到了正确的数据，但假如MCU换了波特率，是以115200来发送呢？所以，我们原则上来说，手机端还是要通过一定的方法，发送一定的命令给CH340转接芯片，配置相应的串口参数。下面，我将会从如何进行USB HOST编程基础开始讲起，对这些问题进行阐述。

 其实不管是进行什么样方式的通信，归纳起来，无非就是四个步骤走：发现设备----->打开(连接)设备----->数据通信----->关闭设备。

 1、添加权限（安卓动不动就要添加权限，这个还是些许无聊的。）

[html]  view plain  copy
  1. <uses-feature android:name="android.hardware.usb.host" />  
  2.     <uses-permission android:name="android.hardware.usb.host" />  
  3.     <uses-permission android:name="ANDROID.PERMISSION.HARDWARE_TEST" />  
2、添加USB设备信息

在res目录下，新建一个xml文件夹，在里面新建一个xml文件，device_filter.xml，用来存放usb的设备信息。

[html]  view plain  copy
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <span style="white-space:pre">    </span><resources>  
  3.    <span style="white-space:pre">     </span> <usb-device product-id="29987" vendor-id="6790" />  
  4. <span style="white-space:pre">    </span></resources>  
其中的ProductID跟VendorID是你要进行通信的USB设备的 供应商ID（VID）和产品识别码（PID），具体数值多少可以在接下来的枚举设备方法里面得知。

  新建完文件，我们自然要引用他，即在manifest.xml文件中声明。在要启动的Activity里添加 <meta-data />标签。

[html]  view plain  copy
  1. <activity  
  2.             android:name=".MainActivity"  
  3.             android:label="@string/app_name"  
  4.             android:launchMode="singleTask" >  
  5.             <intent-filter>  
  6.                 <action android:name="android.intent.action.MAIN" />  
  7.                 <category android:name="android.intent.category.LAUNCHER" />  
  8.             </intent-filter>  
  9.             <intent-filter>  
  10.                 <action android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED" />  
  11.             </intent-filter>  
  12.             <meta-data  
  13.                 android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED"  
  14.                 android:resource="@xml/device_filter" />  
  15.         </activity>  
此外，我在此Activity中添加一个action为USB_DEVICE_ATTACHED的inten-filter，只是为了在不打开应用的时候监听USB设备的插入，当插入USB设备，则自动打开该应用。并且，为了防止我在已打开应用的的时候，插入USB设备他再次打开一个应用，所以我设置其启动模式为singleTask。

3、枚举（发现）并获取相应的USB设备（相关USB类：UsbManager ，UsbDevice）

     不管进行什么通信，我们首先该做的应是获取相应的设备。此处，应是利用UsbManager 类获取插入到此Andriod手机上的USB设备，用UsbDevice类表示。

[java]  view plain  copy
  1. public UsbDevice EnumerateDevice(){  
  2.         mUsbmanager = (UsbManager) mContext.getSystemService(Context.USB_SERVICE);  
  3.         mPendingIntent = PendingIntent.getBroadcast(mContext, 0, new Intent(mString), 0);  
  4.         HashMap<String, UsbDevice> deviceList = mUsbmanager.getDeviceList();  
  5.         if(deviceList.isEmpty()) {  
  6.             Toast.makeText(mContext, "No Device Or Device Not Match", Toast.LENGTH_LONG).show();  
  7.             return null;  
  8.         }  
  9.         Iterator<UsbDevice> localIterator = deviceList.values().iterator();  
  10.         while(localIterator.hasNext()) {  
  11.             UsbDevice localUsbDevice = localIterator.next();  
  12.             for(int i = 0; i < DeviceCount; ++i) {  
  13. //               Log.d(TAG, "DeviceCount is " + DeviceCount);  
  14.                 if(String.format("%04x:%04x", new Object[]{Integer.valueOf(localUsbDevice.getVendorId()),   
  15.                         Integer.valueOf(localUsbDevice.getProductId()) }).equals(DeviceNum.get(i))) {  
  16.                     IntentFilter filter = new IntentFilter(mString);  
  17.                     filter.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED);  
  18.                     mContext.registerReceiver(mUsbReceiver, filter);  
  19.                     BroadcastFlag = true;  
  20.                     return localUsbDevice;  
  21.                       
  22.                 } else {  
  23.                     Log.d(TAG, "String.format not match");  
  24.                 }  
  25.             }  
  26.         }  
  27.           
  28.         return null;  
  29.     }  
4、打开USB设备
此处较为复杂，其实打开设备只是一个概括性的动作，实际上他还分好几个动作，不然直接打开设备的话无法通信。

 打开设备方法：

[java]  view plain  copy
  1. public synchronized void OpenUsbDevice(UsbDevice mDevice){  
  2.         Object localObject;  
  3.         UsbInterface intf;  
  4.         if(mDevice == null)  
  5.             return;  
  6.         intf = getUsbInterface(mDevice);  
  7.         if((mDevice != null) && (intf != null)) {  
  8.             localObject = this.mUsbmanager.openDevice(mDevice);  
  9.             if(localObject != null) {  
  10.                 if(((UsbDeviceConnection)localObject).claimInterface(intf, true)) {  
  11.                     this.mUsbDevice = mDevice;  
  12.                     this.mDeviceConnection = ((UsbDeviceConnection)localObject);  
  13.                     this.mInterface = intf;  
  14.                     if(!enumerateEndPoint(intf))  
  15.                         return;  
  16.                     Toast.makeText(mContext, "Device Has Attached to Android", Toast.LENGTH_LONG).show();  
  17.                     if(READ_ENABLE == false){  
  18.                         READ_ENABLE = true;  
  19.                         readThread = new read_thread(mBulkInPoint, mDeviceConnection);  
  20.                         readThread.start();  
  21.                     }  
  22.                     return;  
  23.                 }  
  24.             }  
  25.         }  
  26.           
  27.     }  
4.1 获取USB设备接口

获取到UsbDevice之后，我们在该设备上要获取相应的UsbInterface。

[java]  view plain  copy
  1. private UsbInterface getUsbInterface(UsbDevice paramUsbDevice) {  
  2.         if(this.mDeviceConnection != null) {  
  3.             if(this.mInterface != null) {  
  4.                 this.mDeviceConnection.releaseInterface(this.mInterface);  
  5.                 this.mInterface = null;  
  6.             }  
  7.             this.mDeviceConnection.close();  
  8.             this.mUsbDevice = null;  
  9.             this.mInterface = null;  
  10.         }  
  11.         if(paramUsbDevice == null)  
  12.             return null;  
  13.         for (int i = 0; i < paramUsbDevice.getInterfaceCount(); i++) {  
  14.             UsbInterface intf = paramUsbDevice.getInterface(i);  
  15.             if (intf.getInterfaceClass() == 0xff  
  16.                     && intf.getInterfaceSubclass() == 0x01  
  17.                     && intf.getInterfaceProtocol() == 0x02) {  
  18.                 return intf;  
  19.             }  
  20.         }  
  21.         return null;  
  22.     }  
4.2  分配端点，IN | OUT| 

获取到USB设备接口之后，我们还不能进行USB通信，USB通信需要使用UsbEndpoint端点。

[java]  view plain  copy
  1. private boolean enumerateEndPoint(UsbInterface sInterface){  
  2.         if(sInterface == null)  
  3.             return false;  
  4.         for(int i = 0; i < sInterface.getEndpointCount(); ++i) {  
  5.             UsbEndpoint endPoint = sInterface.getEndpoint(i);  
  6.             if(endPoint.getType() == UsbConstants.USB_ENDPOINT_XFER_BULK && endPoint.getMaxPacketSize() == 0x20) {  
  7.                 if(endPoint.getDirection() == UsbConstants.USB_DIR_IN) {  
  8.                     mBulkInPoint = endPoint;  
  9.                 } else {  
  10.                     mBulkOutPoint = endPoint;  
  11.                 }  
  12.                 this.mBulkPacketSize = endPoint.getMaxPacketSize();  
  13.             } else if(endPoint.getType() == UsbConstants.USB_ENDPOINT_XFER_CONTROL) {  
  14.                     mCtrlPoint = endPoint;  
  15.             }  
  16.         }  
  17.         return true;  
  18.     }  
其中In端点mBulkInPoint是输入端点，是要来读数据的，Out端点mBulkOutPoint是输出端点，是写数据用的。

4.3 打开并连接USB设备

此处跟前面获取端点是可以互换顺序的。但从理解角度来说，我还是倾向于把打开设备放在最后，因为一般都是把配置方面都做好了，才去连接设备的。

此处直接使用UsbManager的方法进行连接：mUsbmanager.openDevice(mDevice);

到了这里，一般的即可进行USB数据的读写了。

5、读写USB数据

读数据：使用 mConn.bulkTransfer（）方法，mBulkInPoint端点。另外，串口是的缓存很小的，最大也就几K，可认为几乎没有，具体大小取决于串口设备端的MCU，所以我们必须开一个线程去不断循环读取数据，不然倘若读取速度小于设备端的发送速度，这样就会导致数据丢失。

[java]  view plain  copy
  1. private class read_thread  extends Thread {  
  2.         UsbEndpoint endpoint;  
  3.         UsbDeviceConnection mConn;  
  4.         read_thread(UsbEndpoint point, UsbDeviceConnection con){  
  5.             endpoint = point;  
  6.             mConn = con;  
  7.             this.setPriority(Thread.MAX_PRIORITY);  
  8.         }  
  9.         public void run()  
  10.         {         
  11.             while(READ_ENABLE == true)  
  12.             {  
  13.                 while(totalBytes > (maxnumbytes - 63))  
  14.                 {  
  15.                     try   
  16.                     {  
  17.                         Thread.sleep(5);  
  18.                     }  
  19.                     catch (InterruptedException e) {e.printStackTrace();}  
  20.                 }  
  21.                 synchronized(ReadQueueLock)  
  22.                 {  
  23.                     if(endpoint != null)  
  24.                     {     
  25.                         readcount = mConn.bulkTransfer(endpoint, usbdata, 64, ReadTimeOutMillis);  
  26.                         if(readcount > 0)  
  27.                         {  
  28.                             for(int count = 0; count< readcount; count++)  
  29.                             {                                     
  30.                                 readBuffer[writeIndex] = usbdata[count];  
  31.                                 writeIndex++;  
  32.                                 writeIndex %= maxnumbytes;  
  33.                             }  
  34.                             if(writeIndex >= readIndex)  
  35.                                 totalBytes = writeIndex-readIndex;  
  36.                             else  
  37.                                 totalBytes = (maxnumbytes-readIndex)+writeIndex;  
  38.                         }  
  39.                     }  
  40.                 }  
  41.             }  
  42.         }  
  43.     }  
当要取数据的时候，直接去取readBuffer数组的数据即可。

   写数据：也是使用 mConn.bulkTransfer（）方法，但是却用的mBulkOutPoint端点。

[java]  view plain  copy
  1.  public int WriteData(byte[] buf, int length, int timeoutMillis)  
  2. {  
  3.     int offset = 0;  
  4.     int HasWritten = 0;  
  5.     int odd_len = length;  
  6.     if(this.mBulkOutPoint == null)  
  7.         return -1;  
  8.     while(offset < length)  
  9.     {  
  10.         synchronized(this.WriteQueueLock) {  
  11.             int mLen = Math.min(odd_len, this.mBulkPacketSize);  
  12.             byte[] arrayOfByte = new byte[mLen];  
  13.             if(offset == 0) {  
  14.                 System.arraycopy(buf, 0, arrayOfByte, 0, mLen);  
  15.             } else {  
  16.                 System.arraycopy(buf, offset, arrayOfByte, 0, mLen);  
  17.             }  
  18.             HasWritten = this.mDeviceConnection.bulkTransfer(this.mBulkOutPoint, arrayOfByte, mLen, timeoutMillis);  
  19.             if(HasWritten < 0) {  
  20.                 return -2;  
  21.             } else {  
  22.                 offset += HasWritten;  
  23.                 odd_len -= HasWritten;  
  24. /                   Log.d(TAG, "offset " + offset + " odd_len " + odd_len);  
  25.             }  
  26.         }  
  27.     }  
  28.     return offset;  
  29. }  
到了这里，一般的读写已可以了。网上的文章一般也就说到这一步。但是如同开头所说，并没有解决串口设置的问题，此时很大可能会接收到错误的数据，这不是我们所希望的。此时，就需要我们的下一步了。

6、串口配置

在我们的这个CH340单转接芯片里，我们采用的是mDeviceConnection.controlTransfer（）这个方法来进行配置。

 6.1 ：初始化串口：

[java]  view plain  copy
  1. public boolean UartInit(){  
  2.         int ret;  
  3.         int size = 8;  
  4.         byte[] buffer = new byte[size];  
  5.         Uart_Control_Out(UartCmd.VENDOR_SERIAL_INIT, 0x0000, 0x0000);  
  6.         ret = Uart_Control_In(UartCmd.VENDOR_VERSION, 0x0000, 0x0000, buffer, 2);  
  7.         if(ret < 0)  
  8.             return false;  
  9.         Uart_Control_Out(UartCmd.VENDOR_WRITE, 0x1312, 0xD982);  
  10.         Uart_Control_Out(UartCmd.VENDOR_WRITE, 0x0f2c, 0x0004);  
  11.         ret = Uart_Control_In(UartCmd.VENDOR_READ, 0x2518, 0x0000, buffer, 2);  
  12.         if(ret < 0)  
  13.             return false;  
  14.         Uart_Control_Out(UartCmd.VENDOR_WRITE, 0x2727, 0x0000);  
  15.         Uart_Control_Out(UartCmd.VENDOR_MODEM_OUT, 0x00ff, 0x0000);  
  16.         return true;  
  17.     }  
[java]  view plain  copy
  1. public int Uart_Control_Out(int request, int value, int index)  
  2.     {  
  3.         int retval = 0;  
  4.         retval = mDeviceConnection.controlTransfer(UsbType.USB_TYPE_VENDOR | UsbType.USB_RECIP_DEVICE | UsbType.USB_DIR_OUT,  
  5.                 request, value, index, null, 0, DEFAULT_TIMEOUT);  
  6.           
  7.         return retval;  
  8.     }  
[java]  view plain  copy
  1. public int Uart_Control_In(int request, int value, int index, byte[] buffer, int length)  
  2.     {  
  3.         int retval = 0;  
  4.         retval = mDeviceConnection.controlTransfer(UsbType.USB_TYPE_VENDOR | UsbType.USB_RECIP_DEVICE | UsbType.USB_DIR_IN,  
  5.                     request, value, index, buffer, length, DEFAULT_TIMEOUT);  
  6.         return retval;  
  7.     }  

 6.2：配置串口参数（主要是波特率，数据位，停止位，奇偶校验位以及流控）

[java]  view plain  copy
  1. public boolean SetConfig(int baudRate, byte dataBit, byte stopBit, byte parity, byte flowControl){  
  2.         int value = 0;  
  3.         int index = 0;  
  4.         char valueHigh = 0, valueLow = 0, indexHigh = 0, indexLow = 0;  
  5.         switch(parity) {  
  6.         case 0: /*NONE*/  
  7.             valueHigh = 0x00;  
  8.             break;  
  9.         case 1: /*ODD*/  
  10.             valueHigh |= 0x08;  
  11.             break;  
  12.         case 2: /*Even*/  
  13.             valueHigh |= 0x18;  
  14.             break;  
  15.         case 3: /*Mark*/  
  16.             valueHigh |= 0x28;  
  17.             break;  
  18.         case 4: /*Space*/  
  19.             valueHigh |= 0x38;  
  20.             break;  
  21.         default:    /*None*/  
  22.             valueHigh = 0x00;  
  23.             break;  
  24.         }  
  25.           
  26.         if(stopBit == 2) {  
  27.             valueHigh |= 0x04;  
  28.         }  
  29.           
  30.         switch(dataBit) {  
  31.         case 5:  
  32.             valueHigh |= 0x00;  
  33.             break;  
  34.         case 6:  
  35.             valueHigh |= 0x01;  
  36.             break;  
  37.         case 7:  
  38.             valueHigh |= 0x02;  
  39.             break;  
  40.         case 8:  
  41.             valueHigh |= 0x03;  
  42.             break;  
  43.         default:  
  44.             valueHigh |= 0x03;  
  45.             break;  
  46.         }  
  47.           
  48.         valueHigh |= 0xc0;  
  49.         valueLow = 0x9c;  
  50.           
  51.         value |= valueLow;  
  52.         value |= (int)(valueHigh << 8);  
  53.           
  54.         switch(baudRate) {  
  55.         case 50:  
  56.             indexLow = 0;  
  57.             indexHigh = 0x16;  
  58.             break;  
  59.         case 75:  
  60.             indexLow = 0;  
  61.             indexHigh = 0x64;  
  62.             break;  
  63.         case 110:  
  64.             indexLow = 0;  
  65.             indexHigh = 0x96;  
  66.             break;  
  67.         case 135:  
  68.             indexLow = 0;  
  69.             indexHigh = 0xa9;  
  70.             break;  
  71.         case 150:  
  72.             indexLow = 0;  
  73.             indexHigh = 0xb2;  
  74.             break;      
  75.         case 300:  
  76.             indexLow = 0;  
  77.             indexHigh = 0xd9;  
  78.             break;  
  79.         case 600:  
  80.             indexLow = 1;  
  81.             indexHigh = 0x64;  
  82.             break;  
  83.         case 1200:  
  84.             indexLow = 1;  
  85.             indexHigh = 0xb2;  
  86.             break;  
  87.         case 1800:  
  88.             indexLow = 1;  
  89.             indexHigh = 0xcc;  
  90.             break;  
  91.         case 2400:  
  92.             indexLow = 1;  
  93.             indexHigh = 0xd9;  
  94.             break;  
  95.         case 4800:  
  96.             indexLow = 2;  
  97.             indexHigh = 0x64;  
  98.             break;  
  99.         case 9600:  
  100.             indexLow = 2;  
  101.             indexHigh = 0xb2;  
  102.             break;  
  103.         case 19200:  
  104.             indexLow = 2;  
  105.             indexHigh = 0xd9;  
  106.             break;  
  107.         case 38400:  
  108.             indexLow = 3;  
  109.             indexHigh = 0x64;  
  110.             break;  
  111.         case 57600:  
  112.             indexLow = 3;  
  113.             indexHigh = 0x98;  
  114.             break;  
  115.         case 115200:  
  116.             indexLow = 3;  
  117.             indexHigh = 0xcc;  
  118.             break;  
  119.         case 230400:  
  120.             indexLow = 3;  
  121.             indexHigh = 0xe6;  
  122.             break;  
  123.         case 460800:  
  124.             indexLow = 3;  
  125.             indexHigh = 0xf3;  
  126.             break;                    
  127.         case 500000:  
  128.             indexLow = 3;                                      
  129.             indexHigh = 0xf4;  
  130.             break;  
  131.         case 921600:  
  132.             indexLow = 7;  
  133.             indexHigh = 0xf3;  
  134.             break;  
  135.         case 1000000:  
  136.             indexLow = 3;  
  137.             indexHigh = 0xfa;  
  138.             break;  
  139.         case 2000000:  
  140.             indexLow = 3;  
  141.             indexHigh = 0xfd;  
  142.             break;  
  143.         case 3000000:  
  144.             indexLow = 3;  
  145.             indexHigh = 0xfe;  
  146.             break;  
  147.         default:    // default baudRate "9600"  
  148.             indexLow = 2;  
  149.             indexHigh = 0xb2;  
  150.             break;   
  151.         }  
  152.           
  153.         index |= 0x88 |indexLow;  
  154.         index |= (int)(indexHigh << 8);  
  155.           
  156.         Uart_Control_Out(UartCmd.VENDOR_SERIAL_INIT, value, index);  
  157.         if(flowControl == 1) {  
  158.             Uart_Tiocmset(UartModem.TIOCM_DTR | UartModem.TIOCM_RTS, 0x00);  
  159.         }  
  160.         return true;  
  161.     }  
这样，串口已经初始化，以及配置好相关的波特率之类的，就可以进行正确的数据收发了，就可以实现我们的USB--UART串口通信了。

7、关闭设备

当然，最后不要忘记关闭设备，释放资源。

[java]  view plain  copy
  1. public synchronized void CloseDevice() {  
  2.     try {  
  3.         Thread.sleep(10);  
  4.     } catch (Exception e) {  
  5.     }  
  6.   
  7.     if (this.mDeviceConnection != null) {  
  8.         if (this.mInterface != null) {  
  9.             this.mDeviceConnection.releaseInterface(this.mInterface);  
  10.             this.mInterface = null;  
  11.         }  
  12.   
  13.         this.mDeviceConnection.close();  
  14.     }  
  15.   
  16.     if (this.mUsbDevice != null) {  
  17.         this.mUsbDevice = null;  
  18.     }  
  19.   
  20.     if (this.mUsbmanager != null) {  
  21.         this.mUsbmanager = null;  
  22.     }  
  23.   
  24.     if (READ_ENABLE == true) {  
  25.         READ_ENABLE = false;  
  26.     }  
  27.   
  28.     /* 
  29.      * No need unregisterReceiver 
  30.      */  
  31.     if (BroadcastFlag == true) {  
  32.         this.mContext.unregisterReceiver(mUsbReceiver);  
  33.         BroadcastFlag = false;  
  34.     }  
  35.   
  36.     // System.exit(0);  
  37. }  

本文主要参考CH34X系列厂商提供的官方开发手册以及demo，有兴趣的朋友可以直接前往官网下载相关资料。

http://www.wch.cn/download/CH341SER_ANDROID_ZIP.html

本人知识有限，如果有说的不对的地方，欢迎留言指点，大家一起交流。 

另外亦可以加Q交流，QQ：469325534 。

附源代码下载地址：http://download.csdn.net/detail/ever_gz/9250423。

Android USB转ttl串口
2401_84537826的博客
04-26 643
setTitle(“提示”).setMessage(“您的设备不支持USBhost”).setPositiveButton(“确认”,@Override//保持屏幕常亮状态//打开流程主要步骤为ResumeUsbList，UartInit@Override});//设备回来的数据/*卡号/*余额//转换成分//转换成元synthesizer.showVideo(“您的卡上余额为:”+s+“元”);@Override。
Android 实现USB转串口通信
Wang_Ritian的博客
01-27 6848
目前我正在使用工业安卓平板做上位机，工业安卓平板带有232、485串口以及USB接口，通常驱动232、485接口需要有厂家提供的JNI库以及相关的java类。某天浏览Android Developers开发者指南时，看到了关于USB使用的文档，因此想参考文档做USB转串口的通信实验，但实验的过程中遇到了不少问题，特此记录。 说明一下实验所用的硬件： 1.工业安卓平板（带有USB接口） 2.USB转TTL数据线（芯片型号PL2303HXD) 遇到的问题 首先USB转TTL线插到工业安卓平板的USB口，然后根据
全面解读USB转串口驱动安装与配置
最新发布
weixin_32098457的博客
09-05 3006
本文还有配套的精品资源，点击获取 简介：USB转串口驱动是一种常用技术，它允许USB设备与传统的串行设备进行通信。文章将详细探讨其工作原理、安装流程和应用。核心在于虚拟COM端口（VCP）驱动程序，它使得操作系统能够识别USB转串口适配器为标准的串行端口。本文还会解释USB转串口驱动的工作流程，包括设备连接、驱动安装、初始化及数据传输。USB转串口驱动广泛应用于嵌入式开发、...
Android USB转串口编程
11-07
Android通过USB转串口跟串口设备进行通信。
安卓USB转串口
08-25 2577
准备硬件 1.先得准备一个有OTP功能的手机，也就是可以作为USB主机的手机，当然，现在绝大部分手机都是支持这个功能的，除非是早期的安卓老爷机才不支持。我的旧手机荣耀6plus都支持。 2.一根USB专接线，把手机USB口转成电脑USB口。 3.USB转串口板。随便在某宝上买一下CH340芯片的就行，几块钱。 硬件测试： 安装个串口调试工具APP，先测试一下当前硬件的收发功能是否正常。 ...
android usb转串口数据通信示例
09-14
android usb转串口数据通信示例。物联网开发中也会经常用到usb转串口，对android手机进行通信。一般都会用otc线进行转换。我在GitHub下来一份代码，亲测可用。并进行了修改封装。我的博客地址：...
android+usb转串口+唯一id,Android USB转串口通信
weixin_29699579的博客
05-26 983
一、引用二、截图废话不多说，先上图，micro usb -> usb 连接的测试温度的外设(其实是个测试粮油品质的，还有TPM值等等)usb_connect.png三、流程1、mainfest中注册监听USB拔插动作并且过滤对应vid,pid的设备。这个是静态的，在下面实例中用的是动态的，具体可以参考引用中的第【2】个。2、查找所有的USB设备3、动态注册需要用的USB设备权限4、连接已注册...
android usb转串口
06-30
在Android系统中，USB转串口技术是一种将USB设备转换为串行通信接口（通常为UART）的方法，以便Android设备可以与各种外部设备进行通信，如传感器、控制器、GPS模块等。这种技术对于开发和调试硬件设备或者进行...
Android之USB转串口通信-基本流程
lerous的专栏
07-06 3865
背景：近期公司一个项目对接第三方支付设备（类似平板的设备外接usb转串口设备），需要使用usb转串口，实现通信和交互，今天记下过程。 有引用这个库https://github.com/mik3y/usb-serial-for-android，感谢开源的大佬。 这个库已经集合了一般的芯片协议，就不需要自己再配置了。我们设备是用的ProlificSerialDriver. 唯一要注意的是配置设...
android通过usb转串口跟串口设备进行通信。
04-13
Android通过USB转串口跟串口设备进行通信。稍微更改后可集成在自己的系统里了
安卓USB转串口APK
08-14
此APK可用在安卓3.1版本以上系统，需安卓USB支持OTG或HOST功能。可支持的USB转串口芯片有FT232R,FT231XS,FT232H，FT230XS
Android之USB转串口通信
热门推荐
drinkingcode
02-26 2万+
实验目的： STM32通过USB转串口向Android Device持续发送数据，并让其显示在Android Device的Editview界面上 manifest.xml <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.example.dai.usb_t
Android USB通信（host转串口）
无
07-28 9908
公司属于北斗通信行业，项目大多都需要和各式各样的硬件设备相结合来满足项目需求，因此所涉及到的各种技术也相对比较冷门。前段时间有个项目用到了一款定制 Android 设备，其中有多个接口，包括两个 USB 接口和一个 RS232 串口，需要用到其中一个 USB 连接北斗设备实现指令互通，经过摸索现在也大致了解了 Android USB（host）通信流程后续还有另一个项目则用到了 USB（accessory）有空再写一篇。在这里记录和分享一下，有错漏或可优化之处欢迎大家留言。
Android USB串口开发
u011555996的博客
01-10 1538
因为第一次接触Android下的串口开发，在网上找了很多例子都不能满足自己的需要以及不能正常使用，于是结合网上的资源以及查阅资料，终于完成了关于这个串口的开发，在此记录下usb转串口通信开发的过程。 Android串口开发步骤总共分为四大类，如下  1. 权限获取  2. 发现打开串口  3. 串口操作（发送与读取）  4. 关闭串口 一、权限获取 首先我们需要在AndroidMainfes...
Android：usb转232串口通信
谢桥的博客
04-18 1261
首先得adb进入盒子root模式，将/dev/ttys1这个文件改为777，使得所有用户可操作。消息也一直没有发送过去（当前串口的apk我甚至赋予系统权限了～丢包的问题也没有得到解决）但是，我遇到了一个问题，串口一直在lose丢包。如果没有报错的话，再执行串口就不会报错了。记一下，解决了我再更新2023年4月18日。进入设备的root模式，执行。串口建立连接是没有什么问题的。执行完成后退出 exit。
Android USB通信与USB转串口通信
shu_quan的博客
07-09 848
前段时间公司有个项目，涉及Android BLE硬件通讯，需要用到Android USB转PL232、FD232Rl等串口进行硬件与app的通信，楼主以前并没做过USB通信，也是一脸的懵逼哈，于是乎查阅了网上的资料，发现USB通信较为简单，网上资源也比较多，但是转串口的话，通信通道持续建立不起来。后来发现是缺少串口驱动，下面大致过程分享下吧。 首先是单纯的USB通信，大致分为以下几个主要步骤： 一：查找连接手机的USB设备，使用到的是官方的UsbManager类。分为获取usbManager对象...
安卓通过usb互相通信_基于安卓平台的USB接口与串口通信转换的实现
weixin_42170790的博客
12-24 815
龙源期刊网http://www.qikan.com.cn基于安卓平台的USB接口与串口通信转换的实现作者：冯生强张新龙来源：《中国新通信》2016年第18期【摘要】在数据通信中，接口的使用尤其重要，特别是USB接口以及串口的应用较为广泛，随着智能家居、物联网以及安卓系统的飞速发展，基于安卓系统的多个通信接口之间转换成为拓展应用空间、延伸应用领域的有效通联手段。本文提出一种基于安卓系统的USB接口与...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值