Modbus TCP protocol client library

1.0.0-rc 2018-06-02 20:00 UTC


Build Status codecov


composer require aldas/modbus-tcp-client

Supported functions


  • PHP 7.0+ (64bit PHP if you need to read 64bit integers from modbus responses. NB: PHP supports only signed 64bit integers so usigned 64bit ints will overflow when 64th bit is set)
  • Release 0.2.0 was last to support PHP 5.6


This library is influenced by phpmodbus library and meant to be provide decoupled Modbus protocol (request/response packets) and networking related features so you could build modbus client with our own choice of networking code (ext_sockets/streams/Reactphp/Amp asynchronous streams) or use library provided networking classes (php Streams)


Applies to multibyte data that are stored in Word/Double/Quad word registers basically everything that is not (u)int16/byte/char.

So if we receive from network 0x12345678 (bytes: ABCD) and want to convert that to a 32 bit register there could be 4 different ways to interpret bytes and word order depending on modbus server architecture and client architecture. NB: TCP, and UDP, are transmitted in big-endian order so we choose this as base for examples

Library supports following byte and word orders:

  • Big endian (ABCD - word1 = 0x1234, word2 = 0x5678)
  • Big endian low word first (CDAB - word1 = 0x5678, word2 = 0x1234) (used by Wago-750)
  • Little endian (DCBA - word1 = 0x3412, word2 = 0x7856)
  • Little endian low word first (BADC - word1 = 0x7856, word2 = 0x3412)

See Endian.php for additional info and Types.php for supported data types.

Example (fc3 - read holding registers)

Some of the Modbus function examples are in examples/ folder

Advanced usage:

Request multiple packets with higher level API:

$fc3 = ReadRegistersBuilder::newReadHoldingRegisters('tcp://')
    ->bit(256, 15, 'pump2_feedbackalarm_do')
    // will be split into 2 requests as 1 request can return only range of 124 registers max
    ->int16(657, 'battery3_voltage_wo')
    // will be another request as uri is different for subsequent int16 register
        function ($value, $address, $response) {
            return 'prefix_' . $value; // optional: transform value after extraction
        function (\Exception $exception, Address $address, $response) {
            // optional: callback called then extraction failed with an error
            return $address->getType() === Address::TYPE_STRING ? '' : null; // does not make sense but gives you an idea
    ->build(); // returns array of 3 ReadHoldingRegistersRequest requests

// this will use PHP non-blocking stream io to recieve responses
$responses = (new NonBlockingClient(['readTimeoutSec' => 0.2]))->sendReadRequests($fc3);

Response structure

    [ 'pump2_feedbackalarm_do' => true, ],
    [ 'battery3_voltage_wo' => 12, ],
    [ 'username_plc2' => 'prefix_admin', ]

Low level - send packets:

$connection = BinaryStreamConnection::getBuilder()
$packet = new ReadHoldingRegistersRequest(256, 8); //create FC3 request packet

try {
    $binaryData = $connection->connect()->sendAndReceive($packet);

    //parse binary data to response object
    $response = ResponseFactory::parseResponseOrThrow($binaryData);
    //same as 'foreach ($response->getWords() as $word) {'
    foreach ($response as $word) { 
    // print registers as double words in big endian low word first order (as WAGO-750 does)
    foreach ($response->getDoubleWords() as $dword) {
    // set internal index to match start address to simplify array access
    $responseWithStartAddress = $response->withStartAddress(256);
    print_r($responseWithStartAddress[256]->getBytes()); // use array access to get word
} catch (Exception $exception) {
    echo $exception->getMessage() . PHP_EOL;
} finally {

Example of non-blocking socket IO (i.e. modbus request are run in 'parallel')

Example of non-blocking socket IO with

 * Install dependency with 'composer require amphp/socket'
 * This will do 'parallel' socket request with help of Amp socket library

require __DIR__ . '/../vendor/autoload.php';

use ModbusTcpClient\Packet\ModbusFunction\ReadHoldingRegistersRequest;
use ModbusTcpClient\Packet\ResponseFactory;
use function Amp\Socket\connect;

$uri = 'tcp://';
$packets = [
    new ReadHoldingRegistersRequest(256, 10),
    new ReadHoldingRegistersRequest(266, 10),

$promises = [];
foreach ($packets as $packet) {
    $promises[] = Amp\call(function () use ($packet, $uri) {
        /** @var \Amp\Socket\ClientSocket $socket */
        $socket = yield connect($uri);
        try {
            yield $socket->write($packet);

            $chunk = yield $socket->read(); // modbus packet is so small that one read is enough
            if ($chunk === null) {
                return null;
            return ResponseFactory::parseResponse($chunk);
        } finally {

try {
    // will run multiple request in parallel using non-blocking php stream io
    $responses = Amp\Promise\wait(Amp\Promise\all($promises));
} catch (Throwable $e) {

Try communication with PLCs quickly using php built-in web server

Examples folder has index.php which can be used with php built-in web server to test out communication with our own PLCs.

git clone
cd modbus-tcp-client
composer install
php -S localhost:8080 -t examples/

Now open http://localhost:8080 in browser. See additional query parameters from index.php.


  • all composer test
  • unit tests composer test-unit
  • integration tests composer test-integration

For Windows users:

  • all vendor/bin/phpunit
  • unit tests vendor/bin/phpunit --testsuite 'unit-tests'
  • integration tests vendor/bin/phpunit --testsuite 'integration-tests'