蓝牙通讯简单总结

本文为经典蓝牙通讯过程简单梳理。

1.实用工具

image.png

sscom可以调试收发数据。当蓝牙设备连接到PC端，确保相关驱动安装之后，PC能识别蓝牙设备，然后选择适当的波特率，一般是9600，选中端口号后打开串口，就可以发送数据了，也能显示接收的数据。
开发过程中，可以使用这个工具测试一些数据收发问题。

2.蓝牙通讯基本流程

参考这篇即可：
Android蓝牙串口通信
然后还有一些定位权限问题，socket异常处理，需要额外添加。
基本流程如下。

3.数据处理

蓝牙SPP的协议栈使用是rfcomm（串口仿真协议），通过一个虚拟串口通道和对方通信。

蓝牙协议栈

这里蓝牙设备与Android设备采用异步串行接口（UART）进行数据通信。UART是异步串口通信协议的一种，数据传输一般都是以字节传输的，一个字节8个位，将传输数据一位接一位地传输，要传一个字节就需要传8次。

3.1粘包和半包

粘包：
指数据在传输时，在一条消息中读取到了另一条消息的部分数据，这种现象就叫做粘包。
比如发送了两条消息，分别为“ABC”和“DEF”，那么正常情况下接收端也应该收到两条消息“ABC”和“DEF”，但接收端却收到的是“ABCD”，像这种情况就叫做粘包，如下图所示：

image.png
半包：
是指接收端只收到了部分数据，而非完整的数据的情况就叫做半包。比如发送了一条消息是“ABC”，而接收端却收到的是“AB”和“C”两条信息，这种情况就叫做半包，如下图所示：
image.png

产生原因
粘包的主要原因：

• 发送方每次写入数据 < 套接字(Socket)缓冲区大小
• 接收方读取套接字(Socket)缓冲区数据不够及时

半包的主要原因：

• 发送方每次写入数据 > 套接字(Socket)缓冲区大小
• 发送的数据大于协议的 MTU (Maximum Transmission Unit，最大传输单元)，因此必须拆包

其实我们可以换个角度看待问题：

• 从收发的角度看，便是一个发送可能被多次接收，多个发送可能被一次接收。
• 从传输的角度看，便是一个发送可能占用多个传输包，多个发送可能共用一个传输包。

根本原因，其实是TCP 是流式协议，消息无边界。
(PS ： UDP 虽然也可以一次传输多个包或者多次传输一个包，但每个消息都是有边界的，因此不会有粘包和半包问题。)

粘包和半包问题是数据传输中比较常见的问题。

它的解决方案有很多，比较常见的解决方案有：
设置固定的数据传输大小、自定义请求协议的封装，在请求头中加入传输数据的长度、使用特殊符号作为结束符等。

3.2 发送数据处理

为确保数据的完整性（减少错误），数据按照固定的帧格式进行传输。

3.2.1 CRC校验

验证CRC 计算的网站：http://www.ip33.com/crc.html
输入要传入的数据，然后选择参数模型即可，例如CRC-16/Modbus。

B与bit
数据存储是以“字节”（Byte）为单位，数据传输大多是以“位”（bit，又名“比特”）为单位，一个位就代表一个0或1（即二进制），每8个位（bit，简写为b）组成一个字节（Byte，简写为B），是最小一级的信息单位

image.png
image.png

java不论是负数还是正数在定义、存储、计算的过程中，都是用其补码

public static String getCRC(byte[] bytes) {
//        ModBus 通信协议的 CRC ( 冗余循环校验码含2个字节, 即 16 位二进制数。
//        CRC 码由发送设备计算, 放置于所发送信息帧的尾部。
//        接收信息设备再重新计算所接收信息 (除 CRC 之外的部分）的 CRC,
//        比较计算得到的 CRC 是否与接收到CRC相符, 如果两者不相符, 则认为数据出错。
//
//        1) 预置 1 个 16 位的寄存器为十六进制FFFF(即全为 1) , 称此寄存器为 CRC寄存器。
//        2) 把第一个 8 位二进制数据 (通信信息帧的第一个字节) 与 16 位的 CRC寄存器的低 8 位相异或, 把结果放于 CRC寄存器。
//        3) 把 CRC 寄存器的内容右移一位( 朝低位)用 0 填补最高位, 并检查右移后的移出位。
//        4) 如果移出位为 0, 重复第 3 步 ( 再次右移一位); 如果移出位为 1, CRC 寄存器与多项式A001 ( 1010 0000 0000 0001) 进行异或。
//        5) 重复步骤 3 和步骤 4, 直到右移 8 次,这样整个8位数据全部进行了处理。
//        6) 重复步骤 2 到步骤 5, 进行通信信息帧下一个字节的处理。
//        7) 将该通信信息帧所有字节按上述步骤计算完成后,得到的16位CRC寄存器的高、低字节进行交换。
//        8) 最后得到的 CRC寄存器内容即为 CRC码。

        int CRC = 0x0000ffff;
        int POLYNOMIAL = 0x0000a001;

        int i, j;
        for (i = 0; i < bytes.length; i++) {
            CRC ^= (int) bytes[i];
            for (j = 0; j < 8; j++) {
                if ((CRC & 0x00000001) == 1) {
                    CRC >>= 1;
                    CRC ^= POLYNOMIAL;
                } else {
                    CRC >>= 1;
                }
            }
        }
        //高低位转换，看情况使用（譬如本人这次对led彩屏的通讯开发就规定校验码高位在前低位在后，也就不需要转换高低位)
        //CRC = ( (CRC & 0x0000FF00) >> 8) | ( (CRC & 0x000000FF ) << 8);
        Log.d(TAG,"int CRC = " + CRC + " , string src = " + Integer.toHexString(CRC));

        return Integer.toHexString(CRC);
    }

如果协议要求16位CRC高8位在后，低8位在前，就需要使用高低位转换。

3.2.2 数据转换

串口传输接口底层是按位(bit)发送的，上层是按byte发送和接收的，但协议为了方便描述，每个byte用十六进制数（0x00～0xFF）表示,范相当于十进制的0～255,而byte为八位且是有符号类型，相当于十进制的-128～127，明显0x8F_{0xFF（128～255）是不能准确转换为byte的，咋办？因为0xFF被当作255整数处理，255超过了byte(-128}127)的范围，不能直接赋值，只能强转啊。
byte b = (byte) 0xFF;
但此时你会不会觉得这样写就和协议想发送0xFF的想法不匹配了呢，我明明想发个255来着，那我告诉你，你一个一个字节的发，每个字节就只能是-128～127，不能在其他范围，所以强转的目的是你可以发送这个0xFF的前提，发送的值肯定不是255,具体参考下面的例子：

public class Main {
 
    public static void main(String[] args) {
        byte c1 = (byte) 0xFF;
        int c2 = c1 & 0xFF;
        System.out.println(""+c1);
        System.out.println(""+c2);
    }
}// -1  255

可见，实际上是一个-1，但接受端为了表达这是个发送端发送给我的是0xFF(255)而不是-1,你可以通过取到该字节值后 “ 该值 & 0xFF”转为无符号值即255.

3.2.3 组帧

现存在一个byte数组，如下，发送命令前需按CRC-16/Modbus计算CRC，16位CRC高8位在后，低8位在前。

private byte[] bytes= {0x5A, (byte) 0xA5,0x01 ,0x06 ,0x00 ,0x01, 0x00 ,0x17};
...

getCRC(bytes);

可得到数据int CRC = 23976 , string src = 5da8
返回 5da8 。

image.png

CRC-16/Modbus是16位CRC高8位在后，低8位在前。
所以实际需要发送的数据 是
A8 5D
那么getCRC就需要修改一下。使用CRC = ( (CRC & 0x0000FF00) >> 8) | ( (CRC & 0x000000FF ) << 8);进行高低位转换。

如果需要返回byte[]数据的话，就new byte。

return new byte[]
 {(byte) (CRC & 0xff), (byte) (CRC >> 8 & 0xff);};

然后再使用 System.arraycopy拼接。
System.arraycopy(buf, 0, out, 5, len);

arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

• src:源数组;
• srcPos:源数组要复制的起始位置;
• dest:目的数组;
• destPos:目的数组放置的起始位置;
• length:复制的长度.
  5个参数
• 第一个参数是要被复制的数组
• 第二个参数是被复制的数字开始复制的下标
• 第三个参数是目标数组，也就是要把数据放进来的数组
• 第四个参数是从目标数据第几个下标开始放入数据
• 第五个参数表示从被复制的数组中拿几个数值放到目标数组中

3.3 处理接收数据

简单举例。

指令格式

格式说明：
字段说明STX起始符（固定为0x80,1 byte）LEN数据长度（CMD、DATA的长度，2 bytes）CMD业务类型（1 byte）DATA业务参数（TLV格式，可变长度）ETX结束符（固定为0x81,1 byte）CRCCRC32校验（取高位两个字节，2 bytes）

处理逻辑：将每次串口收到的数据追加保存到全局的ByteBuffer中，并每次对ByteBuffer中实际数据长度与字段LEN计算的长度进行比较，截取一条完整有效的指令处理。

public class SerialPortUtils {
    /**
     * 串口数据
     */
    private ByteBuffer byteBuffer;

    public void receiveSerialMsg(String msg) {
        try {
            byte[] receiveBytes = hexStr2bytes(msg);
            // 将串口收到的数据追加到ByteBuffer
            byteBuffer.put(receiveBytes);

            if(byteBuffer.position() >= 3) {
                byte[] byteLength = new byte[2];
                byteLength[0] = byteBuffer.get(1);
                byteLength[1] = byteBuffer.get(2);
// 计算一条完整指令的长度
// 6表示STX(1 byte) + ETX(1 byte) + LEN(2 bytes) + CRC(2 bytes)
                int realLen = (byteLength[0] << 8) + byteLength[1] + 6;
                //byteBuffer实际长度与LEN字段长度比较，若相等则表示已经接收到一条完整的指令
                if(realLen == byteBuffer.position()) {

                    byte[] effectiveBytes = new byte[realLen];
                    byteBuffer.flip();
                    byteBuffer.get(effectiveBytes, 0, realLen);
                    byteBuffer.clear();

                    dealEffectiveBytes(effectiveBytes);

                } else if(realLen < byteBuffer.position()) {   
                //粘包，截取有效数据，当一次收到多条完整指令时，根据业务场景决定多条指令的解析
                    int remainLen = byteBuffer.position() - realLen;
                    byte[] effectiveBytes = new byte[realLen];
                    byte[] remainBytes = new byte[remainLen];

                    byteBuffer.flip();
                    byteBuffer.get(effectiveBytes, 0, realLen);
                    byteBuffer.get(remainBytes, 0, remainLen);  //剩余字节
                    byteBuffer.clear();
                    byteBuffer.put(remainBytes);  //回填剩余字节，下一次收到数据继续追加接

// 根据业务场景，一次性收到多条完整指令时，只处理第一条指令，其余的舍弃
                    dealEffectiveBytes(effectiveBytes);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

// 解析一条完整的指令
    private void dealEffectiveBytes(byte[] effectiveBytes) {
        Map<String, String> outputMap = new HashMap<>();
        //将指令解析结果存到Map中
        int result = dataParser(effectiveBytes, outputMap);
    }
    
    public byte[] hexStr2bytes(String hex) {
        int len = (hex.length() / 2);
        byte[] result = new byte[len];
        char[] achar = hex.toUpperCase().toCharArray();
        for (int i = 0; i < len; i++) {
            int pos = i * 2;
            result[i] = (byte) (hexChar2byte(achar[pos]) << 4 | hexChar2byte(achar[pos + 1]));
        }
        return result;
    }
    //指令中业务参数解析
public int dataParser(byte[] data, Map<String, String> outputMap) {
// 校验STX、ETX
    if (data[0] != (byte) 0x80 || data[data.length - 3] != (byte) 0x81) {
      return ERROR_STX_ETX;
    }
// 校验CRC
    if (!checkCRC(data)) {
      return ERROR_CRC;
    }

    int index, curLen = 0;
    int dataLen = (data[1] << 8) + data[2];
    // 校验长度
    if ((dataLen + 6) != data.length) {
      return ERROR_LENGTH;
    }

    byte[] temp = new byte[1];
    //解析CMD
    temp[0] = data[3];
    String strCmd = byte2hex(temp);
    outputMap.put("SERIAL_PORT_CMD", strCmd.toUpperCase());

    if (data[3] == (byte) 0xA0) { //自定义的CMD
      index = 4;
      while (curLen < (dataLen - 1)) {//解析DATA，TLV格式

        byte type = data[index++];
        int length = data[index++];
        byte[] value = new byte[length];
        for (int i = 0; i < length; i++) {
          value[i] = data[index++];
        }

        if (type == (byte) 0x01) { // 参数：时间
          outputMap.put("SERIAL_PORT_TIME", new String(value));
        } else if(type == (byte) 0x02) { // 参数：握手数据
          outputMap.put("SERIAL_PORT_TEST", new String(value));
        }

        curLen += length + 2;
      }
    }

    return 0;
  }
}

receiveSerialMsg方法，在线程中循环接收到串口数据后调用。

基本逻辑就是 根据数据格式（帧头和帧尾）去取有效数据，过滤无效数据。然后有时候，有效数据中夹杂有一定规律的无效数据，就需要根据具体业务逻辑，用正则去匹配，删掉这些数据。

参考链接：
android串口通信接受自定义协议数据并解析问题

Android蓝牙串口通信
比isConnected()更靠谱的的获取socket实时连接状态！
Android经典蓝牙开发全流程
Android蓝牙开发—经典蓝牙详细开发流程
[蓝牙] 1、蓝牙核心技术了解（蓝牙协议、架构、硬件和软件笔记）
经典蓝牙那些事儿——（登录、登录异常、自动连接、中断、断后重连等）
关于蓝牙开发，必须注意的广播

Android串口通信，分包/黏包数据解析
java实现CRC16 MODBUS校验算法
java byte和int_Java里byte和int对比问题
socket的封包、粘包、解包，做一个即时通讯项目
SOCKET/串口通信粘包问题处理，附带详细代码
Android串口通信，分包/黏包数据解析
【粘包和拆包】数据帧粘包和拆包处理方式
串口通讯（含协议）支持粘包分包解析数据
tcp粘包和拆包的处理方案
android串口通信接受自定义协议数据并解析问题
System.arraycopy的使用方法详解
Modbus 通信协议详解