modbus-webserial/dist/index.d.ts

Tiny TypeScript library for speaking Modbus-RTU from the browser via Web Serial

interface WebSerialOptions {
    baudRate?: number;
    dataBits?: 7 | 8;
    stopBits?: 1 | 2;
    parity?: 'none' | 'even' | 'odd';
    requestFilters?: SerialPortFilter[];
    timeout?: number;
}

/** Result payloads returned by high-level helpers */
interface ReadCoilResult {
    /** packed bits as booleans (C0 … Cn-1) */
    data: boolean[];
    /** raw response frame (incl. CRC) */
    raw: Uint8Array;
}
interface ReadRegisterResult {
    /** 16-bit register words */
    data: number[];
    raw: Uint8Array;
}
interface WriteCoilResult {
    address: number;
    state: boolean;
    raw: Uint8Array;
}
interface WriteRegisterResult {
    address: number;
    value: number;
    raw: Uint8Array;
}
interface WriteMultipleResult {
    address: number;
    length: number;
    raw: Uint8Array;
}
interface MaskWriteResult {
    address: number;
    andMask: number;
    orMask: number;
    raw: Uint8Array;
}
interface WriteFileResult {
    file: number;
    record: number;
    length: number;
    raw: Uint8Array;
}
interface ReadFifoResult {
    data: number[];
    raw: Uint8Array;
}

declare class ModbusRTU {
    private id;
    private transport;
    static openWebSerial(opts?: WebSerialOptions): Promise<ModbusRTU>;
    close(): Promise<void>;
    isOpen(): boolean;
    setID(id: number): void;
    getID(): number;
    setTimeout(ms: number): void;
    getTimeout(): number;
    getPort(): SerialPort;
    /** FC 01 – coils */
    readCoils(addr: number, qty: number): Promise<ReadCoilResult>;
    /** FC 02 – discrete inputs */
    readDiscreteInputs(addr: number, qty: number): Promise<ReadCoilResult>;
    /** FC 03 – holding registers (already existed) */
    readHoldingRegisters(addr: number, qty: number): Promise<ReadRegisterResult>;
    /** FC 04 – input registers */
    readInputRegisters(addr: number, qty: number): Promise<ReadRegisterResult>;
    /** FC 05 – single coil */
    writeCoil(addr: number, state: boolean): Promise<WriteCoilResult>;
    /** FC 0F – multiple coils */
    writeCoils(addr: number, states: boolean[]): Promise<WriteMultipleResult>;
    /** FC 06 – single holding register (already existed) */
    writeRegister(addr: number, value: number): Promise<WriteRegisterResult>;
    /** FC 16 – multiple holding registers */
    writeRegisters(addr: number, values: number[]): Promise<WriteMultipleResult>;
    /** FC 22 – mask write register */
    maskWriteRegister(addr: number, andMask: number, orMask: number): Promise<MaskWriteResult>;
    /** FC 23 – read/write multiple registers */
    readWriteRegisters(readAddr: number, readQty: number, writeAddr: number, values: number[]): Promise<ReadRegisterResult>;
    /** FC 20 – read file record (single reference) */
    readFileRecord(file: number, record: number, length: number): Promise<ReadRegisterResult>;
    /** FC 21 – write file record (single reference) */
    writeFileRecord(file: number, record: number, values: number[]): Promise<WriteFileResult>;
    /** FC 24 – read FIFO queue */
    readFifoQueue(addr: number): Promise<ReadFifoResult>;
}

/**
 * FC_READ_HOLDING_REGISTERS  (0x03)
 * Modbus Application Protocol V1.1b3 §6.3
 */
declare function buildReadHolding(id: number, addr: number, len: number): Uint8Array;
/**
 * FC_WRITE_SINGLE_HOLDING_REGISTER  (0x06)
 * Modbus Application Protocol V1.1b3 §6.6
 */
declare function buildWriteSingle(id: number, addr: number, value: number): Uint8Array;
/**
 * FC_WRITE_MULTIPLE_HOLDING_REGISTERS  (0x10)
 * Modbus Application Protocol V1.1b3 §6.12
 */
declare function buildWriteMultiple(id: number, addr: number, values: number[]): Uint8Array;
/**
 * FC_READ_COILS  (0x01)
 * Modbus Application Protocol V1.1b3 §6.1
 */
declare function buildReadCoils(id: number, addr: number, qty: number): Uint8Array;
/**
 * FC_WRITE_SINGLE_COIL  (0x05)
 * Modbus Application Protocol V1.1b3 §6.5
 */
declare function buildWriteSingleCoil(id: number, addr: number, value: boolean): Uint8Array;
/**
 * FC_WRITE_MULTIPLE_COILS  (0x0F)
 * Modbus Application Protocol V1.1b3 §6.11
 */
declare function buildWriteMultipleCoils(id: number, addr: number, values: boolean[]): Uint8Array;
/**
 * FC_READ_INPUT_REGISTERS  (0x04)
 * Modbus Application Protocol V1.1b3 §6.4
 */
declare function buildReadInputRegisters(id: number, addr: number, qty: number): Uint8Array;
/**
 * FC_READ_DISCRETE_INPUTS  (0x02)
 * Modbus Application Protocol V1.1b3 §6.2
 */
declare function buildReadDiscreteInputs(id: number, addr: number, qty: number): Uint8Array;
/**
 * FC_MASK_WRITE_REGISTER (0x16)
 * Modbus Application Protocol V1.1b3 §6.16
 */
declare function buildMaskWriteRegister(id: number, addr: number, andMask: number, orMask: number): Uint8Array;
/**
 * FC_READ_WRITE_MULTIPLE_REGISTERS (0x17)
 * Modbus Application Protocol V1.1b3 §6.17
 */
declare function buildReadWriteMultiple(id: number, readAddr: number, readQty: number, writeAddr: number, values: number[]): Uint8Array;
/**
 * FC_READ_FILE_RECORD (0x14)
 * Single sub-request only (ref type 0x06)
 * Modbus Application Protocol V1.1b3 §6.14
 */
declare function buildReadFileRecord(id: number, file: number, record: number, length: number): Uint8Array;
/**
 * FC_WRITE_FILE_RECORD (0x15)
 * Single sub-request only (ref type 0x06)
 * Modbus Application Protocol V1.1b3 §6.15
 */
declare function buildWriteFileRecord(id: number, file: number, record: number, values: number[]): Uint8Array;
/**
 * FC_READ_FIFO_QUEUE (0x18)
 * Modbus Application Protocol V1.1b3 §6.18
 */
declare function buildReadFifoQueue(id: number, addr: number): Uint8Array;
/** FC 03 – Read Holding Registers: returns array of words */
declare function parseReadHolding(resp: Uint8Array): number[];
/** FC 06 – Write Single Holding Register: echo frame -> { address, value } */
declare function parseWriteSingle(resp: Uint8Array): {
    address: number;
    value: number;
};
/** FC 01 – Read Coils: returns boolean array (LSB first) */
declare const parseReadCoils: (_frame: Uint8Array) => boolean[];
/** FC 02 – Read Discrete Inputs: identical unpacking logic */
declare const parseReadDiscreteInputs: (_frame: Uint8Array) => boolean[];
/** FC 04 – Read Input Registers: same structure as holding regs */
declare function parseReadInputRegisters(resp: Uint8Array): number[];
/** FC 05 – Write Single Coil: echo frame → { address, state } */
declare function parseWriteSingleCoil(resp: Uint8Array): {
    address: number;
    state: boolean;
};
/** FC 16 – Mask Write Register: echo → { address, andMask, orMask } */
declare function parseMaskWriteRegister(resp: Uint8Array): {
    address: number;
    andMask: number;
    orMask: number;
};
/** FC 23 – Read/Write Multiple Registers: returns array of words */
declare function parseReadWriteMultiple(resp: Uint8Array): number[];
/** FC 20 – Read File Record (single sub-response) */
declare function parseReadFileRecord(resp: Uint8Array): number[];
/** FC 24 – Read FIFO Queue */
declare function parseReadFifoQueue(resp: Uint8Array): number[];

/** Standard Modbus CRC-16 (poly 0xA001, little-endian) */
declare function crc16(buf: Uint8Array): number;

declare class CrcError extends Error {
    constructor();
}
declare class TimeoutError extends Error {
    constructor();
}
declare class ExceptionError extends Error {
    code: number;
    constructor(code: number);
}

export { CrcError, ExceptionError, type MaskWriteResult, ModbusRTU, type ReadFifoResult, type ReadRegisterResult, TimeoutError, type WebSerialOptions, type WriteFileResult, type WriteRegisterResult, buildMaskWriteRegister, buildReadCoils, buildReadDiscreteInputs, buildReadFifoQueue, buildReadFileRecord, buildReadHolding, buildReadInputRegisters, buildReadWriteMultiple, buildWriteFileRecord, buildWriteMultiple, buildWriteMultipleCoils, buildWriteSingle, buildWriteSingleCoil, crc16, parseMaskWriteRegister, parseReadCoils, parseReadDiscreteInputs, parseReadFifoQueue, parseReadFileRecord, parseReadHolding, parseReadInputRegisters, parseReadWriteMultiple, parseWriteSingle, parseWriteSingleCoil };