@totemsdk/edge-modbus 0.1.0 → 0.2.2

package/dist/cjs/index.d.ts

@@ -0,0 +1,7 @@
+export type { ModbusTransportPort, ModbusMessage } from './transport.js';
+export { createModbusGateway } from './gateway.js';
+export type { ModbusGatewayConfig, ModbusGateway } from './gateway.js';
+export { createModbusSensorBridge } from './sensor-bridge.js';
+export type { ModbusSensorBinding, ModbusSensorBridgeConfig, ModbusSensorBridge } from './sensor-bridge.js';
+export { NativeModbusTransport } from './native-transport.js';
+export type { NativeModbusConfig } from './native-transport.js';

package/dist/cjs/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeModbusTransport = exports.createModbusSensorBridge = exports.createModbusGateway = void 0;
+var gateway_js_1 = require("./gateway.js");
+Object.defineProperty(exports, "createModbusGateway", { enumerable: true, get: function () { return gateway_js_1.createModbusGateway; } });
+var sensor_bridge_js_1 = require("./sensor-bridge.js");
+Object.defineProperty(exports, "createModbusSensorBridge", { enumerable: true, get: function () { return sensor_bridge_js_1.createModbusSensorBridge; } });
+var native_transport_js_1 = require("./native-transport.js");
+Object.defineProperty(exports, "NativeModbusTransport", { enumerable: true, get: function () { return native_transport_js_1.NativeModbusTransport; } });

package/dist/cjs/native-transport.d.ts

@@ -0,0 +1,36 @@
+/**
+ * NativeModbusTransport — connects to the edge-modbus Go binary over TCP.
+ *
+ * The Go binary listens on a local TCP socket (default 127.0.0.1:15002)
+ * and accepts newline-delimited JSON requests. This class implements
+ * ModbusTransportPort by forwarding all calls to the Go process.
+ *
+ * Usage:
+ *   const transport = new NativeModbusTransport({ host: '127.0.0.1', port: 15002 });
+ *   await transport.connect();
+ *   const response = await transport.sendFrame(requestFrame);
+ *   transport.disconnect();
+ */
+import type { ModbusTransportPort } from './transport.js';
+export interface NativeModbusConfig {
+    host?: string;
+    port?: number;
+    /** Connection timeout in ms. Default 5000. */
+    connectTimeoutMs?: number;
+    /** Per-request timeout in ms. Default 10000. */
+    requestTimeoutMs?: number;
+}
+export declare class NativeModbusTransport implements ModbusTransportPort {
+    private socket;
+    private buffer;
+    private pending;
+    private frameHandlers;
+    private errorHandlers;
+    private readonly config;
+    constructor(config?: NativeModbusConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    sendFrame(frame: Uint8Array): Promise<Uint8Array>;
+    onFrame(handler: (frame: Uint8Array) => void): () => void;
+    onError(handler: (err: Error) => void): () => void;
+}

package/dist/cjs/native-transport.js

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * NativeModbusTransport — connects to the edge-modbus Go binary over TCP.
+ *
+ * The Go binary listens on a local TCP socket (default 127.0.0.1:15002)
+ * and accepts newline-delimited JSON requests. This class implements
+ * ModbusTransportPort by forwarding all calls to the Go process.
+ *
+ * Usage:
+ *   const transport = new NativeModbusTransport({ host: '127.0.0.1', port: 15002 });
+ *   await transport.connect();
+ *   const response = await transport.sendFrame(requestFrame);
+ *   transport.disconnect();
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeModbusTransport = void 0;
+let requestCounter = 0;
+class NativeModbusTransport {
+    constructor(config = {}) {
+        this.socket = null;
+        this.buffer = '';
+        this.pending = new Map();
+        this.frameHandlers = [];
+        this.errorHandlers = [];
+        this.config = {
+            host: config.host ?? '127.0.0.1',
+            port: config.port ?? 15002,
+            connectTimeoutMs: config.connectTimeoutMs ?? 5000,
+            requestTimeoutMs: config.requestTimeoutMs ?? 10000,
+        };
+    }
+    async connect() {
+        const net = await Promise.resolve().then(() => __importStar(require('net')));
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.socket?.destroy();
+                reject(new Error(`NativeModbusTransport: connect timeout (${this.config.connectTimeoutMs}ms)`));
+            }, this.config.connectTimeoutMs);
+            this.socket = net.createConnection({ host: this.config.host, port: this.config.port }, () => {
+                clearTimeout(timer);
+                resolve();
+            });
+            this.socket.on('data', (chunk) => {
+                this.buffer += chunk.toString('utf-8');
+                const lines = this.buffer.split('\n');
+                this.buffer = lines.pop() ?? '';
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const msg = JSON.parse(line);
+                        if (msg.id && this.pending.has(msg.id)) {
+                            const { resolve: res, reject: rej } = this.pending.get(msg.id);
+                            this.pending.delete(msg.id);
+                            if (msg.ok && msg.frame) {
+                                res(hexToBytes(msg.frame));
+                            }
+                            else {
+                                rej(new Error(msg.error ?? 'unknown error'));
+                            }
+                        }
+                    }
+                    catch {
+                        // ignore parse errors on partial lines
+                    }
+                }
+            });
+            this.socket.on('error', (err) => {
+                for (const handler of this.errorHandlers) {
+                    try {
+                        handler(err);
+                    }
+                    catch { }
+                }
+            });
+            this.socket.on('close', () => {
+                for (const [, pending] of this.pending) {
+                    pending.reject(new Error('NativeModbusTransport: connection closed'));
+                }
+                this.pending.clear();
+            });
+        });
+    }
+    async disconnect() {
+        if (this.socket) {
+            this.socket.destroy();
+            this.socket = null;
+        }
+    }
+    async sendFrame(frame) {
+        if (!this.socket) {
+            throw new Error('NativeModbusTransport: not connected');
+        }
+        const id = `modbus-${++requestCounter}`;
+        const request = { id, frame: bytesToHex(frame) };
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`NativeModbusTransport: request ${id} timed out (${this.config.requestTimeoutMs}ms)`));
+            }, this.config.requestTimeoutMs);
+            this.pending.set(id, {
+                resolve: (data) => { clearTimeout(timer); resolve(data); },
+                reject: (err) => { clearTimeout(timer); reject(err); },
+            });
+            this.socket.write(JSON.stringify(request) + '\n');
+        });
+    }
+    onFrame(handler) {
+        this.frameHandlers.push(handler);
+        return () => {
+            this.frameHandlers = this.frameHandlers.filter(h => h !== handler);
+        };
+    }
+    onError(handler) {
+        this.errorHandlers.push(handler);
+        return () => {
+            this.errorHandlers = this.errorHandlers.filter(h => h !== handler);
+        };
+    }
+}
+exports.NativeModbusTransport = NativeModbusTransport;
+function bytesToHex(bytes) {
+    return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
+}
+function hexToBytes(hex) {
+    if (hex.length % 2 !== 0)
+        throw new Error('Invalid hex string');
+    const arr = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < arr.length; i++) {
+        arr[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    return arr;
+}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/sensor-bridge.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Modbus Sensor Bridge — maps Modbus register reads to Edge proof inputs.
+ *
+ * Shares gateway validation so malformed responses never become sensor proofs.
+ */
+import type { EdgeRuntime } from '@totemsdk/edge';
+import type { ModbusTransportPort } from './transport.js';
+import type { ModbusGateway } from './gateway.js';
+export interface ModbusSensorBinding {
+    sensorId: string;
+    unitId: number;
+    functionCode: number;
+    address: number;
+    count: number;
+    intervalMs: number;
+    dataType: 'coil' | 'register' | 'input';
+    unit?: string;
+}
+export interface ModbusSensorBridgeConfig {
+    runtime: EdgeRuntime;
+    transport: ModbusTransportPort;
+    gateway?: ModbusGateway;
+    bindings: ModbusSensorBinding[];
+}
+export interface ModbusSensorBridge {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    poll(): Promise<void>;
+}
+export declare function createModbusSensorBridge(config: ModbusSensorBridgeConfig): ModbusSensorBridge;

package/dist/cjs/sensor-bridge.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * Modbus Sensor Bridge — maps Modbus register reads to Edge proof inputs.
+ *
+ * Shares gateway validation so malformed responses never become sensor proofs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModbusSensorBridge = createModbusSensorBridge;
+const gateway_js_1 = require("./gateway.js");
+function createModbusSensorBridge(config) {
+    const timers = [];
+    let running = false;
+    const gateway = config.gateway ?? (0, gateway_js_1.createModbusGateway)({ runtime: config.runtime, transport: config.transport });
+    async function pollBinding(binding) {
+        try {
+            const args = [binding.unitId, binding.address, binding.count];
+            const result = binding.functionCode === 1 ? await gateway.readCoils(...args)
+                : binding.functionCode === 2 ? await gateway.readDiscreteInputs(...args)
+                    : binding.functionCode === 3 ? await gateway.readHoldingRegisters(...args)
+                        : binding.functionCode === 4 ? await gateway.readInputRegisters(...args) : undefined;
+            if (!result?.ok || !result.data)
+                return;
+            const values = result.data.values;
+            if (config.runtime.ports.proof) {
+                await config.runtime.ports.proof.createProof({
+                    subject: `sensor:${binding.sensorId}`,
+                    claims: [{
+                            sensorId: binding.sensorId,
+                            unitId: binding.unitId,
+                            address: binding.address,
+                            values,
+                            unit: binding.unit,
+                            timestamp: Date.now(),
+                        }],
+                });
+            }
+        }
+        catch {
+            // Poll failures are non-fatal — next cycle retries
+        }
+    }
+    return {
+        async start() {
+            if (running)
+                return;
+            for (const binding of config.bindings) {
+                await pollBinding(binding);
+                timers.push(setInterval(() => pollBinding(binding), binding.intervalMs));
+            }
+            running = true;
+        },
+        async stop() {
+            for (const t of timers)
+                clearInterval(t);
+            timers.length = 0;
+            running = false;
+        },
+        async poll() {
+            for (const binding of config.bindings) {
+                await pollBinding(binding);
+            }
+        },
+    };
+}

package/dist/cjs/transport.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Modbus transport port — injected by the caller.
+ *
+ * Supports Modbus TCP (port 502) and Modbus RTU (serial).
+ * The caller provides the actual socket/serial implementation.
+ */
+export interface ModbusTransportPort {
+    /** Open the connection. */
+    connect(): Promise<void>;
+    /** Close the connection. */
+    disconnect(): Promise<void>;
+    /**
+     * Exchange [unitId, functionCode, ...PDU data], with no CRC or MBAP header.
+     * Reads return [unitId, functionCode, byteCount, ...data]; successful writes
+     * return [unitId, functionCode, addressHi, addressLo, valueOrCountHi, valueOrCountLo].
+     * The binding must validate wire CRC/MBAP transaction identity and must not
+     * retry writes automatically when the physical outcome is uncertain.
+     */
+    sendFrame(frame: Uint8Array): Promise<Uint8Array>;
+    /** Register a handler for unsolicited/inbound frames. */
+    onFrame(handler: (frame: Uint8Array) => void): () => void;
+    /** Register a handler for connection errors. */
+    onError(handler: (err: Error) => void): () => void;
+}
+export interface ModbusMessage {
+    /** Unit/slave ID (1-247). */
+    unitId: number;
+    /** Modbus function code (1-6, 15, 16). */
+    functionCode: number;
+    /** Starting address (0-based). */
+    address: number;
+    /** Register/coil count or value. */
+    value: number | number[];
+    /** Raw frame bytes. */
+    raw: Uint8Array;
+    /** Timestamp of receipt. */
+    receivedAt: number;
+}

package/dist/cjs/transport.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Modbus transport port — injected by the caller.
+ *
+ * Supports Modbus TCP (port 502) and Modbus RTU (serial).
+ * The caller provides the actual socket/serial implementation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/gateway.d.ts

@@ -1,25 +1,35 @@
 /**
  * Modbus Edge Gateway — wires a ModbusTransportPort into an EdgeRuntime.
+ *
+ * Uses a unit-prefixed PDU (no CRC or MBAP header) at the transport boundary.
+ * The binding owns TCP transaction framing or RTU CRC validation.
  */
 import type { EdgeRuntime, EdgeOperationResult } from '@totemsdk/edge';
 import type { ModbusTransportPort } from './transport.js';
 export interface ModbusGatewayConfig {
     runtime: EdgeRuntime;
     transport: ModbusTransportPort;
-    /** Map unit IDs to sensor/device identifiers. */
     unitMap?: Record<number, string>;
 }
 export interface ModbusGateway {
     start(): Promise<void>;
     stop(): Promise<void>;
     readonly status: 'stopped' | 'running' | 'error';
-    /** Read coils (function code 1). */
     readCoils(unitId: number, address: number, count: number): Promise<EdgeOperationResult<{
         values: boolean[];
     }>>;
-    /** Read holding registers (function code 3). */
-    readRegisters(unitId: number, address: number, count: number): Promise<EdgeOperationResult<{
+    readDiscreteInputs(unitId: number, address: number, count: number): Promise<EdgeOperationResult<{
+        values: boolean[];
+    }>>;
+    readHoldingRegisters(unitId: number, address: number, count: number): Promise<EdgeOperationResult<{
+        values: number[];
+    }>>;
+    readInputRegisters(unitId: number, address: number, count: number): Promise<EdgeOperationResult<{
         values: number[];
     }>>;
+    writeSingleCoil(unitId: number, address: number, value: boolean): Promise<EdgeOperationResult<void>>;
+    writeSingleRegister(unitId: number, address: number, value: number): Promise<EdgeOperationResult<void>>;
+    writeMultipleCoils(unitId: number, address: number, values: boolean[]): Promise<EdgeOperationResult<void>>;
+    writeMultipleRegisters(unitId: number, address: number, values: number[]): Promise<EdgeOperationResult<void>>;
 }
 export declare function createModbusGateway(config: ModbusGatewayConfig): ModbusGateway;