ModbusRTU\TCP消息帧解析(C#实现报文发送与解析)

这篇具有很好参考价值的文章主要介绍了ModbusRTU\TCP消息帧解析(C#实现报文发送与解析)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

知识点

  1. PLC寄存器中存储(整型和无符号整型:2字节。长整型:4字节。单精度浮点数:4字节。双精度浮点数:8字节),我们只要知道数据类型,是2个字节一截取,还是4个字节 ,对接收到的报文进行字节截取然后编码成str就行
  2. 向PLC中写入Float,float占4个字节=2个寄存器,所以要使用功能码“写多寄存器0x10”, 功能码0x06只能写一个寄存器”
  3. serialPort.write(bytes,0,bytes.Length); thread.sleep(300); serialPort.Read() 发完指令后,要等待从站响应300ms,然后再去读数据
  4. 主站请求从站有两种方式:主动(手动点击查询线圈状态的按钮)被动(通过委托方式,一件事情的发生触发另外事件。场景:称菜,菜一放上去,触发去查询的功能代码块)
  5. 一个F要用4个二进制表示,两个F用8个二进制表示,所以 0xFA :表示1个字节
  6. modbusTCP响应 Tx:00 00 00 00 00 03 01 83 02 【83=1000 0011 (功能码03 的高位为1,就是异常)02是错误码代号要查表】
    modbus rtu over tcp/ip c#,c#,网络,服务器
  7. send()/recv()和write()/read():发送数据和接收数据 参考链接
  8. socket原理
  9. 不同协议图,
    modbus rtu over tcp/ip c#,c#,网络,服务器
  10. 比如omoronsocekt, modbustcp,他们都是用socket进行数据交互,只是他们在应用层采用不同的协议约定,对报文进行不同方式的解析;明文协议就是直接编码不组包,其他协议都是组包发出去(如明文协议,将字符串编码后直接send
    modbustcp协议,要组装发送报文为(从站地址+功能码+等等+字符串数据))

常用链接

虚拟串口调试工具 V6.9 汉化版免费版
modbus rtu over tcp/ip c#,c#,网络,服务器
串口、Modbus通信协议

一、Modbus

课程
文章介绍
一篇博客

1.ModbusRTU消息帧解析

modbus rtu over tcp/ip c#,c#,网络,服务器
modbus rtu over tcp/ip c#,c#,网络,服务器
modbus rtu over tcp/ip c#,c#,网络,服务器
modbus rtu over tcp/ip c#,c#,网络,服务器
modbus rtu over tcp/ip c#,c#,网络,服务器
modbus rtu over tcp/ip c#,c#,网络,服务器

modbus rtu over tcp/ip c#,c#,网络,服务器
modbus rtu over tcp/ip c#,c#,网络,服务器
modbus rtu over tcp/ip c#,c#,网络,服务器

2.主站poll、从站slave通讯仿真-modbusRTU

从站slave用于模拟PLC中的功能区,一个tab页表示一个功能模块(下图建了两个功能块)
主站poll发送请求,获取PLC中数据。
poll、slave都要设置connection、setup两个区域,只有参数配对了才能正常收发数据
modbus rtu over tcp/ip c#,c#,网络,服务器

1.功能码=01读线圈状态

modbus rtu over tcp/ip c#,c#,网络,服务器
modbus rtu over tcp/ip c#,c#,网络,服务器

报文都是16进制表示
16进制 0X01=0000 0001,一位16进制需要4位二进制表达(F =1111),两个16进制数字表示1个字节
线圈中数据要么是0,要么是1
读取长度:00 0A表示读取10个寄存器
响应字节数(单位是字节):02 表示两个字节,从02往后数两个字节都是数据未位
输出状态:A2 02 这是两字节,解析:先颠倒高低位 02 A2= 0000 0010 1010 0010 再反向读取数据0100 0101 0100 0000
modbus rtu over tcp/ip c#,c#,网络,服务器

2.功能码=03读保持寄存器

寄存器中数据可以是整数,浮点型 (整型和无符号整型:2字节。长整型:4字节。单精度浮点数:4字节。双精度浮点数:8字节)
modbus rtu over tcp/ip c#,c#,网络,服务器

报文解析(寄存器存整型)

读取长度:00 0A表示读取10个寄存器,1个寄存器是16位=2个字节,所以返回20个字节,一个整型=2字节,所以返回的是10个数据
响应字节数(单位是字节):14 表示20个字节
输出状态:007B 00 00 00 00 00 00 00 00 00 00 这是20个字节,解析: 第一个数为123
modbus rtu over tcp/ip c#,c#,网络,服务器

报文解析(寄存器存float)

读取长度:00 0A表示读取10个寄存器,1个寄存器是16位=2个字节,所以返回20个字节,一个float 占4字节,所以返回的是5个数据
响应字节数(单位是字节):14 表示20个字节
输出状态:解析: 42 0A 00 00 通过IEEE转换标准->第一个数为34.5
modbus rtu over tcp/ip c#,c#,网络,服务器

3.C#模拟主站Poll(ModbusRTU协议-组报文)

说明
1.下面代码模拟的是主站,需要开启小程序mbslave作为从站PLC
2.主站发起的功能码请求有:读线圈,读保持寄存器,写多个寄存器
3.主站发送报文,然后对响应报文按消息帧进行解析

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using System;
using System.Collections.Generic;
using System.IO.Ports;
using System.Linq;
using System.Threading;

namespace 通讯收发功能解析
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");

            //Test_0x01();
            Test_0x03();
            //Test_0x10();
            Console.ReadKey();
        }

        
        static void Test_0x01()/// 01功能码-读线圈状态测试,PLC中线圈全为0
        {
            ushort startAddr = 0;
            ushort readLen = 10;

            // 请求
            // byte[] 需要指定长度;不支持Linq
            List<byte> command = new List<byte>();
            command.Add(0x01);// 1号从站
            command.Add(0x01);// 功能码:读线圈状态
            // 起始地址
            command.Add(BitConverter.GetBytes(startAddr)[1]);
            command.Add(BitConverter.GetBytes(startAddr)[0]);
            // 读取数量
            command.Add(BitConverter.GetBytes(readLen)[1]);
            command.Add(BitConverter.GetBytes(readLen)[0]);

            // CRC
            command = CRC16(command);//command 为长度=8的字节{0x01 0x01 0x00 0x00 0x00 0x0A 0xBC 0x0D}
            // 以上报文组装完成

            // 发送-》SerialPort
            SerialPort serialPort = new SerialPort("COM1", 9600, Parity.None, 8, StopBits.One);
            // 打开串口
            serialPort.Open();
            //将command的第0位->command.count所有数据都发出去
            serialPort.Write(command.ToArray(), 0, command.Count);//发送报文为01 01 00 00 00 0A BC 0D   请求10个线圈的状态,响应时1个字节8位接收不够,所以两字节
            Thread.Sleep(5);//加上延时等待PLC反应时间
            // 进行响应报文的接收和解析 
            byte[] respBytes = new byte[serialPort.BytesToRead];//缓冲区信息
            serialPort.Read(respBytes, 0, respBytes.Length);
            // respBytes -> 01 01 02 00 00 B9 FC

            // 检查一个校验位

            //对报文进行解析数据
            List<byte> respList = new List<byte>(respBytes);
            respList.RemoveRange(0, 3);//00 00 B9 FC
            respList.RemoveRange(respList.Count - 2, 2);//00 00 数据报文
            // 1。高低位切换
            // 2。从后往前读
            respList.Reverse();
            var respStrList = respList.Select(r => Convert.ToString(r, 2)).ToList();
            var values = string.Join("", respStrList).ToList();
            values.Reverse();
            values.ForEach(c => Console.WriteLine(Convert.ToBoolean(int.Parse(c.ToString()))));
            //Convert.ToBoolean('1');
        }


        static void Test_0x03()//读保持寄存器  PLC中第一个寄存器为123,其他=0
        {
            ushort startAddr = 0;
            ushort readLen = 10;

            // 请求
            // byte[] 需要指定长度;不支持Linq
            List<byte> command = new List<byte>();
            command.Add(0x01);// 1号从站
            command.Add(0x03);// 功能码:读保持型寄存器
            // 起始地址
            command.Add(BitConverter.GetBytes(startAddr)[1]);
            command.Add(BitConverter.GetBytes(startAddr)[0]);
            // 读取数量
            command.Add(BitConverter.GetBytes(readLen)[1]);
            command.Add(BitConverter.GetBytes(readLen)[0]);

            // CRC
            command = CRC16(command);

            // 报文组装完成
            // 发送-》SerialPort
            SerialPort serialPort = new SerialPort("COM1", 9600, Parity.None, 8, StopBits.One);
            // 打开串口
            serialPort.Open();

            serialPort.Write(command.ToArray(), 0, command.Count);

            // 进行响应报文的接收和解析
            byte[] respBytes = new byte[serialPort.BytesToRead];
            serialPort.Read(respBytes, 0, respBytes.Length);
            // respBytes -> 01 01 02 00 00 B9 FC
            // 检查一个校验位
            List<byte> respList = new List<byte>(respBytes);
            respList.RemoveRange(0, 3);
            respList.RemoveRange(respList.Count - 2, 2);


            // 拿到实际的数据部分,进行数据解析
            // 明确一点:读的是无符号单精度,占两个字节
            //byte[] data = new byte[2]; 
            //for (int i = 0; i < readLen; i++)
            //{
            //    // 字节序问题    小端   大端
            //    data[0] = respList[i * 2 + 1];
            //    data[1] = respList[i * 2];
            //    // 根据此两个字节转换成想要的实际数字
            //    var value = BitConverter.ToUInt16(data, 0);
            //    Console.WriteLine(value);
            //}

            // 明确一点:读的是Float  占4个字节
            byte[] data = new byte[4];
            for (int i = 0; i < readLen / 2; i++)
            {
                // 字节序问题    小端   大端
                data[0] = respList[i * 4 + 3];
                data[1] = respList[i * 4 + 2];
                data[2] = respList[i * 4 + 1];
                data[3] = respList[i * 4];
                // 根据此两个字节转换成想要的实际数字
                var value = BitConverter.ToSingle(data, 0);
                Console.WriteLine(value);
            }
        }


        

        //向PLC中写入Float,float占4个字节=2个寄存器,所以要使用功能码“写多寄存器0x10”, 功能码0x06只能写一个寄存器”, 
        static void Test_0x10()//写多个寄存器功能码0x10
        {
            ushort startAddr = 2;
            ushort writeLen = 4;
            float[] values = new float[] { 123.45f, 14.3f };

            // 请求
            // byte[] 需要指定长度;不支持Linq
            List<byte> command = new List<byte>();
            command.Add(0x01);// 1号从站
            command.Add(0x10);// 功能码:写多个保持型寄存器
            // 写入地址
            command.Add(BitConverter.GetBytes(startAddr)[1]);
            command.Add(BitConverter.GetBytes(startAddr)[0]);
            // 写入数量
            command.Add(BitConverter.GetBytes(writeLen)[1]);
            command.Add(BitConverter.GetBytes(writeLen)[0]);


            // 获取数值的byte[]
            List<byte> valueBytes = new List<byte>();
            for (int i = 0; i < values.Length; i++)
            {
                List<byte> temp = new List<byte>(BitConverter.GetBytes(values[i]));
                temp.Reverse();// 调整字节序
                valueBytes.AddRange(temp);
            }

            // 字节数
            command.Add((byte)valueBytes.Count);
            command.AddRange(valueBytes);

            // CRC
            command = CRC16(command);

            // 报文组装完成
            // 发送-》SerialPort
            SerialPort serialPort = new SerialPort("COM1", 9600, Parity.None, 8, StopBits.One);
            // 打开串口
            serialPort.Open();

            serialPort.Write(command.ToArray(), 0, command.Count);
        }


        static List<byte> CRC16(List<byte> value, ushort poly = 0xA001, ushort crcInit = 0xFFFF)
        {
            if (value == null || !value.Any())
                throw new ArgumentException("");

            //运算
            ushort crc = crcInit;
            for (int i = 0; i < value.Count; i++)
            {
                crc = (ushort)(crc ^ (value[i]));
                for (int j = 0; j < 8; j++)
                {
                    crc = (crc & 1) != 0 ? (ushort)((crc >> 1) ^ poly) : (ushort)(crc >> 1);
                }
            }
            byte hi = (byte)((crc & 0xFF00) >> 8);  //高位置
            byte lo = (byte)(crc & 0x00FF);         //低位置

            List<byte> buffer = new List<byte>();
            buffer.AddRange(value);
            buffer.Add(lo);
            buffer.Add(hi);
            return buffer;
        }
    }
}

4.NModbus4模拟主站poll(ModbusRTU协议)

modbus rtu over tcp/ip c#,c#,网络,服务器
ReadHoldingRegisters(1, 0, 1)# 参数:从站地址,起始地址,读取数量
modbus rtu over tcp/ip c#,c#,网络,服务器
modbus rtu over tcp/ip c#,c#,网络,服务器
modbus rtu over tcp/ip c#,c#,网络,服务器

5.C#模拟主站Poll(ModbusTCP协议-组报文)

课程视频P17-P14

03读保持寄存器报文
modbus rtu over tcp/ip c#,c#,网络,服务器
modbus rtu over tcp/ip c#,c#,网络,服务器

说明
1.下面代码模拟的是modbusTCP主站,需要开启小程序mbslave作为从站PLC,要设置slave的connection、setup两个区域的TCP相关参数
2.主站发起的功能码请求有:ReadHoldingRegister,ReadInputRegister
3.主站发送报文,然后对响应报文按消息帧进行解析
modbus rtu over tcp/ip c#,c#,网络,服务器

using System;
using System.Collections.Generic;
using System.IO.Ports;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;

namespace 通讯收发功能解析
{
    public class ModbusTcp: ModbusBase
    {
        Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream,ProtocolType.Tcp);

       public Result connect(string host, int port)
        {
            Result result = new Result();
            try
            {
                socket.Connect(host, port);
                result.State = true;
            }
            catch (Exception ex)
            {
                result.State = false;
                result.Exception = ex.Message;
            }
            return result;


        }


        // 读保持型寄存器03
        // ModbusRTU:0x01(从站地址) 03 (功能码)  0x00 0x0A(起始地址)  0x00 0x05(读取长度)   0xXX 0xXX(CRC16校验码)
        // ModbusTCP:请求报文:0x00 0x00(TransationID 最大65535)  0x00 0x00 (Modbus协议标识)   0x00 0x06(后续字节数)   =>  0x01 (单元标识) 0x03  0x0 0x0A 0x00 0x05
        // 响应报文:                   0x00 0x00(TransationID 最大65535)   0x00 0x00 (Modbus协议标识)   0x00 0x0D(后续字节数)   =>  0x01 (单元标识) 0x03(功能码)=>
        //                                       0x0A(返回10个字节数据) 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
        /// <summary>
        ///
        /// </summary>
        /// <param name="unit_id">从站地址</param>
        /// <param name="start_addr">寄存器起始地址</param>
        /// <param name="count">读寄存器数量</param>
        public Result  ReadHoldingRegister(byte unit_id , ushort start_addr,ushort count)
        {
          
            Result result = new Result();
            try {
                
          ushort tid = 0;
          //报文组装
          byte[] req_bytes = new byte[]
          {
              (byte)(tid/256),(byte)(tid%256),
               0x00, 0x00,
               0x00, 0x06,
               unit_id,
               0x03,
                (byte)(start_addr/256),(byte)(start_addr%256),//10进制转成16
                 (byte)(count/256),(byte)(count%256),
          };
                tid++;
                tid %= 65535;

                //var req_bytes = this.ReadCommandBytes( unit_id,  0x03,start_addr,  count);

            //发送请求
            socket.Send(req_bytes);

            //接收响应
            byte[] resp_bytes = new byte[6];//由于plc返回的响应字数长度是不一样的,先取前6个字节
            socket.Receive(resp_bytes, 0 ,6 ,SocketFlags.None);

            var len_bytes = resp_bytes.ToList().GetRange(4, 2);
            ushort len = (ushort)(len_bytes[4] * 256 + len_bytes[5]);//解析报文中返回的有多少个字节数
            resp_bytes = new byte[len];//这个resp_bytes len 表明数据中有多少个字节数据是有用的数据报文
            socket.Receive(resp_bytes, 0, len, SocketFlags.None);//上面从缓存区拿走了6个字节,现在把剩余的都拿走

            //检查响应报文是否正常,功能码的高位为1,就是异常
            //0x83 1000 0011
            if (resp_bytes[1] > 0x80)
            {
                    //说明响应的是异常报文
                    // 返回异常信息 根据resp_bytes[2]字节进行异常的关联
                    throw new Exception("错误了");
            }

            //提取PLC中寄存器中的数据部分报文
             var data_bytes = resp_bytes.ToList().GetRange(3, resp_bytes[2]).ToArray();
                result.State = true;
                result.Datas = data_bytes;
              

            }
            catch(Exception ex)
            {
                result.State = false;
                result.Exception = ex.Message;

            }
            return result;

        }

        public Result ReadInputRegister(byte unit_id, ushort start_addr, ushort count)
        {

            Result result = new Result();
            try
            {
                
                ushort tid = 0;
                //报文组装
                byte[] req_bytes = new byte[]
                {
                (byte)(tid/256),(byte)(tid%256),
                 0x00, 0x00,
                 0x00, 0x06,
                 unit_id,
                 0x04,
                  (byte)(start_addr/256),(byte)(start_addr%256),//10进制转成16
                   (byte)(count/256),(byte)(count%256),
                };
                tid++;
                tid %= 65535;

                //var req_bytes = this.ReadCommandBytes(unit_id, 0x04, start_addr, count);
                //发送请求
                socket.Send(req_bytes);

                //接收响应
                byte[] resp_bytes = new byte[6];//由于plc返回的响应字数长度是不一样的,先取前6个字节
                socket.Receive(resp_bytes, 0, 6, SocketFlags.None);

                var len_bytes = resp_bytes.ToList().GetRange(4, 2);
                ushort len = (ushort)(len_bytes[4] * 256 + len_bytes[5]);//解析报文中返回的有多少个字节数
                resp_bytes = new byte[len];//这个resp_bytes len 表明数据中有多少个字节数据是有用的数据报文
                socket.Receive(resp_bytes, 0, len, SocketFlags.None);//上面从缓存区拿走了6个字节,现在把剩余的都拿走

                //检查响应报文是否正常,功能码的高位为1,就是异常
                //0x83 1000 0011
                if (resp_bytes[1] > 0x80)
                {
                    //说明响应的是异常报文
                    // 返回异常信息 根据resp_bytes[2]字节进行异常的关联
                    throw new Exception("错误了");
                }

                //解析PLC中寄存器中的数据
                var data_bytes = resp_bytes.ToList().GetRange(3, resp_bytes[2]).ToArray();
                result.State = true;
                result.Datas = data_bytes;


            }
            catch (Exception ex)
            {
                result.State = false;
                result.Exception = ex.Message;

            }
            return result;

        }

        public void write()
        {

        }

        public T[] Getvalues<T>(byte[] data_bytes)//解析报文
        {
            var type_len = Marshal.SizeOf(typeof(T));//检查类型的长度 , int32是4字节,float是4字节
            for (var i =0; i<data_bytes.Length;i+=type_len)
            {
                //根据数据类型将报文切割,获取一个类型的字节内容,并将字节转换成对应 的str
                var temp_bytes = data_bytes.ToList().GetRange(i, type_len);
                temp_bytes.Reverse();//字序
                short v = BitConverter.ToInt16(temp_bytes.ToArray(), 0);
                ushort vv = BitConverter.ToUInt16(temp_bytes.ToArray(), 0);
                float vvv = BitConverter.ToSingle(temp_bytes.ToArray(),0);

            }

            return null;
        }

    }
}

6.NModbus4模拟从站slave(ModbusTCP协议)

用小工具poll连接自己建立的从站,可读取从站的值
文章

using System.Threading;
using System.Net.Sockets;
using System.Net;
using Modbus.Data;
using Modbus.Device;
 public class slave
    {
        /// <summary>
        /// 服务器提供的数据区
        /// </summary>
        public  DataStore Data=DataStoreFactory.CreateDefaultDataStore(); //初始化服务数据区;

        /// <summary>
        /// Modbus服务器
        /// </summary>
        public  ModbusSlave modbus_tcp_server;

        public  void modbustcpslave()
        {
            
            modbus_tcp_server = ModbusTcpSlave.CreateTcp(1, new TcpListener(IPAddress.Parse("127.0.0.1"), 502)); //创建ModbusTcp服务器
            modbus_tcp_server.DataStore = Data;//数据区赋值

            Thread th_0 = new Thread(() =>
            {
                modbus_tcp_server.Listen();//异步 非阻塞 启动服务
            })
            {
                IsBackground = true,
            };
            th_0.SetApartmentState(ApartmentState.STA);
            th_0.Start();

            Thread th_1 = new Thread(() =>
            {
                SetData(); //数据区数据赋值
            })
            {
                IsBackground = true,
            };
            th_1.SetApartmentState(ApartmentState.STA);
            th_1.Start();

        }

        
        /// <summary>
        /// 设置数据
        /// </summary>
         public  void SetData() //static修饰的函数或变量都是在类初始化的时候加载的,而非静态的变量都是在对象初始化的时候加载。
        {
            while (true)
            {
                Data.InputRegisters[1] = (ushort)DateTime.Now.Year;         //年
                Data.InputRegisters[2] = (ushort)DateTime.Now.Month;        //月
                Data.InputRegisters[3] = (ushort)DateTime.Now.Day;          //日
                Data.InputRegisters[4] = (ushort)DateTime.Now.Hour;         //时
                Data.InputRegisters[5] = (ushort)DateTime.Now.Minute;       //分
                Data.InputRegisters[6] = (ushort)DateTime.Now.Second;       //秒
                Data.InputRegisters[7] = (ushort)DateTime.Now.Millisecond;  //毫秒
                Random ran = new Random();
                Data.InputRegisters[8] = (ushort)ran.Next(0, 32767);        //产生的随机数
            }
        }
}

7.NModbus4模拟从站slave(ModbusRTU协议)

文章

public class slave_RTU
    {
        public ModbusSlave modbus_rtu_server;
        public void create()
        {
            SerialPort slavePort = new SerialPort();
            slavePort.PortName = "COM1";
            slavePort.BaudRate = 9600;
            slavePort.DataBits = 8;
            slavePort.Parity = Parity.Even;
            slavePort.StopBits = StopBits.One;
            slavePort.Open();
            byte slaveID =1;
            modbus_rtu_server = ModbusSerialSlave.CreateRtu(slaveID, slavePort);
            modbus_rtu_server.ModbusSlaveRequestReceived += new EventHandler<ModbusSlaveRequestEventArgs>(Modbus_Request_Event);
            modbus_rtu_server.DataStore = Modbus.Data.DataStoreFactory.CreateDefaultDataStore();
            modbus_rtu_server.DataStore.DataStoreWrittenTo += new EventHandler<DataStoreEventArgs>(Modbus_DataStoreWriteTo);
            
            modbus_rtu_server.DataStore.InputRegisters[1] = (ushort)DateTime.Now.Year;
            modbus_rtu_server.DataStore.InputRegisters[2] = (ushort)DateTime.Now.Year;
            modbus_rtu_server.DataStore.InputRegisters[3] = (ushort)DateTime.Now.Year;
            modbus_rtu_server.DataStore.CoilDiscretes[1] = true;
            modbus_rtu_server.DataStore.CoilDiscretes[2] = false;
            modbus_rtu_server.DataStore.CoilDiscretes[3] = false;


            modbus_rtu_server.Listen();

        }
        private void Modbus_Request_Event(object sender, Modbus.Device.ModbusSlaveRequestEventArgs e)
        {
            try
            {
                //request from master
                byte fc = e.Message.FunctionCode;
                byte[] data = e.Message.MessageFrame;
                byte[] byteStartAddress = new byte[] { data[3], data[2] };
                byte[] byteNum = new byte[] { data[5], data[4] };
                Int16 StartAddress = BitConverter.ToInt16(byteStartAddress, 0);
                Int16 NumOfPoint = BitConverter.ToInt16(byteNum, 0);

                bool BOOL = true;

                string FCNUM = fc.ToString();
                
                if (fc.ToString() == "6")
                {
                    //AO
                    modbus_rtu_server.DataStore.HoldingRegisters[StartAddress] = 16;
                    modbus_rtu_server.DataStore.HoldingRegisters[StartAddress + 1] = 17;
                }
                
                Console.WriteLine(fc.ToString() + "," + StartAddress.ToString() + "," + NumOfPoint.ToString());
            }
            catch (Exception exc)
            {
                
            }

        }

        private void Modbus_DataStoreWriteTo(object sender, Modbus.Data.DataStoreEventArgs e)
        {
            //this.Text = "DataType=" + e.ModbusDataType.ToString() + "  StartAdress=" + e.StartAddress;
            int iAddress = e.StartAddress;//e.StartAddress;
            switch (e.ModbusDataType)
            {
                case ModbusDataType.HoldingRegister:
                    for (int i = 0; i < e.Data.B.Count; i++)
                    {
                        //Set AO                 
                        modbus_rtu_server.DataStore.HoldingRegisters[e.StartAddress + i + 1] = e.Data.B[i];
                        //e.Data.B[i] already write to slave.DataStore.HoldingRegisters[e.StartAddress + i + 1]
                        //e.StartAddress starts from 0
                        //You can set AO value to hardware here

                        //DoAOUpdate(iAddress, e.Data.B[i].ToString());
                        iAddress++;
                    }
                    break;

                case ModbusDataType.Coil:
                    for (int i = 0; i < e.Data.A.Count; i++)
                    {
                        //Set DO
                        modbus_rtu_server.DataStore.CoilDiscretes[e.StartAddress + i + 1] = e.Data.A[i];
                        //e.Data.A[i] already write to slave.DataStore.CoilDiscretes[e.StartAddress + i + 1]
                        //e.StartAddress starts from 0
                        //You can set DO value to hardware here

                        //DoDOUpdate(iAddress, e.Data.A[i]);
                        iAddress++;
                        if (e.Data.A.Count == 1)
                        {
                            break;
                        }
                    }
                    break;
            }

        }
    }

8.modbusRTU、modbusTCP报文不同之处

modbus rtu over tcp/ip c#,c#,网络,服务器

二、明文TCP

博客
视频
modbus rtu over tcp/ip c#,c#,网络,服务器
modbus rtu over tcp/ip c#,c#,网络,服务器文章来源地址https://www.toymoban.com/news/detail-774674.html

using System.Net;
         //创建Socket套接字
            Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            IPEndPoint point = new IPEndPoint(IPAddress.Parse(textBox1.Text), int.Parse(textBox2.Text));
            try { server.Bind(point); }
            catch (Exception ex)
            {
                MessageBox.Show("无法启动服务器");
            }
            server.Listen(3);//
            Socket Client = server.Accept();//Accept 抓取的连接请求是客户端发来的
             string client = Client.RemoteEndPoint.ToString();
            MessageBox.Show(client+"连接了服务器");
            byte[] b = new byte[1024 * 1024 * 2];//缓冲器
            int length = 0;
            try
            {
                length = Client.Receive(b);
               
            }
            catch
            {
                MessageBox.Show(client + "失去连接");
            }
            if (length > 0)
            {
                string msg = Encoding.Default.GetString(b, 0, length);
                Client.Send(Encoding.Default.GetBytes(textBox3.Text));
            }
            else
            {
                MessageBox.Show(client + "失去连接");
            }

到了这里,关于ModbusRTU\TCP消息帧解析(C#实现报文发送与解析)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 如何在Java实现TCP方式发送和接收Socket消息(多线程模式)

    在Java编程中,使用TCP协议进行Socket通信是非常常见的场景。本文将详细介绍如何在Java中实现TCP方式发送和接收Socket消息,并且利用多线程模式来提高通信效率。 首先,我们需要创建一个Server端来处理接收到的Socket连接请求。以下是实现的步骤: 创建一个ServerSocket对象,并指

    2024年02月12日
    浏览(35)
  • java实现阿里云rocketMQ消息的发送与消费(tcp协议sdk)

    登录阿里云官网,先申请rocketMQ,再申请Topic、Group ID,然后就是参考阿里云的JAVA SDK进行编程实现。 环境要求: 安装JDK 1.8或以上版本 安装Maven 安装Java SDK 参照 阿里云 官方文档,来一步一步操作。 文档提供的SDK有 TCP 和Http协议,这里使用 TCP协议 来实现rocketMQ消息的发送与消

    2024年02月07日
    浏览(42)
  • C#实现钉钉自定义机器人发送群消息帮助类

            在企业中,针对一些关键指标内容(如每天的生产产量、每天的设备报警信息等信息),需要同时给多人分享,此时就可以将需要查看这些数据的人员都拉到一个群中,让群里的机器人将这些关键指标内容推送到群里即可【(目前已实现在钉钉群里创建自定义机器

    2024年02月04日
    浏览(39)
  • 【C#】WCF和TCP消息通信练习,实现聊天功能

    主页面 聊天界面

    2024年02月08日
    浏览(41)
  • TCP之报文格式解析

    TCP网络协议是较常用的,也基本上都会接触,那么来简单了解下它吧。TCP 是一种面向连接的、可靠的传输协议,它能够将数据分成一些小块,并通过 Internet 进行传输。在 TCP 中,数据被分割成一些称为 TCP 报文段(TCP segment)的小块,每个 TCP 报文段携带了一部分数据,以及一

    2024年02月03日
    浏览(52)
  • Modbus TCP通信报文解析

    一、实现了读取线圈状态和写入多个线圈的功能。代码中包含了详细的注释说明,可以清晰地了解每个方法的功能和使用方式。 对于读取线圈状态的方法,使用时需要传入从站地址、起始地址和线圈数量,最后会返回一个 bool 数组,其中每个元素表示一个线圈的状态。 对于

    2024年02月15日
    浏览(47)
  • 【iOS】—— 实现WebSocket发送消息(SocketRocket第三方库的使用和解析)

    偶然之间了解到了利用WebSocket实现后端和前端的相互发送消息,就查了查在iOS里这个东西该怎么写,用舍友写的接口简单实现了两个用户的通信。 WebSocket 是一种在 Web 应用程序中实现双向通信的协议。它允许客户端和服务器之间建立一个持久性的连接,以便可以在任何时间点

    2024年02月15日
    浏览(53)
  • IP报文解析(TCP、UDP、 ICMP)及代码分享(C++)

    1.1 OSI 7层模型: 应用层: 功能:用户接口,文件传输、电子邮件、虚拟终端、文件服务 设备:网关 协议:HTTP、TFTP、SMTP、FTP、SNMP、DNS、Telnet 表示层: 功能:数据的表示,压缩和加密 设备:网关 协议:无 会话层: 功能:会话的建立和结束 设备:网关 协议:无 传输层:

    2024年02月09日
    浏览(42)
  • 全面解析UDP协议(特点、报文格式、UDP和TCP的区别)

    UDP是无连接通信协议,即在数据传输时,数据的发送端和接收端不建立逻辑连接。简单来说,当一台计算机向另外一台计算机发送数据时,发送端不会确认接收端是否存在,就会发出数据,同样接收端在收到数据时,也不会向发送端反馈是否收到数据。 特点 无连接:UDP通信

    2024年02月08日
    浏览(58)
  • 使用C#和RabbitMQ发送和接收消息

    通过NuGet安装 RabbitMQ.Client 以下是一个简单的示例代码,演示如何使用 C# 和 RabbitMQ 客户端库来发送和接收消息: durable持久化 durable 参数用于指定队列是否是持久化的。 当 durable 参数设置为 true 时,表示队列是持久化的。持久化的队列会在RabbitMQ服务器重启后仍然存在,确保

    2024年02月11日
    浏览(42)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包