@yarkivaev/source-to-sink 1.3.0 → 1.3.2

package/index.js

@@ -14,6 +14,8 @@
  * - stompSend: one-shot STOMP publish (accepts URL)
  * - lokiSource: Loki polling source (accepts URL)
  * - modbusSource: Modbus TCP polling source (accepts host/port)
+ * - modbusRtuSource: Modbus RTU polling source (accepts serial path)
+ * - modbusRtuBusSource: Modbus RTU multi-slave bus on one serial path
  * - mqttSink: MQTT publishing sink (accepts URL)
  *
  * @example
@@ -37,6 +39,7 @@ export { default as mqttSource } from './src/mqttSource.js';
 export { default as stompSource } from './src/stompSource.js';
 export { default as stompSend } from './src/stompSend.js';
 export { default as lokiSource } from './src/lokiSource.js';
-export { default as modbusSource } from './src/modbusSource.js';
+export { default as modbusSource, modbusRtuSource } from './src/modbusSource.js';
+export { default as modbusRtuBusSource } from './src/modbusRtuBusSource.js';
 export { default as mqttSink } from './src/mqttSink.js';
 export { default as sqliteSink } from './src/sqliteSink.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yarkivaev/source-to-sink",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "Generic library for building data streaming pipelines",
   "repository": {
     "type": "git",

package/src/modbusRtuBusSource.js

@@ -0,0 +1,118 @@
+import ModbusRTU from 'modbus-serial';
+
+/**
+ * Validates RTU bus source arguments.
+ *
+ * @param {string} path - Serial device path
+ * @param {object} serial - Serial options with baudRate
+ * @param {Array} slaves - Slave descriptors
+ */
+function assertBusArgs(path, serial, slaves) {
+    if (typeof path !== 'string' || path.length === 0) {
+        throw new Error('Serial path must be a non-empty string');
+    }
+    if (!serial || typeof serial.baudRate !== 'number' || serial.baudRate <= 0) {
+        throw new Error('Serial baudRate must be a positive number');
+    }
+    if (!Array.isArray(slaves) || slaves.length === 0) {
+        throw new Error('Slaves must be a non-empty array');
+    }
+}
+
+/**
+ * Reads one slave holding-register block and forwards it to its collector.
+ *
+ * @param {object} client - ModbusRTU client
+ * @param {object} slave - slaveId and collector
+ * @param {number} address - PDU start address
+ * @param {number} count - Register count
+ * @returns {Promise<void>}
+ */
+function readSlave(client, slave, address, count) {
+    client.setID(slave.slaveId);
+    return client.readHoldingRegisters(address, count).then((result) => {
+        slave.collector.accept(result.data);
+    });
+}
+
+/**
+ * Polls all slaves on the bus sequentially.
+ *
+ * @param {object} client - ModbusRTU client
+ * @param {Array} slaves - Slave descriptors
+ * @param {number} address - PDU start address
+ * @param {number} count - Register count
+ * @returns {Promise<void>}
+ */
+function pollSlaves(client, slaves, address, count) {
+    return slaves.reduce((chain, slave) => {
+        return chain.then(() => {
+            return readSlave(client, slave, address, count);
+        });
+    }, Promise.resolve());
+}
+
+/**
+ * Modbus RTU bus source: one serial port, several slave IDs polled in sequence.
+ *
+ * @example
+ * const source = modbusRtuBusSource(
+ *   '/dev/ttyUSB0',
+ *   { baudRate: 9600, stopBits: 2, parity: 'none' },
+ *   [{ slaveId: 1, collector: t1 }, { slaveId: 2, collector: t2 }],
+ *   { address: 1280, count: 30, interval: 5 }
+ * );
+ * source.start();
+ *
+ * @param {string} path - Serial device path
+ * @param {object} serial - baudRate, dataBits, stopBits, parity
+ * @param {Array<{slaveId: number, collector: object}>} slaves - Slave poll targets
+ * @param {object} poll - address, count, interval, optional log
+ * @returns {object} Source with start() and stop()
+ */
+export default function modbusRtuBusSource(path, serial, slaves, poll) {
+    assertBusArgs(path, serial, slaves);
+    const log = poll.log || console;
+    const client = new ModbusRTU();
+    const line = {
+        baudRate: serial.baudRate,
+        dataBits: serial.dataBits || 8,
+        stopBits: serial.stopBits || 1,
+        parity: serial.parity || 'none'
+    };
+    let handle = null;
+    let opened = false;
+    function runPoll() {
+        pollSlaves(client, slaves, poll.address, poll.count).catch((err) => {
+            log.error(`RTU bus poll on ${path} failed: ${err.message}`);
+        });
+    }
+    function attempt() {
+        client.connectRTUBuffered(path, line).then(() => {
+            opened = true;
+            handle = setInterval(runPoll, poll.interval * 1000);
+            runPoll();
+        }).catch((err) => {
+            log.error(`Connection to ${path} failed, retrying: ${err.message}`);
+            handle = setTimeout(attempt, poll.interval * 1000);
+        });
+    }
+    return {
+        start() {
+            if (!(opened || handle)) {
+                attempt();
+            }
+        },
+        stop() {
+            if (handle) {
+                clearInterval(handle);
+                clearTimeout(handle);
+                handle = null;
+            }
+            if (opened) {
+                client.close();
+                opened = false;
+            }
+        }
+    };
+}

package/src/modbusSource.js

@@ -58,42 +58,23 @@ function connected(client) {
 }
 
 /**
- * Modbus TCP polling source for reading holding registers.
+ * Shared Modbus polling lifecycle for TCP and RTU transports.
  *
- * Connects to a Modbus TCP device and polls holding registers
- * at a specified interval. Forwards register arrays to the
- * collector via pollingSource.
- *
- * @example
- * const source = modbusSource('192.168.2.148', 502, 4000, 14, 5, collector, clock);
- * source.start();
- * // ... later
- * source.stop();
- *
- * @param {string} host - Modbus TCP host address
- * @param {number} port - Modbus TCP port
- * @param {number} address - Starting register address
- * @param {number} count - Number of registers to read
- * @param {number} interval - Polling interval in seconds
- * @param {object} collector - Collector with accept() method
- * @param {object} clk - Clock with millis() method
- * @param {object} [log] - Logger with error() method for connection failures
+ * @param {object} options - connect, target, address, count, interval, collector, clk, client, log
  * @returns {object} Source with start() and stop() methods
  */
-export default function modbusSource(host, port, address, count, interval, collector, clk, log = console) {
-  if (typeof host !== 'string' || host.length === 0) {
-    throw new Error('Host must be a non-empty string');
-  }
-  if (typeof port !== 'number' || port <= 0) {
-    throw new Error(`Port must be a positive number, got: ${port}`);
-  }
-  if (typeof address !== 'number' || address < 0) {
-    throw new Error(`Address must be a non-negative number, got: ${address}`);
-  }
-  if (typeof count !== 'number' || count <= 0) {
-    throw new Error(`Count must be a positive number, got: ${count}`);
-  }
-  const client = new ModbusRTU();
+function modbusPollingSource(options) {
+  const {
+    connect,
+    target,
+    address,
+    count,
+    interval,
+    collector,
+    clk,
+    client,
+    log
+  } = options;
   let state = idle();
   async function fetch() {
     const result = await client.readHoldingRegisters(address, count);
@@ -103,12 +84,12 @@ export default function modbusSource(host, port, address, count, interval, colle
   const source = pollingSource(fetch, interval, collector, clk);
   let delay = interval;
   function attempt() {
-    client.connectTCP(host, { port }).then(() => {
+    connect(client).then(() => {
       delay = interval;
       state = connected(client);
       source.start();
     }).catch((err) => {
-      log.error(`Connection to ${host}:${port} failed, retrying in ${delay}s: ${err.message}`);
+      log.error(`Connection to ${target} failed, retrying in ${delay}s: ${err.message}`);
       const handle = setTimeout(attempt, delay * 1000);
       state = retrying(handle);
       delay = Math.min(delay * 2, maxDelay);
@@ -140,3 +121,118 @@ export default function modbusSource(host, port, address, count, interval, colle
     }
   };
 }
+
+/**
+ * Modbus TCP polling source for reading holding registers.
+ *
+ * Connects to a Modbus TCP device and polls holding registers
+ * at a specified interval. Forwards register arrays to the
+ * collector via pollingSource.
+ *
+ * @example
+ * const source = modbusSource('192.168.2.148', 502, 4000, 14, 5, collector, clock);
+ * source.start();
+ *
+ * @param {string} host - Modbus TCP host address
+ * @param {number} port - Modbus TCP port
+ * @param {number} address - Starting register address
+ * @param {number} count - Number of registers to read
+ * @param {number} interval - Polling interval in seconds
+ * @param {object} collector - Collector with accept() method
+ * @param {object} clk - Clock with millis() method
+ * @param {object} [log] - Logger with error() method for connection failures
+ * @returns {object} Source with start() and stop() methods
+ */
+export default function modbusSource(host, port, address, count, interval, collector, clk, log = console) {
+  if (typeof host !== 'string' || host.length === 0) {
+    throw new Error('Host must be a non-empty string');
+  }
+  if (typeof port !== 'number' || port <= 0) {
+    throw new Error(`Port must be a positive number, got: ${port}`);
+  }
+  if (typeof address !== 'number' || address < 0) {
+    throw new Error(`Address must be a non-negative number, got: ${address}`);
+  }
+  if (typeof count !== 'number' || count <= 0) {
+    throw new Error(`Count must be a positive number, got: ${count}`);
+  }
+  const client = new ModbusRTU();
+  function connect(modbusClient) {
+    return modbusClient.connectTCP(host, { port });
+  }
+  return modbusPollingSource({
+    connect,
+    target: `${host}:${port}`,
+    address,
+    count,
+    interval,
+    collector,
+    clk,
+    client,
+    log
+  });
+}
+
+/**
+ * Modbus RTU polling source for reading holding registers over serial.
+ *
+ * Connects to a Modbus RTU device on a serial port and polls holding registers
+ * at a specified interval. Forwards register arrays to the collector via pollingSource.
+ *
+ * @example
+ * const source = modbusRtuSource('/dev/ttyUSB0', { baudRate: 9600, slaveId: 1 }, 4000, 44, 5, collector, clock);
+ * source.start();
+ *
+ * @param {string} path - Serial device path (e.g. /dev/ttyUSB0)
+ * @param {object} serial - baudRate, dataBits, stopBits, parity, slaveId
+ * @param {number} address - Starting register address
+ * @param {number} count - Number of registers to read
+ * @param {number} interval - Polling interval in seconds
+ * @param {object} collector - Collector with accept() method
+ * @param {object} clk - Clock with millis() method
+ * @param {object} [log] - Logger with error() method for connection failures
+ * @returns {object} Source with start() and stop() methods
+ */
+export function modbusRtuSource(path, serial, address, count, interval, collector, clk, log = console) {
+  if (typeof path !== 'string' || path.length === 0) {
+    throw new Error('Serial path must be a non-empty string');
+  }
+  if (!serial || typeof serial !== 'object') {
+    throw new Error('Serial config must be an object');
+  }
+  if (typeof serial.baudRate !== 'number' || serial.baudRate <= 0) {
+    throw new Error(`Baud rate must be a positive number, got: ${serial.baudRate}`);
+  }
+  if (typeof address !== 'number' || address < 0) {
+    throw new Error(`Address must be a non-negative number, got: ${address}`);
+  }
+  if (typeof count !== 'number' || count <= 0) {
+    throw new Error(`Count must be a positive number, got: ${count}`);
+  }
+  const client = new ModbusRTU();
+  const slaveId = serial.slaveId || 1;
+  const dataBits = serial.dataBits || 8;
+  const stopBits = serial.stopBits || 1;
+  const parity = serial.parity || 'none';
+  function connect(modbusClient) {
+    return modbusClient.connectRTUBuffered(path, {
+      baudRate: serial.baudRate,
+      dataBits,
+      stopBits,
+      parity
+    }).then(() => {
+      modbusClient.setID(slaveId);
+    });
+  }
+  return modbusPollingSource({
+    connect,
+    target: path,
+    address,
+    count,
+    interval,
+    collector,
+    clk,
+    client,
+    log
+  });
+}

package/test/test_modbusRtuBusSource.js

@@ -0,0 +1,47 @@
+import assert from 'node:assert';
+import { describe, it } from 'mocha';
+import modbusRtuBusSource from '../src/modbusRtuBusSource.js';
+
+describe('modbusRtuBusSource', () => {
+    it('throws on empty serial path', () => {
+        assert.throws(
+            () => {
+                return modbusRtuBusSource('', { baudRate: 9600 }, [{ slaveId: 1, collector: { accept() {} } }], {
+                    address: 1280,
+                    count: 30,
+                    interval: 5
+                });
+            },
+            /Serial path must be a non-empty string/u,
+            'Should reject empty serial path'
+        );
+    });
+
+    it('throws on empty slaves list', () => {
+        assert.throws(
+            () => {
+                return modbusRtuBusSource(`/dev/ttyUSB${Math.floor(Math.random() * 9)}`, { baudRate: 9600 }, [], {
+                    address: 1280,
+                    count: 30,
+                    interval: 5
+                });
+            },
+            /Slaves must be a non-empty array/u,
+            'Should reject empty slaves array'
+        );
+    });
+
+    it('creates source with start method for multiple slaves', () => {
+        const path = `/dev/ttyUSB${Math.floor(Math.random() * 9)}`;
+        const source = modbusRtuBusSource(
+            path,
+            { baudRate: 9600, stopBits: 2 },
+            [
+                { slaveId: 1, collector: { accept() {} } },
+                { slaveId: 2, collector: { accept() {} } }
+            ],
+            { address: 1280, count: 30, interval: 5 }
+        );
+        assert.strictEqual(typeof source.start, 'function', 'Should expose start for RTU bus source');
+    });
+});

package/test/test_modbusRtuSource.js

@@ -0,0 +1,45 @@
+import assert from 'node:assert';
+import { describe, it } from 'mocha';
+import { modbusRtuSource } from '../src/modbusSource.js';
+import fakeClock from './fakeClock.js';
+
+describe('modbusRtuSource', () => {
+  it('throws on empty serial path', () => {
+    const collector = { accept: () => {} };
+    const clk = fakeClock(Math.floor(Math.random() * 10000));
+    assert.throws(
+      () => {return modbusRtuSource('', { baudRate: 9600 }, 4000, 44, 5, collector, clk)},
+      /Serial path must be a non-empty string/u,
+      'Should reject empty serial path'
+    );
+  });
+
+  it('throws on invalid baud rate', () => {
+    const collector = { accept: () => {} };
+    const clk = fakeClock(Math.floor(Math.random() * 10000));
+    assert.throws(
+      () => {return modbusRtuSource('/dev/ttyUSB0', { baudRate: 0 }, 4000, 44, 5, collector, clk)},
+      /Baud rate must be a positive number/u,
+      'Should reject zero baud rate'
+    );
+  });
+
+  it('creates source with start method', () => {
+    const collector = { accept: () => {} };
+    const clk = fakeClock(Math.floor(Math.random() * 10000));
+    const source = modbusRtuSource(`/dev/ttyUSB${Math.floor(Math.random() * 9)}`, { baudRate: 9600 }, 4000, 44, 5, collector, clk);
+    assert.strictEqual(typeof source.start, 'function', 'Should expose start method for RTU source');
+  });
+
+  it('retries connection on failure', async () => {
+    let logged = false;
+    const log = { error: () => { logged = true; } };
+    const collector = { accept: () => {} };
+    const clk = fakeClock(Math.floor(Math.random() * 10000));
+    const source = modbusRtuSource(`/dev/tty\u044b${Math.random()}`, { baudRate: 9600 }, 4000, 44, 5, collector, clk, log);
+    source.start();
+    await new Promise(resolve => { setTimeout(resolve, 200); });
+    source.stop();
+    assert.strictEqual(logged, true, 'Should log RTU connection failure and retry');
+  });
+});

package/test/test_modbusSource.js

@@ -99,7 +99,8 @@ describe('modbusSource', () => {
     const log = { error: () => { logged = true; } };
     const collector = { accept: () => {} };
     const clk = fakeClock(Math.floor(Math.random() * 10000));
-    const source = modbusSource(`\u00df${Math.random()}`, 502, 4000, 14, 5, collector, clk, log);
+    const port = 65000 + Math.floor(Math.random() * 500);
+    const source = modbusSource('127.0.0.1', port, 4000, 14, 5, collector, clk, log);
     source.start();
     await new Promise(resolve => { setTimeout(resolve, 200); });
     source.stop();
@@ -110,7 +111,8 @@ describe('modbusSource', () => {
     const log = { error: () => {} };
     const collector = { accept: () => {} };
     const clk = fakeClock(Math.floor(Math.random() * 10000));
-    const source = modbusSource(`\u0420${Math.random()}`, 502, 4000, 14, 5, collector, clk, log);
+    const port = 65000 + Math.floor(Math.random() * 500);
+    const source = modbusSource('127.0.0.1', port, 4000, 14, 5, collector, clk, log);
     source.start();
     await new Promise(resolve => { setTimeout(resolve, 200); });
     source.stop();