IOT云平台 simple（5）springboot netty实现modbus TCP Master

Dear 丶 2024-03-31 16:32 64阅读 0赞

本系列教程包括：  
[IOT云平台 simple（0）IOT云平台简介][IOT_ simple_0_IOT]  
[IOT云平台 simple（1）netty入门][IOT_ simple_1_netty]  
[IOT云平台 simple（2）springboot入门][IOT_ simple_2_springboot]  
[IOT云平台 simple（3）springboot netty实现TCP Server][IOT_ simple_3_springboot netty_TCP Server]  
[IOT云平台 simple（4）springboot netty实现简单的mqtt broker][IOT_ simple_4_springboot netty_mqtt broker]  
[IOT云平台 simple（5）springboot netty实现modbus TCP Master][IOT_ simple_5_springboot netty_modbus TCP Master]  
[IOT云平台 simple（6）springboot netty实现IOT云平台基本的架构（mqtt、Rabbitmq）][IOT_ simple_6_springboot netty_IOT_mqtt_Rabbitmq]

本章首先简单的介绍了modbus，然后利用springboot netty实现了简单的modbus TCP Master。

由于modbus是应答式的交互，这里通过HTTP请求触发springboot netty发送modbus TCP请求，网络调试工具收到请求后发送响应message。  
![在这里插入图片描述][175db8de7a504e9fb4fa7eb35e8a4f27.png]

这里：  
**modbus TCP Master**：springboot netty  
**modbus TCP Slave**：网络调试工具  
**postman**：http触发springboot netty主动发送请求；

## 1 Modbus入门 ##

Modbus在串行链路上分为Slave和Master、  
Modbus协议使用的是主从通讯技术，即由主设备主动查询和操作设备。  
Modbus Master：主控设备方；  
Modbus Slave：从设备方。

Modbus协议有3种模式：  
1）RTU  
2）ASCII  
3）TCP

### 1.1 Modbus-RTU ###

基于串口的Modbus-RTU 数据按照标准串口协议进行编码，是使用最广泛的一种Modbus协议，采用CRC-16\_Modbus校验算法。

**具体协议：**  
![在这里插入图片描述][8d34645705bd40a5978516f2b2564cab.png]

### 1.2 Modbus-ASCII ###

基于串口的Modbus-ASCII 所有数据都是ASCII格式，一个字节的原始数据需要两个字符来表示，效率低，采用LRC校验算法。

**具体协议：**  
![在这里插入图片描述][005158546f384ce58d7095e73a5654f9.png]

### 1.3 Modbus-TCP ###

基于网口的Modbus-TCP Modbus-TCP基于TCP/IP协议，占用502端口，数据帧主要包括两部分：MBAP（报文头）+PDU（帧结构），数据块与串行链路是一致的。

**具体协议：**

![在这里插入图片描述][72e8197457ee4a14ba46ab88e4bfe631.png]

## 2 Modbus TCP master集成开发 ##

Modbus TCP是运行在TCP/IP之上的应用层，所以master基本就是个TCP Server。  
创建主要的类：  
1） TCPServer  
server类。  
2 ）TCPServerChannelInitializer  
server channel初始化的类  
3）TCPServerStartListener：监听到springboot启动后，启动TCPServer。

TCPServerChannelInitializer中增加了编码解码器。

socketChannel.pipeline().addLast("decoder", new TCPModbusResDecoder());
            socketChannel.pipeline().addLast("encoder", new TCPModbusReqEncoder());
            socketChannel.pipeline().addLast("tcpModbus", new TCPModbusResHandler());

### 2.1 定义message ###

定义message：

public class TCPModbusMessage {
        
        public MBAPHeader mbapHeader;
        public PduPayload pduPayload;
    }

其中header：

public class MBAPHeader {
        
        //事务处理标识符 递增
        private short transactionId;
        //协议标识符 0x00 标识modbus协议
        private short protocolId;
        //长度,unitId + pdu长度
        private short length;
        //单元标识符,从机地址
        private byte unitId;
    
        public MBAPHeader(short transactionId, short protocolId, short length, byte unitId) {
        
            this.transactionId = transactionId;
        }
    
        public MBAPHeader() {
        
    
        }
    
        public int getTransactionId() {
        
            return transactionId;
        }
    
        public void setTransactionId(short transactionId) {
        
            this.transactionId = transactionId;
        }
    
        public int getProtocolId() {
        
            return protocolId;
        }
    
        public void setProtocolId(short protocolId) {
        
            this.protocolId = protocolId;
        }
    
        public int getLength() {
        
            return length;
        }
    
        public void setLength(short length) {
        
            this.length = length;
        }
    
        public short getUnitId() {
        
            return unitId;
        }
    
        public void setUnitId(byte unitId) {
        
            this.unitId = unitId;
        }
    
        public String toString() {
        
            return "transactionId:" + transactionId
                    + ",protocolId:" + protocolId
                    + ",length:" + length
                    + ",unitId:" + unitId;
    
        }
    }

其中pdu消息主体：

public class PduPayload {
        
        private short functionCode;
        private short dataLength;//数据字节的长度
        private byte[] data;
    
        public void setFunctionCode(short  code){
        
            functionCode = code;
        }
        public short getFunctionCode(){
        
            return functionCode;
        }
    
        public short getDataLength() {
        
            return dataLength;
        }
    
        public void setDataLength(short dataLength) {
        
            this.dataLength = dataLength;
        }
    
        public byte[] getData() {
        
            return data;
        }
    
        public void setData(byte[] data) {
        
            this.data = data;
        }
    
    }

### 2.2 定义编码解码 ###

#### 2.2.1 解码 ####

解码定义ByteToMessageDecoder：

public class TCPModbusResDecoder extends ByteToMessageDecoder {
        
    
        @Override
        protected void decode(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf, List<Object> list) {
        
            try {
        
                byteBuf.resetReaderIndex();
                int count = byteBuf.readableBytes();
                log.info("TCPModbusResDecoder decode:" + count);
    
                ByteBuf byteBuf1 = Unpooled.copiedBuffer(byteBuf);
                TCPModbusByteBufHolder tcpModbusByteBufHolder = new TCPModbusByteBufHolder(byteBuf1);
                list.add(tcpModbusByteBufHolder);
    
                byteBuf.clear();
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }

解码定义SimpleChannelInboundHandler：

public class TCPModbusResHandler extends SimpleChannelInboundHandler<TCPModbusByteBufHolder> {
        
        public static final int HEADER_LENGTH = 8;// // transactionId(2) + protocolId(2) + length(2) + unitId(1)+ functionCode(1)
    
        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
        
            log.info("channelActive");
            Channel channel = ctx.channel();
            log.info("channelActive channelId:" + channel.id().asLongText());
            log.info("channelActive 终端:" + channel.remoteAddress());
            ChannelManager.addChannel(channel.remoteAddress().toString(), channel);
        }
    
        @Override
        public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        
            log.info("channelInactive");
            Channel channel = ctx.channel();
            ChannelManager.removeChannel(channel.remoteAddress().toString());
        }
    
        @Override
        protected void channelRead0(ChannelHandlerContext channelHandlerContext, TCPModbusByteBufHolder modbusByteBufHolder) {
        
            log.info("channelRead0");
            int totalLen = modbusByteBufHolder.content().readableBytes();
            log.info("channelRead0:" + totalLen);
            if (totalLen < HEADER_LENGTH) {
        
                log.info("not modbus TCP protocol:");
                return;
            }
            //header
            MBAPHeader mbapHeader = MBAPHeaderDecoder.decode(modbusByteBufHolder.content());
            log.info("mbapHeader:" + mbapHeader.toString());
            //pdu
            PduPayload pduPayload = new PduPayload();
            short functionCode = modbusByteBufHolder.content().readUnsignedByte();
            pduPayload.setFunctionCode(functionCode);
            log.info("functionCode:" + functionCode);
            int dataLength = 0;
            if (totalLen > HEADER_LENGTH) {
        
                dataLength = totalLen - HEADER_LENGTH;
            }
            pduPayload.setDataLength((short) dataLength);
            log.info("dataLength:" + dataLength);
            byte[] data = new byte[dataLength];
            modbusByteBufHolder.content().readBytes(data);
            pduPayload.setData(data);
    
            RecMessageStrategy messageStrategy = RecMessageStrategyManager.getMessageStrategy(functionCode);
            if (messageStrategy != null) {
        
                messageStrategy.recMessage(channelHandlerContext.channel(), mbapHeader, pduPayload);
            } else {
        
                log.info("not support function code...");
            }
    
        }
    
        @Override
        public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        
            log.info("channelReadComplete");
            ctx.flush();
        }
    
        @Override
        public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        
            log.info("handlerRemoved");
            ctx.close();
        }
    
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        
            log.info("exceptionCaught");
            Channel channel = ctx.channel();
            ChannelManager.removeChannel(channel.remoteAddress().toString());
            cause.printStackTrace();
        }
    }

这里针对Message接收处理定义了一个策略：

public interface RecMessageStrategy {
        
        void recMessage(Channel channel, MBAPHeader mbapHeader, PduPayload pduPayload);
    }

增加了不同类型消息策略的管理：

public class RecMessageStrategyManager {
        
    
        //根据消息类型获取对应的策略类
        public static RecMessageStrategy getMessageStrategy(int functionCode){
        
            switch (functionCode){
        
                case FunctionCodeConstants
                        .ReadCoils:
                    return new ReadCoilsResMessageStrategy();
                case FunctionCodeConstants
                        .ReadDiscreteInputs:
                    return new ReadDiscreteInputsResMessageStrategy();
                case FunctionCodeConstants
                        .ReadHoldingRegisters:
                    return new ReadHoldingRegistersResMessageStrategy();
                case FunctionCodeConstants
                        .ReadInputRegisters:
                    return new ReadInputRegistersResMessageStrategy();
                case FunctionCodeConstants
                        .WriteSingleCoil:
                    return new WriteSingleCoilResMessageStrategy();
                case FunctionCodeConstants
                        .WriteSingleRegister:
                    return new WriteSingleRegisterResMessageStrategy();
                case FunctionCodeConstants
                        .WriteMultipleCoils:
                    return new WriteMultipleCoilsResMessageStrategy();
                case FunctionCodeConstants
                        .WriteMultipleRegisters:
                    return new WriteMultipleRegistersResMessageStrategy();
                default:
                    return null;
            }
        }
    
    }

#### 2.2.2 编码 ####

定义编码器：

public class TCPModbusReqEncoder extends MessageToByteEncoder<TCPModbusMessage> {
        
    
        @Override
        protected void encode(ChannelHandlerContext channelHandlerContext, TCPModbusMessage tcpModbusMessage, ByteBuf byteBuf) throws Exception {
        
            log.info("-----------TCPModbusReqEncoder encode begin------------");
            //header
            MBAPHeaderEncoder.encode(byteBuf, tcpModbusMessage.mbapHeader);
            log.info("header:"+tcpModbusMessage.mbapHeader.toString());
    
            //functionCode
            int functionCode = tcpModbusMessage.pduPayload.getFunctionCode();
            log.info("functionCode:"+functionCode);
    
            SendMessageStrategy sendMessageStrategy = new SendMessageStrategy();
            sendMessageStrategy.sendMessage(byteBuf,tcpModbusMessage.pduPayload);
            log.info("data:"+ ByteUtil.bytesToHexString(tcpModbusMessage.pduPayload.getData()));
            log.info("-----------TCPModbusReqEncoder encode end------------");
        }
    }

这里定义了一个message发送的策略：

public class SendMessageStrategy {
        
    
        public ByteBuf sendMessage(ByteBuf byteBuf, PduPayload pduPayload) {
        
            log.info("SendMessageStrategy ");
            byteBuf.writeByte(pduPayload.getFunctionCode());
            byteBuf.writeBytes(pduPayload.getData());
            return byteBuf;
        }
    }

## 3 测试运行 ##

这里通过测试以下功能：  
1）读线圈状态（readCoils）  
2）读保持寄存器（readHoldingRegisters）  
3）写单个线圈（writeSingleCoil）  
4）写单个寄存器（writeSingleRegister）

注：这里网络调试工具发送modbus TCP响应message是手动输入模拟的。

### 3.1 读线圈状态（readCoils） ###

事务处理标识符（transactionId）：1  
功能码（functionCode）：1  
从机地址（unitId）：1

第1步：http触发请求：  
![在这里插入图片描述][b10d2543d23640fcbe65c6a97c728dd8.png]  
第2步：springboot netty发送modbus TCP请求：  
![在这里插入图片描述][fa0bd52acc5b45629cb2458502dbec2b.png]  
第3步：网络调试工具收到请求：  
![在这里插入图片描述][ae7f2936934c4e96916b41284f547b21.png]  
第4步：网络调试工具发送modbus TCP响应：  
![在这里插入图片描述][ddcb8fc7db9e469e87dd8aef46410e33.png]  
第5步：springboot netty收到响应：  
![在这里插入图片描述][fa613340906841a485eb760fc589e67f.png]

### 3.2 读保持寄存器（readHoldingRegisters） ###

事务处理标识符（transactionId）：2  
功能码（functionCode）：3  
从机地址（unitId）：1

第1步：http触发请求：  
![在这里插入图片描述][40d9d9b2cc5b46158aab14485fa8debb.png]  
第2步：springboot netty发送modbus TCP请求：  
![在这里插入图片描述][43e30223d36e4ad383fbcc4e02b00bd5.png]  
第3步：网络调试工具收到请求：  
![在这里插入图片描述][df269c16932d46528aa599e8c083b5a5.png]  
第4步：网络调试工具发送modbus TCP响应：  
![在这里插入图片描述][623183992b6b435cb951b44f77090c51.png]  
第5步：springboot netty收到响应：  
![在这里插入图片描述][779cc5d6158b47dab2b11cc0944e183c.png]

### 3.3 写单个线圈（writeSingleCoil） ###

事务处理标识符（transactionId）：3  
功能码（functionCode）：5  
从机地址（unitId）：1

第1步：http触发请求：  
![在这里插入图片描述][2038f0f4f73a46888ac0c5d09050bf63.png]  
第2步：springboot netty发送modbus TCP请求：  
![在这里插入图片描述][bbc6e7aaa49c420aa6c93325d4df8466.png]  
第3步：网络调试工具收到请求：  
![在这里插入图片描述][98ba167cc2d5484fba51464723dbeca6.png]  
第4步：网络调试工具发送modbus TCP响应：  
![在这里插入图片描述][5963e744d84146abafca6db81fdc73fe.png]  
第5步：springboot netty收到响应：  
![在这里插入图片描述][4d28013512d449698d33163a052bed8d.png]

### 3.4 写单个寄存器（writeSingleRegister） ###

事务处理标识符（transactionId）：4  
功能码（functionCode）：6  
从机地址（unitId）：1

第1步：http触发请求：  
![在这里插入图片描述][2f4b9fe91ed144e6b1854a15f403de1f.png]  
第2步：springboot netty发送modbus TCP请求：  
![在这里插入图片描述][fb2840cc2bdf49759075532c811be52f.png]  
第3步：网络调试工具收到请求：  
![在这里插入图片描述][cf0599bb228443a5b30caebbf3197d2a.png]  
第4步：网络调试工具发送modbus TCP响应：  
![在这里插入图片描述][512a81a689504d4e8a9ee09bc8cf468f.png]  
第5步：springboot netty收到响应：  
![在这里插入图片描述][4e571f2f7d87487b8ba814747ca6dae1.png]

代码详见：  
[https://gitee.com/linghufeixia/iot-simple][https_gitee.com_linghufeixia_iot-simple]  
code4

[IOT_ simple_0_IOT]: https://blog.csdn.net/afei8080/article/details/115539444
[IOT_ simple_1_netty]: https://blog.csdn.net/afei8080/article/details/115539643
[IOT_ simple_2_springboot]: https://blog.csdn.net/afei8080/article/details/115540777
[IOT_ simple_3_springboot netty_TCP Server]: https://blog.csdn.net/afei8080/article/details/127832895
[IOT_ simple_4_springboot netty_mqtt broker]: https://blog.csdn.net/afei8080/article/details/127899022
[IOT_ simple_5_springboot netty_modbus TCP Master]: https://blog.csdn.net/afei8080/article/details/128242813
[IOT_ simple_6_springboot netty_IOT_mqtt_Rabbitmq]: https://blog.csdn.net/afei8080/article/details/128557674
[175db8de7a504e9fb4fa7eb35e8a4f27.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/f22c2a7a561b4eccb0bb6f90a39ed409.png
[8d34645705bd40a5978516f2b2564cab.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/95493718a7f241ba94b115c4c4b35174.png
[005158546f384ce58d7095e73a5654f9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/ef2e4a73b13a4f418d2d5462b2e762a5.png
[72e8197457ee4a14ba46ab88e4bfe631.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/e0fa6796ac6d448cb8d098acc1836bd3.png
[b10d2543d23640fcbe65c6a97c728dd8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/6415e15ab81c40c7bfc6a3ecedd9702e.png
[fa0bd52acc5b45629cb2458502dbec2b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/1c871938eec343bba6057605e4104a4e.png
[ae7f2936934c4e96916b41284f547b21.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/b50b3ccb1d0b4326840440584b004ef8.png
[ddcb8fc7db9e469e87dd8aef46410e33.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/ab80d9d3ddb04841a3d3e46178f465aa.png
[fa613340906841a485eb760fc589e67f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/c47015f5bf6e4bbea56a107670876f84.png
[40d9d9b2cc5b46158aab14485fa8debb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/d2812d0ed0064413856c6b3a3368a05e.png
[43e30223d36e4ad383fbcc4e02b00bd5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/29ae121ba8d1483aad39a730011b620e.png
[df269c16932d46528aa599e8c083b5a5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/d1d0f1b37fd54ad5ae45744b717875cc.png
[623183992b6b435cb951b44f77090c51.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/8fa9d8912f1444c3b6bfe0495ee5a3dd.png
[779cc5d6158b47dab2b11cc0944e183c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/fa463debd95e499692fdc8b7cbb80c42.png
[2038f0f4f73a46888ac0c5d09050bf63.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/a5d8dac713f741468165d6a65a615e1e.png
[bbc6e7aaa49c420aa6c93325d4df8466.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/3cf53d9b42144712948e1e7470904f35.png
[98ba167cc2d5484fba51464723dbeca6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/f007328dd15d42ab9a59f1ca96e5eb73.png
[5963e744d84146abafca6db81fdc73fe.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/f1aae71eae8546e599bd7e340f92ee5f.png
[4d28013512d449698d33163a052bed8d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/2ad9a6af865649bb9ab07750cef01023.png
[2f4b9fe91ed144e6b1854a15f403de1f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/d8815fee247b4d72a176abfa224f4b43.png
[fb2840cc2bdf49759075532c811be52f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/e9d7bc7d5c504410bf578379ebfcd5af.png
[cf0599bb228443a5b30caebbf3197d2a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/1ba1d7db6fc246c9922ef639d0af8fda.png
[512a81a689504d4e8a9ee09bc8cf468f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/8535b93459aa4f5a90e33950eeddd558.png
[4e571f2f7d87487b8ba814747ca6dae1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/b4c7e7532d484118abe5f3022f233120.png
[https_gitee.com_linghufeixia_iot-simple]: https://gitee.com/linghufeixia/iot-simple