Android基于Modbus RTU协议通过蓝牙与蓝牙串口开发板通信#

[TOC]

前言#

最近接到一位老师的项目，他们公司要求利用Android基于Modbus RTU协议通过蓝牙与蓝牙串口开发板通信，然后通过开发板控制硬件设备从而实现Android移动设备与硬件交互。所以今天我给大家分享下Android基于Modbus RTU协议的蓝牙通信。当然Android也可以直接通过串口利用Modbus RTU协议与开发板通信，或者基于Modbus TCP通信。至于非蓝牙非Modbus RTU协议通信，大家可以跳转到这位博主的博客：Steven Jon

实现原理#

要想实现Android与开发板通信，那么必将涉及到协议问题。Android采用蓝牙协议通信，而开发板使用的是串口的协议(Modbus协议)，那么应该如何实现让采用两种不同协议通信的设备进行交互呢？那当然是两种协议的套接啦，接下来我将以Modbus RTU协议给大家介绍下实现原理： (1) 在Android中我们不能直接将指令放在蓝牙帧的数据域内，因为这样不能满足Modbus RTU协议，因此开发板无法从蓝牙帧中正确解析出你的指令，所以我们应该先将指令数据按照Modbus RTU协议先进行指令封装，然后将封装好的Modbus RTU协议指令帧整个放在蓝牙帧的数据域内。这样当开发板获取蓝牙帧时会自动获取数据域内的数据，这时候将获取到含有指令的Modbus RTU协议帧，然后从含有指令的Modbus RTU协议帧中解析出指令操作。 (2) 当然开发板要想从蓝牙帧中自动提取数据域中的数据也是有条件的，那就是在开发板上必须加上串口转蓝牙接口。这个串口转蓝牙接口就是实现两种协议套接的核心。它的作用是如果获取到的是Android发出的蓝牙帧时自动提取数据区域内的Modbus RTU协议帧，而如果收到的是开发板发出的Modbus RTU协议帧时则自动将它封装到蓝牙帧中。都是文字的话大家是不是很难理解，那么接下来上原理图：

套接原理图：

功能原理图：

看完实现原理接下来介绍最重要的代码实现。

在Android上实现Modbus RTU Master#

在Android中针对Modbus RTU消息帧没有现成的组装模块，因此需要自己写。

组装Modbus RTU消息帧#

这里是将输入的指令转换成对应的Modbus RTU协议的帧。

1
     /**
2
     * 组装Modbus RTU消息帧
3
     * @param slave 从站地址号
4
     * @param function_code 功能码
5
     * @param starting_address 读取寄存器起始地址 / 写入寄存器地址 / 写入寄存器起始地址
6
     * @param quantity_of_x 读取寄存器个数 / 写入寄存器个数
7
     * @param output_value 需要写入单个寄存器的数值
8
     * @param output_values 需要写入多个寄存器的数组
9
     * @return 将整个消息帧转成byte[]
10
     * @throws ModbusError Modbus错误
11
     */
12
    synchronized private byte[] execute(int slave, int function_code, int starting_address, int quantity_of_x,
13
                                        int output_value, int[] output_values) throws ModbusError {
14
        //检查参数是否符合协议规定
15
        if (slave < 0 || slave > 0xff) {
16
            throw new ModbusError(ModbusErrorType.ModbusInvalidArgumentError, "Invalid slave " + slave);
17
        }
18
        if (starting_address < 0 || starting_address > 0xffff) {
19
            throw new ModbusError(ModbusErrorType.ModbusInvalidArgumentError, "Invalid starting_address " + starting_address);
20
        }
21
        if (quantity_of_x < 1 || quantity_of_x > 0xff) {
22
            throw new ModbusError(ModbusErrorType.ModbusInvalidArgumentError, "Invalid quantity_of_x " + quantity_of_x);
23
        }
24

25
        // 构造request
26
        ByteArrayWriter request = new ByteArrayWriter();
27
        //写入从站地址号
28
        request.writeInt8(slave);
29
        //根据功能码组装数据区
30
        //如果为读取寄存器指令
31
        if (function_code == ModbusFunction.READ_COILS || function_code == ModbusFunction.READ_DISCRETE_INPUTS
32
                || function_code == ModbusFunction.READ_INPUT_REGISTERS || function_code == ModbusFunction.READ_HOLDING_REGISTERS) {
33
            request.writeInt8(function_code);
34
            request.writeInt16(starting_address);
35
            request.writeInt16(quantity_of_x);
36

37
        } else if (function_code == ModbusFunction.WRITE_SINGLE_COIL || function_code == ModbusFunction.WRITE_SINGLE_REGISTER) {//写单个寄存器指令
38
            if (function_code == ModbusFunction.WRITE_SINGLE_COIL)
39
                if (output_value != 0) output_value = 0xff00;//如果为线圈寄存器（写1时为 FF 00,写0时为00 00）
40
            request.writeInt8(function_code);
41
            request.writeInt16(starting_address);
42
            request.writeInt16(output_value);
43

44
        } else if (function_code == ModbusFunction.WRITE_COILS) {//写多个线圈寄存器
45
            request.writeInt8(function_code);
46
            request.writeInt16(starting_address);
47
            request.writeInt16(quantity_of_x);
48

49
            //计算写入字节数
50
            int writeByteCount = (quantity_of_x / 8) + 1;/// 满足关系-> (w /8) + 1
51
            //写入数量 == 8 ,则写入字节数为1
52
            if (quantity_of_x % 8 == 0) {
53
                writeByteCount -= 1;
54
            }
55
            request.writeInt8(writeByteCount);
56

57
            int index = 0;
58
            //如果写入数据数量 > 8 ，则需要拆分开来
59
            int start = 0;//数组开始位置
60
            int end = 7;//数组结束位置
61
            int[] splitData = new int[8];
62
            //循环写入拆分数组，直到剩下最后一组 元素个数 <= 8 的数据
63
            while (writeByteCount > 1) {
64
                writeByteCount--;
65
                int sIndex = 0;
66
                for (index = start; index <= end; index++){
67
                    splitData [sIndex++] = output_values[index];
68
                }
69
                //数据反转 对于是否要反转要看你传过来的数据，如果高低位顺序正确则不用反转
70
                splitData = reverseArr(splitData);
71
                //写入拆分数组
72
                request.writeInt8(toDecimal(splitData));
73
                start = index;
74
                end += 8;
75
            }
76
            //写入最后剩下的数据
77
            int last = quantity_of_x - index;
78
            int[] tData = new int[last];
79
            System.arraycopy(output_values, index, tData, 0, last);
80
            //数据反转 对于是否要反转要看你传过来的数据，如果高低位顺序正确则不用反转
81
            tData = reverseArr(tData);
82
            request.writeInt8(toDecimal(tData));
83
        } else if (function_code == ModbusFunction.WRITE_HOLDING_REGISTERS) {//写多个保持寄存器
84
            request.writeInt8(function_code);
85
            request.writeInt16(starting_address);
86
            request.writeInt16(quantity_of_x);
87
            request.writeInt8(2 * quantity_of_x);
88
            //写入数据
89
            for (int v : output_values) {
90
                request.writeInt16(v);
91
            }
92
        } else {
93
            throw new ModbusError(ModbusErrorType.ModbusFunctionNotSupportedError, "Not support function " + function_code);
94
        }
95
        byte[] bytes = request.toByteArray();
96
        //计算CRC校验码
97
        int crc = CRC16.compute(bytes);
98
        request.writeInt16Reversal(crc);
99
        bytes = request.toByteArray();
100
        return bytes;
101
    }

ModbusErrorType#

定义Modbus通讯错误类型

1
/**
2
 * 常见的Modbus通讯错误
3
 */
4
public enum ModbusErrorType {
5
    ModbusError,
6
    ModbusFunctionNotSupportedError,
7
    ModbusDuplicatedKeyError,
8
    ModbusMissingKeyError,
9
    ModbusInvalidBlockError,
10
    ModbusInvalidArgumentError,
11
    ModbusOverlapBlockError,
12
    ModbusOutOfBlockError,
13
    ModbusInvalidResponseError,
14
    ModbusInvalidRequestError,
15
    ModbusTimeoutError
16
}

ModbusError#

1
public class ModbusError extends Exception {
2
    private int code;
3

4
    public ModbusError(int code, String message) {
5
        super(!TextUtils.isEmpty(message) ? message : "Modbus Error: Exception code = " + code);
6
        this.code = code;
7
    }
8

9
    public ModbusError(int code) {
10
        this(code, null);
11
    }
12

13
    public ModbusError(ModbusErrorType type, String message) {
14
        super(type.name() + ": " + message);
15
    }
16

17
    public ModbusError(String message) {
18
        super(message);
19
    }
20

21
    public int getCode() {
22
        return this.code;
23
    }
24
}

ModbusFunction#

功能码定义

1
/**
2
 * 功能码（十进制显示）
3
 */
4
public class ModbusFunction {
5

6
    //读线圈寄存器
7
    public static final int READ_COILS = 1;
8

9
    //读离散输入寄存器
10
    public static final int READ_DISCRETE_INPUTS = 2;
11

12
    //读保持寄存器
13
    public static final int READ_HOLDING_REGISTERS = 3;
14

15
    //读输入寄存器
16
    public static final int READ_INPUT_REGISTERS = 4;
17

18
    //写单个线圈寄存器
19
    public static final int WRITE_SINGLE_COIL = 5;
20

21
    //写单个保持寄存器
22
    public static final int WRITE_SINGLE_REGISTER = 6;
23

24
    //写入多个线圈寄存器
25
    public static final int WRITE_COILS = 15;
26

27
    //写入多个保持寄存器
28
    public static final int WRITE_HOLDING_REGISTERS = 16;
29
}

ByteArrayWriter#

1
public class ByteArrayWriter extends ByteArrayOutputStream {
2
    public ByteArrayWriter() {
3
        super();
4
    }
5

6
    public void writeInt8(byte b)
7
    {
8
        this.write(b);
9
    }
10

11
    public void writeInt8(int b)
12
    {
13
        this.write((byte)b);
14
    }
15

16
    public void writeInt16(int n) {
17
        byte[] bytes = ByteUtil.fromInt16(n);
18
        this.write(bytes, 0, bytes.length);
19
    }
20

21
    public void writeInt16Reversal(int n){
22
        byte[] bytes=ByteUtil.fromInt16Reversal(n);
23
        this.write(bytes,0,bytes.length);
24
    }
25

26
    public void writeInt32(int n) {
27
        byte[] bytes = ByteUtil.fromInt32(n);
28
        this.write(bytes, 0, bytes.length);
29
    }
30

31
    public void writeBytes(byte[] bs,int len){
32
        this.write(bs,0,len);
33
    }
34

35
}

ByteUtil#

1
public class ByteUtil {
2

3
    public static String toHexString(byte[] input, String separator) {
4
        if (input==null) return null;
5

6
        StringBuilder sb = new StringBuilder();
7
        for (int i = 0; i < input.length; i++) {
8
            if (separator != null && sb.length() > 0) {
9
                sb.append(separator);
10
            }
11
            String str = Integer.toHexString(input[i] & 0xff);
12
            if (str.length() == 1) str = "0" + str;
13
            sb.append(str);
14
        }
15
        return sb.toString();
16
    }
17

18
    public static String toHexString(byte[] input) {
19
        return toHexString(input, " ");
20
    }
21

22
    public static byte[] fromInt32(int input){
23
        byte[] result=new byte[4];
24
        result[3]=(byte)(input >> 24 & 0xFF);
25
        result[2]=(byte)(input >> 16 & 0xFF);
26
        result[1]=(byte)(input >> 8 & 0xFF);
27
        result[0]=(byte)(input & 0xFF);
28
        return result;
29
    }
30

31
    public static byte[] fromInt16(int input){
32
        byte[] result=new byte[2];
33
        result[0]=(byte)(input >> 8 & 0xFF);
34
        result[1]=(byte)(input & 0xFF);
35
        return result;
36
    }
37

38
    public static byte[] fromInt16Reversal(int input){
39
        byte[] result=new byte[2];
40
        result[1]=(byte)(input>>8&0xFF);
41
        result[0]=(byte)(input&0xFF);
42
        return result;
43
    }
44

45
}

CRC16#

1
public class CRC16 {
2
    private static final byte[] crc16_tab_h = { (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40,
3
            (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x01, (byte) 0xC0, (byte) 0x80,
4
            (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0,
5
            (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x00,
6
            (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41,
7
            (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81,
8
            (byte) 0x40, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0,
9
            (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01,
10
            (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41,
11
            (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80,
12
            (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x00, (byte) 0xC1,
13
            (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00,
14
            (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41,
15
            (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81,
16
            (byte) 0x40, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0,
17
            (byte) 0x80, (byte) 0x41, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00,
18
            (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41,
19
            (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x00, (byte) 0xC1, (byte) 0x81,
20
            (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x01, (byte) 0xC0,
21
            (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x00,
22
            (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41,
23
            (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80,
24
            (byte) 0x41, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1,
25
            (byte) 0x81, (byte) 0x40, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01,
26
            (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41,
27
            (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80,
28
            (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x00, (byte) 0xC1,
29
            (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00,
30
            (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41,
31
            (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81,
32
            (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1,
33
            (byte) 0x81, (byte) 0x40, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01,
34
            (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41,
35
            (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x00, (byte) 0xC1, (byte) 0x81,
36
            (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1,
37
            (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x01,
38
            (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40 };
39

40
    private static final byte[] crc16_tab_l = { (byte) 0x00, (byte) 0xC0, (byte) 0xC1, (byte) 0x01,
41
            (byte) 0xC3, (byte) 0x03, (byte) 0x02, (byte) 0xC2, (byte) 0xC6, (byte) 0x06, (byte) 0x07,
42
            (byte) 0xC7, (byte) 0x05, (byte) 0xC5, (byte) 0xC4, (byte) 0x04, (byte) 0xCC, (byte) 0x0C,
43
            (byte) 0x0D, (byte) 0xCD, (byte) 0x0F, (byte) 0xCF, (byte) 0xCE, (byte) 0x0E, (byte) 0x0A,
44
            (byte) 0xCA, (byte) 0xCB, (byte) 0x0B, (byte) 0xC9, (byte) 0x09, (byte) 0x08, (byte) 0xC8,
45
            (byte) 0xD8, (byte) 0x18, (byte) 0x19, (byte) 0xD9, (byte) 0x1B, (byte) 0xDB, (byte) 0xDA,
46
            (byte) 0x1A, (byte) 0x1E, (byte) 0xDE, (byte) 0xDF, (byte) 0x1F, (byte) 0xDD, (byte) 0x1D,
47
            (byte) 0x1C, (byte) 0xDC, (byte) 0x14, (byte) 0xD4, (byte) 0xD5, (byte) 0x15, (byte) 0xD7,
48
            (byte) 0x17, (byte) 0x16, (byte) 0xD6, (byte) 0xD2, (byte) 0x12, (byte) 0x13, (byte) 0xD3,
49
            (byte) 0x11, (byte) 0xD1, (byte) 0xD0, (byte) 0x10, (byte) 0xF0, (byte) 0x30, (byte) 0x31,
50
            (byte) 0xF1, (byte) 0x33, (byte) 0xF3, (byte) 0xF2, (byte) 0x32, (byte) 0x36, (byte) 0xF6,
51
            (byte) 0xF7, (byte) 0x37, (byte) 0xF5, (byte) 0x35, (byte) 0x34, (byte) 0xF4, (byte) 0x3C,
52
            (byte) 0xFC, (byte) 0xFD, (byte) 0x3D, (byte) 0xFF, (byte) 0x3F, (byte) 0x3E, (byte) 0xFE,
53
            (byte) 0xFA, (byte) 0x3A, (byte) 0x3B, (byte) 0xFB, (byte) 0x39, (byte) 0xF9, (byte) 0xF8,
54
            (byte) 0x38, (byte) 0x28, (byte) 0xE8, (byte) 0xE9, (byte) 0x29, (byte) 0xEB, (byte) 0x2B,
55
            (byte) 0x2A, (byte) 0xEA, (byte) 0xEE, (byte) 0x2E, (byte) 0x2F, (byte) 0xEF, (byte) 0x2D,
56
            (byte) 0xED, (byte) 0xEC, (byte) 0x2C, (byte) 0xE4, (byte) 0x24, (byte) 0x25, (byte) 0xE5,
57
            (byte) 0x27, (byte) 0xE7, (byte) 0xE6, (byte) 0x26, (byte) 0x22, (byte) 0xE2, (byte) 0xE3,
58
            (byte) 0x23, (byte) 0xE1, (byte) 0x21, (byte) 0x20, (byte) 0xE0, (byte) 0xA0, (byte) 0x60,
59
            (byte) 0x61, (byte) 0xA1, (byte) 0x63, (byte) 0xA3, (byte) 0xA2, (byte) 0x62, (byte) 0x66,
60
            (byte) 0xA6, (byte) 0xA7, (byte) 0x67, (byte) 0xA5, (byte) 0x65, (byte) 0x64, (byte) 0xA4,
61
            (byte) 0x6C, (byte) 0xAC, (byte) 0xAD, (byte) 0x6D, (byte) 0xAF, (byte) 0x6F, (byte) 0x6E,
62
            (byte) 0xAE, (byte) 0xAA, (byte) 0x6A, (byte) 0x6B, (byte) 0xAB, (byte) 0x69, (byte) 0xA9,
63
            (byte) 0xA8, (byte) 0x68, (byte) 0x78, (byte) 0xB8, (byte) 0xB9, (byte) 0x79, (byte) 0xBB,
64
            (byte) 0x7B, (byte) 0x7A, (byte) 0xBA, (byte) 0xBE, (byte) 0x7E, (byte) 0x7F, (byte) 0xBF,
65
            (byte) 0x7D, (byte) 0xBD, (byte) 0xBC, (byte) 0x7C, (byte) 0xB4, (byte) 0x74, (byte) 0x75,
66
            (byte) 0xB5, (byte) 0x77, (byte) 0xB7, (byte) 0xB6, (byte) 0x76, (byte) 0x72, (byte) 0xB2,
67
            (byte) 0xB3, (byte) 0x73, (byte) 0xB1, (byte) 0x71, (byte) 0x70, (byte) 0xB0, (byte) 0x50,
68
            (byte) 0x90, (byte) 0x91, (byte) 0x51, (byte) 0x93, (byte) 0x53, (byte) 0x52, (byte) 0x92,
69
            (byte) 0x96, (byte) 0x56, (byte) 0x57, (byte) 0x97, (byte) 0x55, (byte) 0x95, (byte) 0x94,
70
            (byte) 0x54, (byte) 0x9C, (byte) 0x5C, (byte) 0x5D, (byte) 0x9D, (byte) 0x5F, (byte) 0x9F,
71
            (byte) 0x9E, (byte) 0x5E, (byte) 0x5A, (byte) 0x9A, (byte) 0x9B, (byte) 0x5B, (byte) 0x99,
72
            (byte) 0x59, (byte) 0x58, (byte) 0x98, (byte) 0x88, (byte) 0x48, (byte) 0x49, (byte) 0x89,
73
            (byte) 0x4B, (byte) 0x8B, (byte) 0x8A, (byte) 0x4A, (byte) 0x4E, (byte) 0x8E, (byte) 0x8F,
74
            (byte) 0x4F, (byte) 0x8D, (byte) 0x4D, (byte) 0x4C, (byte) 0x8C, (byte) 0x44, (byte) 0x84,
75
            (byte) 0x85, (byte) 0x45, (byte) 0x87, (byte) 0x47, (byte) 0x46, (byte) 0x86, (byte) 0x82,
76
            (byte) 0x42, (byte) 0x43, (byte) 0x83, (byte) 0x41, (byte) 0x81, (byte) 0x80, (byte) 0x40 };
77

78
    /**
79
     * 计算CRC16校验
80
     *
81
     * @param data
82
     *            需要计算的数组
83
     * @return CRC16校验值
84
     */
85
    public static int compute(byte[] data) {
86
        return compute(data, 0, data.length);
87
    }
88

89
    /**
90
     * 计算CRC16校验
91
     *
92
     * @param data
93
     *            需要计算的数组
94
     * @param offset
95
     *            起始位置
96
     * @param len
97
     *            长度
98
     * @return CRC16校验值
99
     */
100
    public static int compute(byte[] data, int offset, int len) {
101
        return compute(data, offset, len, 0xffff);
102
    }
103

104
    /**
105
     * 计算CRC16校验
106
     *
107
     * @param data
108
     *            需要计算的数组
109
     * @param offset
110
     *            起始位置
111
     * @param len
112
     *            长度
113
     * @param preval
114
     *            之前的校验值
115
     * @return CRC16校验值
116
     */
117
    public static int compute(byte[] data, int offset, int len, int preval) {
118
        int ucCRCHi = (preval & 0xff00) >> 8;
119
        int ucCRCLo = preval & 0x00ff;
120
        int iIndex;
121
        for (int i = 0; i < len; ++i) {
122
            iIndex = (ucCRCLo ^ data[offset + i]) & 0x00ff;
123
            ucCRCLo = ucCRCHi ^ crc16_tab_h[iIndex];
124
            ucCRCHi = crc16_tab_l[iIndex];
125
        }
126
        int result=((ucCRCHi & 0x00ff) << 8) | (ucCRCLo & 0x00ff) & 0xffff;
127
        return result;
128
    }
129
}

ModbusRtuMaster完整代码#

这个类主要的功能就是将输入的指令转换成符合ModbusRtu协议的指令并返回，之后Android只需将返回的byte[]类型的值用蓝牙发送即可。

1
import java.util.Formatter;
2

3
public class ModbusRtuMaster {
4

5

6
    /**
7
     * 组装Modbus RTU消息帧
8
     *
9
     * @param slave            从站地址号
10
     * @param function_code    功能码
11
     * @param starting_address 读取寄存器起始地址 / 写入寄存器地址 / 写入寄存器起始地址
12
     * @param quantity_of_x    读取寄存器个数 / 写入寄存器个数
13
     * @param output_value     需要写入单个寄存器的数值
14
     * @param output_values    需要写入多个寄存器的数组
15
     * @return 将整个消息帧转成byte[]
16
     * @throws ModbusError Modbus错误
17
     */
18
    synchronized private byte[] execute(int slave, int function_code, int starting_address, int quantity_of_x,
19
                                        int output_value, int[] output_values) throws ModbusError {
20
        //检查参数是否符合协议规定
21
        if (slave < 0 || slave > 0xff) {
22
            throw new ModbusError(ModbusErrorType.ModbusInvalidArgumentError, "Invalid slave " + slave);
23
        }
24
        if (starting_address < 0 || starting_address > 0xffff) {
25
            throw new ModbusError(ModbusErrorType.ModbusInvalidArgumentError, "Invalid starting_address " + starting_address);
26
        }
27
        if (quantity_of_x < 1 || quantity_of_x > 0xff) {
28
            throw new ModbusError(ModbusErrorType.ModbusInvalidArgumentError, "Invalid quantity_of_x " + quantity_of_x);
29
        }
30

31
        // 构造request
32
        ByteArrayWriter request = new ByteArrayWriter();
33
        //写入从站地址号
34
        request.writeInt8(slave);
35
        //根据功能码组装数据区
36
        //如果为读取寄存器指令
37
        if (function_code == ModbusFunction.READ_COILS || function_code == ModbusFunction.READ_DISCRETE_INPUTS
38
                || function_code == ModbusFunction.READ_INPUT_REGISTERS || function_code == ModbusFunction.READ_HOLDING_REGISTERS) {
39
            request.writeInt8(function_code);
40
            request.writeInt16(starting_address);
41
            request.writeInt16(quantity_of_x);
42

43
        } else if (function_code == ModbusFunction.WRITE_SINGLE_COIL || function_code == ModbusFunction.WRITE_SINGLE_REGISTER) {//写单个寄存器指令
44
            if (function_code == ModbusFunction.WRITE_SINGLE_COIL)
45
                if (output_value != 0) output_value = 0xff00;//如果为线圈寄存器（写1时为 FF 00,写0时为00 00）
46
            request.writeInt8(function_code);
47
            request.writeInt16(starting_address);
48
            request.writeInt16(output_value);
49

50
        } else if (function_code == ModbusFunction.WRITE_COILS) {//写多个线圈寄存器
51
            request.writeInt8(function_code);
52
            request.writeInt16(starting_address);
53
            request.writeInt16(quantity_of_x);
54

55
            //计算写入字节数
56
            int writeByteCount = (quantity_of_x / 8) + 1;/// 满足关系-> (w /8) + 1
57
            //写入数量 == 8 ,则写入字节数为1
58
            if (quantity_of_x % 8 == 0) {
59
                writeByteCount -= 1;
60
            }
61
            request.writeInt8(writeByteCount);
62

63
            int index = 0;
64
            //如果写入数据数量 > 8 ，则需要拆分开来
65
            int start = 0;//数组开始位置
66
            int end = 7;//数组结束位置
67
            int[] splitData = new int[8];
68
            //循环写入拆分数组，直到剩下最后一组 元素个数 <= 8 的数据
69
            while (writeByteCount > 1) {
70
                writeByteCount--;
71
                int sIndex = 0;
72
                for (index = start; index <= end; index++) {
73
                    splitData[sIndex++] = output_values[index];
74
                }
75
                //数据反转 对于是否要反转要看你传过来的数据，如果高低位顺序正确则不用反转
76
                splitData = reverseArr(splitData);
77
                //写入拆分数组
78
                request.writeInt8(toDecimal(splitData));
79
                start = index;
80
                end += 8;
81
            }
82
            //写入最后剩下的数据
83
            int last = quantity_of_x - index;
84
            int[] tData = new int[last];
85
            System.arraycopy(output_values, index, tData, 0, last);
86
            //数据反转 对于是否要反转要看你传过来的数据，如果高低位顺序正确则不用反转
87
            tData = reverseArr(tData);
88
            request.writeInt8(toDecimal(tData));
89
        } else if (function_code == ModbusFunction.WRITE_HOLDING_REGISTERS) {//写多个保持寄存器
90
            request.writeInt8(function_code);
91
            request.writeInt16(starting_address);
92
            request.writeInt16(quantity_of_x);
93
            request.writeInt8(2 * quantity_of_x);
94
            //写入数据
95
            for (int v : output_values) {
96
                request.writeInt16(v);
97
            }
98
        } else {
99
            throw new ModbusError(ModbusErrorType.ModbusFunctionNotSupportedError, "Not support function " + function_code);
100
        }
101
        byte[] bytes = request.toByteArray();
102
        //计算CRC校验码
103
        int crc = CRC16.compute(bytes);
104
        request.writeInt16Reversal(crc);
105
        bytes = request.toByteArray();
106
        return bytes;
107
    }
108

109
    /**
110
     * 读多个线圈寄存器
111
     *
112
     * @param slave          从站地址
113
     * @param startAddress   起始地址
114
     * @param numberOfPoints 读取线圈寄存器个数
115
     * @throws ModbusError Modbus错误
116
     */
117
    public byte[] readCoils(int slave, int startAddress, int numberOfPoints) throws ModbusError {
118
        byte[] sendBytes = execute(slave, ModbusFunction.READ_COILS, startAddress, numberOfPoints, 0, null);
119
        return sendBytes;
120
    }
121

122
    //读单个线圈寄存器
123
    public byte[] readCoil(int slave, int address) throws ModbusError {
124
        byte[] sendBytes = readCoils(slave, address, 1);
125
        return sendBytes;
126
    }
127

128
    /**
129
     * 读多个保持寄存器
130
     *
131
     * @param slave          从站地址
132
     * @param startAddress   起始地址
133
     * @param numberOfPoints 读取保持寄存器个数
134
     * @throws ModbusError Modbus错误
135
     */
136
    public byte[] readHoldingRegisters(int slave, int startAddress, int numberOfPoints) throws ModbusError {
137
        byte[] sendBytes = execute(slave, ModbusFunction.READ_HOLDING_REGISTERS, startAddress, numberOfPoints, 0, null);
138

139
        return sendBytes;
140
    }
141

142
    //读单个保持寄存器
143
    public byte[] readHoldingRegister(int slave, int address) throws ModbusError {
144
        byte[] sendBytes = readHoldingRegisters(slave, address, 1);
145
        return sendBytes;
146
    }
147

148

149
    /**
150
     * 读多个输入寄存器
151
     *
152
     * @param slave          从站地址
153
     * @param startAddress   起始地址
154
     * @param numberOfPoints 读取输入寄存器个数
155
     * @throws ModbusError Modbus错误
156
     */
157
    public byte[] readInputRegisters(int slave, int startAddress, int numberOfPoints) throws ModbusError {
158
        byte[] sendBytes = execute(slave, ModbusFunction.READ_INPUT_REGISTERS, startAddress, numberOfPoints, 0, null);
159
        return sendBytes;
160
    }
161

162
    //读单个输入寄存器
163
    public byte[] readInputRegister(int slave, int address) throws ModbusError {
164
        byte[] sendBytes = readInputRegisters(slave, address, 1);
165
        return sendBytes;
166
    }
167

168
    /**
169
     * 读多个离散输入寄存器
170
     *
171
     * @param slave          从站地址
172
     * @param startAddress   起始地址
173
     * @param numberOfPoints 读取离散输入寄存器个数
174
     * @throws ModbusError Modbus错误
175
     */
176
    public byte[] readDiscreteInputs(int slave, int startAddress, int numberOfPoints) throws ModbusError {
177
        byte[] sendBytes = execute(slave, ModbusFunction.READ_DISCRETE_INPUTS, startAddress, numberOfPoints, 0, null);
178
        return sendBytes;
179
    }
180

181
    //读单个离散输入寄存器
182
    public byte[] readDiscreteInput(int slave, int address) throws ModbusError {
183
        byte[] sendBytes = readDiscreteInputs(slave, address, 1);
184
        return sendBytes;
185
    }
186

187
    /**
188
     * 写单个线圈寄存器
189
     *
190
     * @param slave   从站地址
191
     * @param address 写入寄存器地址
192
     * @param value   写入值（true/false)
193
     * @throws ModbusError Modbus错误
194
     */
195
    public byte[] writeSingleCoil(int slave, int address, boolean value) throws ModbusError {
196
        byte[] sendBytes = execute(slave, ModbusFunction.WRITE_SINGLE_COIL, address, 1, value ? 1 : 0, null);
197
        return sendBytes;
198
    }
199

200
    /**
201
     * 写单个保持寄存器
202
     *
203
     * @param slave   从站地址
204
     * @param address 写入寄存器地址
205
     * @param value   写入值
206
     * @throws ModbusError Modbus错误
207
     */
208
    public byte[] writeSingleRegister(int slave, int address, int value) throws ModbusError {
209
        byte[] sendBytes = execute(slave, ModbusFunction.WRITE_SINGLE_REGISTER, address, 1, value, null);
210
        return sendBytes;
211
    }
212

213
    /**
214
     * 写入多个保持寄存器
215
     *
216
     * @param slave   从站地址
217
     * @param address 写入寄存器地址
218
     * @param sCount  写入寄存器个数
219
     * @param data    写入数据
220
     * @throws ModbusError
221
     */
222
    public byte[] writeHoldingRegisters(int slave, int address, int sCount, int[] data) throws ModbusError {
223
        byte[] sendBytes = execute(slave, ModbusFunction.WRITE_HOLDING_REGISTERS, address, sCount, 0, data);
224
        return sendBytes;
225
    }
226

227
    /**
228
     * 写入多个位
229
     *
230
     * @param slave   从站地址
231
     * @param address 写入寄存器地址
232
     * @param bCount  写入寄存器个数
233
     * @param data    写入数据{1,0}
234
     * @throws ModbusError
235
     */
236
    public byte[] writeCoils(int slave, int address, int bCount, int[] data) throws ModbusError {
237
        byte[] sendBytes = execute(slave, ModbusFunction.WRITE_COILS, address, bCount, 0, data);
238
        return sendBytes;
239
    }
240

241

242
    //将数组反转
243
    private int[] reverseArr(int[] arr) {
244
        int[] tem = new int[arr.length];
245
        for (int i = 0; i < arr.length; i++) {
246
            tem[i] = arr[arr.length - 1 - i];
247
        }
248
        return tem;
249
    }
250

251
    /**
252
     * 字节转换为 16 进制字符串
253
     *
254
     * @param b 字节
255
     * @return Hex 字符串
256
     */
257
    static String byte2Hex(byte b) {
258
        StringBuilder hex = new StringBuilder(Integer.toHexString(b));
259
        if (hex.length() > 2) {
260
            hex = new StringBuilder(hex.substring(hex.length() - 2));
261
        }
262
        while (hex.length() < 2) {
263
            hex.insert(0, "0");
264
        }
265
        return hex.toString();
266
    }
267

268

269
    /**
270
     * 字节数组转换为 16 进制字符串
271
     *
272
     * @param bytes 字节数组
273
     * @return Hex 字符串
274
     */
275
    static String bytes2Hex(byte[] bytes) {
276
        Formatter formatter = new Formatter();
277
        for (byte b : bytes) {
278
            formatter.format("%02x ", b);
279
        }
280
        String hash = formatter.toString();
281
        formatter.close();
282
        return hash;
283
    }
284

285
    //将int[1,0,0,1,1,0]数组转换为十进制数据
286
    private int toDecimal(int[] data) {
287
        int result = 0;
288
        if (data != null) {
289
            StringBuilder sData = new StringBuilder();
290
            for (int d : data) {
291
                sData.append(d);
292
            }
293
            try {
294
                result = Integer.parseInt(sData.toString(), 2);
295
            } catch (NumberFormatException e) {
296
                result = -1;
297
            }
298

299
        }
300
        return result;
301
    }
302
}

在Android上实现用蓝牙传递Modbus Rtu协议帧#

今天分享的是Android如何基于Modbus RTU协议与蓝牙串口开发板通信，至于Android如何搜索蓝牙设备，如何连接我这就不多做介绍了，网上有很多博主做了一大堆了。接下来来看看我们写好的ModbusRtuMaster怎么使用吧。

1
//首先在你的activity中定义一个ModbusRtuMaster类型
2
private ModbusRtuMaster modbusRtuMaster;
3
//然后在activity中的onCreate方法里初始化ModbusRtuMaster
4
modbusRtuMaster = new ModbusRtuMaster();
5
//最后利用ModbusRtuMaster对输入的指令进行协议封装并接收返回结果
6
//这时候results就是一个符合ModbusRtu协议的消息针了
7
byte[] results = modbusRtuMaster.writeHoldingRegisters(Rs485, Rsaddress, Hvalue.length, Hvalue);
8
//接下来可以把results用蓝牙发给你的蓝牙串口开发板了
9
private final OutputStream mmOutStream;
10
mmOutStream.write(results)

字节数组转换为 16 进制字符串的方法#

这里我再提下ModbusRtuMaster里面的bytes2Hex方法，如果你想把转换后的指令或者是串口返回的数据显示在Android设备上，那么必须将其转化为Hex类型的16进制字符串，如果不转换成Hex那么显示出来将是乱码等，因为那些数据是btye类型，然后就是这里不能使用 new String(byte[]) 去将byte数组转换成string，否则将显示成符号字母，请务必按照我在ModbusRtuMaster内写的bytes2Hex将字节数组转换为 16 进制字符串，再输出显示。

1
static String bytes2Hex(byte[] bytes) {
2
        Formatter formatter = new Formatter();
3
        for (byte b : bytes) {
4
            formatter.format("%02x ", b);
5
        }
6
        String hash = formatter.toString();
7
        formatter.close();
8
        return hash;
9
    }

如何使用bytes2Hex

1
String result = modbusRtuMaster.bytes2Hex(results);

最终效果#

最后让我们来看看使用ModbusRtuMaster返回帧通过蓝牙传给蓝牙串口开发板的效果吧！(蓝色代表发送指令，绿色代表接收开发板返回的数据)

以上就是《Android基于ModbusRtu协议通过蓝牙与蓝牙串口开发板通信》的全部内容了，我也是第一次使用Android去通信开发板与硬件交互。这里非常感谢另一位博主的文章 Steven Jon，我也是借鉴了他博客中的一篇关于ModbusRtuMaster的文章才实现通信的，对其他通信方法感兴趣的小伙伴可以点击去Steven Jon大佬的博客继续学习。

音乐

音乐