Modbus Serial

https://github.com/yaacov/node-modbus-serial
Admin
modbus-serial is a pure JavaScript implementation of the Modbus-RTU and Modbus-TCP protocols for...
Tokens:56,042
Snippets:654
Trust Score:9.1
License:ISC
Update:1 month ago
Show doc for...
Tokens:
Raw
### Complete ServerTCP implementation

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ServerTCP.md

A full example demonstrating how to define a service vector for coils and registers, and how to instantiate and start a ServerTCP instance.

```javascript
const { ServerTCP } = require('modbus-serial');

// Define device state
const coils = new Array(100).fill(false);
const registers = new Array(100).fill(0);

// Service vector
const vector = {
    getCoil: (addr, unitID) => {
        return coils[addr] || false;
    },
    
    setCoil: (addr, value, unitID) => {
        coils[addr] = value;
        console.log(`Coil ${addr} set to ${value}`);
    },
    
    getHoldingRegister: (addr, unitID) => {
        return registers[addr] || 0;
    },
    
    setRegister: (addr, value, unitID) => {
        registers[addr] = value;
        console.log(`Register ${addr} set to ${value}`);
    },
    
    setRegisterArray: (addr, values, unitID) => {
        for (let i = 0; i < values.length; i++) {
            registers[addr + i] = values[i];
        }
        console.log(`Registers ${addr}-${addr + values.length - 1} updated`);
    }
};

// Create and start server
const server = new ServerTCP(vector, {
    host: '0.0.0.0',
    port: 502,
    debug: false
});

server.on('initialized', () => {
    console.log('Modbus TCP server listening on port 502');
});

server.on('socketError', (err) => {
    console.error('Socket error:', err.message);
});
```

--------------------------------

### Constructor Example

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ModbusRTU.md

Example of importing and instantiating the ModbusRTU client.

```javascript
const ModbusRTU = require('modbus-serial');
const client = new ModbusRTU();
```

--------------------------------

### ServerSerial Configuration Example

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ServerSerial.md

Example showing the definition of a service vector and the initialization of a ServerSerial instance with serial port options.

```javascript
const vector = {
    getCoil: (addr, unitID) => addr % 2 === 0,
    setCoil: (addr, value, unitID) => console.log('Set coil', addr, value),
    getHoldingRegister: (addr, unitID) => addr * 10,
    setRegister: (addr, value, unitID) => console.log('Set register', addr, value)
};

const server = new ServerSerial(vector, {
    path: '/dev/ttyUSB0',
    baudRate: 9600,
    dataBits: 8,
    stopBits: 1,
    parity: 'none',
    debug: false,
    unitID: 1
});
```

--------------------------------

### ServerTCP usage example

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ServerTCP.md

Example showing the definition of a service vector and the instantiation of a ServerTCP server with specific options.

```javascript
const vector = {
    getCoil: (addr, unitID) => addr % 2 === 0,
    setCoil: (addr, value, unitID) => console.log('Set coil', addr, value),
    getHoldingRegister: (addr, unitID) => addr * 10,
    setRegister: (addr, value, unitID) => console.log('Set register', addr, value)
};

const server = new ServerTCP(vector, {
    host: '0.0.0.0',
    port: 502,
    debug: false,
    unitID: 1
});
```

--------------------------------

### writeCoil Example

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ModbusRTU.md

Example of writing a single coil.

```javascript
await client.writeCoil(0, true);
console.log('Coil written');
```

--------------------------------

### writeCoils Example

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ModbusRTU.md

Example of writing multiple coils.

```javascript
await client.writeCoils(0, [true, false, true, true]);
```

--------------------------------

### open Method Signature and Example

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ModbusRTU.md

Opens the connection to the device. Includes a callback for error handling.

```javascript
open(callback?: Function): void
```

```javascript
client.open((err) => {
    if (err) console.error('Open failed:', err);
});
```

--------------------------------

### readDeviceIdentification Example

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ModbusRTU.md

Example usage of readDeviceIdentification to retrieve vendor and product information.

```javascript
const info = await client.readDeviceIdentification(1, 0);
console.log('Vendor:', info.data[0]);
console.log('Product code:', info.data[1]);
```

--------------------------------

### Read Input Registers Example

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/TestPort.md

Demonstrates reading input registers using the TestPort client.

```javascript
const client = new ModbusRTU(new TestPort());
client.setID(1);

const result = await client.readInputRegisters(0, 5);
console.log(result.data);  // [0, 1, 2, 3, 4]

const result2 = await client.readInputRegisters(5, 3);
console.log(result2.data);  // [5, 6, 7]
```

--------------------------------

### writeRegister Example

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ModbusRTU.md

Example of writing a single register.

```javascript
await client.writeRegister(10, 1234);
console.log('Register written');
```

--------------------------------

### Example ASCII Frame

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/PortImplementations.md

A sample Modbus ASCII frame showing the start character, data, and line termination.

```text
:010300000002B82D

```

--------------------------------

### Complete Modbus TestPort Example

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/TestPort.md

Demonstrates initializing a ModbusRTU client with a TestPort instance and performing various read and write operations to verify client behavior.

```javascript
const { ModbusRTU } = require('modbus-serial');
const TestPort = ModbusRTU.TestPort;

async function testModbus() {
    // Create client with test port
    const client = new ModbusRTU(new TestPort());
    
    // Set configuration
    client.setID(1);  // Use normal slave
    client.setTimeout(5000);
    
    try {
        // Test connection
        console.log('Test port open:', client.isOpen);
        
        // Read coil status
        let result = await client.readCoils(0, 8);
        console.log('Coils:', result.data);
        
        // Read discrete inputs
        result = await client.readDiscreteInputs(0, 8);
        console.log('Discrete inputs:', result.data);
        
        // Read holding registers
        result = await client.readHoldingRegisters(0, 10);
        console.log('Holding registers:', result.data);
        
        // Read input registers
        result = await client.readInputRegisters(0, 5);
        console.log('Input registers:', result.data);
        
        // Write single coil
        result = await client.writeCoil(0, true);
        console.log('Write coil result:', result);
        
        // Write single register
        result = await client.writeRegister(0, 1000);
        console.log('Write register result:', result);
        
        // Write multiple registers
        result = await client.writeRegisters(0, [10, 20, 30, 40, 50]);
        console.log('Write registers result:', result);
        
        // Mask write register
        result = await client.maskWriteRegister(0, 0xFF00, 0x00FF);
        console.log('Mask write result:', result);
        
        console.log('\n✓ All tests passed!');
    } catch (err) {
        console.error('✗ Test failed:', err.message);
    } finally {
        client.close();
    }
}

testModbus();
```

--------------------------------

### Complete ServerSerial Implementation

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ServerSerial.md

This example demonstrates how to define a service vector for handling Modbus operations and initialize a ServerSerial instance on a specific serial port. It includes event listeners for initialization and error handling, as well as a graceful shutdown procedure.

```javascript
const { ServerSerial } = require('modbus-serial');

// Define device state
const coils = new Array(100).fill(false);
const registers = new Array(100).fill(0);

// Service vector
const vector = {
    getCoil: (addr, unitID) => {
        return coils[addr] || false;
    },
    
    setCoil: (addr, value, unitID) => {
        coils[addr] = value;
        console.log(`Unit ${unitID}: Coil ${addr} set to ${value}`);
    },
    
    getInputRegister: (addr, unitID) => {
        // Simulate sensor data
        return Math.floor(Math.random() * 100);
    },
    
    getHoldingRegister: (addr, unitID) => {
        return registers[addr] || 0;
    },
    
    setRegister: (addr, value, unitID) => {
        registers[addr] = value;
        console.log(`Unit ${unitID}: Register ${addr} set to ${value}`);
    },
    
    setRegisterArray: (addr, values, unitID) => {
        for (let i = 0; i < values.length; i++) {
            registers[addr + i] = values[i];
        }
        console.log(`Unit ${unitID}: Registers ${addr}-${addr + values.length - 1} written`);
    },
    
    setRegisterMask: (addr, andMask, orMask, unitID) => {
        const current = registers[addr] || 0;
        registers[addr] = (current & andMask) | orMask;
        console.log(`Unit ${unitID}: Mask write at ${addr} result=${registers[addr]}`);
    }
};

// Create serial server
const server = new ServerSerial(vector, {
    path: '/dev/ttyUSB0',
    baudRate: 9600,
    dataBits: 8,
    stopBits: 1,
    parity: 'none',
    debug: false,
    unitID: 1
});

server.on('initialized', () => {
    console.log('Modbus RTU server listening on /dev/ttyUSB0');
});

server.on('socketError', (err) => {
    console.error('Serial error:', err.message);
});

server.on('error', (err) => {
    console.error('Server error:', err.message);
});

// Graceful shutdown
process.on('SIGINT', () => {
    console.log('Shutting down...');
    server.close(() => {
        console.log('Server closed');
        process.exit(0);
    });
});
```

--------------------------------

### writeRegisters Example

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ModbusRTU.md

Example of writing multiple registers using an array or a Buffer.

```javascript
await client.writeRegisters(0, [100, 200, 300]);
// or
const buf = Buffer.from([0x00, 0x64, 0x00, 0xC8]);
await client.writeRegisters(0, buf);
```

--------------------------------

### maskWriteRegister Example

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ModbusRTU.md

Examples of applying mask operations to a register.

```javascript
// Set bit 3, clear bit 0
await client.maskWriteRegister(50, 0xFFFF, 0x0008);

// Clear bits 4-7, keep others
await client.maskWriteRegister(50, 0xFF0F, 0x0000);
```

--------------------------------

### Read Holding Registers Example

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/TestPort.md

Demonstrates reading holding registers using the TestPort client.

```javascript
const client = new ModbusRTU(new TestPort());
client.setID(1);

const result = await client.readHoldingRegisters(0, 10);
console.log(result.data);
// [0, 0, 0, 0, 0, 0, 0, 0, 0xa12b, 0xffff]

const result2 = await client.readHoldingRegisters(8, 2);
console.log(result2.data);  // [0xa12b, 0xffff] = [41227, 65535]
```

--------------------------------

### Setup client and worker

Source: https://github.com/yaacov/node-modbus-serial/blob/main/worker/README.md

Initialize the Modbus client and configure worker options such as maximum concurrent requests and debug mode.

```javascript
const client = new ModbusRTU()

client.connect..........

client.setWorkerOptions({
    maxConcurrentRequests: 10, // it will send 10 requests or less at a time if any
    debug: true
})
```

--------------------------------

### getCoil handler implementation examples

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ServerTCP.md

Demonstrates synchronous, callback-based, and promise-based implementations for the getCoil handler.

```javascript
// Synchronous
getCoil: (addr, unitID) => {
    return addr < 10;
},

// Callback-based (asynchronous)
getCoil: (addr, unitID, cb) => {
    setTimeout(() => {
        cb(null, addr % 2 === 0);
    }, 100);
},

// Promise-based
getCoil: (addr, unitID) => {
    return Promise.resolve(addr % 2 === 0);
}
```

--------------------------------

### Configure Serial Connection

Source: https://github.com/yaacov/node-modbus-serial/blob/main/README.md

Example of connecting to a serial device using specific baud rate and parity settings.

```javascript
client.connectRTUBuffered("/dev/ttyUSB0", { baudRate: 9600, parity: 'even' });
```

--------------------------------

### getInputRegister handler implementation

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ServerTCP.md

Example of a callback-based implementation for the getInputRegister handler to simulate sensor reading.

```javascript
getInputRegister: (addr, unitID, cb) => {
    // Simulate sensor reading
    setTimeout(() => {
        const value = Math.floor(Math.random() * 100);
        cb(null, value);
    }, 50);
}
```

--------------------------------

### customFunction Example

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ModbusRTU.md

Example of sending a custom Modbus function code.

```javascript
const result = await client.customFunction(65, [1, 2, 3]);
console.log('Response:', result.data);
```

--------------------------------

### close Method Signature and Example

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ModbusRTU.md

Closes the connection gracefully with an optional callback.

```javascript
close(callback?: Function): void
```

```javascript
client.close((err) => {
    if (err) console.error('Close failed:', err);
    else console.log('Connection closed');
});
```

--------------------------------

### ModbusRTU Execution Example

Source: https://github.com/yaacov/node-modbus-serial/wiki/Example:--server

Shows how to execute a Modbus read operation using the thread-safe wrapper.

```javascript
let result = await runInSafeThread (async () => await rtuClientIniciazated.readInputRegisters(14, 1));
console.log(result);
```

--------------------------------

### destroy Method Signature and Example

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ModbusRTU.md

Immediately closes the connection and cancels all pending transactions.

```javascript
destroy(callback?: Function): void
```

```javascript
client.destroy(() => console.log('Destroyed'));
```

--------------------------------

### Full ModbusRTU Thread-Safe Implementation

Source: https://github.com/yaacov/node-modbus-serial/wiki/Example:--server

A complete example combining the queue, runner, wrapper, and execution logic for ModbusRTU.

```javascript
const queue = require('async/queue');
let queueRTU = queue(this.runner.bind(this), 1);

async runner(magicPromise) {
    try{
        magicPromise.resolve(await magicPromise.action());
    } catch (error) {
        magicPromise.reject(error);
    }
    // callback(); // You won't use callback due async enviroment
}


const runInSafeThread = (action) => {
    let resolve, reject;
    let magicPromise = new Promise((res, rej) => {
        resolve = res;
        reject = rej;
    });
    magicPromise.action= action;
    magicPromise.resolve = resolve;
    magicPromise.reject  = reject;

    queueRTU.push(magicPromise); // Here we send the magicPromise to be processed by the worker

    return magicPromise;
};

let result = await runInSafeThread(async () => await rtuClientIniciazated.readInputRegisters(14, 1));
console.log(result);
```

--------------------------------

### ModbusRTU Server Queue Setup

Source: https://github.com/yaacov/node-modbus-serial/wiki/Example:--server

Initializes an async queue with a single worker to manage concurrent ModbusRTU operations safely.

```javascript
const queue = require('async/queue');
let queueRTU = queue(this.runner.bind(this), 1);
```

--------------------------------

### Enron Protocol Client Configuration

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/configuration.md

Example of initializing a ModbusRTU client with Enron protocol support enabled and custom table ranges.

```javascript
const client = new ModbusRTU();
await client.connectRTU('/dev/ttyUSB0', {
    baudRate: 9600,
    enron: true,
    enronTables: {
        booleanRange: [1001, 1999],
        shortRange: [3001, 3999],
        longRange: [5001, 5999],
        floatRange: [7001, 7999]
    }
});
```

--------------------------------

### get isOpen

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/TestPort.md

Checks the current status of the simulated port.

```APIDOC
## get isOpen

### Description
Returns the current connection status of the port. For TestPort, this always returns true.

### Signature
`get isOpen(): boolean`

### Returns
- **boolean** - Always returns true.
```

--------------------------------

### Implement setRegisterArray

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ServerTCP.md

Example implementation for handling write multiple registers (FC=16) requests.

```javascript
setRegisterArray: async (addr, values, unitID) => {
    console.log(`Write ${values.length} registers at address ${addr}`);
    for (let i = 0; i < values.length; i++) {
        await writeRegister(addr + i, values[i]);
    }
}
```

--------------------------------

### Persistent Connection Example

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/PortImplementations.md

Demonstrates a persistent connection using TCP, where the connection remains open for multiple read operations.

```javascript
// Connection stays open for multiple requests
const client = new ModbusRTU();
await client.connectTCP('192.168.1.100', { port: 502 });

// Multiple operations on same connection
const data1 = await client.readHoldingRegisters(0, 10);
const data2 = await client.readInputRegisters(0, 5);
const data3 = await client.readCoils(0, 20);

await client.close();
```

--------------------------------

### Connectionless UDP Example

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/PortImplementations.md

Demonstrates the connectionless nature of UDP, where each request is independent and sent as a separate datagram.

```javascript
// Each request is independent
const client = new ModbusRTU();
await client.connectUDP('192.168.1.100', { port: 8502 });

// Each read is a separate UDP datagram
const data1 = await client.readHoldingRegisters(0, 10);
const data2 = await client.readHoldingRegisters(10, 10);
```

--------------------------------

### Project File Organization

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/README.md

The directory structure of the documentation workspace, showing the location of main guides and API references.

```text
/workspace/home/output/
├── README.md                          # This file
├── INDEX.md                           # Master navigation index
├── types.md                           # Type definitions
├── configuration.md                   # Configuration options
├── errors.md                          # Error reference
└── api-reference/
    ├── ModbusRTU.md                  # Main client class
    ├── ServerTCP.md                  # TCP server
    ├── ServerSerial.md               # Serial server
    ├── PortImplementations.md        # Port types guide
    └── TestPort.md                   # Test port
```

--------------------------------

### Handling Modbus Exceptions

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/errors.md

Example demonstrating how to catch Modbus exceptions and interpret the modbusCode property to provide descriptive error messages.

```javascript
const client = new ModbusRTU();
await client.connectTCP('192.168.1.100', { port: 502 });
client.setID(1);

try {
    // Try to read from an invalid address
    await client.readHoldingRegisters(10000, 10);
} catch (err) {
    if (err.modbusCode) {
        const errorMessages = [
            'Unknown error',
            'Illegal function',
            'Illegal data address',
            'Illegal data value',
            'Device failure',
            'Acknowledge',
            'Device busy',
            'Negative acknowledge',
            'Memory parity error'
        ];
        
        const description = errorMessages[err.modbusCode] || 'Unknown error';
        console.error(`Modbus error ${err.modbusCode}: ${description}`);
    } else {
        console.error('Non-Modbus error:', err.message);
    }
}
```

--------------------------------

### setCoil handler implementation

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ServerTCP.md

Example of a synchronous implementation for the setCoil handler that logs the action and interacts with a device control object.

```javascript
setCoil: (addr, value, unitID) => {
    console.log(`Device ${unitID}: Set coil ${addr} to ${value}`);
    deviceControl.setCoil(addr, value);
}
```

--------------------------------

### readHoldingRegisters Example

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ModbusRTU.md

Example usage of readHoldingRegisters to read 10 registers starting from address 0.

```javascript
const result = await client.readHoldingRegisters(0, 10);
console.log('Register values:', result.data);  // [100, 200, 300, ...]
```

--------------------------------

### readDiscreteInputs Example

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ModbusRTU.md

Example usage of readDiscreteInputs to read 4 inputs starting from address 0.

```javascript
const result = await client.readDiscreteInputs(0, 4);
console.log('Discrete inputs:', result.data);
```

--------------------------------

### readInputRegisters Example

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ModbusRTU.md

Example usage of readInputRegisters to read 4 input registers starting from address 0.

```javascript
const temps = await client.readInputRegisters(0, 4);
console.log('Temperature readings:', temps.data);
```

--------------------------------

### Implement setRegisterMask

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ServerTCP.md

Example implementation for handling mask write register (FC=22) requests using the formula result = (current & andMask) | orMask.

```javascript
setRegisterMask: (addr, andMask, orMask, unitID) => {
    const current = registers[addr] || 0;
    const result = (current & andMask) | orMask;
    registers[addr] = result;
    console.log(`Mask write: addr=${addr}, result=${result}`);
}
```

--------------------------------

### Get Available Ports

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ModbusRTU.md

Retrieve a list of available serial ports. Requires the serialport package to be installed.

```javascript
const ports = await ModbusRTU.getPorts();
console.log(ports);
// Output: [{ path: '/dev/ttyUSB0', manufacturer: 'FTDI' }, ...]
```

--------------------------------

### Initialize modbusdb and perform read/write operations

Source: https://github.com/yaacov/node-modbus-serial/blob/main/README.md

Demonstrates how to define a schema, configure unit settings, initialize the database instance, and perform batch read (mget) and write (mset) operations.

```typescript
import Modbus from 'modbus-serial';
import { Modbusdb, ModbusSerialDriver, Datamap, createRegisterKey, TypeEnum, ScopeEnum } from "modbusdb";

// create an empty modbus client
const client = new Modbus();

client.connectTcpRTUBuffered("127.0.0.1", { port: 8502 }, app) // or use any other available connection methods

function app() {

  // First you need to define a schema for a database:
  // createRegisterKey(UNIT_ADDRESS, MODBUS_TABLE, REGISTER_ADDRESS, BIT_INDEX)
  const schema = [
    { key: createRegisterKey(1, ScopeEnum.InternalRegister, 10),    type: TypeEnum.Int16 },
    { key: createRegisterKey(1, ScopeEnum.InternalRegister, 11),    type: TypeEnum.Int32 },
    { key: createRegisterKey(1, ScopeEnum.PhysicalRegister, 99),    type: TypeEnum.UInt16 },
    { key: createRegisterKey(1, ScopeEnum.InternalRegister, 15, 2), type: TypeEnum.Bit },
  ];

  // Define unit-scoped config if needed:
  const units = [
    {
      address: 1, // This is unit address
      forceWriteMany: true, // Use 15(0x0f) and 16(0x10) functions for single register, default: false
      bigEndian: true, // You can use BigEndian for byte order, default: false
      swapWords: false, // This is applicable only for multi-registers types such as int32, float etc, default: false
      requestWithGaps: true, // If you are requesting addresses 10 and 13, allow to send one request to the device, default: true
      maxRequestSize: 32, // How many registers to be requested in one round-trip with device, default: 1
    }
  ];

  // Let`s create an instance of a database:
  const db = new Modbusdb({
    driver: new ModbusSerialDriver(client),
    datamap: new Datamap(schema, units)
  });

  // Now we can request three registers:
  // NOTICE: Modbusdb under the hood will make all needed requests for you in using an optimal plan
  //         If registers can be requested using a single request, be sure it will
  db.mget([
    createRegisterKey(1, ScopeEnum.InternalRegister, 10),
    createRegisterKey(1, ScopeEnum.InternalRegister, 11),
    createRegisterKey(1, ScopeEnum.PhysicalRegister, 99)
  ]).then(result => {
    console.log('mget', result)
  })

  // You can store register`s key to be used later:
  const speedSetPoint = createRegisterKey(1, ScopeEnum.InternalRegister, 10);
  const workingMode = createRegisterKey(1, ScopeEnum.InternalRegister, 11);

  // Write values directly into modbus device as easy as possible:
  // NOTICE: Modbusdb under the hood will make all needed requests for you
  //         Write operations have higher priority over the read operations
  db.mset([
    [speedSetPoint, 60],
    [workingMode, 10],
  ]).then(result => {
    console.log('mset', result)
  })
}
```

--------------------------------

### Connect via UDP

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/INDEX.md

Establishes a lightweight network connection.

```javascript
connectUDP('192.168.1.100')
```

--------------------------------

### open(callback?: Function)

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ModbusRTU.md

Opens the connection to the device.

```APIDOC
## open(callback?: Function)

### Description
Opens the connection to the device.

### Parameters
- **callback** (Function) - Optional - Callback (error?: Error) => void
```

--------------------------------

### Import TestPort

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/PortImplementations.md

Shows how to import the TestPort class for in-memory simulation and unit testing.

```javascript
const { TestPort } = ModbusRTU;
// or
const TestPort = ModbusRTU.TestPort;
```

--------------------------------

### Create TestPort Instance

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/TestPort.md

Initialize a new ModbusRTU client using a TestPort instance.

```javascript
const client = new ModbusRTU(new TestPort());
```

--------------------------------

### Listen to the 'data' event

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/TestPort.md

Demonstrates how to listen for the 'data' event emitted by the TestPort instance when a response is ready.

```javascript
const port = new TestPort();
port.on('data', (data) => {
    console.log('Response:', data);
});
```

--------------------------------

### getTimeout()

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ModbusRTU.md

Gets the current read timeout.

```APIDOC
## getTimeout()

### Description
Gets the current read timeout.

### Returns
- **number** - Timeout in milliseconds
```

--------------------------------

### Open Port Method

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/TestPort.md

Simulates opening the port, which always succeeds.

```javascript
open(callback?: Function): void
```

```javascript
const port = new TestPort();
port.open((err) => {
    if (err) console.error('Open failed:', err);
    else console.log('Port open');
});
```

--------------------------------

### getID()

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ModbusRTU.md

Gets the current slave unit ID.

```APIDOC
## getID()

### Description
Gets the current slave unit ID.

### Returns
- **number** - Current slave ID
```

--------------------------------

### Test Happy Path with TestPort

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/TestPort.md

Demonstrates a successful execution flow for reading coils, input registers, holding registers, and writing a register using TestPort.

```javascript
async function testHappyPath() {
    const client = new ModbusRTU(new TestPort());
    client.setID(1);  // Normal slave
    client.setTimeout(1000);
    
    try {
        const coils = await client.readCoils(0, 8);
        console.log('✓ Read coils:', coils.data);
        
        const inputs = await client.readInputRegisters(0, 5);
        console.log('✓ Read inputs:', inputs.data);
        
        const holdings = await client.readHoldingRegisters(0, 10);
        console.log('✓ Read holdings:', holdings.data);
        
        await client.writeRegister(0, 100);
        console.log('✓ Write register');
        
        return true;
    } catch (err) {
        console.error('✗ Test failed:', err.message);
        return false;
    }
}
```

--------------------------------

### getTimeout Method Signature and Example

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ModbusRTU.md

Retrieves the current read timeout in milliseconds.

```javascript
getTimeout(): number
```

```javascript
const timeout = client.getTimeout();
console.log('Timeout:', timeout, 'ms');
```

--------------------------------

### Initialize ServerSerial

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/configuration.md

Configures a Serial server using the ServerSerial constructor, requiring a device path and supporting various serial communication parameters.

```javascript
const { ServerSerial } = require('modbus-serial');

const server = new ServerSerial(vector, {
    path: '/dev/ttyUSB0',
    baudRate: 9600,
    dataBits: 8,
    stopBits: 1,
    parity: 'none',
    debug: false,
    unitID: 1
});
```

--------------------------------

### setTimeout Method Signature and Example

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ModbusRTU.md

Sets the read operation timeout in milliseconds.

```javascript
setTimeout(duration: number): void
```

```javascript
client.setTimeout(5000);  // 5 second timeout
```

--------------------------------

### Connect via ASCII

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/INDEX.md

Establishes a connection for legacy serial devices.

```javascript
connectAsciiSerial('/dev/ttyUSB0')
```

--------------------------------

### getID Method Signature and Example

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ModbusRTU.md

Retrieves the current slave unit ID.

```javascript
getID(): number
```

```javascript
const id = client.getID();
console.log('Current slave ID:', id);
```

--------------------------------

### .connectRTU (path, options, callback)

Source: https://github.com/yaacov/node-modbus-serial/wiki/Methods

Connect using serial port.

```APIDOC
## .connectRTU (path, options, callback)

### Description
Connect using serial port.

### Parameters
- **path** (string) - Required - The port path (e.g. "/dev/ttyS0").
- **options** (object) - Optional - The options for this connection.
- **callback** (function) - Optional - Called once the client is connected.
```

--------------------------------

### readCoils(coil, len)

Source: https://github.com/yaacov/node-modbus-serial/blob/main/README.md

Reads the status of coils starting from the specified address.

```APIDOC
## readCoils(coil, len)

### Description
Reads the status of coils starting from the specified address.

### Parameters
- **coil** (number) - Required - The starting coil address.
- **len** (number) - Required - The number of coils to read.
```

--------------------------------

### open(callback)

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/TestPort.md

Simulates the opening of a Modbus port.

```APIDOC
## open(callback)

### Description
Simulates opening the port. This operation always succeeds.

### Signature
`open(callback?: Function): void`

### Parameters
- **callback** (Function) - Optional - Callback function with signature `(error) => void`.
```

--------------------------------

### Create ModbusRTU Instance

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ModbusRTU.md

Initialize a new instance of the ModbusRTU client.

```javascript
const client = new ModbusRTU();
```

--------------------------------

### Create ServerTCP instance

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ServerTCP.md

Initialize a new ServerTCP instance with a service vector and optional configuration.

```javascript
const server = new ServerTCP(vector, options);
```

--------------------------------

### readDiscreteInputs(addr, arg)

Source: https://github.com/yaacov/node-modbus-serial/blob/main/README.md

Reads the status of discrete inputs starting from the specified address.

```APIDOC
## readDiscreteInputs(addr, arg)

### Description
Reads the status of discrete inputs starting from the specified address.

### Parameters
- **addr** (number) - Required - The starting address.
- **arg** (number) - Required - The number of inputs to read.
```

--------------------------------

### Handling initialized event

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ServerTCP.md

Listens for the server initialization event, indicating the server is ready to accept connections.

```javascript
server.on('initialized', () => {
    console.log('Server ready');
});
```

--------------------------------

### Using Promise-based API

Source: https://github.com/yaacov/node-modbus-serial/wiki/Methods

Demonstrates configuring the client with a unit ID and timeout, followed by a read operation using promises.

```javascript
// set the client's unit id
client.setID(1);

// set a timout for requests default is null (no timeout)
client.setTimeout(1000);

// read 8 discrete inputs starting at input 10
// (function use the unit id 1, we set earlier)
client.readDiscreteInputs(10, 8)
    .then(function(data) {
        console.log(data);
    });
```

--------------------------------

### BLE Port Connection

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/PortImplementations.md

Example of connecting to a Modbus device over BLE using the device name.

```javascript
const client = new ModbusRTU();
await client.connectBle({ deviceName: 'MB-Device' });
```

--------------------------------

### Initialize ServerTCP

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/configuration.md

Configures a TCP server using the ServerTCP constructor with options for host, port, debug mode, and unit ID.

```javascript
const { ServerTCP } = require('modbus-serial');

const server = new ServerTCP(vector, {
    host: '0.0.0.0',
    port: 502,
    debug: false,
    unitID: 1
});
```

--------------------------------

### ModbusTCP Server Implementation

Source: https://github.com/yaacov/node-modbus-serial/wiki/Example:--server

Demonstrates how to create a ModbusTCP server by defining a vector object for register and coil access and initializing the ServerTCP instance.

```javascript
// create an empty modbus client
var ModbusRTU = require("modbus-serial");
var vector = {
  getInputRegister: function(addr, unitID) { return addr; },
  getHoldingRegister: function(addr, unitID) { return addr + 8000; },
  getCoil: function(addr, unitID) { return (addr % 2) === 0; },
  setRegister: function(addr, value, unitID) { console.log('set register', addr, value, unitID); return; },
  setCoil: function(addr, value, unitID) { console.log('set coil', addr, value, unitID); return; }
};

// set the server to answer for modbus requests
console.log('ModbusTCP listening on modbus://0.0.0.0:502');
var serverTCP = new ModbusRTU.ServerTCP(vector, {host: '0.0.0.0'});
```

--------------------------------

### RTU Socket Port Connection

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/PortImplementations.md

Example of connecting to a Modbus RTU device using an externally managed net.Socket.

```javascript
const net = require('net');
const socket = new net.Socket();
socket.connect(502, '192.168.1.100');

const client = new ModbusRTU();
await client.connectRTUSocket(socket);
```

--------------------------------

### writeRegisters(dataAddress: number, values: number[] | Buffer)

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ModbusRTU.md

Writes multiple registers (FC=16) starting from the specified address.

```APIDOC
## writeRegisters(dataAddress: number, values: number[] | Buffer)

### Description
Writes multiple registers (FC=16) starting from the specified address.

### Parameters
- **dataAddress** (number) - Required - Starting register address
- **values** (number[] | Buffer) - Required - Values to write

### Returns
- **Promise<WriteMultipleResult>** - Object containing address and length

### Example
```javascript
await client.writeRegisters(0, [100, 200, 300]);
```
```

--------------------------------

### Constructor Signature

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ModbusRTU.md

The constructor accepts an optional port instance.

```javascript
constructor(port?: any)
```

--------------------------------

### Read data from device

Source: https://github.com/yaacov/node-modbus-serial/blob/main/worker/README.md

Read multiple values starting from a specific register address with a defined data type.

```javascript
// Read 4 values starting from 10009 register.
// Under the hood it will read 8 registers due to int32 type
const response = await client.send({
    unit: 1,
    fc: 3,
    address: 10009,
    quantity: 4,
    type: 'int32',
});
```

--------------------------------

### Create ServerSerial Instance

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ServerSerial.md

Instantiate a new ServerSerial object using a service vector and optional configuration.

```javascript
const server = new ServerSerial(vector, options);
```

--------------------------------

### readCoils Method Signature and Example

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ModbusRTU.md

Reads coil status (FC=01). Returns a promise with the coil data as a boolean array.

```javascript
readCoils(dataAddress: number, length: number): Promise<ReadCoilResult>
```

```javascript
client.setID(1);
try {
    const result = await client.readCoils(0, 8);
    console.log('Coils:', result.data);  // [true, false, true, ...]
} catch (err) {
    console.error('Read failed:', err.message);
}
```

--------------------------------

### Read and Write RTU Client

Source: https://github.com/yaacov/node-modbus-serial/wiki/Examples:-clients

Shows how to connect to a serial port, write values to registers, and then read them back using promise chaining.

```javascript
// create an empty modbus client
var ModbusRTU = require("modbus-serial");
var client = new ModbusRTU();

// open connection to a serial port
client.connectRTU("/dev/ttyUSB0", {baudRate: 9600}, write);

function write() {
    client.setID(1);

    // write the values 0, 0xffff to registers starting at address 5
    // on device number 1.
    client.writeRegisters(5, [0 , 0xffff])
        .then(read);
}

function read() {
    // read the 2 registers starting at address 5
    // on device number 1.
    client.readHoldingRegisters(5, 2)
        .then(console.log);
}
```

--------------------------------

### Invoke close method

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ServerTCP.md

Example usage of the close method with a callback to handle potential errors or confirm server shutdown.

```javascript
server.close((err) => {
    if (err) console.error('Close error:', err);
    else console.log('Server closed');
});
```

--------------------------------

### Connect via RTU

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/INDEX.md

Establishes a direct serial connection using path and baudRate.

```javascript
connectRTU('/dev/ttyUSB0')
```

--------------------------------

### Connect ASCII Port

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/PortImplementations.md

Establishes a Modbus ASCII connection over a serial device, optionally specifying the start frame character.

```javascript
const client = new ModbusRTU();
await client.connectAsciiSerial('/dev/ttyUSB0', {
    baudRate: 9600,
    startOfSlaveFrameChar: 0x3A  // Optional
});
```

--------------------------------

### Handle Port Not Open Error

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/errors.md

Ensure the connection is fully established using await before attempting to perform read or write operations.

```javascript
// Make sure to wait for connection
const client = new ModbusRTU();
await client.connectRTU('/dev/ttyUSB0', { baudRate: 9600 });  // Wait for this

// Then perform operations
const data = await client.readHoldingRegisters(0, 10);
```

--------------------------------

### connectUDP()

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/configuration.md

Configures a connection to a UDP server.

```APIDOC
## connectUDP(host, options)

### Description
Establishes a connection to a UDP server.

### Parameters
- **host** (string) - Required - UDP server hostname or IP address.
- **options** (object) - Required - Configuration object containing port, localAddress, or family.
```

--------------------------------

### Connect via RTU Buffered

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/INDEX.md

Establishes a serial connection with buffering enabled.

```javascript
connectRTUBuffered('/dev/ttyUSB0')
```

--------------------------------

### Read and Write with ModbusRTU

Source: https://github.com/yaacov/node-modbus-serial/blob/main/README.md

Demonstrates connecting to a serial port, writing to registers, and reading them back using promises.

```javascript
// create an empty modbus client
const ModbusRTU = require("modbus-serial");
const client = new ModbusRTU();

// open connection to a serial port
client.connectRTUBuffered("/dev/ttyUSB0", { baudRate: 9600 }, write);

function write() {
    client.setID(1);

    // write the values 0, 0xffff to registers starting at address 5
    // on device number 1.
    client.writeRegisters(5, [0 , 0xffff])
        .then(read);
}

function read() {
    // read the 2 registers starting at address 5
    // on device number 1.
    client.readHoldingRegisters(5, 2)
        .then(console.log);
}
```

--------------------------------

### Connect via TCP

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/INDEX.md

Establishes a connection to modern Ethernet devices using host and port configuration.

```javascript
connectTCP('192.168.1.100', {port:502})
```

--------------------------------

### Using Callback-based API

Source: https://github.com/yaacov/node-modbus-serial/wiki/Methods

Demonstrates performing a read operation using the callback pattern.

```javascript

// read 8 holding registers starting at register 10
// (function use the unit id 1)
client.writeFC3(1, 10, 8, function(err, data) {
      if (err) {
            console.log(err);
      } else {
            console.log(data);
      }
});
```

--------------------------------

### Logger TCP Client

Source: https://github.com/yaacov/node-modbus-serial/wiki/Examples:-clients

Demonstrates connecting to a TCP Modbus device and continuously reading 10 input registers starting at address 0 using promises.

```javascript
// create an empty modbus client
var ModbusRTU = require("modbus-serial");
var client = new ModbusRTU();

// open connection to a tcp line
client.connectTCP("192.168.1.42", run);

// read the values of 10 registers starting at address 0
// on device number 1. and log the values to the console.
function run() {
    client.setID(1);

    client.readInputRegisters(0, 10)
        .then(console.log)
        .then(run);
}
```

--------------------------------

### .connectTCP (ip, options, callback)

Source: https://github.com/yaacov/node-modbus-serial/wiki/Methods

Connect using tcp/ip.

```APIDOC
## .connectTCP (ip, options, callback)

### Description
Connect using tcp/ip.

### Parameters
- **ip** (string) - Required - The port ip (e.g. "24.230.1.42").
- **options** (object) - Optional - The options for this connection.
- **callback** (function) - Optional - Called once the client is connected.
```

--------------------------------

### TCP Connection Methods

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/configuration.md

Methods for establishing TCP connections or linking to existing sockets.

```APIDOC
## connectTCP(host, options)
## linkTCP(socket)

### Description
Connects to a Modbus TCP server or links the client to an existing net.Socket instance.

### Parameters
- **host** (string) - Required (for connectTCP) - Hostname or IP address
- **options** (Object) - Optional - Configuration object containing port, timeout, localAddress, and IP family
- **socket** (Socket) - Required (for linkTCP) - An existing net.Socket instance
```

--------------------------------

### IServerOptions Interface

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/types.md

Configuration options for initializing a TCP server.

```typescript
interface IServerOptions {
  host?: string;
  port?: number;
  debug?: boolean;
  unitID?: number;
}
```

--------------------------------

### new ServerSerial(vector, options)

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ServerSerial.md

Constructor for creating a new Modbus serial server instance.

```APIDOC
## Constructor: new ServerSerial(vector, options)

### Description
Creates a new Modbus serial server instance that listens for Modbus RTU protocol requests on a specified serial port.

### Parameters
- **vector** (IServiceVector) - Required - Service handler functions for Modbus operations.
- **options** (IServerSerialOptions) - Optional - Configuration for the server and serial port.

### Options (IServerSerialOptions)
- **path** (string) - Required - Serial port path (e.g., /dev/ttyUSB0, COM3).
- **baudRate** (number) - Optional - Serial port baud rate (default: 9600).
- **dataBits** (number) - Optional - Data bits (5-8) (default: 8).
- **stopBits** (number) - Optional - Stop bits (1-2) (default: 1).
- **parity** (string) - Optional - Parity: 'none', 'even', 'odd', 'mark', 'space' (default: 'none').
- **debug** (boolean) - Optional - Enable debug logging (default: false).
- **unitID** (number) - Optional - Default unit ID for responses (default: 1).
- **openCallback** (ErrorCallback) - Optional - Callback when serial port opens.

### Example
```javascript
const vector = {
    getCoil: (addr, unitID) => addr % 2 === 0,
    setCoil: (addr, value, unitID) => console.log('Set coil', addr, value),
    getHoldingRegister: (addr, unitID) => addr * 10,
    setRegister: (addr, value, unitID) => console.log('Set register', addr, value)
};

const server = new ServerSerial(vector, {
    path: '/dev/ttyUSB0',
    baudRate: 9600,
    dataBits: 8,
    stopBits: 1,
    parity: 'none',
    debug: false,
    unitID: 1
});
```
```

--------------------------------

### .connectRTUBuffered (path, options, callback)

Source: https://github.com/yaacov/node-modbus-serial/wiki/Methods

Connect using buffered serial port.

```APIDOC
## .connectRTUBuffered (path, options, callback)

### Description
Connect using buffered serial port. Use when serial port has long delays inside packets.

### Parameters
- **path** (string) - Required - The port path (e.g. "/dev/ttyS0").
- **options** (object) - Optional - The options for this connection.
- **callback** (function) - Optional - Called once the client is connected.
```

--------------------------------

### ServerTCP Initialization

Source: https://github.com/yaacov/node-modbus-serial/blob/main/_autodocs/api-reference/ServerTCP.md

Initializes a new Modbus TCP server instance with a service vector and configuration options.

```APIDOC
## new ServerTCP(vector, options)

### Description
Creates and starts a new Modbus TCP server instance.

### Parameters
- **vector** (Object) - Required - An object containing methods to handle Modbus requests (getCoil, setCoil, getHoldingRegister, setRegister, setRegisterArray).
- **options** (Object) - Required - Configuration object containing host, port, and debug settings.
```
Tokens:
Raw