Modbus在Android上的应用之Modbus RTU Master
Posted Steven Jon
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Modbus在Android上的应用之Modbus RTU Master相关的知识，希望对你有一定的参考价值。
Modbus RTU
如果不了解Modbus协议的同学，可以看我之前写的文章。Modbus在Android上的应用之Modbus TCP Master
Modbus协议包括ASCII、RTU和TCP等，并没有规定物理层。此协议定义了控制器能够认识和使用的消息结构，而不管它们是经过哪种网络进行通信的。Modbus的ASCII、RTU协议规定了消息、数据结构、命令和应答方式，数据通讯采用Master/Slave方式，Master端发送数据请求消息，Slave端接收到正确的消息之后就可以发送数据到Master端以响应请求，Master端也可以直接发送消息修改Slave端的数据，实现双向读写。
Modbus协议需要对数据进行校验，串行协议中除了奇偶校验之外，ASCII模式采用LRC校验，RTU模式采用16位CRC校验，但是TCP模式没有额外规定校验，因为TCP协议是一个面向连接的可靠协议。
Modbus RTU协议结构
地址码：就是从站地址号。每个从机都必须有唯一的地址码，并且只有符合地址码的从机才能响应请求。
功能码：主机发送的功能码告诉从机执行什么任务。
一般常用的公共功能代码如下：（十六进制显示）
读线圈状态----------------01
读离散输入寄存器-------02
读保持寄存器-------------03
读输入寄存器-------------04
写单个线圈----------------05
写单个保持寄存器-------06
写多个线圈----------------0F
写多个保持寄存器-------10
数据区：数据区包含需要从机执行什么动作或者从机采集的返回信息，这些信息可以是数值、参考地址等。例如：功能码告诉从机读取寄存器的值，则数据区必须包含要读取寄存器的起始地址和读取寄存器个数。
错误校验码：主机或者从机可用校验码判别接收的信息是否出错。有时候，由于电子噪声或者一些其他的干扰，信息在传输的过程中可能会发生细微的变化，错误校验码保证了主机或者从机在对传输过程中错误的信息不起作用，可以理解为接收错误的信息不执行响应请求，这样增加了系统的安全和效率。
一般Modbus RTU采用16位CRC校验。循环冗余码（CRC）由发送端计算，放置于发送消息的尾部，接收端对接收的信息重新计算CRC码吗，比较计算得到的CRC码与接收到的是否相符，如果不相符，则表明数据有错，不进行消息响应。
如何在android上实现Modbus RTU Master？
- 首先要获取到SerialPort实例
我之前写了三种方法可以获取到SerialPort实例。
1、快速使用Android串口
2、Android串口使用2之使用Google官方库android-serialport-api
3、Android串口使用3之使用CMake工具完成android-serialport-api库的移植
//第1种使用serialport第三方库
public ModbusRtuMaster(SerialHelper serialHelper)
this.serialHelper = serialHelper;
//第2、3种使用Google官方库android-serialport-api
public ModbusRtuMaster(SerialPort serialPort)
this.serialPort = serialPort;
无论是哪种方式获取，目的都是获取输出流，发送数据。
//第1种
this.serialHelper.send(sendBytes);
//第2、3种
this.mOutputStream = this.serialPort.getOutputStream();
this.mOutputStream.write(sendBytes);
- 组装Modbus RTU消息帧
/**
* 组装Modbus RTU消息帧
* @param slave 从站地址号
* @param function_code 功能码
* @param starting_address 读取寄存器起始地址 / 写入寄存器地址 / 写入寄存器起始地址
* @param quantity_of_x 读取寄存器个数 / 写入寄存器个数
* @param output_value 需要写入单个寄存器的数值
* @param output_values 需要写入多个寄存器的数组
* @return 将整个消息帧转成byte[]
* @throws ModbusError Modbus错误
*/
synchronized private byte[] execute(int slave, int function_code, int starting_address, int quantity_of_x,
int output_value, int[] output_values) throws ModbusError
//检查参数是否符合协议规定
if (slave < 0 || slave > 0xff)
throw new ModbusError(ModbusErrorType.ModbusInvalidArgumentError, "Invalid slave " + slave);
if (starting_address < 0 || starting_address > 0xffff)
throw new ModbusError(ModbusErrorType.ModbusInvalidArgumentError, "Invalid starting_address " + starting_address);
if (quantity_of_x < 1 || quantity_of_x > 0xff)
throw new ModbusError(ModbusErrorType.ModbusInvalidArgumentError, "Invalid quantity_of_x " + quantity_of_x);
// 构造request
ByteArrayWriter request = new ByteArrayWriter();
//写入从站地址号
request.writeInt8(slave);
//根据功能码组装数据区
//如果为读取寄存器指令
if (function_code == ModbusFunction.READ_COILS || function_code == ModbusFunction.READ_DISCRETE_INPUTS
|| function_code == ModbusFunction.READ_INPUT_REGISTERS || function_code == ModbusFunction.READ_HOLDING_REGISTERS)
request.writeInt8(function_code);
request.writeInt16(starting_address);
request.writeInt16(quantity_of_x);
else if (function_code == ModbusFunction.WRITE_SINGLE_COIL || function_code == ModbusFunction.WRITE_SINGLE_REGISTER) //写单个寄存器指令
if (function_code == ModbusFunction.WRITE_SINGLE_COIL)
if (output_value != 0) output_value = 0xff00;//如果为线圈寄存器（写1时为 FF 00,写0时为00 00）
request.writeInt8(function_code);
request.writeInt16(starting_address);
request.writeInt16(output_value);
else if (function_code == ModbusFunction.WRITE_COILS) //写多个线圈寄存器
request.writeInt8(function_code);
request.writeInt16(starting_address);
request.writeInt16(quantity_of_x);
//计算写入字节数
int writeByteCount = (quantity_of_x / 8) + 1;/// 满足关系-> (w /8) + 1
//写入数量 == 8 ,则写入字节数为1
if (quantity_of_x % 8 == 0)
writeByteCount -= 1;
request.writeInt8(writeByteCount);
int index = 0;
//如果写入数据数量 > 8 ，则需要拆分开来
int start = 0;//数组开始位置
int end = 7;//数组结束位置
int[] splitData = new int[8];
//循环写入拆分数组，直到剩下最后一组 元素个数 <= 8 的数据
while (writeByteCount > 1)
writeByteCount--;
int sIndex = 0;
for (index = start; index <= end; index++)
splitData [sIndex++] = output_values[index];
//数据反转 对于是否要反转要看你传过来的数据，如果高低位顺序正确则不用反转
splitData = reverseArr(splitData);
//写入拆分数组
request.writeInt8(toDecimal(splitData));
start = index;
end += 8;
//写入最后剩下的数据
int last = quantity_of_x - index;
int[] tData = new int[last];
System.arraycopy(output_values, index, tData, 0, last);
//数据反转 对于是否要反转要看你传过来的数据，如果高低位顺序正确则不用反转
tData = reverseArr(tData);
request.writeInt8(toDecimal(tData));
else if (function_code == ModbusFunction.WRITE_HOLDING_REGISTERS) //写多个保持寄存器
request.writeInt8(function_code);
request.writeInt16(starting_address);
request.writeInt16(quantity_of_x);
request.writeInt8(2 * quantity_of_x);
//写入数据
for (int v : output_values)
request.writeInt16(v);
else
throw new ModbusError(ModbusErrorType.ModbusFunctionNotSupportedError, "Not support function " + function_code);
byte[] bytes = request.toByteArray();
//计算CRC校验码
int crc = CRC16.compute(bytes);
request.writeInt16Reversal(crc);
bytes = request.toByteArray();
return bytes;
ModbusErrorType
/**
* 常见的Modbus通讯错误
*/
public enum ModbusErrorType
ModbusError,
ModbusFunctionNotSupportedError,
ModbusDuplicatedKeyError,
ModbusMissingKeyError,
ModbusInvalidBlockError,
ModbusInvalidArgumentError,
ModbusOverlapBlockError,
ModbusOutOfBlockError,
ModbusInvalidResponseError,
ModbusInvalidRequestError,
ModbusTimeoutError
ModbusError
public class ModbusError extends Exception
private int code;
public ModbusError(int code, String message)
super(!TextUtils.isEmpty(message) ? message : "Modbus Error: Exception code = " + code);
this.code = code;
public ModbusError(int code)
this(code, null);
public ModbusError(ModbusErrorType type, String message)
super(type.name() + ": " + message);
public ModbusError(String message)
super(message);
public int getCode()
return this.code;
ModbusFunction
/**
* 功能码（十进制显示）
*/
public class ModbusFunction
//读线圈寄存器
public static final int READ_COILS = 1;
//读离散输入寄存器
public static final int READ_DISCRETE_INPUTS = 2;
//读保持寄存器
public static final int READ_HOLDING_REGISTERS = 3;
//读输入寄存器
public static final int READ_INPUT_REGISTERS = 4;
//写单个线圈寄存器
public static final int WRITE_SINGLE_COIL = 5;
//写单个保持寄存器
public static final int WRITE_SINGLE_REGISTER = 6;
//写入多个线圈寄存器
public static final int WRITE_COILS = 15;
//写入多个保持寄存器
public static final int WRITE_HOLDING_REGISTERS = 16;
ByteArrayWriter
public class ByteArrayWriter extends ByteArrayOutputStream
public ByteArrayWriter()
super();
public void writeInt8(byte b)
this.write(b);
public void writeInt8(int b)
this.write((byte)b);
public void writeInt16(int n)
byte[] bytes = ByteUtil.fromInt16(n);
this.write(bytes, 0, bytes.length);
public void writeInt16Reversal(int n)
byte[] bytes=ByteUtil.fromInt16Reversal(n);
this.write(bytes,0,bytes.length);
public void writeInt32(int n)
byte[] bytes = ByteUtil.fromInt32(n);
this.write(bytes, 0, bytes.length);
public void writeBytes(byte[] bs,int len)
this.write(bs,0,len);
ByteUtil
public class ByteUtil
public static String toHexString(byte[] input, String separator)
if (input==null) return null;
StringBuilder sb = new StringBuilder();
for (int i = 0; i < input.length; i++)
if (separator != null && sb.length() > 0)
sb.append(separator);
String str = Integer.toHexString(input[i] & 0xff);
if (str.length() == 1) str = "0" + str;
sb.append(str);
return sb.toString();
public static String toHexString(byte[] input)
return toHexString(input, " ");
public static byte[] fromInt32(int input)
byte[] result=new byte[4];
result[3]=(byte)(input >> 24 & 0xFF);
result[2]=(byte)(input >> 16 & 0xFF);
result[1]=(byte)(input >> 8 & 0xFF);
result[0]=(byte)(input & 0xFF);
return result;
public static byte[] fromInt16(int input)
byte[] result=new byte[2];
result[0]=(byte)(input >> 8 & 0xFF);
result[1]=(byte)(input & 0xFF);
return result;
public static byte[] fromInt16Reversal(int input)
byte[] result=new byte[2];
result[1]=(byte)(input>>8&0xFF);
result[0]=(byte)(input&0xFF);
return result;
CRC16
public class CRC16
private static final byte[] crc16_tab_h = (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40,
(byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x01, (byte) 0xC0, (byte) 0x80,
(byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0,
(byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x00,
(byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41,
(byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81,
(byte) 0x40, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01, (byte) 0xC0,
(byte) 0x80, (byte) 0x41, (byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) 0x01,
(byte) 0xC0, (byte) 0x80, (byte) 0x41, (byte) 0x01, (byte) 0xC0, (byte) 0x80, (byte) 0x41,
(byte) 0x00, (byte) 0xC1, (byte) 0x81, (byte) 0x40, (byte) Modbus库开发笔记之二：Modbus消息帧的生成
Modbus库开发笔记之三：Modbus TCP Server开发
Modbus协议栈应用实例之二：Modbus RTU从站应用
Modbus库开发笔记之九：利用协议栈开发Modbus TCP Server应用