Android与单片机 | 开发板 | 智能硬件 | 智能设备 | 数据协议 |开发总结

工作中经常遇到需要Android程序与各式各样的板子、智能设备进行交互，通信的方式也基本上都是 Ble 或者 Socket tcp/udp 等等.....其中最重要的一点就是通信的 协议 、 协议 、 协议 重要的是说三遍；通信协议就是用来定义与设备交互的方式和交互过程中数据包的格式 如： （包头—数据包长度—数据—校验位—包尾）

二、这里先来理理各种数据类型、所占的字节数等

1、我们写的代码最终都是转化成各种机器所能识别的二进制或者字节码，不同的编程语言具有不同的 数据类型 基本的也好不基本的也好、当然有不同的也就有相同的 byte （字节）就是其中的一个； 2、日常开发中我们进行通信发送的内容最终都会以字节的形式进行发送，这里以 Java 的 Socket 为例，我们来看下源码

• 创建一个socket连接，发送数据

Socket socket = new Socket(ip, port);
OutputStream outputStream = socket.getOutputStream();
//发送数据
outputStream.write("Hello World!".getBytes());
outputStream.flush();
//关闭连接
outputStream.close();
socket.close();
复制代码

• 我们来看下 OutputStream 的 wirte(byte[] b) 函数
• OutputStream # write(byte[] b)

//1 接着又调用了write(byte b[], int off, int len)
public void write(byte b[]) throws IOException {
    write(b, 0, b.length);
}

//2 最后又调用了write(byte b)
public void write(byte b[], int off, int len) throws IOException {
    if (b == null) {
        throw new NullPointerException();
    } else if ((off < 0) || (off > b.length) || (len < 0) ||
               ((off + len) > b.length) || ((off + len) < 0)) {
        throw new IndexOutOfBoundsException();
    } else if (len == 0) {
        return;
    }
    //3 这里就是讲我们发送的一个bye[]进行for循环一个个写入了
    for (int i = 0 ; i < len ; i++) {
        write(b[off + i]);
    }
}

//4 end
public abstract void write(int b) throws IOException;
复制代码

小结：无论定义的通讯格式是什么样的最终肯定要转成 byte[]（字节数组） 进行发送，所以只要将数据转成字节数组即可，下面进入 数据类型 科普时间

三、 Java 中的数据类型所占的字节数和bit数

• String在Java中不属于基本数据类型，一个汉字占2个字节，一个英文字母占1个字节
• 小结：1 byte = 8 bit

3.1 什么是bit呢？什么又是高低位呢？在Java中又怎么写代码呢？

• bit就是 位 也就是 二进制 数据，取值只有 0 , 1 - 高位在左，低位在右
• 在Java中获取byte的8个bit

/**
 * byte转8 bit
 *
 * @param b byte
 * @return 高位到低位顺序, 以byte123 为例： 0111 1011
 */
public static byte[] byte2Bit(byte b) {
    byte[] arr = new byte[8];
    for (int i = 7; i >= 0; i--) {
        arr[i] = (byte) (b & 1);
        b = (byte) (b >> 1);
    }
    return arr;
}
复制代码

• 既然把byte转为了8个bit位，那我们又怎么再把bit转回为byte呢？

/**
 * 8个bit位转为byte
 */
public static byte bit2Byte(byte[] bytes) {
    if (bytes.length != 8) return 0;
    String binary = "";
    byte result;
    for (byte b : bytes) {
        binary += b;
    }
    if (bytes[0] == 0) {
        // 正数
        result = (byte) Integer.parseInt(binary, 2);
    } else {
        // 负数
        result = (byte) (Integer.parseInt(binary, 2) - 256);
    }
    return result;
}
复制代码

3.2 上面已经说了byte与bit的相互转化，现在就轮到 int 了

• 上面已经说了一个 int 占 4 个字节 32 个 bit
• Integer类已经为我们封装好了转bit的方法，如下：

String s = Integer.toBinaryString(35235);
//输出结果
1000100110100011
复制代码

• 可以看到没有32位，这是为什么呢？这是因为高位都是为 0 所以就直接省略了，当然我们也可以主动补齐 32 位只需要在高位补 0 即可。
• bit再转回为int

int result = Integer.parseInt("1000100110100011", 2);
//输出结果
35235
复制代码

• 这里需要注意的是Integer.toBinaryString()可以将负数转化为二进制，但是Integer.parseInt("", 2)不能直接将负数的二进制转为int，如下：

String radix = Integer.toBinaryString(-35235);
System.out.println(radix);
int result = Integer.parseInt(radix, 2);
System.out.println(result);
复制代码

程序执行会报一个 java.lang.NumberFormatException: For input string:"11111111111111110111011001011101" 异常，那我们怎么将负数的转回为int呢？当然是有方法的啦，如下：

//需要借助 BigInteger类
String radix = Integer.toBinaryString(-3535);
BigInteger integer = new BigInteger(radix, 2);
System.out.println(integer.intValue());
//输出结果
-3535
复制代码

3.3当然我们可以通过电脑的计算器来计算二进制

3.4 上面我们说了一个 int 占 32 个字节也就是 4 个 byte ，那理所当然一个 int 可以转成2个byte或者 4 个 byte ，如下：

/**
 * 一个int转2个字节的byte数组
 * 由低位到高位的转换
 *
 * @param value
 * @return
 */
public static byte[] intTo2Bytes(int value) {
    byte[] src = new byte[2];
    src[0] = (byte) (value & 0xFF);
    src[1] = (byte) ((value >> 8) & 0xFF);
    return src;
}

/**
 * 一个int转4个字节的byte数组
 * 由低位到高位的转换
 *
 * @param value
 * @return
 */
public static byte[] intTo4Bytes(int value) {
    byte[] src = new byte[4];
    src[0] = (byte) (value & 0xFF);
    src[1] = (byte) ((value >> 8) & 0xFF);
    src[2] = (byte) ((value >> 16) & 0xFF);
    src[3] = (byte) ((value >> 24) & 0xFF);
    return src;
}
复制代码

这里需要注意的是 int转byte[] 的时候是 高位 在 数组的0下标 还是 低位 在 数组的0下标 ，上面的两个方法都是 低位在数组的0下标

四、上面bb了一大堆，现在我们通过一个具体的协议来深入了解这些内容

4.1 协议如下：

这里需要解释下 uchar 、 uint 是什么意思？uchar = unsigned char 、uint = unsigned int，也就是无符号的数据，也就是表示了这个数据是 正数

• 1、对协议进行分析可以得知：整个数据包是由两部分组成的 包头 + 扩展数据包 ，其中包头占固定的32个字节
• 2、首先我们得分析包头里面的每一个字段所占了多少个 字节
  • uchar 占1个字节
  • uint 占4个字节
• 2、那我们重点就是得来分析包头的数据需要怎么封装，通过协议我们可以看出 包头 内一共包含6个字段,分别表示如下：
  • 第一个为固定的 "DH" ，总共占 2 个字节
  • 第二个为版本 1.0 ，总共占 2 个字节
  • 第三个为扩展数据长度 "extlen" ，总共占 4 个字节
  • 第四个为扩展数据类型 取值0或1 ，总共占 1 个字节
  • 第五个为保留字段不使用就 0 补齐，总共占 3 个字节
  • 第六个为保留字段不使用就 0 补齐，总共占 20 个字节
• 3、通过上面一顿分析，我们就轻松的理清了每个字段所占的字节了

4.2 Talk is cheap. Show me the code.

//magic
byte[] magicB = {'D', 'H'};
//协议版本1.0转成int也就是1
byte[] versionB = {0, 1};
//扩展数据长度，这里假定扩展数据的长度为67
byte[] extLenB = intTo4Bytes(67);
//扩展数据类型 0：JSON、1：二进制数据；这里使用JSON
byte[] extType = {0};
//两个保留字段，直接0补齐，上面已经分析了两个字段一共占23个字节
byte[] reserved = new byte[23];
//这里将上面的多个数据合并至一个byte[]
byte[] data = byteMergerAll(magicB, versionB, extLenB, extType, reserved);
复制代码

到这里包头的数据就已经处理好了，还可以进一步对它进行封装

• 这里提供一个多个数据数组合并的 工具 方法

/**
 * 多个数组合并一个
 *
 * @return
 */
public static byte[] byteMergerAll(byte[]... bytes) {
    int allLength = 0;
    for (byte[] b : bytes) {
        allLength += b.length;
    }
    byte[] allByte = new byte[allLength];
    int countLength = 0;
    for (byte[] b : bytes) {
        System.arraycopy(b, 0, allByte, countLength, b.length);
        countLength += b.length;
    }
    return allByte;
}
复制代码

4.3 封装包头数据

/**
 * 封装包头数据
 * 固定32个字节，其余的0补齐
 *
 * @param extLen 扩展数据长度
 */
public static byte[] getPkgHead(int extLen) {
    //magic
    byte[] magicB = {'D', 'H'};
    //协议版本1.0转成int也就是1
    byte[] versionB = {0, 1};
    //扩展数据长度，这里假定扩展数据的长度为67
    byte[] extLenB = intTo4Bytes(extLen);
    //扩展数据类型 0：JSON、1：二进制数据；这里使用JSON
    byte[] extType = {0};
    //两个保留字段，直接0补齐，上面已经分析了两个字段一共占23个字节
    byte[] reserved = new byte[23];
    //这里将上面的多个数据合并至一个byte[]
    return byteMergerAll(magicB, versionB, extLenB, extType, reserved);
}
复制代码

4.4上面已经把包头处理好了那现在就可以发送命令了

//扩展数据：这里就需要根据实际的文档来生成了，我这里就随便写一个了
String extData = "{\"id\":12,\"cmd\":\"open\"}";
 byte[] extDataB = extData.getBytes();
 //获取包头
 byte[] pkgHead = getPkgHead(extDataB.length);
 //一个完整的数据包
 byte[] sendData = byteMergerAll(pkgHead, extDataB);
复制代码

到这里一个完整的数据包就愉快的结束了也就实现了与设备的通信了；重点：以后再拿到一个协议首先研究一下由多少个部分组成，每个组成的部分占多少个字节，是高位到低位还是低位到高位