What is Modbus?

Modbus is the oldest and most widely used industrial communication protocol, developed by Modicon in 1979. Originally designed for serial communication between programmable logic controllers (PLCs), it has remained the dominant field bus for industrial automation for over four decades.

Two transport variants are in active use today: Modbus RTU runs over RS-485 serial lines and is common in legacy equipment, sensors, and embedded devices. Modbus TCP encapsulates the same protocol over standard Ethernet on port 502, enabling easy integration with modern IT infrastructure and cloud SCADA systems.

Modbus is found in PLCs, variable-frequency drives (VFDs), energy meters, SCADA systems, building automation controllers, solar inverters, battery management systems, and thousands of other industrial devices.

Modbus Data Model

Every Modbus device exposes four address spaces. Each space has its own function codes for reading and writing.

Function Codes

RTU vs TCP

Types

type
  TMBContext = Integer;  { Modbus context handle }

  TMBMode = (
    mbRTU = 0,  { serial RTU }
    mbTCP = 1   { TCP/IP }
  );

  TMBParity = (
    mbParNone = 0,  { 'N' }
    mbParEven = 1,  { 'E' — most common in Modbus }
    mbParOdd  = 2   { 'O' }
  );

  TMBError = (
    mbeIllegalFunction        = 1,
    mbeIllegalDataAddress     = 2,
    mbeIllegalDataValue       = 3,
    mbeSlaveDeviceFailure     = 4,
    mbeAcknowledge            = 5,
    mbeSlaveDeviceBusy        = 6,
    mbeMemoryParityError      = 8,
    mbeGatewayPathUnavailable = 10,
    mbeGatewayTargetFailed    = 11
  );

API Reference

Context Creation

Connection

Read Functions

Write Functions

TCP Slave (Server) Mode

Error Handling

Code Example — Energy Meter via Modbus TCP

Read voltage, current, and active power from a three-phase energy meter that exposes its measurements as IEEE 754 float pairs in holding registers.

uses libmodbus;

var
  Ctx: TMBContext;
  Regs: array of Integer;
  Voltage, Current, Power: Single;
begin
  Ctx := NewTCP('192.168.1.100', 502);
  Connect(Ctx);
  SetSlave(Ctx, 1);
  SetTimeout(Ctx, 1000);

  { Read 6 holding registers starting at address 0 }
  Regs := ReadHoldingRegisters(Ctx, 0, 6);

  { Convert register pairs to floats (big-endian IEEE 754) }
  Voltage := ReadFloat(Ctx, 0);   { V_RMS }
  Current := ReadFloat(Ctx, 2);   { I_RMS }
  Power   := ReadFloat(Ctx, 4);   { Active power W }

  WriteLn('Voltage: ', Voltage:6:1, ' V');
  WriteLn('Current: ', Current:6:3, ' A');
  WriteLn('Power:   ', Power:6:1, ' W');

  Disconnect(Ctx);
  FreeContext(Ctx);
end.

RTU Example — Serial RS-485 Connection

Configure a Modbus RTU master on a USB-to-RS485 adapter. Even parity and 1 stop bit are the Modbus standard default framing.

uses libmodbus;

var
  Ctx: TMBContext;
  Regs: array of Integer;
begin
  { /dev/ttyUSB0, 9600 baud, Even parity, 8 data bits, 1 stop bit }
  Ctx := NewRTU('/dev/ttyUSB0', 9600, mbParEven, 8, 1);
  Connect(Ctx);
  SetSlave(Ctx, 1);

  { Read 10 input registers (measurements) from slave address 1 }
  Regs := ReadInputRegisters(Ctx, 0, 10);
  WriteLn('Register[0] = ', Regs[0]);

  { Write setpoint to holding register 100 }
  WriteRegister(Ctx, 100, 1500);

  Disconnect(Ctx);
  FreeContext(Ctx);
end.

Error Handling

All read and write functions raise an exception on transport or protocol failure. Use GetLastError for the system-level message and GetExceptionCode to distinguish Modbus exception responses from the slave device.

uses libmodbus;

var Ctx: TMBContext;
begin
  Ctx := NewTCP('192.168.1.50', 502);
  try
    Connect(Ctx);
    SetSlave(Ctx, 1);
    WriteRegister(Ctx, 200, 9999);
  except
    var Code := GetExceptionCode;
    if Code = 3 then
      WriteLn('Slave rejected value: illegal data value')
    else if Code = 2 then
      WriteLn('Slave rejected address: illegal data address')
    else
      WriteLn('Error: ' + GetLastError);
  end;
  Disconnect(Ctx);
  FreeContext(Ctx);
end.