modbus-webserial 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,3 @@
+MIT License
+
+todo

package/README.md

@@ -0,0 +1 @@
+ modbus-webserial (alpha)

package/dist/index.d.ts

@@ -0,0 +1,55 @@
+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 ReadRegisterResult {
+    data: number[];
+    raw: Uint8Array;
+}
+interface WriteRegisterResult {
+    address: number;
+    value: 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;
+    readHoldingRegisters(addr: number, len: number): Promise<ReadRegisterResult>;
+    writeRegister(addr: number, value: number): Promise<WriteRegisterResult>;
+}
+
+declare function buildReadHolding(id: number, addr: number, len: number): Uint8Array;
+declare function buildWriteSingle(id: number, addr: number, value: number): Uint8Array;
+declare function parseReadHolding(resp: Uint8Array): number[];
+declare function parseWriteSingle(resp: Uint8Array): {
+    address: number;
+    value: 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, ModbusRTU, type ReadRegisterResult, TimeoutError, type WebSerialOptions, type WriteRegisterResult, buildReadHolding, buildWriteSingle, crc16, parseReadHolding, parseWriteSingle };

package/dist/index.js

@@ -0,0 +1,175 @@
+// src/core/errors.ts
+var CrcError = class extends Error {
+  constructor() {
+    super("CRC check failed");
+  }
+};
+var TimeoutError = class extends Error {
+  constructor() {
+    super("Modbus response timed out");
+  }
+};
+var ExceptionError = class extends Error {
+  code;
+  constructor(code) {
+    super(`Modbus exception ${code.toString(16)}`);
+    this.code = code;
+  }
+};
+
+// src/transport/webserial.ts
+var WebSerialTransport = class _WebSerialTransport {
+  port;
+  reader;
+  writer;
+  timeout = 500;
+  static async open(opts = {}) {
+    const t = new _WebSerialTransport();
+    await t.init(opts);
+    return t;
+  }
+  async init(opts) {
+    this.timeout = opts.timeout ?? 500;
+    this.port = await navigator.serial.requestPort({ filters: opts.requestFilters ?? [] });
+    await this.port.open({
+      baudRate: opts.baudRate ?? 9600,
+      dataBits: opts.dataBits ?? 8,
+      stopBits: opts.stopBits ?? 1,
+      parity: opts.parity ?? "none"
+    });
+    this.reader = this.port.readable.getReader();
+    this.writer = this.port.writable.getWriter();
+  }
+  async transact(frame) {
+    await this.writer.write(frame);
+    const timeout = new Promise(
+      (_, reject) => setTimeout(() => reject(new TimeoutError()), this.timeout)
+    );
+    const { value } = await Promise.race([this.reader.read(), timeout]);
+    if (!value) throw new TimeoutError();
+    return value;
+  }
+  async close() {
+    var _a, _b, _c;
+    await ((_a = this.reader) == null ? void 0 : _a.cancel());
+    await ((_b = this.writer) == null ? void 0 : _b.close());
+    await ((_c = this.port) == null ? void 0 : _c.close());
+  }
+};
+
+// src/core/types.ts
+var FC_READ_HOLDING = 3;
+var FC_WRITE_SINGLE = 6;
+
+// src/core/crc16.ts
+function crc16(buf) {
+  let crc = 65535;
+  for (let b of buf) {
+    crc ^= b;
+    for (let i = 0; i < 8; i++) {
+      crc = crc >> 1 ^ (crc & 1 ? 40961 : 0);
+    }
+  }
+  return crc;
+}
+
+// src/core/frames.ts
+function buildReadHolding(id, addr, len) {
+  const frame = new Uint8Array(8);
+  frame[0] = id;
+  frame[1] = FC_READ_HOLDING;
+  frame[2] = addr >> 8;
+  frame[3] = addr & 255;
+  frame[4] = len >> 8;
+  frame[5] = len & 255;
+  const crc = crc16(frame.subarray(0, 6));
+  frame[6] = crc & 255;
+  frame[7] = crc >> 8;
+  return frame;
+}
+function buildWriteSingle(id, addr, value) {
+  const frame = new Uint8Array(8);
+  frame[0] = id;
+  frame[1] = FC_WRITE_SINGLE;
+  frame[2] = addr >> 8;
+  frame[3] = addr & 255;
+  frame[4] = value >> 8;
+  frame[5] = value & 255;
+  const crc = crc16(frame.subarray(0, 6));
+  frame[6] = crc & 255;
+  frame[7] = crc >> 8;
+  return frame;
+}
+function parseReadHolding(resp) {
+  basicChecks(resp, FC_READ_HOLDING);
+  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 parseWriteSingle(resp) {
+  basicChecks(resp, FC_WRITE_SINGLE);
+  const addr = resp[2] << 8 | resp[3];
+  const value = resp[4] << 8 | resp[5];
+  return { address: addr, value };
+}
+function basicChecks(frame, expectedFC) {
+  const crcExpected = crc16(frame.subarray(0, frame.length - 2));
+  const crcGot = frame[frame.length - 2] | frame[frame.length - 1] << 8;
+  if (crcExpected !== crcGot) throw new CrcError();
+  const fc = frame[1] & 127;
+  const isException = (frame[1] & 128) !== 0;
+  if (isException) throw new ExceptionError(frame[2]);
+  if (fc !== expectedFC) throw new Error("Unexpected function code");
+}
+
+// src/client.ts
+var ModbusRTU = class _ModbusRTU {
+  id = 1;
+  transport;
+  /* ---------- static factory ---------- */
+  static async openWebSerial(opts) {
+    const cli = new _ModbusRTU();
+    cli.transport = await WebSerialTransport.open(opts);
+    return cli;
+  }
+  /* ---------- housekeeping ---------- */
+  async close() {
+    await this.transport.close();
+  }
+  isOpen() {
+    return !!this.transport;
+  }
+  /* ---------- config ---------- */
+  setID(id) {
+    this.id = id;
+  }
+  getID() {
+    return this.id;
+  }
+  /* ---------- helpers (v0.1) ---------- */
+  async readHoldingRegisters(addr, len) {
+    const req = buildReadHolding(this.id, addr, len);
+    const raw = await this.transport.transact(req);
+    return { data: parseReadHolding(raw), raw };
+  }
+  async writeRegister(addr, value) {
+    const req = buildWriteSingle(this.id, addr, value);
+    const raw = await this.transport.transact(req);
+    const { address, value: v } = parseWriteSingle(raw);
+    return { address, value: v, raw };
+  }
+};
+export {
+  CrcError,
+  ExceptionError,
+  ModbusRTU,
+  TimeoutError,
+  buildReadHolding,
+  buildWriteSingle,
+  crc16,
+  parseReadHolding,
+  parseWriteSingle
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "modbus-webserial",
+  "version": "0.1.0-alpha.0",
+  "description": "Tiny TypeScript library for speaking Modbus-RTU from the browser via Web Serial",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "prepublishOnly": "npm run build && npm test",
+    "test": "vitest"
+  },
+  "repository": "git+https://github.com/your-gh-user/modbus-webserial.git",
+  "keywords": [
+    "modbus",
+    "rtu",
+    "webserial",
+    "browser",
+    "typescript"
+  ],
+  "author": "Your Name <you@example.com>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@types/w3c-web-serial": "^1",
+    "tsup": "^8",
+    "typescript": "^5",
+    "vitest": "^1"
+  }
+}