secs4js 0.1.0

package/LICENSE.md

@@ -0,0 +1,20 @@
+# MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,442 @@
+<h1 align="center">Secs4js</h1>
+
+<p align="center">A simple, efficient, and user-friendly SECS/GEM protocol library implemented in TypeScript.</p>
+
+## Introduction
+
+This project is a TypeScript implementation of the SECS/GEM protocol, inspired by [pysemisecs](https://github.com/kenta-shimizu/pysemisecs).
+
+A special thanks to the author **kenta-shimizu** for their open-source contribution.
+
+Secs4js is a simple, efficient, and user-friendly SECS/GEM protocol library implemented in TypeScript. It provides a straightforward way to communicate with SECS/GEM devices, enabling you to easily read and write data using the SECS/GEM protocol.
+
+## Supported Features
+
+- SECS-I (SEMI-E4)
+- SECS-I Virtual Serial Port (SECS-I on TCP/IP)
+- SECS-II (SEMI-E5)
+- GEM (SEMI-E30)
+- HSMS-SS (SEMI-E37.1)
+- **No HSMS-GS (SEMI-E37.2)**
+
+## Installation
+
+```shell
+npm i secs4js
+
+pnpm add secs4js
+
+yarn add secs4js
+
+bun add secs4js
+```
+
+## Getting Started from Source
+
+If you want to run some examples, they can be found in the `examples` directory.
+
+Run the following commands to start these examples:
+
+```shell
+pnpm dlx tsx examples/gem_example.ts
+
+# ...
+pnpm dlx tsx examples/<example_file_name>.ts
+```
+
+## Usage
+
+### 1. Creating SECS-II Messages
+
+I provide a concise, clear, and efficient way to create SECS-II message types. You can use the following code to import the required items:
+
+```ts
+import { B, U1, U2, U4, U8, I1, I2, I4, I8, F4, F8, A, L } from "secs4js";
+```
+
+Using these items, you can easily create SECS-II message types. For example, to create a message containing L, A, and U1 items, you can use the following code:
+
+```ts
+import { L, A, U1, SecsMessage } from "secs4js";
+
+const body: AbstractSecs2Item = L(A("Hello, SECS/GEM!"), U1(123));
+```
+
+Doesn't this highly resemble SML text syntax?
+
+All SECS-II messages are derived from the `AbstractSecs2Item` class, so you can use it to declare any SECS-II message of unknown type.
+
+If you don't like this approach, you can also use SML text syntax or the factory methods we provide to create SECS-II messages.
+
+Factory methods:
+
+```ts
+import { Secs2ItemFactory } from "secs4js";
+
+// Create a message containing L, A, and U1 items
+const newMsg = Secs2ItemFactory.createListItem(
+	Secs2ItemFactory.createAsciiItem("Hello World"),
+	Secs2ItemFactory.createU1Item(123),
+);
+```
+
+SML Conversion Support:
+
+You can use the `toSml` method of the `AbstractSecs2Item` class to convert SECS-II messages to SML text. For example:
+
+```ts
+console.log(newMsg.toSml());
+
+// Output:
+// <L
+//     <A "Hello World">
+//     <U1 123>
+// >.
+```
+
+### 2. Creating SECS Messages
+
+We provide two ways to create SECS-II messages:
+
+1. Use the `SecsMessage` class to create SECS-II messages.
+2. Create SECS-II messages by parsing SML syntax text. You can use the `SmlParser` static class to parse SML text and create corresponding SECS-II messages.
+
+#### new SecsMessage(...)
+
+> You can use the `SecsMessage` class to create SECS-II messages. The class constructor accepts the following parameters:
+>
+> - `stream`: Stream number, one byte, range 0-255.
+> - `function`: Function number, one byte, range 0-255.
+> - `wBit`: W-bit, a boolean indicating whether to enable W-bit (i.e., whether a reply is required).
+> - `body`: SECS-II message body, an `AbstractSecs2Item` instance.
+> - We will automatically generate the message's `length` and `systemBytes`, so you don't need to manage them manually.
+
+```ts
+import { SecsMessage } from "secs4js";
+
+const newMsg = new SecsMessage(1, 13, true, L(L(A("Hello World"), U1(123))));
+```
+
+#### SmlParser
+
+```ts
+import { SmlParser } from "secs4js";
+
+// Complete SML text
+const sml = `
+    S1F13 W
+    <L
+        <B 0x20>
+        <A "Hello World">
+    >.
+    `;
+
+// SML text containing only the message body
+const smlBody = `
+    <L
+        <B 0x20>
+        <A "Hello World">
+    >.
+    `;
+
+// Parse complete SML text into a SecsMessage instance using the parse method
+const parsedMessage = SmlParser.parse(sml);
+const firstBodyItem =
+	parsedMessage.body instanceof Secs2ItemList
+		? parsedMessage.body.value[0]
+		: null;
+const bytes =
+	firstBodyItem instanceof Secs2ItemBinary ? firstBodyItem.value : null;
+console.log(
+	parsedMessage.stream,
+	parsedMessage.func,
+	parsedMessage.wBit,
+	bytes,
+);
+
+// Parse SML text containing only the message body into an AbstractSecs2Item instance using the parseBody method
+const parsedBody = SmlParser.parseBody(smlBody);
+console.log(parsedBody?.toSml());
+```
+
+## HSMS-SS
+
+For HSMS-SS protocol support, you can act as the passive end (Equipment) or the active end (HOST/EAP).
+
+### Active
+
+Quick start:
+
+```ts
+const active = new HsmsActiveCommunicator({
+	ip: "127.0.0.1",
+	port: 5000,
+	deviceId: 10,
+	isEquip: false,
+	// If you need to customize the timeout values, you can add additional parameters
+	// timeoutT1: 10,
+	// ...
+});
+
+active.on("connected", () => console.log("Active TCP Connected"));
+active.on("disconnected", () => console.log("Active Disconnected"));
+active.on("selected", () => console.log("Active Selected (HSMS Ready)"));
+
+await active.open();
+console.log("Active opened");
+
+// Active will automatically send SelectReq and start heartbeat
+
+await active.untilConnected(); // Wait for Select success
+
+// When you need to receive and process messages, you can listen for the "message" event
+active.on("message", (msg: SecsMessage) => {
+	void (async () => {
+		console.log(`Active received: ${msg.toSml()}`);
+		if (msg.stream === 1 && msg.func === 1) {
+			await active.reply(msg, 1, 2, L(A("MDLN-A"), A("SOFTREV-1")));
+		}
+		if (msg.stream === 1 && msg.func === 13) {
+			await active.reply(msg, 1, 14, L(A("ACK")));
+		}
+	})();
+});
+
+const reply = await active.send(1, 1, true);
+console.log(`Active received reply: ${reply?.toSml()}`);
+
+// Interaction results with the simulator
+// Our reply message:
+// 2025-12-30 01:26:44.866:onReceivedEvent[TOOL] DeviceID=[10] SB=[6110]
+// S1F2
+// <L[2/1]
+// 	<A[6/1] "MDLN-A">
+// 	<A[9/1] "SOFTREV-1">
+// >.
+
+// Message actively sent by the simulator:
+// 2025-12-30 01:26:44.864:OnSent[TOOL] DeviceID=[1] SB=[6110]
+
+// S1F1 W.
+// 2025-12-30 01:26:44.864:Send the Message successfully.
+
+// Message replied by the simulator:
+// 2025-12-30 01:26:40.449:OnSent[TOOL] DeviceID=[10] SB=[2]
+// S1F2
+// <L[0/1]>.
+
+// Message we actively sent:
+// 2025-12-30 01:26:40.445:Do not find Tool in QutoReply List by Tool[TOOL] SFName=[S1F1]
+// 2025-12-30 01:26:40.444:onReceivedEvent[TOOL] DeviceID=[10] SB=[2]
+// S1F1 W.
+```
+
+### Passive
+
+```ts
+import {
+	HsmsPassiveCommunicator,
+	SecsMessage,
+	CommAck,
+	OnlAck,
+	Gem,
+} from "secs4js";
+
+// 1. Set up Equipment side (Passive)
+const equipComm = new HsmsPassiveCommunicator({
+	ip: "127.0.0.1",
+	port: 5000,
+	deviceId: 1,
+	isEquip: true,
+	name: "Equipment",
+});
+
+// Use the GEM helper class (optional)
+const equipGem = new Gem(equipComm);
+equipGem.mdln = "MyEquip";
+equipGem.softrev = "1.0.0";
+
+// Handle received messages
+equipComm.on("message", (msg: SecsMessage) => {
+	void (async () => {
+		try {
+			// S1F13: Establish Communications Request
+			if (msg.stream === 1 && msg.func === 13) {
+				console.log("[Equip] Received S1F13, replying S1F14...");
+				await equipGem.s1f14(msg, CommAck.OK);
+			}
+			// S1F17: Request ON-LINE
+			else if (msg.stream === 1 && msg.func === 17) {
+				console.log("[Equip] Received S1F17, replying S1F18...");
+				await equipGem.s1f18(msg, OnlAck.OK);
+			}
+			// S2F17: Date and Time Request
+			else if (msg.stream === 2 && msg.func === 17) {
+				console.log("[Equip] Received S2F17, replying S2F18...");
+				await equipGem.s2f18Now(msg);
+			} else {
+				console.log(
+					`[Equip] Received unhandled message S${msg.stream}F${msg.func}`,
+				);
+			}
+		} catch (err) {
+			console.error("[Equip] Error handling message:", err);
+		}
+	})();
+});
+
+await equipComm.open();
+console.log("Passive opened and listening");
+```
+
+## SECS-I Serial
+
+Supports SECS-I communication via serial port.
+
+**Note**:
+
+- Serial port communication needs to be tested on devices that support the SECS-I protocol.
+- Ensure the serial port path and baud rate match your device configuration.
+- If you want to test locally first, we recommend using a **virtual serial port tool** to simulate serial port communication.
+
+### Active
+
+```ts
+import { A, L, Secs1SerialCommunicator, SecsMessage } from "secs4js";
+
+async function SerialActive() {
+	const active = new Secs1SerialCommunicator({
+		path: "COM5", // Serial port path
+		baudRate: 9600, // Baud rate
+		deviceId: 10,
+		isEquip: false, // Whether it is equipment
+	});
+
+	active.on("message", (msg: SecsMessage) => {
+		void (async () => {
+			console.log(`Active received: ${msg.toSml()}`);
+			if (msg.stream === 1 && msg.func === 1) {
+				await active.reply(msg, 1, 2, L(A("MDLN-A"), A("SOFTREV-1")));
+			}
+		})();
+	});
+
+	active.on("connected", () => {
+		console.log("Active connected");
+	});
+
+	await active.open();
+	console.log("Active opened");
+}
+
+SerialActive().catch((err) => console.error(err));
+
+// Communication results with the simulator
+// Our reply message:
+// 2025-12-30 01:35:40.187:onReceivedEvent[SERIAL_EQP] DeviceID=[10] SB=[5985]
+// S1F2
+// <L[2/1]
+// 	<A[6/1] "MDLN-A">
+// 	<A[9/1] "SOFTREV-1">
+// >.
+
+// Message actively sent by the simulator:
+// 2025-12-30 01:35:40.155:OnSent[SERIAL_EQP] DeviceID=[1] SB=[5985]
+
+// S1F1 W.
+// 2025-12-30 01:35:40.095:Send the Message successfully.
+```
+
+### Passive
+
+```ts
+import { Secs1SerialCommunicator, SecsMessage, L, A } from "secs4js";
+
+async function SerialPassive() {
+	const passive = new Secs1SerialCommunicator({
+		path: "COM5",
+		baudRate: 9600,
+		deviceId: 10,
+		isEquip: true,
+	});
+
+	passive.on("message", (msg: SecsMessage) => {
+		void (async () => {
+			if (msg.stream === 1 && msg.func === 1) {
+				await passive.reply(msg, 1, 2, L(A("MDLN-A"), A("SOFTREV-1")));
+			}
+			console.log(`Passive received: ${msg.toSml()}`);
+		})();
+	});
+
+	await passive.open();
+	console.log("Passive opened");
+}
+
+SerialPassive().catch((err) => console.error(err));
+```
+
+## SECS-I On TCP/IP
+
+Supports SECS-I serial communication via TCP/IP (usually used for testing or connecting through a terminal server).
+
+### Active
+
+```ts
+import { Secs1OnTcpIpActiveCommunicator, SecsMessage, L, A } from "secs4js";
+
+async function TcpActive() {
+	const active = new Secs1OnTcpIpActiveCommunicator({
+		ip: "127.0.0.1",
+		port: 5000,
+		deviceId: 10,
+		isEquip: false,
+	});
+
+	active.on("message", (msg: SecsMessage) => {
+		void (async () => {
+			console.log(`Active received: ${msg.toSml()}`);
+			// Handle message...
+		})();
+	});
+
+	active.on("connected", () => {
+		console.log("Active connected");
+	});
+
+	await active.open();
+}
+```
+
+### Passive
+
+```ts
+import { Secs1OnTcpIpPassiveCommunicator, SecsMessage, L, A } from "secs4js";
+
+async function TcpPassive() {
+	const passive = new Secs1OnTcpIpPassiveCommunicator({
+		ip: "0.0.0.0",
+		port: 5000,
+		deviceId: 10,
+		isEquip: true,
+	});
+
+	passive.on("message", (msg: SecsMessage) => {
+		void (async () => {
+			console.log(`Passive received: ${msg.toSml()}`);
+			// Process message and reply...
+		})();
+	});
+
+	await passive.open();
+	console.log("Passive server started");
+}
+```
+
+## Development
+
+If you are interested in this project, welcome to contribute your code!
+
+Thank you for your contribution! 💖
+
+> 💝 This project was generated using [`create-typescript-app`](https://github.com/JoshuaKGoldberg/create-typescript-app) and the [Bingo framework](https://create.bingo).

package/lib/core/AbstractSecsCommunicator.d.ts

@@ -0,0 +1,76 @@
+import { AbstractSecs2Item } from "./secs2item/AbstractSecs2Item.js";
+import { SecsMessage } from "./AbstractSecsMessage.js";
+import { EventEmitter } from "events";
+
+//#region src/core/AbstractSecsCommunicator.d.ts
+
+/**
+ * @param message The message received.
+ * @param error The error occurred.
+ * @param connected The connection is established.
+ * @param disconnected The connection is closed.
+ */
+interface SecsCommunicatorEvents {
+  message: [SecsMessage];
+  error: [Error];
+  connected: [];
+  disconnected: [];
+}
+/**
+ * @param deviceId The device ID.
+ * @param isEquip Whether the device is an equip.
+ * @param name The name of the connection.
+ * @param timeoutT1 Only SECS-I supports this parameter, ENQ retransmission interval.
+ * @param timeoutT2 Only SECS-I supports this parameter, ENQ wait-for-response timeout.
+ * @param timeoutT3 Support SECS-I and SECS-II, W-Bit timeout.
+ * @param timeoutT4 Only SECS-I supports this parameter, data block retransmission interval.
+ * @param timeoutT5 Support SECS-I and SECS-II, establishment of communication session timeout.
+ * @param timeoutT6 Only HSMS supports this parameter, reply control message timeout.
+ * @param timeoutT7 Only HSMS supports this parameter, create connection timeout.
+ * @param timeoutT8 Only HSMS supports this parameter, the maximum time interval between message bytes when receiving a message
+ */
+interface SecsCommunicatorConfig {
+  deviceId: number;
+  isEquip: boolean;
+  name?: string;
+  timeoutT1?: number;
+  timeoutT2?: number;
+  timeoutT3?: number;
+  timeoutT4?: number;
+  timeoutT5?: number;
+  timeoutT6?: number;
+  timeoutT7?: number;
+  timeoutT8?: number;
+}
+declare abstract class AbstractSecsCommunicator<Events extends Record<keyof Events, unknown[]> & SecsCommunicatorEvents = SecsCommunicatorEvents> extends EventEmitter {
+  readonly deviceId: number;
+  readonly isEquip: boolean;
+  readonly name: string;
+  timeoutT1: number;
+  timeoutT2: number;
+  timeoutT3: number;
+  timeoutT4: number;
+  timeoutT5: number;
+  timeoutT6: number;
+  timeoutT7: number;
+  timeoutT8: number;
+  protected _systemBytesCounter: number;
+  protected _transactions: Map<number, {
+    resolve: (msg: SecsMessage) => void;
+    reject: (err: Error) => void;
+    timer: NodeJS.Timeout;
+  }>;
+  constructor(config: SecsCommunicatorConfig);
+  abstract open(): Promise<void>;
+  abstract close(): Promise<void>;
+  protected emitInternal(eventName: string | symbol, ...args: unknown[]): boolean;
+  protected abstract sendBuffer(buffer: Buffer): Promise<void>;
+  protected abstract createMessage(stream: number, func: number, wBit: boolean, body: AbstractSecs2Item | null, systemBytes: number): SecsMessage;
+  send(stream: number, func: number, wBit: boolean, body?: AbstractSecs2Item | null): Promise<SecsMessage | null>;
+  reply(primaryMsg: SecsMessage, stream: number, func: number, body?: AbstractSecs2Item | null): Promise<void>;
+  protected getNextSystemBytes(): number;
+  protected handleMessage(msg: SecsMessage): void;
+}
+//#endregion
+export { AbstractSecsCommunicator, SecsCommunicatorConfig, SecsCommunicatorEvents };
+//# sourceMappingURL=AbstractSecsCommunicator.d.ts.map

package/lib/core/AbstractSecsCommunicator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractSecsCommunicator.d.ts","names":[],"sources":["../../src/core/AbstractSecsCommunicator.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAUA;AAoBA;AAcA;;AACgB,UAnCC,sBAAA,CAmCD;EAAkC,OAAA,EAAA,CAlCvC,WAkCuC,CAAA;EAChD,KAAA,EAAA,CAlCO,KAkCP,CAAA;EAmBgB,SAAA,EAAA,EAAA;EACD,YAAA,EAAA,EAAA;;;;;;;;;;;;;;;AAwFb,UA5Ha,sBAAA,CA4Hb;EAkB0B,QAAA,EAAA,MAAA;EA7HpB,OAAA,EAAA,OAAA;EAAY,IAAA,CAAA,EAAA,MAAA;;;;;;;;;;uBAHA,wCACN,aAAa,qBAAqB,yBAChD,gCACQ,YAAA;;;;;;;;;;;;;2BAec;mBAGN;kBACD;WACP,MAAA,CAAO;;sBAII;mBAeH;oBACC;;wCAgBoB,SAAS;sFAMxC,gDAEJ;2DAMI,2BACJ,QAAQ;oBAgCE,kDAGN,2BACJ;;+BAkB0B"}

package/lib/core/AbstractSecsCommunicator.js

@@ -0,0 +1,85 @@
+import { EventEmitter } from "events";
+
+//#region src/core/AbstractSecsCommunicator.ts
+var AbstractSecsCommunicator = class extends EventEmitter {
+	deviceId;
+	isEquip;
+	name;
+	timeoutT1 = 1;
+	timeoutT2 = 15;
+	timeoutT3 = 45;
+	timeoutT4 = 45;
+	timeoutT5 = 10;
+	timeoutT6 = 5;
+	timeoutT7 = 10;
+	timeoutT8 = 5;
+	_systemBytesCounter = 0;
+	_transactions = /* @__PURE__ */ new Map();
+	constructor(config) {
+		super();
+		this.deviceId = config.deviceId;
+		this.isEquip = config.isEquip;
+		this.name = config.name ?? "SecsCommunicator";
+		if (config.timeoutT1 !== void 0) this.timeoutT1 = config.timeoutT1;
+		if (config.timeoutT2 !== void 0) this.timeoutT2 = config.timeoutT2;
+		if (config.timeoutT3 !== void 0) this.timeoutT3 = config.timeoutT3;
+		if (config.timeoutT4 !== void 0) this.timeoutT4 = config.timeoutT4;
+		if (config.timeoutT5 !== void 0) this.timeoutT5 = config.timeoutT5;
+		if (config.timeoutT6 !== void 0) this.timeoutT6 = config.timeoutT6;
+		if (config.timeoutT7 !== void 0) this.timeoutT7 = config.timeoutT7;
+		if (config.timeoutT8 !== void 0) this.timeoutT8 = config.timeoutT8;
+	}
+	emitInternal(eventName, ...args) {
+		return super.emit.call(this, eventName, ...args);
+	}
+	async send(stream, func, wBit, body = null) {
+		const systemBytes = this.getNextSystemBytes();
+		const msg = this.createMessage(stream, func, wBit, body, systemBytes);
+		if (wBit) return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				if (this._transactions.has(systemBytes)) {
+					this._transactions.delete(systemBytes);
+					reject(/* @__PURE__ */ new Error(`T3 Timeout waiting for reply to S${String(stream)}F${String(func)} [SysBytes=${String(systemBytes)}]`));
+				}
+			}, this.timeoutT3 * 1e3);
+			this._transactions.set(systemBytes, {
+				resolve,
+				reject,
+				timer
+			});
+			this.sendBuffer(msg.toBuffer()).catch((err) => {
+				clearTimeout(timer);
+				this._transactions.delete(systemBytes);
+				reject(err instanceof Error ? err : new Error(String(err)));
+			});
+		});
+		else {
+			await this.sendBuffer(msg.toBuffer());
+			return null;
+		}
+	}
+	async reply(primaryMsg, stream, func, body = null) {
+		const msg = this.createMessage(stream, func, false, body, primaryMsg.systemBytes);
+		console.log("Reply Buffer:", msg.toBuffer());
+		console.log(`Reply: ${msg.toSml()}`);
+		await this.sendBuffer(msg.toBuffer());
+	}
+	getNextSystemBytes() {
+		this._systemBytesCounter = this._systemBytesCounter + 1 >>> 0;
+		return this._systemBytesCounter;
+	}
+	handleMessage(msg) {
+		const tx = this._transactions.get(msg.systemBytes);
+		if (tx) {
+			clearTimeout(tx.timer);
+			this._transactions.delete(msg.systemBytes);
+			tx.resolve(msg);
+			return;
+		}
+		this.emitInternal("message", msg);
+	}
+};
+
+//#endregion
+export { AbstractSecsCommunicator };
+//# sourceMappingURL=AbstractSecsCommunicator.js.map

package/lib/core/AbstractSecsCommunicator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractSecsCommunicator.js","names":[],"sources":["../../src/core/AbstractSecsCommunicator.ts"],"sourcesContent":["import { EventEmitter } from \"events\";\nimport { SecsMessage } from \"./AbstractSecsMessage.js\";\nimport { AbstractSecs2Item } from \"./secs2item/AbstractSecs2Item.js\";\n\n/**\n * @param message The message received.\n * @param error The error occurred.\n * @param connected The connection is established.\n * @param disconnected The connection is closed.\n */\nexport interface SecsCommunicatorEvents {\n\tmessage: [SecsMessage];\n\terror: [Error];\n\tconnected: [];\n\tdisconnected: [];\n}\n\n/**\n * @param deviceId The device ID.\n * @param isEquip Whether the device is an equip.\n * @param name The name of the connection.\n * @param timeoutT1 Only SECS-I supports this parameter, ENQ retransmission interval.\n * @param timeoutT2 Only SECS-I supports this parameter, ENQ wait-for-response timeout.\n * @param timeoutT3 Support SECS-I and SECS-II, W-Bit timeout.\n * @param timeoutT4 Only SECS-I supports this parameter, data block retransmission interval.\n * @param timeoutT5 Support SECS-I and SECS-II, establishment of communication session timeout.\n * @param timeoutT6 Only HSMS supports this parameter, reply control message timeout.\n * @param timeoutT7 Only HSMS supports this parameter, create connection timeout.\n * @param timeoutT8 Only HSMS supports this parameter, the maximum time interval between message bytes when receiving a message\n */\nexport interface SecsCommunicatorConfig {\n\tdeviceId: number;\n\tisEquip: boolean;\n\tname?: string;\n\ttimeoutT1?: number;\n\ttimeoutT2?: number;\n\ttimeoutT3?: number;\n\ttimeoutT4?: number;\n\ttimeoutT5?: number;\n\ttimeoutT6?: number;\n\ttimeoutT7?: number;\n\ttimeoutT8?: number;\n}\n\nexport abstract class AbstractSecsCommunicator<\n\tEvents extends Record<keyof Events, unknown[]> & SecsCommunicatorEvents =\n\t\tSecsCommunicatorEvents,\n> extends EventEmitter {\n\tpublic readonly deviceId: number;\n\tpublic readonly isEquip: boolean;\n\tpublic readonly name: string;\n\n\tpublic timeoutT1 = 1;\n\tpublic timeoutT2 = 15;\n\tpublic timeoutT3 = 45;\n\tpublic timeoutT4 = 45;\n\tpublic timeoutT5 = 10;\n\tpublic timeoutT6 = 5;\n\tpublic timeoutT7 = 10;\n\tpublic timeoutT8 = 5;\n\n\tprotected _systemBytesCounter = 0;\n\tprotected _transactions = new Map<\n\t\tnumber,\n\t\t{\n\t\t\tresolve: (msg: SecsMessage) => void;\n\t\t\treject: (err: Error) => void;\n\t\t\ttimer: NodeJS.Timeout;\n\t\t}\n\t>();\n\n\tconstructor(config: SecsCommunicatorConfig) {\n\t\tsuper();\n\t\tthis.deviceId = config.deviceId;\n\t\tthis.isEquip = config.isEquip;\n\t\tthis.name = config.name ?? \"SecsCommunicator\";\n\t\tif (config.timeoutT1 !== undefined) this.timeoutT1 = config.timeoutT1;\n\t\tif (config.timeoutT2 !== undefined) this.timeoutT2 = config.timeoutT2;\n\t\tif (config.timeoutT3 !== undefined) this.timeoutT3 = config.timeoutT3;\n\t\tif (config.timeoutT4 !== undefined) this.timeoutT4 = config.timeoutT4;\n\t\tif (config.timeoutT5 !== undefined) this.timeoutT5 = config.timeoutT5;\n\t\tif (config.timeoutT6 !== undefined) this.timeoutT6 = config.timeoutT6;\n\t\tif (config.timeoutT7 !== undefined) this.timeoutT7 = config.timeoutT7;\n\t\tif (config.timeoutT8 !== undefined) this.timeoutT8 = config.timeoutT8;\n\t}\n\n\tabstract open(): Promise<void>;\n\tabstract close(): Promise<void>;\n\n\tprotected emitInternal(\n\t\teventName: string | symbol,\n\t\t...args: unknown[]\n\t): boolean {\n\t\treturn (\n\t\t\tsuper.emit as (\n\t\t\t\tthis: AbstractSecsCommunicator<Events>,\n\t\t\t\teventName: string | symbol,\n\t\t\t\t...args: unknown[]\n\t\t\t) => boolean\n\t\t).call(this, eventName, ...args);\n\t}\n\n\t// This method sends the message bytes. To be implemented by subclasses.\n\tprotected abstract sendBuffer(buffer: Buffer): Promise<void>;\n\n\tprotected abstract createMessage(\n\t\tstream: number,\n\t\tfunc: number,\n\t\twBit: boolean,\n\t\tbody: AbstractSecs2Item | null,\n\t\tsystemBytes: number,\n\t): SecsMessage;\n\n\tasync send(\n\t\tstream: number,\n\t\tfunc: number,\n\t\twBit: boolean,\n\t\tbody: AbstractSecs2Item | null = null,\n\t): Promise<SecsMessage | null> {\n\t\tconst systemBytes = this.getNextSystemBytes();\n\t\tconst msg = this.createMessage(stream, func, wBit, body, systemBytes);\n\n\t\tif (wBit) {\n\t\t\treturn new Promise((resolve, reject) => {\n\t\t\t\tconst timer = setTimeout(() => {\n\t\t\t\t\tif (this._transactions.has(systemBytes)) {\n\t\t\t\t\t\tthis._transactions.delete(systemBytes);\n\t\t\t\t\t\treject(\n\t\t\t\t\t\t\tnew Error(\n\t\t\t\t\t\t\t\t`T3 Timeout waiting for reply to S${String(stream)}F${String(func)} [SysBytes=${String(systemBytes)}]`,\n\t\t\t\t\t\t\t),\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t}, this.timeoutT3 * 1000);\n\n\t\t\t\tthis._transactions.set(systemBytes, { resolve, reject, timer });\n\n\t\t\t\tthis.sendBuffer(msg.toBuffer()).catch((err: unknown) => {\n\t\t\t\t\tclearTimeout(timer);\n\t\t\t\t\tthis._transactions.delete(systemBytes);\n\t\t\t\t\treject(err instanceof Error ? err : new Error(String(err)));\n\t\t\t\t});\n\t\t\t});\n\t\t} else {\n\t\t\tawait this.sendBuffer(msg.toBuffer());\n\t\t\treturn null;\n\t\t}\n\t}\n\n\tasync reply(\n\t\tprimaryMsg: SecsMessage,\n\t\tstream: number,\n\t\tfunc: number,\n\t\tbody: AbstractSecs2Item | null = null,\n\t): Promise<void> {\n\t\tconst msg = this.createMessage(\n\t\t\tstream,\n\t\t\tfunc,\n\t\t\tfalse,\n\t\t\tbody,\n\t\t\tprimaryMsg.systemBytes,\n\t\t);\n\t\tconsole.log(\"Reply Buffer:\", msg.toBuffer());\n\t\tconsole.log(`Reply: ${msg.toSml()}`);\n\t\tawait this.sendBuffer(msg.toBuffer());\n\t}\n\n\tprotected getNextSystemBytes(): number {\n\t\tthis._systemBytesCounter = (this._systemBytesCounter + 1) >>> 0; // Ensure 32-bit unsigned\n\t\treturn this._systemBytesCounter;\n\t}\n\n\tprotected handleMessage(msg: SecsMessage) {\n\t\t// Check if it's a reply\n\t\t// Usually, if we have a transaction waiting for this SystemBytes, we treat it as a reply.\n\t\t// However, Stream 0 (HSMS Control) messages are never replies to SECS-II messages.\n\t\t// SECS-II replies usually have the same SystemBytes as the primary.\n\n\t\tconst tx = this._transactions.get(msg.systemBytes);\n\t\tif (tx) {\n\t\t\tclearTimeout(tx.timer);\n\t\t\tthis._transactions.delete(msg.systemBytes);\n\t\t\ttx.resolve(msg);\n\t\t\treturn;\n\t\t}\n\n\t\t// If not a reply, emit event\n\t\tthis.emitInternal(\"message\", msg);\n\t}\n}\n"],"mappings":";;;AA4CA,IAAsB,2BAAtB,cAGU,aAAa;CACtB,AAAgB;CAChB,AAAgB;CAChB,AAAgB;CAEhB,AAAO,YAAY;CACnB,AAAO,YAAY;CACnB,AAAO,YAAY;CACnB,AAAO,YAAY;CACnB,AAAO,YAAY;CACnB,AAAO,YAAY;CACnB,AAAO,YAAY;CACnB,AAAO,YAAY;CAEnB,AAAU,sBAAsB;CAChC,AAAU,gCAAgB,IAAI,KAO3B;CAEH,YAAY,QAAgC;AAC3C,SAAO;AACP,OAAK,WAAW,OAAO;AACvB,OAAK,UAAU,OAAO;AACtB,OAAK,OAAO,OAAO,QAAQ;AAC3B,MAAI,OAAO,cAAc,OAAW,MAAK,YAAY,OAAO;AAC5D,MAAI,OAAO,cAAc,OAAW,MAAK,YAAY,OAAO;AAC5D,MAAI,OAAO,cAAc,OAAW,MAAK,YAAY,OAAO;AAC5D,MAAI,OAAO,cAAc,OAAW,MAAK,YAAY,OAAO;AAC5D,MAAI,OAAO,cAAc,OAAW,MAAK,YAAY,OAAO;AAC5D,MAAI,OAAO,cAAc,OAAW,MAAK,YAAY,OAAO;AAC5D,MAAI,OAAO,cAAc,OAAW,MAAK,YAAY,OAAO;AAC5D,MAAI,OAAO,cAAc,OAAW,MAAK,YAAY,OAAO;;CAM7D,AAAU,aACT,WACA,GAAG,MACO;AACV,SACC,MAAM,KAKL,KAAK,MAAM,WAAW,GAAG,KAAK;;CAcjC,MAAM,KACL,QACA,MACA,MACA,OAAiC,MACH;EAC9B,MAAM,cAAc,KAAK,oBAAoB;EAC7C,MAAM,MAAM,KAAK,cAAc,QAAQ,MAAM,MAAM,MAAM,YAAY;AAErE,MAAI,KACH,QAAO,IAAI,SAAS,SAAS,WAAW;GACvC,MAAM,QAAQ,iBAAiB;AAC9B,QAAI,KAAK,cAAc,IAAI,YAAY,EAAE;AACxC,UAAK,cAAc,OAAO,YAAY;AACtC,4BACC,IAAI,MACH,oCAAoC,OAAO,OAAO,CAAC,GAAG,OAAO,KAAK,CAAC,aAAa,OAAO,YAAY,CAAC,GACpG,CACD;;MAEA,KAAK,YAAY,IAAK;AAEzB,QAAK,cAAc,IAAI,aAAa;IAAE;IAAS;IAAQ;IAAO,CAAC;AAE/D,QAAK,WAAW,IAAI,UAAU,CAAC,CAAC,OAAO,QAAiB;AACvD,iBAAa,MAAM;AACnB,SAAK,cAAc,OAAO,YAAY;AACtC,WAAO,eAAe,QAAQ,MAAM,IAAI,MAAM,OAAO,IAAI,CAAC,CAAC;KAC1D;IACD;OACI;AACN,SAAM,KAAK,WAAW,IAAI,UAAU,CAAC;AACrC,UAAO;;;CAIT,MAAM,MACL,YACA,QACA,MACA,OAAiC,MACjB;EAChB,MAAM,MAAM,KAAK,cAChB,QACA,MACA,OACA,MACA,WAAW,YACX;AACD,UAAQ,IAAI,iBAAiB,IAAI,UAAU,CAAC;AAC5C,UAAQ,IAAI,UAAU,IAAI,OAAO,GAAG;AACpC,QAAM,KAAK,WAAW,IAAI,UAAU,CAAC;;CAGtC,AAAU,qBAA6B;AACtC,OAAK,sBAAuB,KAAK,sBAAsB,MAAO;AAC9D,SAAO,KAAK;;CAGb,AAAU,cAAc,KAAkB;EAMzC,MAAM,KAAK,KAAK,cAAc,IAAI,IAAI,YAAY;AAClD,MAAI,IAAI;AACP,gBAAa,GAAG,MAAM;AACtB,QAAK,cAAc,OAAO,IAAI,YAAY;AAC1C,MAAG,QAAQ,IAAI;AACf;;AAID,OAAK,aAAa,WAAW,IAAI"}

package/lib/core/AbstractSecsMessage.d.ts

@@ -0,0 +1,36 @@
+import { AbstractSecs2Item } from "./secs2item/AbstractSecs2Item.js";
+
+//#region src/core/AbstractSecsMessage.d.ts
+
+/**
+ * @param stream The stream number.
+ * @param func The function number.
+ * @param wBit Whether the message is a request.
+ * @param body The body of the message.
+ * @param systemBytes The system bytes.
+ * @param deviceId The device ID.
+ */
+declare class SecsMessage {
+  readonly stream: number;
+  readonly func: number;
+  readonly wBit: boolean;
+  readonly body: AbstractSecs2Item | null;
+  readonly systemBytes: number;
+  readonly deviceId: number;
+  constructor(stream: number, func: number, wBit: boolean, body?: AbstractSecs2Item | null, systemBytes?: number,
+  // Typically 4 bytes, treated as integer for convenience if it fits, or Buffer
+  deviceId?: number);
+  /**
+   * @description Returns the SML representation of the message.
+   * @returns The SML representation.
+   */
+  toSml(): string;
+  /**
+   * @description Returns the binary representation of the message.
+   * @returns The binary representation.
+   */
+  toBuffer(): Buffer;
+}
+//#endregion
+export { SecsMessage };
+//# sourceMappingURL=AbstractSecsMessage.d.ts.map

package/lib/core/AbstractSecsMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractSecsMessage.d.ts","names":[],"sources":["../../src/core/AbstractSecsMessage.ts"],"sourcesContent":[],"mappings":";;;;;;AAUA;;;;;;cAAa,WAAA;;;;iBAKW;;;kEAAA;;;;;;;;;;;;cAyBX"}