Bootstrap

NModbus常用方法

常用方法

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();
        }
    }
}

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
SAP PP学习笔记24 - 生产订单（制造指图）的创建
ant design pro 暗黑模式失效解决
Js计算指定日期加上多少天、加多少月、加多少年的日期
simulink生成c语言代码_从MATLAB代码生成独立c语言代码
sqluldr2的使用方法
基于AT89C51单片机的抢答器的设计
吃透Python-第 5 章 对象和类型
【C语言】动态分配一个二维数组+图解
vue执行npm install问题idealTree:yudao-ui-admin-vben: sill idealTree buildDeps
js： 字符截取，转换通用操作
;