Try the FieldTalk Modbus libraries! Proven for industrial applications.

Check the specifications or download a 30-day evaluation copy today!

Modbus Master Driver
Click or drag to resize


This FieldTalk Modbus Slave Library for .NET allows you to incorporate Modbus slave functionality into your your and C# programs.

Industrial Modbus application

Typical applications are Modbus based Supervisory Control and Data Acquisition Systems (SCADA), Modbus data concentrators, Modbus gateways, User Interfaces and Factory Information Systems (FIS).


  • Robust design suitable for real-time and industrial applications
  • Full implementation of Bit Access and 16 Bits Access Function Codes as well as a subset of the most commonly used Diagnostics Function Codes
  • Standard Modbus bit and 16-bit integer data types (coils, discretes & registers)
  • Daniel/Enron single register 32-bit transfers
  • Support of Broadcasting
  • Master time-out supervision
  • Failure and transmission counters
  • Supports single or multiple slave addresses

Library Structure

The FieldTalk .NET library consists of two components: a .NET Interop Library with MSIL code (managed code) and a Modbus Core Driver written in native code (unmanaged code). This architecture has significant performance benefits for .NET applications because the time critical communication code is executed as native code.

FieldTalk .NET Modbus Library Architecture

The two components are contained in separate files: FieldTalk.Modbus.Slave.dll contains the .NET Interop Library and libmbusslave.dll the native Modbus Core Driver. These two library files have to be deployed with your application.

For .NET Core, the deployment and loading of the native code library is taken care of by .NET core's package management. This works for Windows as well as for Linux platforms.

For classic .NET Framework 4.0 and 2.0, the deployment of the native code library is taken care of by the FieldTalk.Modbus.Slave.prop file which the NutGet package manager will automatically add to your project. With that file, when compiling, a bin/x86 and a bin/x64 subfolder is created in the bin directory and the native libraries copied into these subfolders. When the .NET assembly is loaded, the correct native library will be loaded from one of these two sub-folders.

For the .NET Compact Framework (Windows Embedded Compact, Windows CE and Windows Mobile) the deployment of the native libray must be done manually.

The library's API The library is organised in two categories of classes.

One category implements the Server Engines for each Modbus slave protocol flavour. There is one Server Engine class for each protocol flavour and a common Server Engine base class, which applies to all protocol flavours. Because the two serial protocols ASCII and RTU share some common code, an intermediate base class implements the functions specific to serial protocols.

Modbus Slave classes inheritance diagram

The second category of classes is Data Providers classes. Data Provider classes represent the interface between the Server Engine and your application.

Modbus Slave classes collaboration diagram

The base class MbusSlaveServer contains a protocol unspecific contains a protocol unspecific Server Engine and the protocol state machine. All protocol flavours inherit from this base class.

The class MbusAsciiSlaveProtocol implements the Modbus ASCII protocol, the class MbusRtuSlaveProtocol implements the Modbus RTU protocol and the class MbusTcpSlaveProtocol implements the MODBUS/TCP protocol.

Before a server can be used, a Data Provider has to be declared. A Data Provider is created by declaring a new class derived from MbusDataTableInterface. The class MbusDataTableInterface is the base class for a Data Provider and implements a set of default methods. An application specific Data Provider simply overrides selected default methods and the Modbus slave is ready.

class MyDatatable: MbusDataTableInterface
    ... // Application specific data interface

MyDatatable dataTable = new MyDatatable();

In order to use one of the three slave protocols, the desired protocol flavour class has to be instantiated and associated with the Data Provider. The following example creates an RTU protocol and links a data table to slave address 20:

MbusRtuSlaveProtocol mbusServer = new MbusRtuSlaveProtocol();
mbusProtocol.addDataTable(20, dataTable);

After a protocol object has been declared and started up the server loop has to be executed cyclically. The Modbus slave is ready to accept connections and to reply to master queries.

    result = mbusServer.serverLoop();
} while (!(result != BusProtocolErrors.FTALK_SUCCESS));