NModbus常用方法

最新推荐文章于 2024-03-23 00:07:56 发布
最新推荐文章于 2024-03-23 00:07:56 发布
阅读量311 收藏 2
点赞数
分类专栏： Modbus 文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46437645/article/details/134292565
版权

常用方法

using Modbus;
using System;
using System.Linq;

public class ModbusHelper
{
    private IModbusMaster modbusMaster;
public ModbusHelper(IModbusMaster modbusMaster)
{
    this.modbusMaster = modbusMaster;
}

/// <summary>
/// 从Modbus设备中读取保持寄存器的数据
/// </summary>
/// <param name="slaveAddress">Modbus 从站地址</param>
/// <param name="startAddress">要读取的保持寄存器的起始地址</param>
/// <param name="numberOfPoints">要读取的连续寄存器数量</param>
/// <returns>读取到的寄存器数据</returns>
public ushort[] ReadHoldingRegisters(byte slaveAddress, ushort startAddress, ushort numberOfPoints)
{
    return modbusMaster.ReadHoldingRegisters(slaveAddress, startAddress, numberOfPoints);
}

/// <summary>
/// 向Modbus设备写入单个保持寄存器的值
/// </summary>
/// <param name="slaveAddress">Modbus 从站地址</param>
/// <param name="address">要写入的保持寄存器的地址</param>
/// <param name="value">要写入的值</param>
public void WriteSingleRegister(byte slaveAddress, ushort address, ushort value)
{
    modbusMaster.WriteSingleRegister(slaveAddress, address, value);
}

/// <summary>
/// 向Modbus设备写入多个保持寄存器的数据
/// </summary>
/// <param name="slaveAddress">Modbus 从站地址</param>
/// <param name="startAddress">要写入的保持寄存器的起始地址</param>
/// <param name="data">要写入的数据数组</param>
public void WriteMultipleRegisters(byte slaveAddress, ushort startAddress, ushort[] data)
{
    modbusMaster.WriteMultipleRegisters(slaveAddress, startAddress, data);
}

/// <summary>
/// 从Modbus设备中读取线圈的状态
/// </summary>
/// <param name="slaveAddress">Modbus 从站地址</param>
/// <param name="startAddress">要读取的线圈的起始地址</param>
/// <param name="numberOfPoints">要读取的连续线圈数量</param>
/// <returns>读取到的线圈状态</returns>
public bool[] ReadCoils(byte slaveAddress, ushort startAddress, ushort numberOfPoints)
{
    return modbusMaster.ReadCoils(slaveAddress, startAddress, numberOfPoints);
}

/// <summary>
/// 向Modbus设备写入单个线圈的状态
/// </summary>
/// <param name="slaveAddress">Modbus 从站地址</param>
/// <param name="address">要写入的线圈的地址</param>
/// <param name="value">要写入的状态，通常是 true 或 false</param>
public void WriteSingleCoil(byte slaveAddress, ushort address, bool value)
{
    modbusMaster.WriteSingleCoil(slaveAddress, address, value);
}

/// <summary>
/// 向Modbus设备写入多个线圈的状态
/// </summary>
/// <param name="slaveAddress">Modbus 从站地址</param>
/// <param name="startAddress">要写入的线圈的起始地址</param>
/// <param name="data">要写入的线圈状态数组</param>
public void WriteMultipleCoils(byte slaveAddress, ushort startAddress, bool[] data)
{
    modbusMaster.WriteMultipleCoils(slaveAddress, startAddress, data);
}

/// <summary>
/// 从Modbus设备中读取输入寄存器的数据
/// </summary>
/// <param name="slaveAddress">Modbus 从站地址</param>
/// <param name="startAddress">要读取的输入寄存器的起始地址</param>
/// <param name="numberOfPoints">要读取的连续输入寄存器数量</param>
/// <returns>读取到的寄存器数据</returns>
public ushort[] ReadInputRegisters(byte slaveAddress, ushort startAddress, ushort numberOfPoints)
{
    return modbusMaster.ReadInputRegisters(slaveAddress, startAddress, numberOfPoints);
}

/// <summary>
/// 从Modbus设备中读取输入状态（离散输入）的状态
/// </summary>
/// <param name="slaveAddress">Modbus 从站地址</param>
/// <param name="startAddress">要读取的输入状态的起始地址</param>
/// <param name="numberOfPoints">要读取的连续输入状态数量</param>
/// <returns>读取到的输入状态</returns>
public bool[] ReadInputStatus(byte slaveAddress, ushort startAddress, ushort numberOfPoints)
{
    return modbusMaster.ReadInputStatus(slaveAddress, startAddress, numberOfPoints);
}
}

例子

ReadHoldingRegisters

using System;
using System.Windows.Forms;
using Modbus;
using Modbus.Serial;
using System.IO.Ports;

namespace ModbusRtuExample
{
    public partial class MainForm : Form
    {
        private IModbusMaster modbusMaster;
        private SerialPort serialPort;

        public MainForm()
        {
            InitializeComponent();
            InitializeModbus();
        }

        private void InitializeModbus()
        {
            // 初始化串口设置
            serialPort = new SerialPort("COM1");
            serialPort.BaudRate = 9600;
            serialPort.Parity = Parity.None;
            serialPort.StopBits = StopBits.One;
            serialPort.DataBits = 8;
            serialPort.Open();

            // 创建 Modbus 主站
            modbusMaster = ModbusSerialMaster.CreateRtu(serialPort);
            modbusMaster.Transport.ReadTimeout = 1000; // 设置读超时时间

            // 其他初始化操作，如设置从站地址等
            modbusMaster.Transport.Retries = 3; // 设置重试次数
            modbusMaster.Transport.WaitToRetryMilliseconds = 50; // 设置重试间隔
        }

        private void btnReadHoldingRegisters_Click(object sender, EventArgs e)
        {
            try
            {
                byte slaveAddress = 1; // 从站地址
                ushort startAddress = 0; // 起始寄存器地址
                ushort numberOfPoints = 10; // 读取的寄存器数量

                ushort[] data = modbusMaster.ReadHoldingRegisters(slaveAddress, startAddress, numberOfPoints);

                // 将读取到的数据显示在文本框中
                txtResult.Text = string.Join(", ", data);
            }
            catch (Exception ex)
            {
                MessageBox.Show("读取失败：" + ex.Message);
            }
        }

        private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            // 在窗体关闭时释放资源
            if (modbusMaster != null)
                modbusMaster.Dispose();

            if (serialPort != null && serialPort.IsOpen)
                serialPort.Close();
        }
    }
}

WriteSingleRegister

using System;
using System.Windows.Forms;
using Modbus;
using Modbus.Serial;
using System.IO.Ports;

namespace ModbusRtuWriteExample
{
    public partial class MainForm : Form
    {
        private IModbusMaster modbusMaster;
        private SerialPort serialPort;

        public MainForm()
        {
            InitializeComponent();
            InitializeModbus();
        }

        private void InitializeModbus()
        {
            // 初始化串口设置
            serialPort = new SerialPort("COM1");
            serialPort.BaudRate = 9600;
            serialPort.Parity = Parity.None;
            serialPort.StopBits = StopBits.One;
            serialPort.DataBits = 8;
            serialPort.Open();

            // 创建 Modbus 主站
            modbusMaster = ModbusSerialMaster.CreateRtu(serialPort);
            modbusMaster.Transport.ReadTimeout = 1000; // 设置读超时时间

            // 其他初始化操作，如设置从站地址等
            modbusMaster.Transport.Retries = 3; // 设置重试次数
            modbusMaster.Transport.WaitToRetryMilliseconds = 50; // 设置重试间隔
        }

        private void btnWriteSingleRegister_Click(object sender, EventArgs e)
        {
            try
            {
                byte slaveAddress = 1; // 从站地址
                ushort address = 0; // 寄存器地址
                ushort valueToWrite = Convert.ToUInt16(txtValueToWrite.Text); // 从文本框获取要写入的值

                modbusMaster.WriteSingleRegister(slaveAddress, address, valueToWrite);

                MessageBox.Show("写入成功");
            }
            catch (Exception ex)
            {
                MessageBox.Show("写入失败：" + ex.Message);
            }
        }

        private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            // 在窗体关闭时释放资源
            if (modbusMaster != null)
                modbusMaster.Dispose();

            if (serialPort != null && serialPort.IsOpen)
                serialPort.Close();
        }
    }
}

WriteMultipleRegisters

using System;
using System.Windows.Forms;
using Modbus;
using Modbus.Serial;
using System.IO.Ports;

namespace ModbusRtuWriteMultipleRegistersExample
{
    public partial class MainForm : Form
    {
        private IModbusMaster modbusMaster;
        private SerialPort serialPort;

        public MainForm()
        {
            InitializeComponent();
            InitializeModbus();
        }

        private void InitializeModbus()
        {
            // 初始化串口设置
            serialPort = new SerialPort("COM1");
            serialPort.BaudRate = 9600;
            serialPort.Parity = Parity.None;
            serialPort.StopBits = StopBits.One;
            serialPort.DataBits = 8;
            serialPort.Open();

            // 创建 Modbus 主站
            modbusMaster = ModbusSerialMaster.CreateRtu(serialPort);
            modbusMaster.Transport.ReadTimeout = 1000; // 设置读超时时间

            // 其他初始化操作，如设置从站地址等
            modbusMaster.Transport.Retries = 3; // 设置重试次数
            modbusMaster.Transport.WaitToRetryMilliseconds = 50; // 设置重试间隔
        }

        private void btnWriteMultipleRegisters_Click(object sender, EventArgs e)
        {
            try
            {
                byte slaveAddress = 1; // 从站地址
                ushort startAddress = 0; // 起始寄存器地址
                ushort[] dataToWrite = new ushort[] { 100, 200, 300, 400, 500 }; // 从数组获取要写入的数据

                modbusMaster.WriteMultipleRegisters(slaveAddress, startAddress, dataToWrite);

                MessageBox.Show("写入成功");
            }
            catch (Exception ex)
            {
                MessageBox.Show("写入失败：" + ex.Message);
            }
        }

        private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            // 在窗体关闭时释放资源
            if (modbusMaster != null)
                modbusMaster.Dispose();

            if (serialPort != null && serialPort.IsOpen)
                serialPort.Close();
        }
    }
}

ReadCoils

using System;
using System.Windows.Forms;
using Modbus;
using Modbus.Serial;
using System.IO.Ports;

namespace ModbusRtuReadCoilsExample
{
    public partial class MainForm : Form
    {
        private IModbusMaster modbusMaster;
        private SerialPort serialPort;

        public MainForm()
        {
            InitializeComponent();
            InitializeModbus();
        }

        private void InitializeModbus()
        {
            // 初始化串口设置
            serialPort = new SerialPort("COM1");
            serialPort.BaudRate = 9600;
            serialPort.Parity = Parity.None;
            serialPort.StopBits = StopBits.One;
            serialPort.DataBits = 8;
            serialPort.Open();

            // 创建 Modbus 主站
            modbusMaster = ModbusSerialMaster.CreateRtu(serialPort);
            modbusMaster.Transport.ReadTimeout = 1000; // 设置读超时时间

            // 其他初始化操作，如设置从站地址等
            modbusMaster.Transport.Retries = 3; // 设置重试次数
            modbusMaster.Transport.WaitToRetryMilliseconds = 50; // 设置重试间隔
        }

        private void btnReadCoils_Click(object sender, EventArgs e)
        {
            try
            {
                byte slaveAddress = 1; // 从站地址
                ushort startAddress = 0; // 起始线圈地址
                ushort numberOfPoints = 10; // 读取的线圈数量

                bool[] coilStatus = modbusMaster.ReadCoils(slaveAddress, startAddress, numberOfPoints);

                // 将读取到的线圈状态显示在文本框中
                txtCoilStatus.Text = string.Join(", ", coilStatus);
            }
            catch (Exception ex)
            {
                MessageBox.Show("读取失败：" + ex.Message);
            }
        }

        private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            // 在窗体关闭时释放资源
            if (modbusMaster != null)
                modbusMaster.Dispose();

            if (serialPort != null && serialPort.IsOpen)
                serialPort.Close();
        }
    }
}

WriteSingleCoil

using System;
using System.Windows.Forms;
using Modbus;
using Modbus.Serial;
using System.IO.Ports;

namespace ModbusRtuWriteSingleCoilExample
{
    public partial class MainForm : Form
    {
        private IModbusMaster modbusMaster;
        private SerialPort serialPort;

        public MainForm()
        {
            InitializeComponent();
            InitializeModbus();
        }

        private void InitializeModbus()
        {
            // 初始化串口设置
            serialPort = new SerialPort("COM1");
            serialPort.BaudRate = 9600;
            serialPort.Parity = Parity.None;
            serialPort.StopBits = StopBits.One;
            serialPort.DataBits = 8;
            serialPort.Open();

            // 创建 Modbus 主站
            modbusMaster = ModbusSerialMaster.CreateRtu(serialPort);
            modbusMaster.Transport.ReadTimeout = 1000; // 设置读超时时间

            // 其他初始化操作，如设置从站地址等
            modbusMaster.Transport.Retries = 3; // 设置重试次数
            modbusMaster.Transport.WaitToRetryMilliseconds = 50; // 设置重试间隔
        }

        private void btnWriteSingleCoil_Click(object sender, EventArgs e)
        {
            try
            {
                byte slaveAddress = 1; // 从站地址
                ushort address = 0; // 线圈地址
                bool valueToWrite = chkCoilStatus.Checked; // 从复选框获取要写入的状态

                modbusMaster.WriteSingleCoil(slaveAddress, address, valueToWrite);

                MessageBox.Show("写入成功");
            }
            catch (Exception ex)
            {
                MessageBox.Show("写入失败：" + ex.Message);
            }
        }

        private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            // 在窗体关闭时释放资源
            if (modbusMaster != null)
                modbusMaster.Dispose();

            if (serialPort != null && serialPort.IsOpen)
                serialPort.Close();
        }
    }
}

WriteMultipleCoils

using System;
using System.Windows.Forms;
using Modbus;
using Modbus.Serial;
using System.IO.Ports;

namespace ModbusRtuWriteMultipleCoilsExample
{
    public partial class MainForm : Form
    {
        private IModbusMaster modbusMaster;
        private SerialPort serialPort;

        public MainForm()
        {
            InitializeComponent();
            InitializeModbus();
        }

        private void InitializeModbus()
        {
            // 初始化串口设置
            serialPort = new SerialPort("COM1");
            serialPort.BaudRate = 9600;
            serialPort.Parity = Parity.None;
            serialPort.StopBits = StopBits.One;
            serialPort.DataBits = 8;
            serialPort.Open();

            // 创建 Modbus 主站
            modbusMaster = ModbusSerialMaster.CreateRtu(serialPort);
            modbusMaster.Transport.ReadTimeout = 1000; // 设置读超时时间

            // 其他初始化操作，如设置从站地址等
            modbusMaster.Transport.Retries = 3; // 设置重试次数
            modbusMaster.Transport.WaitToRetryMilliseconds = 50; // 设置重试间隔
        }

        private void btnWriteMultipleCoils_Click(object sender, EventArgs e)
        {
            try
            {
                byte slaveAddress = 1; // 从站地址
                ushort startAddress = 0; // 起始线圈地址
                bool[] dataToWrite = new bool[] { true, false, true, false, true }; // 从数组获取要写入的数据

                modbusMaster.WriteMultipleCoils(slaveAddress, startAddress, dataToWrite);

                MessageBox.Show("写入成功");
            }
            catch (Exception ex)
            {
                MessageBox.Show("写入失败：" + ex.Message);
            }
        }

        private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            // 在窗体关闭时释放资源
            if (modbusMaster != null)
                modbusMaster.Dispose();

            if (serialPort != null && serialPort.IsOpen)
                serialPort.Close();
        }
    }
}

ReadInputRegisters

using System;
using System.Windows.Forms;
using Modbus;
using Modbus.Serial;
using System.IO.Ports;

namespace ModbusRtuReadInputRegistersExample
{
    public partial class MainForm : Form
    {
        private IModbusMaster modbusMaster;
        private SerialPort serialPort;

        public MainForm()
        {
            InitializeComponent();
            InitializeModbus();
        }

        private void InitializeModbus()
        {
            // 初始化串口设置
            serialPort = new SerialPort("COM1");
            serialPort.BaudRate = 9600;
            serialPort.Parity = Parity.None;
            serialPort.StopBits = StopBits.One;
            serialPort.DataBits = 8;
            serialPort.Open();

            // 创建 Modbus 主站
            modbusMaster = ModbusSerialMaster.CreateRtu(serialPort);
            modbusMaster.Transport.ReadTimeout = 1000; // 设置读超时时间

            // 其他初始化操作，如设置从站地址等
            modbusMaster.Transport.Retries = 3; // 设置重试次数
            modbusMaster.Transport.WaitToRetryMilliseconds = 50; // 设置重试间隔
        }

        private void btnReadInputRegisters_Click(object sender, EventArgs e)
        {
            try
            {
                byte slaveAddress = 1; // 从站地址
                ushort startAddress = 0; // 起始输入寄存器地址
                ushort numberOfPoints = 10; // 读取的输入寄存器数量

                ushort[] inputRegisterData = modbusMaster.ReadInputRegisters(slaveAddress, startAddress, numberOfPoints);

                // 将读取到的输入寄存器数据显示在文本框中
                txtInputRegisterData.Text = string.Join(", ", inputRegisterData);
            }
            catch (Exception ex)
            {
                MessageBox.Show("读取失败：" + ex.Message);
            }
        }

        private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            // 在窗体关闭时释放资源
            if (modbusMaster != null)
                modbusMaster.Dispose();

            if (serialPort != null && serialPort.IsOpen)
                serialPort.Close();
        }
    }
}

ReadInputStatus

using System;
using System.Windows.Forms;
using Modbus;
using Modbus.Serial;
using System.IO.Ports;

namespace ModbusRtuReadInputStatusExample
{
    public partial class MainForm : Form
    {
        private IModbusMaster modbusMaster;
        private SerialPort serialPort;

        public MainForm()
        {
            InitializeComponent();
            InitializeModbus();
        }

        private void InitializeModbus()
        {
            // 初始化串口设置
            serialPort = new SerialPort("COM1");
            serialPort.BaudRate = 9600;
            serialPort.Parity = Parity.None;
            serialPort.StopBits = StopBits.One;
            serialPort.DataBits = 8;
            serialPort.Open();

            // 创建 Modbus 主站
            modbusMaster = ModbusSerialMaster.CreateRtu(serialPort);
            modbusMaster.Transport.ReadTimeout = 1000; // 设置读超时时间

            // 其他初始化操作，如设置从站地址等
            modbusMaster.Transport.Retries = 3; // 设置重试次数
            modbusMaster.Transport.WaitToRetryMilliseconds = 50; // 设置重试间隔
        }

        private void btnReadInputStatus_Click(object sender, EventArgs e)
        {
            try
            {
                byte slaveAddress = 1; // 从站地址
                ushort startAddress = 0; // 起始输入状态地址
                ushort numberOfPoints = 10; // 读取的输入状态数量

                bool[] inputStatusData = modbusMaster.ReadInputStatus(slaveAddress, startAddress, numberOfPoints);

                // 将读取到的输入状态数据显示在文本框中
                txtInputStatusData.Text = string.Join(", ", inputStatusData);
            }
            catch (Exception ex)
            {
                MessageBox.Show("读取失败：" + ex.Message);
            }
        }

        private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            // 在窗体关闭时释放资源
            if (modbusMaster != null)
                modbusMaster.Dispose();

            if (serialPort != null && serialPort.IsOpen)
                serialPort.Close();
        }
    }
}
氓仙
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
NMODBUS中文API手册
11-23
NMODBUS中文API手册
NModbus类库使用
ysds20211402的博客
04-17 3424
转自：微点阅读https://www.weidianyuedu.com/content/4817804073853.html 通过串口进行通信: 1、将nMobus类库导入工程中，添加引用、命名空间。工程属性必须配置为.nET 4.0。 2、创建SerialPort类的一个实例，配置参数，打开串口，如： 组 bool[] Readcoils(byte slaveAddress, ushort startAddress, ushort numberofPoints); publi..
C#使用NModbus4库实现ModbusRtu通信
最新发布
qq_32114737的博客
03-23 621
下面代码为常用功能的方法：01-读线圈，02-读离散量输入，03-读保持型寄存器，04-读输入寄存器，05-写单个线圈，06-写单个寄存器，15-写多个线圈，16-写多个寄存器。NModbus4可以实现ModbusRtu、ModbusTcp等串口通信，组件使用很方便，封装很好，不需要了解底层协议的具体格式内容，便于软体工程师使用。在此使用C#与modbus slave进行modbusRtu通信，需要了解协议格式的，可以在modbus slave中监控协议内容。
C# NModbus的主从站开发以及Modbus Slave、Modbus Poll工具的使用
乌里随记的博客
10-20 1万+
NModbus的主站开发 1.开发环境要求：PC端作为主站，控制器作为从站 2.PC端初始化代码： serialPort = new SerialPort(); serialPort.PortName = "COM1"; serialPort.BaudRate = 9600; serialPort.DataBits = 8; serialPort.StopBits = StopBits.One; serialPort.Parity = Parity.Even; master = ModbusSeri
c# NModBus 使用
sunstar8921的博客
01-18 1万+
最近在做一个项目，串口通讯，接口是RS232，通讯协议是ModBus，一开始真的是一头雾水，如果不管协议，直接用C#自带的SerialPort类，直接发送指令，获取返回信息，解析相对应的结果，得出需要使用的字段，这样可以不管是什么协议，只要知道指令解析方式即可。 如果指令较多，还非得按照ModBus协议解析，可以用NModBus4，百度有很多解释，包括需要理解下ModBus的相关协议，及其定义的...
Modbus简介以及NModbus学习分享
magicchz的博客
02-06 7356
Modbus简介，以及用C#实现数据操作，包括读写（通过NModebus）
C#实现ModbusRTU详解【五】—— NModbus4的使用
热门推荐
XUMENGCAS的博客
01-04 4万+
使用NModbus4实现ModbusRTU通讯
C# 使用NModbus 多Slave站编程方法
yuming的专栏
11-24 3341
但NModbus4已经7年多没有更新，测试发现读取数据时，如果长度超出Modbus协议约束的长度，会导致异常造成服务退出，而且这个异常是应用层拦截和屏蔽不了。实际应用中，可以读完一个仪表的数据，然后分类（bool和其他，其他包括word、int、float等）写入，同类的一次更新完，使用也比较方便。实际应用中，常常有将各种RS232、RS485等设备联网，供远程服务器读取的需求，这是采用一台边缘的转换网关，连接多台设备，然后转换为Modbus是一个不错的方案。
C# Modbus库推荐：轻松实现Modbus通信的利器
雨中深巷的油纸伞
12-29 2264
NModbus是一个开源的C# Modbus库，具有丰富的功能和良好的性能。EasyModbusTCP.NET是一个Modbus TCP、Modbus UDP 和 Modbus RTU 客户端/服务器库，用于 .NET 行业认证！在C#中，有许多Modbus库可供选择，这些库提供了方便的API和丰富的功能，使Modbus通信变得更加简单和高效。也是一款支持modbus协议的组件，本组件基于.NET Standard 2.0，可用于.Net的跨平台开发，如Windows、Linux甚至可运行于树莓派上。
NModbus类库使用总结
03-28
自己使用NModbus类库实现Modbus协议的过程中作的总结，总结了如何使用NModbus类库
NModbus.dll
07-01
用于modbus协议的库，可用dll，可以直接调用
NModbus开源库
01-14
Nmodbus开源库，需要的可以下载，之前看到个50分的资源以为是新版，结果下下来跟我下载的一样，有点坑，这里5分分享
用Nmodbus开发 源码
09-05
用Nmodbus开发 源代码，用于开发者使用
NMODBUS.zip
10-13
封装了一些数据转换与写入PLC的方法，适合新手使用
C# WPF学习之旅——Nmodbus库的使用，Modbus-RTU的使用。
weixin_42205408的博客
08-12 2926
下载完成后首先要调用该库。 using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Windows.Forms; using System.IO; using Sy
基于C#的Modbus的(NModbus)研究（DTS686电表）——实现RTU通信连接（一）
superlee
10-29 1万+
2019.10.26 更新第三篇文章原创 Modbus的(NModbus)研究（电表、水表等RS485/RS232等）——实现RTU/TCP通信连接（三） 前言：最近一个月的任务用nmodbus实现rtu/tcp通信连接，前期通过翻看书本 杨更更的Modbus软件开发指南 根据里面的指导来完成limodbus和numodbus 但是效果并没有太理想，详见上一篇文章，后来在一位博友的帮助下了解...
C#学习记录——Modbus学习（NModbus4）
做有价值的事，积累有价值的笔记！
10-17 5987
需要通过ModbusRTU协议读取单片机寄存器的数据。需要研究学习用ModbusRTU协议的使用。本例是通过NModbus4；
用NModbus4 实现Modbus服务器端（从站，Slave，有源码地址）
helldoger的博客
06-10 1812
我们做上位机除了读取PLC，单片机的数据，也经常需要转发数据，将数据转发给BS应用等，这时候一个Modbus服务器就非常有必要了，它简单开源稳定，今天我就用C# 实现一个Modbus服务器。GitHub地址：https://gitee.com/helodoger/my-csharp-code.git。
c# NMODBUS
09-13
c# NMODBUS是一个用于在C#中实现Modbus通信协议的库。它提供了一组类和方法，用于创建Modbus主站和从站实例，以便进行通信。其中，ModbusMaster类是NMODBUS库中的一个关键类，用于创建Modbus主站实例。可以使用ModbusMaster的ExecuteCustomMessage方法来生成自定义的请求报文和响应报文。不过在NModbus4库中已经为我们提供了常用的报文类，所以我们通常无需自行定义报文类。如果有兴趣学习如何自行创建实现IModbusMessage的类，可以在GitHub上下载NModbus4的源码进行研究。 在使用NModbus4库时，我们通常使用IModbusMaster接口来创建通讯实例。例如，我们可以通过以下代码创建一个串口实例，并使用ModbusSerialMaster.CreateRtu方法来创建一个ModbusRTU主站实例： ```csharp //创建串口实例 SerialPort sport = new SerialPort("COM11", 9600, Parity.None, 8, StopBits.One); //创建ModbusRTU主站实例 IModbusMaster master = ModbusSerialMaster.CreateRtu(sport); ``` 通过这样的方式，我们可以使用NMODBUS库来实现Modbus通信功能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值