【教程】Android手机通过OTG线连接Arduino，读写串口数据

ninjiafan

因为自己对电子电路是半桶水，复杂的单片机电路把我难倒了，幸好Arduino的出现，让一切都简化了不少。平时和朋友们就喜欢制作一些Arduino的小玩意儿来帮助生活和工作。

因为朋友单位需要采购一些数据采集和云台控制的设备，就定制了些，全是用UNO和Arduino Nano来做的。但是这些设备所在的位置很分散，在城市的周边地区（非常的偏远，甚至是人迹罕见的地方，那是爬山涉水翻山越岭啊）。

而数据采集的调试很麻烦，因为每部设备所在的位置和环境的不同，必须设置不同的参数，值得庆幸的是程序不需要修改了，只修改参数即可。于是我和朋友只需要带手机和外置电池就行了。

言归正传，UNO和Nano的USB串口通信被Android 4.0以上手机支持的，所以通过OTG线连接并使用软件可以直接读取和发送数据。并且Arduino串口波特率必须为9600！
这是我的手机对应的OTG线，有弯头和直头两种，我更喜欢弯头的。对了,提醒一点,OTG线让Android手机为Arduino供电的，所以无需外接电源。



Android手机需要下载谷歌电子市场中的Arduino Uno Communicat：（在谷歌的Play商店下载东西让人放心，不会有木马或者病毒之类的。其他的电子市场就不好说了。）


通过OTG线插入Arduino时会出现提示：


这是插上Arduino后的运行结果：也？回车怎么变成“.”了？


我们现在已经能够查看Arduino串口输出了，但是无法输入，而且回车也变成点了，不好看。不过查看程序工作日志已经够了。

那么我们有没有更好的软件呢？有的！！！
谷歌电子市场下载USB Serial Monitor Lite：


程序主界面


设置菜单，选择Setting


设置界面，有串口和显示设置


串口波特率改为9600


显示可以用默认，也可以自己定制


你需要显示字符、十进制、十六进制？


设置完成后连接好Arduino后，选择Open Device


运行结果：


应坛友要求提取电子市场的USB Serial Monitor Lite，请有条件的坛友测试下。
补充说明：有坛友说无法在电子市场找到，这个问题我觉得是谷歌电子市场分类导致的，可能是手机的系统版本太低无法支持，也可能是手机达不到这个程序的基本硬件需求所以被屏蔽，当然，我说的是谷歌的Play商店，不是第三方电子市场。我的手机是三星的Galaxy Nexus，系统是谷歌原版的Android 4.0.4。

迷你强

好贴顶一个。。。等线到了就试试，貌似很好玩

zhangdeyue1

这个可以有
呵呵~~~~~~~~~~！

Randy

{:soso_e142:}

gaoshine

以前安卓手机和arduino通过蓝牙通讯，现在看来可以直接用OTG USB线通讯了，赞一个！

贴2段 andriod的代码，供各位参考。

1. /*
   
2. * Copyright (C) 2012 Mathias Jeppsson
   
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. *      [url]http://www.apache.org/licenses/LICENSE-2.0[/url]
   
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. */
    
16. 
    
17. package com.primavera.arduino.listener;
    
18. 
    
19. import java.util.ArrayList;
    
20. import java.util.HashMap;
    
21. import java.util.Iterator;
    
22. 
    
23. import android.app.ListActivity;
    
24. import android.app.PendingIntent;
    
25. import android.content.BroadcastReceiver;
    
26. import android.content.Context;
    
27. import android.content.Intent;
    
28. import android.content.IntentFilter;
    
29. import android.hardware.usb.UsbDevice;
    
30. import android.hardware.usb.UsbManager;
    
31. import android.os.Bundle;
    
32. import android.util.Log;
    
33. import android.view.Menu;
    
34. import android.view.MenuItem;
    
35. import android.view.View;
    
36. import android.widget.ArrayAdapter;
    
37. import android.widget.ListView;
    
38. import android.widget.Toast;
    
39. 
    
40. public class ArduinoCommunicatorActivity extends ListActivity {
    
41. 
    
42.     private static final int ARDUINO_USB_VENDOR_ID = 0x2341;
    
43.     private static final int ARDUINO_UNO_USB_PRODUCT_ID = 0x01;
    
44.     private static final int ARDUINO_MEGA_2560_USB_PRODUCT_ID = 0x10;
    
45.     private static final int ARDUINO_MEGA_2560_R3_USB_PRODUCT_ID = 0x42;
    
46.     private static final int ARDUINO_UNO_R3_USB_PRODUCT_ID = 0x43;
    
47. 
    
48.     private final static String TAG = "ArduinoCommunicatorActivity";
    
49.     private final static boolean DEBUG = false;
    
50.    
    
51.     private Boolean mIsReceiving;
    
52.     private ArrayList<ByteArray> mTransferedDataList = new ArrayList<ByteArray>();
    
53.     private ArrayAdapter<ByteArray> mDataAdapter;
    
54. 
    
55.     private void findDevice() {
    
56.         UsbManager usbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
    
57.         UsbDevice usbDevice = null;
    
58.         HashMap<String, UsbDevice> usbDeviceList = usbManager.getDeviceList();
    
59.         if (DEBUG) Log.d(TAG, "length: " + usbDeviceList.size());
    
60.         Iterator<UsbDevice> deviceIterator = usbDeviceList.values().iterator();
    
61.         if (deviceIterator.hasNext()) {
    
62.             UsbDevice tempUsbDevice = deviceIterator.next();
    
63. 
    
64.             // Print device information. If you think your device should be able
    
65.             // to communicate with this app, add it to accepted products below.
    
66.             if (DEBUG) Log.d(TAG, "VendorId: " + tempUsbDevice.getVendorId());
    
67.             if (DEBUG) Log.d(TAG, "ProductId: " + tempUsbDevice.getProductId());
    
68.             if (DEBUG) Log.d(TAG, "DeviceName: " + tempUsbDevice.getDeviceName());
    
69.             if (DEBUG) Log.d(TAG, "DeviceId: " + tempUsbDevice.getDeviceId());
    
70.             if (DEBUG) Log.d(TAG, "DeviceClass: " + tempUsbDevice.getDeviceClass());
    
71.             if (DEBUG) Log.d(TAG, "DeviceSubclass: " + tempUsbDevice.getDeviceSubclass());
    
72.             if (DEBUG) Log.d(TAG, "InterfaceCount: " + tempUsbDevice.getInterfaceCount());
    
73.             if (DEBUG) Log.d(TAG, "DeviceProtocol: " + tempUsbDevice.getDeviceProtocol());
    
74. 
    
75.             if (tempUsbDevice.getVendorId() == ARDUINO_USB_VENDOR_ID) {
    
76.                 if (DEBUG) Log.i(TAG, "Arduino device found!");
    
77. 
    
78.                 switch (tempUsbDevice.getProductId()) {
    
79.                 case ARDUINO_UNO_USB_PRODUCT_ID:
    
80.                     Toast.makeText(getBaseContext(), "Arduino Uno " + getString(R.string.found), Toast.LENGTH_SHORT).show();
    
81.                     usbDevice = tempUsbDevice;
    
82.                     break;
    
83.                 case ARDUINO_MEGA_2560_USB_PRODUCT_ID:
    
84.                     Toast.makeText(getBaseContext(), "Arduino Mega 2560 " + getString(R.string.found), Toast.LENGTH_SHORT).show();
    
85.                     usbDevice = tempUsbDevice;
    
86.                     break;
    
87.                 case ARDUINO_MEGA_2560_R3_USB_PRODUCT_ID:
    
88.                     Toast.makeText(getBaseContext(), "Arduino Mega 2560 R3 " + getString(R.string.found), Toast.LENGTH_SHORT).show();
    
89.                     usbDevice = tempUsbDevice;
    
90.                     break;
    
91.                 case ARDUINO_UNO_R3_USB_PRODUCT_ID:
    
92.                     Toast.makeText(getBaseContext(), "Arduino Uno R3 " + getString(R.string.found), Toast.LENGTH_SHORT).show();
    
93.                     usbDevice = tempUsbDevice;
    
94.                     break;
    
95.                 }
    
96.             }
    
97.         }
    
98. 
    
99.         if (usbDevice == null) {
    
100.             if (DEBUG) Log.i(TAG, "No device found!");
     
101.             Toast.makeText(getBaseContext(), getString(R.string.no_device_found), Toast.LENGTH_LONG).show();
     
102.         } else {
     
103.             if (DEBUG) Log.i(TAG, "Device found!");
     
104.             Intent startIntent = new Intent(getApplicationContext(), ArduinoCommunicatorService.class);
     
105.             PendingIntent pendingIntent = PendingIntent.getService(getApplicationContext(), 0, startIntent, 0);
     
106.             usbManager.requestPermission(usbDevice, pendingIntent);
     
107.         }
     
108.     }
     
109. 
     
110.     @Override
     
111.     public void onCreate(Bundle savedInstanceState) {
     
112.         super.onCreate(savedInstanceState);
     
113.         if (DEBUG) Log.d(TAG, "onCreate()");
     
114. 
     
115.         IntentFilter filter = new IntentFilter();
     
116.         filter.addAction(ArduinoCommunicatorService.DATA_RECEIVED_INTENT);
     
117.         filter.addAction(ArduinoCommunicatorService.DATA_SENT_INTERNAL_INTENT);
     
118.         registerReceiver(mReceiver, filter);
     
119. 
     
120.         mDataAdapter = new ArrayAdapter<ByteArray>(this, android.R.layout.simple_list_item_1, mTransferedDataList);
     
121.         setListAdapter(mDataAdapter);
     
122. 
     
123.         findDevice();
     
124.     }
     
125. 
     
126.     @Override
     
127.     protected void onListItemClick(ListView l, View v, int position, long id) {
     
128.         super.onListItemClick(l, v, position, id);
     
129. 
     
130.         if (DEBUG) Log.i(TAG, "onListItemClick() " + position + " " + id);
     
131.         ByteArray transferedData = mTransferedDataList.get(position);
     
132.         transferedData.toggleCoding();
     
133.         mTransferedDataList.set(position, transferedData);
     
134.         mDataAdapter.notifyDataSetChanged();
     
135.     }
     
136. 
     
137.     @Override
     
138.     protected void onNewIntent(Intent intent) {
     
139.         if (DEBUG) Log.d(TAG, "onNewIntent() " + intent);
     
140.         super.onNewIntent(intent);
     
141. 
     
142.         if (UsbManager.ACTION_USB_DEVICE_ATTACHED.contains(intent.getAction())) {
     
143.             if (DEBUG) Log.d(TAG, "onNewIntent() " + intent);
     
144.             findDevice();
     
145.         }
     
146.     }
     
147. 
     
148.     @Override
     
149.     protected void onDestroy() {
     
150.         if (DEBUG) Log.d(TAG, "onDestroy()");
     
151.         super.onDestroy();
     
152.         unregisterReceiver(mReceiver);
     
153.     }
     
154. 
     
155.     @Override
     
156.     public boolean onCreateOptionsMenu(Menu menu) {
     
157.         getMenuInflater().inflate(R.menu.options, menu);
     
158.         return true;
     
159.     }
     
160. 
     
161.     @Override
     
162.     public boolean onOptionsItemSelected(MenuItem item) {
     
163.         switch (item.getItemId()) {
     
164.         case R.id.help:
     
165.             startActivity(new Intent(this, Help.class));
     
166.             return true;
     
167.         default:
     
168.             return super.onOptionsItemSelected(item);
     
169.         }
     
170.     }
     
171. 
     
172.     BroadcastReceiver mReceiver = new BroadcastReceiver() {
     
173. 
     
174.         private void handleTransferedData(Intent intent, boolean receiving) {
     
175.             if (mIsReceiving == null || mIsReceiving != receiving) {
     
176.                 mIsReceiving = receiving;
     
177.                 mTransferedDataList.add(new ByteArray());
     
178.             }
     
179. 
     
180.             final byte[] newTransferedData = intent.getByteArrayExtra(ArduinoCommunicatorService.DATA_EXTRA);
     
181.             if (DEBUG) Log.i(TAG, "data: " + newTransferedData.length + " "" + new String(newTransferedData) + """);
     
182. 
     
183.             ByteArray transferedData = mTransferedDataList.get(mTransferedDataList.size() - 1);
     
184.             transferedData.add(newTransferedData);
     
185.             mTransferedDataList.set(mTransferedDataList.size() - 1, transferedData);
     
186.             mDataAdapter.notifyDataSetChanged();
     
187.         }
     
188. 
     
189.         @Override
     
190.         public void onReceive(Context context, Intent intent) {
     
191.             final String action = intent.getAction();
     
192.             if (DEBUG) Log.d(TAG, "onReceive() " + action);
     
193. 
     
194.             if (ArduinoCommunicatorService.DATA_RECEIVED_INTENT.equals(action)) {
     
195.                 handleTransferedData(intent, true);
     
196.             } else if (ArduinoCommunicatorService.DATA_SENT_INTERNAL_INTENT.equals(action)) {
     
197.                 handleTransferedData(intent, false);
     
198.             }
     
199.         }
     
200.     };
     
201. }
     

复制代码

1. /*
   
2. * Copyright (C) 2012 Mathias Jeppsson
   
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. *      [url]http://www.apache.org/licenses/LICENSE-2.0[/url]
   
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. */
    
16. 
    
17. package com.primavera.arduino.listener;
    
18. 
    
19. import android.app.Service;
    
20. import android.content.BroadcastReceiver;
    
21. import android.content.Context;
    
22. import android.content.Intent;
    
23. import android.content.IntentFilter;
    
24. import android.hardware.usb.UsbConstants;
    
25. import android.hardware.usb.UsbDevice;
    
26. import android.hardware.usb.UsbDeviceConnection;
    
27. import android.hardware.usb.UsbEndpoint;
    
28. import android.hardware.usb.UsbInterface;
    
29. import android.hardware.usb.UsbManager;
    
30. import android.os.Handler;
    
31. import android.os.IBinder;
    
32. import android.os.Looper;
    
33. import android.os.Message;
    
34. import android.util.Log;
    
35. import android.widget.Toast;
    
36. 
    
37. public class ArduinoCommunicatorService extends Service {
    
38. 
    
39.     private final static String TAG = "ArduinoCommunicatorService";
    
40.     private final static boolean DEBUG = false;
    
41. 
    
42.     private boolean mIsRunning = false;
    
43.     private SenderThread mSenderThread;
    
44. 
    
45.     private volatile UsbDevice mUsbDevice = null;
    
46.     private volatile UsbDeviceConnection mUsbConnection = null;
    
47.     private volatile UsbEndpoint mInUsbEndpoint = null;
    
48.     private volatile UsbEndpoint mOutUsbEndpoint = null;
    
49. 
    
50.     final static String DATA_RECEIVED_INTENT = "primavera.arduino.intent.action.DATA_RECEIVED";
    
51.     final static String SEND_DATA_INTENT = "primavera.arduino.intent.action.SEND_DATA";
    
52.     final static String DATA_SENT_INTERNAL_INTENT = "primavera.arduino.internal.intent.action.DATA_SENT";
    
53.     final static String DATA_EXTRA = "primavera.arduino.intent.extra.DATA";
    
54. 
    
55.     @Override
    
56.     public IBinder onBind(Intent arg0) {
    
57.         return null;
    
58.     }
    
59. 
    
60.     @Override
    
61.     public void onCreate() {
    
62.         if (DEBUG) Log.d(TAG, "onCreate()");
    
63.         super.onCreate();
    
64.         IntentFilter filter = new IntentFilter();
    
65.         filter.addAction(SEND_DATA_INTENT);
    
66.         filter.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED);
    
67.         registerReceiver(mReceiver, filter);
    
68.     }
    
69. 
    
70.     @Override
    
71.     public int onStartCommand(Intent intent, int flags, int startId) {
    
72.         if (DEBUG) Log.d(TAG, "onStartCommand() " + intent + " " + flags + " " + startId);
    
73. 
    
74.         if (mIsRunning) {
    
75.             if (DEBUG) Log.i(TAG, "Service already running.");
    
76.             return Service.START_REDELIVER_INTENT;
    
77.         }
    
78. 
    
79.         mIsRunning = true;
    
80. 
    
81.         if (!intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
    
82.             if (DEBUG) Log.i(TAG, "Permission denied");
    
83.             Toast.makeText(getBaseContext(), getString(R.string.permission_denied), Toast.LENGTH_LONG).show();
    
84.             stopSelf();
    
85.             return Service.START_REDELIVER_INTENT;
    
86.         }
    
87. 
    
88.         if (DEBUG) Log.d(TAG, "Permission granted");
    
89.         mUsbDevice = (UsbDevice) intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
    
90.         if (!initDevice()) {
    
91.             if (DEBUG) Log.e(TAG, "Init of device failed!");
    
92.             stopSelf();
    
93.             return Service.START_REDELIVER_INTENT;
    
94.         }
    
95. 
    
96.         if (DEBUG) Log.i(TAG, "Receiving!");
    
97.         Toast.makeText(getBaseContext(), getString(R.string.receiving), Toast.LENGTH_SHORT).show();
    
98.         startReceiverThread();
    
99.         startSenderThread();
    
100. 
     
101.         return Service.START_REDELIVER_INTENT;
     
102.     }
     
103. 
     
104.     @Override
     
105.     public void onDestroy() {
     
106.         if (DEBUG) Log.i(TAG, "onDestroy()");
     
107.         super.onDestroy();
     
108.         unregisterReceiver(mReceiver);
     
109.         mUsbDevice = null;
     
110.         if (mUsbConnection != null) {
     
111.             mUsbConnection.close();
     
112.         }
     
113.     }
     
114. 
     
115.     private byte[] getLineEncoding(int baudRate) {
     
116.         final byte[] lineEncodingRequest = { (byte) 0x80, 0x25, 0x00, 0x00, 0x00, 0x00, 0x08 };
     
117.         switch (baudRate) {
     
118.         case 14400:
     
119.             lineEncodingRequest[0] = 0x40;
     
120.             lineEncodingRequest[1] = 0x38;
     
121.             break;
     
122. 
     
123.         case 19200:
     
124.             lineEncodingRequest[0] = 0x00;
     
125.             lineEncodingRequest[1] = 0x4B;
     
126.             break;
     
127.         }
     
128. 
     
129.         return lineEncodingRequest;
     
130.     }
     
131. 
     
132.     private boolean initDevice() {
     
133.         UsbManager usbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
     
134.         mUsbConnection = usbManager.openDevice(mUsbDevice);
     
135.         if (mUsbConnection == null) {
     
136.             if (DEBUG) Log.e(TAG, "Opening USB device failed!");
     
137.             Toast.makeText(getBaseContext(), getString(R.string.opening_device_failed), Toast.LENGTH_LONG).show();
     
138.             return false;
     
139.         }
     
140.         UsbInterface usbInterface = mUsbDevice.getInterface(1);
     
141.         if (!mUsbConnection.claimInterface(usbInterface, true)) {
     
142.             if (DEBUG) Log.e(TAG, "Claiming interface failed!");
     
143.             Toast.makeText(getBaseContext(), getString(R.string.claimning_interface_failed), Toast.LENGTH_LONG).show();
     
144.             mUsbConnection.close();
     
145.             return false;
     
146.         }
     
147. 
     
148.         // Arduino USB serial converter setup
     
149.         // Set control line state
     
150.         mUsbConnection.controlTransfer(0x21, 0x22, 0, 0, null, 0, 0);
     
151.         // Set line encoding.
     
152.         mUsbConnection.controlTransfer(0x21, 0x20, 0, 0, getLineEncoding(9600), 7, 0);
     
153. 
     
154.         for (int i = 0; i < usbInterface.getEndpointCount(); i++) {
     
155.             if (usbInterface.getEndpoint(i).getType() == UsbConstants.USB_ENDPOINT_XFER_BULK) {
     
156.                 if (usbInterface.getEndpoint(i).getDirection() == UsbConstants.USB_DIR_IN) {
     
157.                     mInUsbEndpoint = usbInterface.getEndpoint(i);
     
158.                 } else if (usbInterface.getEndpoint(i).getDirection() == UsbConstants.USB_DIR_OUT) {
     
159.                     mOutUsbEndpoint = usbInterface.getEndpoint(i);
     
160.                 }
     
161.             }
     
162.         }
     
163. 
     
164.         if (mInUsbEndpoint == null) {
     
165.             if (DEBUG) Log.e(TAG, "No in endpoint found!");
     
166.             Toast.makeText(getBaseContext(), getString(R.string.no_in_endpoint_found), Toast.LENGTH_LONG).show();
     
167.             mUsbConnection.close();
     
168.             return false;
     
169.         }
     
170. 
     
171.         if (mOutUsbEndpoint == null) {
     
172.             if (DEBUG) Log.e(TAG, "No out endpoint found!");
     
173.             Toast.makeText(getBaseContext(), getString(R.string.no_out_endpoint_found), Toast.LENGTH_LONG).show();
     
174.             mUsbConnection.close();
     
175.             return false;
     
176.         }
     
177. 
     
178.         return true;
     
179.     }
     
180. 
     
181.     BroadcastReceiver mReceiver = new BroadcastReceiver() {
     
182.         @Override
     
183.         public void onReceive(Context context, Intent intent) {
     
184.             final String action = intent.getAction();
     
185.             if (DEBUG) Log.d(TAG, "onReceive() " + action);
     
186. 
     
187.             if (SEND_DATA_INTENT.equals(action)) {
     
188.                 final byte[] dataToSend = intent.getByteArrayExtra(DATA_EXTRA);
     
189.                 if (dataToSend == null) {
     
190.                     if (DEBUG) Log.i(TAG, "No " + DATA_EXTRA + " extra in intent!");
     
191.                     String text = String.format(getResources().getString(R.string.no_extra_in_intent), DATA_EXTRA);
     
192.                     Toast.makeText(context, text, Toast.LENGTH_LONG).show();
     
193.                     return;
     
194.                 }
     
195. 
     
196.                 mSenderThread.mHandler.obtainMessage(10, dataToSend).sendToTarget();
     
197.             } else if (UsbManager.ACTION_USB_DEVICE_DETACHED.equals(action)) {
     
198.                 Toast.makeText(context, getString(R.string.device_detaches), Toast.LENGTH_LONG).show();
     
199.                 mSenderThread.mHandler.sendEmptyMessage(11);
     
200.                 stopSelf();
     
201.             }
     
202.         }
     
203.     };
     
204. 
     
205.     private void startReceiverThread() {
     
206.         new Thread("arduino_receiver") {
     
207.             public void run() {
     
208.                 byte[] inBuffer = new byte[4096];
     
209.                 while(mUsbDevice != null ) {
     
210.                     if (DEBUG) Log.d(TAG, "calling bulkTransfer() in");
     
211.                     final int len = mUsbConnection.bulkTransfer(mInUsbEndpoint, inBuffer, inBuffer.length, 0);
     
212.                     if (len > 0) {
     
213.                         Intent intent = new Intent(DATA_RECEIVED_INTENT);
     
214.                         byte[] buffer = new byte[len];
     
215.                         System.arraycopy(inBuffer, 0, buffer, 0, len);
     
216.                         intent.putExtra(DATA_EXTRA, buffer);
     
217.                         sendBroadcast(intent);
     
218.                     } else {
     
219.                         if (DEBUG) Log.i(TAG, "zero data read!");
     
220.                     }
     
221.                 }
     
222. 
     
223.                 if (DEBUG) Log.d(TAG, "receiver thread stopped.");
     
224.             }
     
225.         }.start();
     
226.     }
     
227. 
     
228.     private void startSenderThread() {
     
229.         mSenderThread = new SenderThread("arduino_sender");
     
230.         mSenderThread.start();
     
231.     }
     
232. 
     
233.     private class SenderThread extends Thread {
     
234.         public Handler mHandler;
     
235. 
     
236.         public SenderThread(String string) {
     
237.             super(string);
     
238.         }
     
239. 
     
240.         public void run() {
     
241. 
     
242.             Looper.prepare();
     
243. 
     
244.             mHandler = new Handler() {
     
245.                 public void handleMessage(Message msg) {
     
246.                     if (DEBUG) Log.i(TAG, "handleMessage() " + msg.what);
     
247.                     if (msg.what == 10) {
     
248.                         final byte[] dataToSend = (byte[]) msg.obj;
     
249. 
     
250.                         if (DEBUG) Log.d(TAG, "calling bulkTransfer() out");
     
251.                         final int len = mUsbConnection.bulkTransfer(mOutUsbEndpoint, dataToSend, dataToSend.length, 0);
     
252.                         if (DEBUG) Log.d(TAG, len + " of " + dataToSend.length + " sent.");
     
253.                         Intent sendIntent = new Intent(DATA_SENT_INTERNAL_INTENT);
     
254.                         sendIntent.putExtra(DATA_EXTRA, dataToSend);
     
255.                         sendBroadcast(sendIntent);
     
256.                     } else if (msg.what == 11) {
     
257.                         Looper.myLooper().quit();
     
258.                     }
     
259.                 }
     
260.             };
     
261. 
     
262.             Looper.loop();
     
263.             if (DEBUG) Log.i(TAG, "sender thread stopped");
     
264.         }
     
265.     }
     
266. }
     

复制代码

东爱之都

小辣椒。。。

沧海笑1122

OTG线，请问对安卓手机有限制吗？版本、型号等。。。被ADK弄怕了

heiketiguo

2.3版的手机怕刷机有风险。对此只能羡慕！

darkorigin

其实可以集思广益，如果OTG支持（ARDUINO这类模块应该是被USB转COM口的），那么用蓝牙模块+arduino 应该也可以被安卓支持吧？毕竟蓝牙也会虚拟出一个COM口貌似。
哇卡卡 ，楼主 你打开了一个巨大的宝藏啊，我等有福了，不需要安卓4了

totson

好文章啊 谢谢楼主

hi.t

能用手机编译、下载，那就好了

AdmiralSoft

能够支持OTG的手机实在太少了，大多数手机应该是取不到电。若可行请给出手机型号版本或刷机办法。

AdmiralSoft

gaoshine 发表于 2012-10-24 18:12
以前安卓手机和arduino通过蓝牙通讯，现在看来可以直接用OTG USB线通讯了，赞一个！

贴2段 andriod的代 ...

要是使用OTG连接是不是需要在手机上安装驱动啊？！

gaoshine

AdmiralSoft 发表于 2012-10-25 06:39
要是使用OTG连接是不是需要在手机上安装驱动啊？！

理论上不用，OTG其实就是相当于让手机拥有电脑一样的USB口，可以接键盘、鼠标等等
安卓底层还是linux的，就如同arduino uno 接入 linux无需驱动一样，手机应该也不需要驱动（树莓派就是个例子啊）

darkorigin

蓝牙确实很早就有，但是你这个软件可以直接用安卓手机直接连接ARDUINO板。进行通讯和改数据成为可能。（甚至可能直接进行编程，因为LINUX内核的安卓手机貌似应该能支持LINUX版的ARDUINO编辑器。。。太强大了）