modbus-webserial 0.9.2 → 0.10.0

package/README.md

@@ -32,7 +32,7 @@ console.log('HR0=', data[0], 'HR1=', data[1]);
 // Write values to holding registers 0x00 and 0x01
 await client.writeRegisters(0, [0x0A, 0x0B]);
 ```
-**Can also be used *without* WebSerial for building modbus frames in any enviorement**
+**Can also be used *without* WebSerial for building modbus frames in any environment**
 ```javascript
 import {
   buildReadHoldingRegisters,
@@ -67,7 +67,13 @@ The following Modbus-RTU function calls are implemented:
 | `writeRegister(addr, value)`      | FC 06 – Write single holding register    |
 | `writeCoils(addr, states)`        | FC 15 – Write multiple coils             |
 | `writeRegisters(addr, values)`    | FC 16 – Write multiple holding registers |
-
+| `readFileRecord(file, rec, len)`  | FC 20 – Read file record (single ref)    |
+| `writeFileRecord(file, rec, vals)`| FC 21 – Write file record (single ref)   |
+| `maskWriteRegister(addr, and, or)`| FC 22 – Mask write register              |
+| `readWriteRegisters(rAddr, rQty, wAddr, vals)` | FC 23 – Read/write multiple regs |
+| `readFifoQueue(addr)`             | FC 24 – Read FIFO queue                  |
+> [!CAUTION]
+> Not all slave libraries support file records, FIFO queues, mask writes or read-write calls
 ### Auxiliary Client Methods
 
 Utility and configuration methods exposed on `ModbusRTU`:
@@ -91,8 +97,8 @@ The following demos are fully self‑contained HTML files, served via GitHub Pag
   Automated loop testing read/write of 64 registers, coils, and discrete inputs with live counters and error logging.
 
 ## Current state
-
-* **v0.9.0**: Full passing tests, smoke test passed, complete README, build scripts in place
+* **v0.10**: Full modbus data-access coverage
+* **v0.9**: Full passing tests, smoke test passed, complete README, build scripts in place
 * **Beta**: Full Modbus RTU function‑code coverage
 * **Alpha**: Basic structure and layout
 

package/dist/index.d.ts

@@ -34,6 +34,22 @@ interface WriteMultipleResult {
     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;
@@ -61,6 +77,16 @@ declare class ModbusRTU {
     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>;
 }
 
 /**
@@ -103,6 +129,33 @@ declare function buildReadInputRegisters(id: number, addr: number, qty: number):
  * 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 } */
@@ -121,6 +174,18 @@ 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;
@@ -136,4 +201,4 @@ declare class ExceptionError extends Error {
     constructor(code: number);
 }
 
-export { CrcError, ExceptionError, ModbusRTU, type ReadRegisterResult, TimeoutError, type WebSerialOptions, type WriteRegisterResult, buildReadCoils, buildReadDiscreteInputs, buildReadHolding, buildReadInputRegisters, buildWriteMultiple, buildWriteMultipleCoils, buildWriteSingle, buildWriteSingleCoil, crc16, parseReadCoils, parseReadDiscreteInputs, parseReadHolding, parseReadInputRegisters, parseWriteSingle, parseWriteSingleCoil };
+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 };

package/dist/index.js

@@ -152,6 +152,11 @@ var FC_WRITE_SINGLE_COIL = 5;
 var FC_WRITE_MULTIPLE_COILS = 15;
 var FC_READ_INPUT_REGISTERS = 4;
 var FC_READ_DISCRETE_INPUTS = 2;
+var FC_READ_FILE_RECORD = 20;
+var FC_WRITE_FILE_RECORD = 21;
+var FC_MASK_WRITE_REGISTER = 22;
+var FC_READ_WRITE_MULTIPLE_REGISTERS = 23;
+var FC_READ_FIFO_QUEUE = 24;
 
 // src/core/frames.ts
 function buildReadHolding(id, addr, len) {
@@ -281,6 +286,102 @@ function buildReadDiscreteInputs(id, addr, qty) {
   frame[7] = crc >> 8;
   return frame;
 }
+function buildMaskWriteRegister(id, addr, andMask, orMask) {
+  const frame = new Uint8Array(10);
+  frame[0] = id;
+  frame[1] = FC_MASK_WRITE_REGISTER;
+  frame[2] = addr >> 8;
+  frame[3] = addr & 255;
+  frame[4] = andMask >> 8;
+  frame[5] = andMask & 255;
+  frame[6] = orMask >> 8;
+  frame[7] = orMask & 255;
+  const crc = crc16(frame.subarray(0, 8));
+  frame[8] = crc & 255;
+  frame[9] = crc >> 8;
+  return frame;
+}
+function buildReadWriteMultiple(id, readAddr, readQty, writeAddr, values) {
+  const writeQty = values.length;
+  if (readQty < 1 || readQty > 125) throw new Error("Invalid read quantity");
+  if (writeQty < 1 || writeQty > 121) throw new Error("Invalid write quantity");
+  const byteCount = writeQty * 2;
+  const frame = new Uint8Array(11 + byteCount + 2);
+  frame[0] = id;
+  frame[1] = FC_READ_WRITE_MULTIPLE_REGISTERS;
+  frame[2] = readAddr >> 8;
+  frame[3] = readAddr & 255;
+  frame[4] = readQty >> 8;
+  frame[5] = readQty & 255;
+  frame[6] = writeAddr >> 8;
+  frame[7] = writeAddr & 255;
+  frame[8] = writeQty >> 8;
+  frame[9] = writeQty & 255;
+  frame[10] = byteCount;
+  for (let i = 0; i < writeQty; i++) {
+    const v = values[i] & 65535;
+    frame[11 + i * 2] = v >> 8;
+    frame[12 + i * 2] = v & 255;
+  }
+  const crc = crc16(frame.subarray(0, frame.length - 2));
+  frame[frame.length - 2] = crc & 255;
+  frame[frame.length - 1] = crc >> 8;
+  return frame;
+}
+function buildReadFileRecord(id, file, record, length) {
+  if (length < 1 || length > 120) throw new Error("Invalid record length");
+  const frame = new Uint8Array(12);
+  frame[0] = id;
+  frame[1] = FC_READ_FILE_RECORD;
+  frame[2] = 7;
+  frame[3] = 6;
+  frame[4] = file >> 8;
+  frame[5] = file & 255;
+  frame[6] = record >> 8;
+  frame[7] = record & 255;
+  frame[8] = length >> 8;
+  frame[9] = length & 255;
+  const crc = crc16(frame.subarray(0, 10));
+  frame[10] = crc & 255;
+  frame[11] = crc >> 8;
+  return frame;
+}
+function buildWriteFileRecord(id, file, record, values) {
+  const len = values.length;
+  if (len < 1 || len > 120) throw new Error("Invalid record length");
+  const byteCount = 7 + len * 2;
+  const frame = new Uint8Array(3 + byteCount + 2);
+  frame[0] = id;
+  frame[1] = FC_WRITE_FILE_RECORD;
+  frame[2] = byteCount;
+  frame[3] = 6;
+  frame[4] = file >> 8;
+  frame[5] = file & 255;
+  frame[6] = record >> 8;
+  frame[7] = record & 255;
+  frame[8] = len >> 8;
+  frame[9] = len & 255;
+  for (let i = 0; i < len; i++) {
+    const v = values[i] & 65535;
+    frame[10 + i * 2] = v >> 8;
+    frame[11 + i * 2] = v & 255;
+  }
+  const crc = crc16(frame.subarray(0, frame.length - 2));
+  frame[frame.length - 2] = crc & 255;
+  frame[frame.length - 1] = crc >> 8;
+  return frame;
+}
+function buildReadFifoQueue(id, addr) {
+  const frame = new Uint8Array(6);
+  frame[0] = id;
+  frame[1] = FC_READ_FIFO_QUEUE;
+  frame[2] = addr >> 8;
+  frame[3] = addr & 255;
+  const crc = crc16(frame.subarray(0, 4));
+  frame[4] = crc & 255;
+  frame[5] = crc >> 8;
+  return frame;
+}
 function parseReadHolding(resp) {
   basicChecks(resp, FC_READ_HOLDING_REGISTERS);
   const byteCount = resp[2];
@@ -314,6 +415,42 @@ function parseWriteSingleCoil(resp) {
   const val = resp[4] << 8 | resp[5];
   return { address: addr, state: val === 65280 };
 }
+function parseMaskWriteRegister(resp) {
+  basicChecks(resp, FC_MASK_WRITE_REGISTER);
+  const addr = resp[2] << 8 | resp[3];
+  const andMask = resp[4] << 8 | resp[5];
+  const orMask = resp[6] << 8 | resp[7];
+  return { address: addr, andMask, orMask };
+}
+function parseReadWriteMultiple(resp) {
+  basicChecks(resp, FC_READ_WRITE_MULTIPLE_REGISTERS);
+  const byteCount = resp[2];
+  const words = [];
+  for (let i = 0; i < byteCount; i += 2) {
+    words.push(resp[3 + i] << 8 | resp[4 + i]);
+  }
+  return words;
+}
+function parseReadFileRecord(resp) {
+  basicChecks(resp, FC_READ_FILE_RECORD);
+  const dataLen = resp[3] - 1;
+  const words = [];
+  for (let i = 0; i < dataLen; i += 2) {
+    words.push(resp[5 + i] << 8 | resp[6 + i]);
+  }
+  return words;
+}
+function parseReadFifoQueue(resp) {
+  basicChecks(resp, FC_READ_FIFO_QUEUE);
+  const count = resp[4] << 8 | resp[5];
+  const words = [];
+  for (let i = 0; i < count; i++) {
+    const hi = resp[6 + i * 2];
+    const lo = resp[7 + i * 2];
+    words.push(hi << 8 | lo);
+  }
+  return words;
+}
 function _parseBits(expectedFC) {
   return (_frame) => {
     basicChecks(_frame, expectedFC);
@@ -416,25 +553,69 @@ var ModbusRTU = class _ModbusRTU {
     const length = values.length;
     return { address: addr, length, raw };
   }
+  /* ================== OPTIONAL DATA-ACCESS FUNCTIONS ================== */
+  /** FC 22 – mask write register */
+  async maskWriteRegister(addr, andMask, orMask) {
+    const raw = await this.transport.transact(buildMaskWriteRegister(this.id, addr, andMask, orMask));
+    const { address, andMask: a, orMask: o } = parseMaskWriteRegister(raw);
+    return { address, andMask: a, orMask: o, raw };
+  }
+  /** FC 23 – read/write multiple registers */
+  async readWriteRegisters(readAddr, readQty, writeAddr, values) {
+    const raw = await this.transport.transact(
+      buildReadWriteMultiple(this.id, readAddr, readQty, writeAddr, values)
+    );
+    return { data: parseReadWriteMultiple(raw), raw };
+  }
+  /** FC 20 – read file record (single reference) */
+  async readFileRecord(file, record, length) {
+    const raw = await this.transport.transact(
+      buildReadFileRecord(this.id, file, record, length)
+    );
+    return { data: parseReadFileRecord(raw), raw };
+  }
+  /** FC 21 – write file record (single reference) */
+  async writeFileRecord(file, record, values) {
+    const raw = await this.transport.transact(
+      buildWriteFileRecord(this.id, file, record, values)
+    );
+    return { file, record, length: values.length, raw };
+  }
+  /** FC 24 – read FIFO queue */
+  async readFifoQueue(addr) {
+    const raw = await this.transport.transact(
+      buildReadFifoQueue(this.id, addr)
+    );
+    return { data: parseReadFifoQueue(raw), raw };
+  }
 };
 export {
   CrcError,
   ExceptionError,
   ModbusRTU,
   TimeoutError,
+  buildMaskWriteRegister,
   buildReadCoils,
   buildReadDiscreteInputs,
+  buildReadFifoQueue,
+  buildReadFileRecord,
   buildReadHolding,
   buildReadInputRegisters,
+  buildReadWriteMultiple,
+  buildWriteFileRecord,
   buildWriteMultiple,
   buildWriteMultipleCoils,
   buildWriteSingle,
   buildWriteSingleCoil,
   crc16,
+  parseMaskWriteRegister,
   parseReadCoils,
   parseReadDiscreteInputs,
+  parseReadFifoQueue,
+  parseReadFileRecord,
   parseReadHolding,
   parseReadInputRegisters,
+  parseReadWriteMultiple,
   parseWriteSingle,
   parseWriteSingleCoil
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modbus-webserial",
-  "version": "0.9.2",
+  "version": "0.10.0",
   "description": "Tiny TypeScript library for speaking Modbus-RTU from the browser via Web Serial",
   "type": "module",
   "author": "Antti Kotajärvi <antti.kotajarvi@hotmail.com>",