Use NModbus4 communication library to perform write operations in C#

introduction

Modbus is a widely used industrial communication protocol that defines how devices communicate over a serial or Ethernet connection. In C#, the NModbus4 library provides a convenient way to interact with devices that support the Modbus protocol. This article will introduce how to use the NModbus4 communication library to perform write operations in C#, including installation and configuration, creating write operation functions, writing main functions to perform write operations, testing whether the operation is successful, and summarizing how to deal with more complex write operations scenarios.

1. Install the NModbus4 library

First, you need to install the NModbus4 library in your C# project. It can be installed through the NuGet package manager:

Install-Package NModbus4

2. Introduce the necessary namespace

In your C# code file, introduce the following namespace:

using NModbus4;
using ;
using System;

3. Configure Modbus factory and connection

Create a Modbus factory and configure connection parameters. Here we take serial connection as an example:

public class ModbusFactory : IModbusFactory
{
    public IModbusFactory Configure(IModbusFactory factory)
    {
         = (5);
         = 5;
        return factory;
    }
}
public class ModbusMaster : IModbusMaster
{
    public IModbusMaster Configure(IModbusMaster master)
    {
         = new ModbusSerialTransport(new SerialPortAdapter
        {
            PortName = "COM1", // Modify to your serial port            BaudRate = 9600,
            DataBits = 8,
            Parity = ,
            StopBits = 
        });
        return master;
    }
}

4. Perform a write operation

Write operations are usually used to modify a value in the device's memory. Here is an example of writing a single register:

public void WriteSingleRegister(ushort slaveAddress, ushort address, ushort value)
{
    using (var master = (new ModbusMaster()))
    {
        try
        {
            ();
            (slaveAddress, address, value);
            ("Writing successfully");
        }
        catch (Exception ex)
        {
            ($"Write failed：{}");
        }
        finally
        {
            ();
        }
    }
}

In this example, slaveAddress is the address of the target device, address is the register address to be written, and value is the data to be written.

5. Complete example

Here is a complete example, including connection, write operations, and disconnection:

class Program
{
    static void Main(string[] args)
    {
        WriteSingleRegister(1, 0x10, 0x0101); // Device address 1, register address 0x10, write data 0x0101        ();
    }
    public static void WriteSingleRegister(ushort slaveAddress, ushort address, ushort value)
    {
        using (var master = (new ModbusMaster()))
        {
            try
            {
                ();
                (slaveAddress, address, value);
                ($"equipment{slaveAddress}，register{address}Writing successfully，The value is{value:X4}");
            }
            catch (Exception ex)
            {
                ($"equipment{slaveAddress}，register{address}Write failed：{}");
            }
            finally
            {
                ();
            }
        }
    }
}

Run this program and you will see a message that the write is successful in the console.

• Summary point 1:Test whether the write operation is successful. In actual application, you need to verify whether the write operation is successful. This usually involves checking the Modbus response or otherwise confirming that the data on the device has changed. You can add appropriate logic to test the results of the write operation.
• Summary point 2:Summary of complex write operation scenarios For more complex write operation scenarios, you may need to write multiple registers, perform asynchronous operations, or handle errors. In these cases, you can extend the above example, for example:

Write multiple registers using the WriteMultipleRegisters method.

Use the BeginWrite and EndWrite methods to perform asynchronous write operations.

Catch and handle exceptions to ensure program stability and device correctness.

in conclusion

Using the NModbus4 communication library to perform write operations in C# is a relatively straightforward process. By creating Modbus factories and connections, you can easily interact with devices that support Modbus protocol. This article provides a simple example showing how to create a write operation function, write the main function to perform a write operation, and test whether the operation is successful or not. In practical applications, you may need to deal with more complex scenarios, but the basic steps and methods will remain similar. By using the NModbus4 library, you can take full advantage of the power of the Modbus protocol to enable effective communication between devices.

This is the end of this article about using the NModbus4 communication library to perform writing operations in C#. For more related C# NModbus4 communication content, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!