我试图在我的Android手机（目标4.3）上显示从传输arduino类型设备接收的传感器数据 . 传输通过蓝牙进行 . 我能够连接到arduino类型的设备，甚至共享数据，但由于某种原因我有同步问题 .

现在设置arduino的方式，在成功连接之后它等待从我的电话接收一个字节（无符号字节值255），当它接收到该字节时，它通过发送包含来自三个信息的数据包（3个字节）来响应不同的传感器即

packet:
byte 1: temperature data
byte 2: cadence data
byte 3: speed data

我所要做的就是重复显示这些数据（现场更新），直到用户终止Android手机上的连接 .

这是我的代码，我觉得我在逻辑中的某处发生了一个小错误 .

MessageHandler

Handler mHandler = new Handler(){           
            public void handleMessage(Message msg){
                super.handleMessage(msg);
                switch(msg.what){
                    case SUCCESS_CONNECT:
                        // Do Something;
                        ConnectedThread connectedThread = new ConnectedThread((BluetoothSocket)msg.obj);
                        Toast.makeText(getActivity(),"CONNECTED",Toast.LENGTH_SHORT).show();
                        /*
                         * Could send test string here
                         */
                        /*
                         * String connect_string = "test";
                         * connectedThread.write(connect_string.getBytes());
                         */
                        connectedThread.start();
                        break;
                    case MESSAGE_READ:
                        byte[] readBuf = (byte[])msg.obj;
                        int tempInt = byteToInt(readBuf[0]);
                        int cadenceInt = byteToInt(readBuf[1]);
                        int speedInt = byteToInt(readBuf[2]);
                        EditText temperatureData = (EditText)getActivity().findViewById(R.id.temperatureData);
                        temperatureData.setText(Integer.toString(tempInt));
                        EditText cadenceData = (EditText)getActivity().findViewById(R.id.cadence);
                        cadenceData.setText(Integer.toString(cadenceInt));
                        EditText speedData = (EditText)getActivity().findViewById(R.id.speed_data);
                        speedData.setText(Integer.toString(speedInt));

                }
            }       
        };

ConnectThread

public class ConnectThread extends Thread {
    private final BluetoothSocket mmSocket;
    private final BluetoothDevice mmDevice;
    public ConnectThread(BluetoothDevice device) {

        /*
         *  Use a temporary object that is later assigned to mmSocket,
         *  because mmSocket is final                
         */

        BluetoothSocket tmp = null;

        mmDevice = device;

        // Get a BluetoothSocket to connect with the given BluetoothDevice
        try {
            // MY_UUID is the app's UUID string, also used by the server code
            tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
        } catch (IOException e) { }
        mmSocket = tmp;
    }

    public void run() {
        // Cancel discovery because it will slow down the connection
        mBluetoothAdapter.cancelDiscovery();

        try {
        // Connect the device through the socket. This will block
            // until it succeeds or throws an exception
            mmSocket.connect();
        } catch (IOException connectException) {
            // Unable to connect; close the socket and get out
            try {
                mmSocket.close();
            } catch (IOException closeException) {
                Toast.makeText(getActivity(), "Connecting to device failed!", Toast.LENGTH_LONG).show();
            }
                return;
        }

            // Do work to manage the connection (in a separate thread)
            mHandler.obtainMessage(SUCCESS_CONNECT, mmSocket).sendToTarget();
    }

    /** Will cancel an in-progress connection, and close the socket */
    public void cancel() {
        try {
            mmSocket.close();
           } catch (IOException e) { }
    }

}

ConnectedThread

private class ConnectedThread extends Thread {
    private final BluetoothSocket mmSocket;
    private final InputStream mmInStream;
    private final OutputStream mmOutStream;

    public ConnectedThread(BluetoothSocket socket) {
        mmSocket = socket;
        InputStream tmpIn = null;
        OutputStream tmpOut = null;

        // Get the input and output streams, using temp objects because
        // member streams are final
        try {
            tmpIn = socket.getInputStream();
            tmpOut = socket.getOutputStream();
        } catch (IOException e) { }

        mmInStream = tmpIn;
        mmOutStream = tmpOut;
    }

    public void run() {
        byte[] buffer; // buffer store for the stream
        int bytes; // bytes returned from read()
        // Keep listening to the InputStream until an exception occurs
        while (true) {
            try {
                // Read from the InputStream
                buffer = new byte[3];
                byte maxByte = (byte) 1;
                mmOutStream.write(255);
                bytes = mmInStream.read(buffer,0,buffer.length);
                // Send the obtained bytes to the message handler

                mHandler.obtainMessage(MESSAGE_READ,buffer).sendToTarget();
                }
             catch (IOException e) {
                 break;
             }
        }
     }

    /* Call this from the main activity to send data to the remote device */
    public void write(byte[] bytes) {
        try {
            mmOutStream.write(bytes);
        } catch (IOException e) { }
    }
}

Byte To Int方法

public static int byteToInt(byte b){
    int value;
    value = b & 0xFF;
    return  value;
}

我收到的数据正在显示但通常最终错误，主要是因为字节数组序列关闭导致显示错误的值 . 我一直试图弄清楚这一点，任何输入都会有所帮助 .