我有一个自制的蓝牙设备，测量500Hz的心电图：设备每2 ms发送9个字节的数据（标头，ECG测量，页脚）。所以这大约是9 * 500 = 4.5kbytes / s的数据流。
我有一个C ++ Windows程序能够连接设备并检索数据流（用Qt / qwt显示）。在这种情况下，我使用Windows控制面板来绑定设备，然后使用boost serial_port接口通过虚拟COM端口连接它。这非常有效，而且我实时接收数据流：我每隔2ms就得到一个测量点。
我通过QtCreator（Qt 5.3.2）在Android上移植了整个C ++程序。我有实时问题。数据流在前5秒内是“实时”的，然后性能会急剧下降（见How to do good real-time data streaming using Java Android SDK）。
因为我认为这个问题可能是由于C ++ / Qt，我用Eclipse编写了一个完全空白的纯Java / Android项目。它有同样的问题!!!
问题是：这段代码有问题吗？为什么我只在5秒内实时接收数据？在Android平台上使用5秒强化BT之后会发生什么？为什么它会减慢BT数据的接收速度？
这是我的Java程序：
BluetoothHelper.java（具有连接/断开/读取和写入数据的功能：
package com.example.helloworld;
import android.util.Log;
import android.content.Context;
import android.os.Bundle;
import java.util.Locale;
import java.util.concurrent.Semaphore;
import java.lang.String;
import java.lang.Thread;
import java.io.IOException;
import java.io.OutputStream;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.lang.InterruptedException;
import android.app.Activity;
import android.app.AlertDialog;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
import android.bluetooth.BluetoothManager;
import android.util.SparseArray;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.BroadcastReceiver;
import java.util.UUID;
import java.util.Date;
import java.util.Calendar;
import java.util.Vector;
import java.util.Set;
import java.util.Arrays;
public class BluetoothHelper
{
private BluetoothManager mBluetoothManager;
private BluetoothAdapter mBluetoothAdapter;
private BluetoothDevice mDevice;
private BluetoothSocket mSocket;
private OutputStream mOutputStream;
private InputStream mInputStream;
private BroadcastReceiver mReceiver;
private Activity myActivity;
private Vector<BluetoothDevice> mDevices;
private byte[] mHeader;
private byte[] mFrame;
public BluetoothHelper(Activity a)
{
myActivity = a;
mHeader = new byte[3];
mFrame = new byte[256];
mDevices = new Vector();
}
/* Check bluetooth is enabled, return "" if OK, else, return error string */
public String initializeBluetooth(){
String error = "";
System.out.println("Initializing bluetooth...");
mBluetoothManager = (BluetoothManager) myActivity.getSystemService(Context.BLUETOOTH_SERVICE);
if ( mBluetoothManager == null )
{
error = "Bluetooth manager is not found";
}
else
{
mBluetoothAdapter = mBluetoothManager.getAdapter();
if( mBluetoothAdapter == null )
{
error = "Bluetooth adapter is not found";
}
else if( ! mBluetoothAdapter.isEnabled() )
{
error = "Bluetooth adapter is off";
}
else
{
System.out.println("Bluetooth successfully initialized");
return "";
}
}
return error;
}
private void addDevice( final BluetoothDevice device )
{
mDevices.add(device);
}
public Vector<BluetoothDevice> getDevices() { return mDevices; }
/* Clear previously detected device list */
public boolean clearDeviceList(){
// Clear old list
mDevices.clear();
return true;
}
/* Fill local device list with paired devices */
public boolean addPairedDevices(){
//System.out.println("Entering addPairedDevices");
if( mBluetoothAdapter == null )
{
System.out.println("No bluetooth adapter");
return false;
}
Set<BluetoothDevice> pairedDevices = mBluetoothAdapter.getBondedDevices();
// If there are paired devices
if (pairedDevices.size() > 0)
{
//System.out.println("Found paired devices");
// Loop through paired devices
for (BluetoothDevice device : pairedDevices)
{
addDevice( device );
}
}
return true;
}
public String connectToDevice(final BluetoothDevice device)
{
if ( mDevice != null )
disconnectDevice();
if( mBluetoothAdapter == null || myActivity == null )
return "System not initialized or bluetooth not active";
if ( device.getBondState() != BluetoothDevice.BOND_BONDED )
{
// TODO: find a way to do a synchronized bounding operation
return "Device is not bonded";
}
final boolean[] the_result = new boolean[1];
the_result[0] = false;
final Semaphore mutex = new Semaphore(0);
Runnable connectRunnable = new Runnable() {
@Override
public void run() {
UUID MY_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");
try
{
mSocket = device.createInsecureRfcommSocketToServiceRecord( MY_UUID );
System.out.println("Created RFcomm socket");
mSocket.connect();
if ( mSocket.isConnected() )
{
System.out.println("Connected RFcomm socket");
mOutputStream = mSocket.getOutputStream();
mInputStream = mSocket.getInputStream();
System.out.println("Retrieved output stream");
the_result[0] = true;
}
else
{
System.out.println("Failed to connect RFcomm socket");
}
}
catch (IOException e)
{
System.out.println("Failed to open RFcomm socket (createRfcommSocketToServiceRecord)");
System.out.println(e.toString());
}
mutex.release();
}
};
myActivity.runOnUiThread( connectRunnable );
// waiting for thread to be completed...
try {
mutex.acquire();
} catch (InterruptedException e) {
e.printStackTrace();
}
if ( the_result[0] )
{
System.out.println("Connection succeeded");
return "";
}
else
{
System.out.println("Connection failed");
return "Failed to connect device";
}
}
/* Request to disconnect the device */
public boolean disconnectDevice(){
System.out.println("Disconnecting device...");
if ( mSocket != null )
{
// block read/write
mOutputStream = null;
mInputStream = null;
try
{
mSocket.close();
}
catch( IOException e )
{
e.printStackTrace();
return false;
}
mSocket = null;
}
mDevice = null;
return true;
}
/* Send bytes to the connected device */
public boolean writeData( byte[] buffer )
{
if( mOutputStream == null )
{
System.out.println("No connection, can't send data");
}
else
{
try
{
mOutputStream.write( buffer );
return true;
}
catch (IOException e)
{
System.out.println( "Failed to send data" );
e.printStackTrace();
}
}
return false;
}
public static String byteArrayToHex(byte[] a, int size) {
StringBuilder sb = new StringBuilder(size * 5);
for( int i = 0; i != size; ++i )
sb.append(String.format("0x%02x ", a[i] & 0xff));
return sb.toString();
}
public int getBytesPending()
{
try
{
return mInputStream.available();
}
catch (IOException e)
{
return 0;
}
}
/* Non blocking read function. Read bytes from the connected device.
* Return number of bytes read
* return 0 if not enough bytes available
* return -1 in case of error
*/
public int readData( byte[] buffer, int size, boolean blocking )
{
if ( mInputStream == null )
{
System.out.println("No connection, can't receive data");
}
else
{
try
{
final boolean verbose = false;
if ( blocking )
{
if ( verbose )
System.out.println( "Blocking request of " + buffer.length + " byte(s)" );
int res = 0;
int temp = 0;
while ( true )
{
temp = mInputStream.read( buffer, res, size - res );
res += temp;
if ( res >= size )
{
break;
}
else
{
if ( verbose )
System.out.println( "Received " + res + " byte(s) to far : " + byteArrayToHex(buffer,size) );
}
try {
Thread.sleep(10);
} catch(InterruptedException ex) {
}
}
if ( verbose )
System.out.println( "Received " + res + " byte(s) : " + byteArrayToHex(buffer,size) );
return res;
}
else
{
int available = mInputStream.available();
if ( verbose && available != 0 )
{
Calendar c = Calendar.getInstance();
Date date = new Date();
c.setTime(date);
c.get(Calendar.MILLISECOND);
SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
String currentTime = sdf.format(date);
System.out.println( currentTime + ":" + c.get(Calendar.MILLISECOND) + " - " + available + " bytes available, requested " + buffer.length );
}
if ( available >= size )
{
int res = mInputStream.read( buffer, 0, size ); // only call read if we know it's not blocking
if ( verbose )
System.out.println( "Received " + res + " byte(s) : " + byteArrayToHex(buffer,size) );
return res;
}
else
{
return 0;
}
}
}
catch (IOException e)
{
System.out.println( "Failed to read data...disconnected?" );
//e.printStackTrace();
}
}
return -1;
}
public byte[] readNextFrame( boolean blocking )
{
if ( readData( mHeader, mHeader.length, blocking ) == mHeader.length )
{
int size = mHeader[2];
if ( size < 0 )
size = -size;
if ( readData( mFrame, size, blocking ) == size )
{
byte[] res = new byte[mHeader.length + size];
System.arraycopy(mHeader, 0, res, 0, mHeader.length);
System.arraycopy(mFrame, 0, res, mHeader.length, size);
return res;
}
}
return null;
}
*/ read frame but without allocating any memory, does not retur condumed bytes */
public boolean eatNextFrame( boolean blocking )
{
if ( readData( mHeader, mHeader.length, blocking ) == mHeader.length )
{
int size = mHeader[2];
if ( size < 0 )
size = -size;
if ( readData( mFrame, size, blocking ) == size )
{
return true;
}
}
return false;
}
public boolean startECG()
{
// some code sending instructions to configure my device
}
}
主Java文件，连接并执行10秒采集：
// Here is the code for Medoc:
BluetoothHelper helper = new BluetoothHelper(this);
String error = helper.initializeBluetooth();
if ( error.isEmpty() )
{
if ( helper.addPairedDevices( ) )
{
if ( !helper.getDevices().isEmpty() )
{
if ( helper.getDevices().size() == 1 )
{
BluetoothDevice device = helper.getDevices().firstElement();
error = helper.connectToDevice( device );
if ( error.isEmpty() )
{
if ( helper.startECG() )
{
// acquiere data for 10 seconds
Date start = new Date();
Date end = new Date();
Date empty = null;
int lastMinute = 0;
int maxBufferSize = 0;
boolean receivedData = false;
while ( end.getTime() - start.getTime() < 10 * 1000 )
{
int currentMinute = (int) (( end.getTime() - start.getTime() ) / 1000);
if ( currentMinute != lastMinute )
{
if ( receivedData )
System.out.println( "During second #" + lastMinute + " max buffer size was : " + maxBufferSize );
else
System.out.println( "During second #" + lastMinute + " no data was received!" );
maxBufferSize = 0;
receivedData = false;
lastMinute = currentMinute;
}
if ( helper.eatNextFrame(false) )
{
receivedData = true;
}
if ( helper.getBytesPending() == 0 )
{
if ( empty == null )
{
empty = new Date();
}
}
else
{
if ( empty != null )
{
Date now = new Date();
int elapsed = (int) ( now.getTime() - empty.getTime() );
if ( elapsed > 100 )
System.out.println( "No pending data, during " + elapsed + "ms" );
empty = null;
}
}
maxBufferSize = Math.max( helper.getBytesPending(), maxBufferSize );
end = new Date();
}
AlertDialog.Builder dlgAlert = new AlertDialog.Builder(this);
dlgAlert.setMessage( "Done" );
dlgAlert.setPositiveButton("Ok",null);
dlgAlert.create().show();
}
else
{
error = "Failed to start ECG";
}
helper.disconnectDevice();
}
}
else
{
error = "Too many devices found";
}
}
else
{
error = "No device found";
}
}
else
{
error = "Failed to scan for devices";
}
}
if ( !error.isEmpty() )
{
AlertDialog.Builder dlgAlert2 = new AlertDialog.Builder(this);
dlgAlert2.setMessage( error );
dlgAlert2.setPositiveButton("Ok",null);
dlgAlert2.create().show();
}
在这里，程序的输出：
12-01 14:12:51.755: I/System.out(15940): During second #0 max buffer size was : 63
12-01 14:12:52.755: I/System.out(15940): During second #1 max buffer size was : 133
12-01 14:12:53.755: I/System.out(15940): During second #2 max buffer size was : 66
12-01 14:12:54.755: I/System.out(15940): During second #3 max buffer size was : 61
12-01 14:12:55.755: I/System.out(15940): During second #4 max buffer size was : 129
12-01 14:12:56.705: I/System.out(15940): No pending data, during 501ms
12-01 14:12:56.755: I/System.out(15940): During second #5 max buffer size was : 939
12-01 14:12:57.755: I/System.out(15940): During second #6 max buffer size was : 980
12-01 14:12:58.755: I/System.out(15940): During second #7 max buffer size was : 1008
12-01 14:12:59.195: I/System.out(15940): No pending data, during 488ms
12-01 14:12:59.695: I/System.out(15940): No pending data, during 489ms
12-01 14:12:59.755: I/System.out(15940): During second #8 max buffer size was : 990
12-01 14:13:00.185: I/System.out(15940): No pending data, during 490ms
12-01 14:13:01.205: I/System.out(15940): Disconnecting device...
正如您所看到的，在5秒内，读取缓冲区保持较小的状态，并且缓冲区空的时间超过100毫秒（参见输出“无挂起数据”的代码）。然后，从第五秒开始我们：
在数据采集的第一个5秒之后，就像数据在某处被缓冲一样，并且可以通过~500ms的块在InputStream中读取数据.....
有时，甚至可能是最糟糕的，5秒后根本没有收到任何数据：
12-01 14:35:54.595: I/System.out(16386): During second #0 max buffer size was : 22
12-01 14:35:55.595: I/System.out(16386): During second #1 max buffer size was : 93
12-01 14:35:56.595: I/System.out(16386): During second #2 max buffer size was : 108
12-01 14:35:57.595: I/System.out(16386): During second #3 max buffer size was : 61
12-01 14:35:58.595: I/System.out(16386): During second #4 max buffer size was : 64
12-01 14:35:59.595: I/System.out(16386): During second #5 max buffer size was : 63
12-01 14:36:00.595: I/System.out(16386): During second #6 no data was received!
12-01 14:36:01.595: I/System.out(16386): During second #7 no data was received!
12-01 14:36:02.595: I/System.out(16386): During second #8 no data was received!
注意：在创建BluetoothHelper之前和调用startECG()之前，我试着睡了几秒钟。相同的行为（获取速度减慢或在5秒后停止）。
编辑：我正在体验：
但不适用于定制CyanogenMod 11 Android 4.4.2的Galaxy S3：数据流看起来很完美，5秒后没有冻结，数据实时到达......
编辑12月15日：
建议将读取移动到单独的线程：
制作BluetoothHelper工具Runnable并将这些方法/属性添加到类中：
private int mFramesReceived;
private long mLongestPause;
public void clearReceived()
{
mFramesReceived = 0;
mLongestPause = 0;
}
public int received()
{
return mFramesReceived;
}
public long longestPause()
{
return mLongestPause;
}
@Override
public void run() {
System.out.println( "Started thread" );
int lastSeconde = 0;
long currentTimeMillis = System.currentTimeMillis();
long started = System.currentTimeMillis();
// Keep listening to the InputStream until an exception occurs
while (true) {
if ( eatNextFrame( true ) )
{
//System.out.println( "Got some data" );
mLongestPause = Math.max( mLongestPause, System.currentTimeMillis() - currentTimeMillis );
currentTimeMillis = System.currentTimeMillis();
mFramesReceived++;
int currentSeconde = (int) (( System.currentTimeMillis() - started ) / 1000);
if ( currentSeconde != lastSeconde )
{
if ( mFramesReceived != 0 )
System.out.println( "During second #" + lastSeconde + " max pause was : " + mLongestPause );
else
System.out.println( "During second #" + lastSeconde + " no data was received!" );
clearReceived();
lastSeconde = currentSeconde;
}
}
else
{
System.out.println( "Failed to get some data, connection closed?" );
break;
}
}
}
然后将来电者更改为：
if ( helper.startECG() )
{
new Thread(helper).start();
try {
Thread.sleep(10000); // wait 10 seconds
} catch(InterruptedException ex) {
Thread.currentThread().interrupt();
}
AlertDialog.Builder dlgAlert = new AlertDialog.Builder(this);
dlgAlert.setMessage( "Done" );
dlgAlert.setPositiveButton("Ok",null);
dlgAlert.create().show();
}
else
{
error = "Failed to start ECG";
}
helper.disconnectDevice();
它没有解决问题，这是输出：
During second #0 max pause was : 48
During second #1 max pause was : 45
During second #2 max pause was : 33
During second #3 max pause was : 35
During second #4 max pause was : 58
During second #5 max pause was : 498
During second #6 max pause was : 477
During second #7 max pause was : 480
During second #8 max pause was : 986
During second #9 max pause was : 497
答案 0 :(得分：6)
此问题显然与报告here的问题类似。
5秒后，我连接丢失，实时流媒体播放速度急剧下降。
正如所说here Android＆gt; 4.3显然不喜欢单向通信超过5秒。所以我现在每1次借调就向设备发送一个虚拟命令（类型为＃34; keep-alive＆＃34;命令），现在Android很高兴，因为它不再是单向通信了......所以数据流在第五秒之后就比以前好了！
答案 1 :(得分：3)
在外围设备上同时使用线程概念读写字节。使用android蓝牙数据传输示例来解决问题。您正在使用普通的java类向另一个无效方法的设备发送和接收数据。您应该使用线程概念通过蓝牙发送和接收数据。
请参阅以下链接，通过蓝牙读取和写入数据。
http://developer.android.com/guide/topics/connectivity/bluetooth.html
答案 2 :(得分：1)
您不应该依赖InputStream.available()来告知流中可用的字节数（有关详细信息，请参阅https://developer.android.com/reference/java/io/InputStream.html#available()）。
由于您知道数据包的确切大小（9个字节），因此每次在缓冲区中读取9个字节：mInputStream.read(buffer, 0, 9)。
使用蓝牙很难保证实时二进制传输，因为延迟可能有很多原因（例如设备之间距离增加，障碍物等）。因此，通常最好不断调用read并将检索到的数据部分转发到处理组件。例如，在我的一个项目中，我实现了Android Service，等待来自蓝牙的数据包，并通过接收到的数据通知UI。您可以为此实施Service或AsyncTask。
另一个建议：避免在经常调用的方法中进行不必要的内存分配（例如readData）。您可以使用System.currentTimeMillis()来衡量已用时间。垃圾收集可能是您遇到性能下降的原因之一。