device-communication-node 1.0.0-beta.1

package/src/device/channel/UdpChannel.js

@@ -0,0 +1,96 @@
+const dgram = require('dgram')
+const CommChannel = require('./CommChannel')
+
+class UdpChannel extends CommChannel {
+    constructor(remoteHost, remotePort, localPort = 0) {
+        super()
+
+        this.remoteHost = remoteHost
+        this.remotePort = remotePort
+        this.localPort = localPort
+
+        this.socket = null
+    }
+
+    getIsOpen() {
+        return this.isOpen
+    }
+
+    getConfig() {
+        return {
+            remoteHost: this.remoteHost,
+            remotePort: this.remotePort,
+            localPort: this.localPort
+        }
+    }
+
+    open() {
+        return this._dedupeOpen(() => {
+
+            return new Promise((resolve, reject) => {
+
+                this.socket = dgram.createSocket('udp4')
+
+                const onError = (err) => {
+                    reject(new Error(`UDP初始化失败: ${err.message}`))
+                }
+
+                this.socket.on('error', onError)
+
+                this.socket.on('message', (msg, rinfo) => {
+                    this.onReceive(rinfo, msg)
+                })
+
+                this.socket.bind(this.localPort || 0, () => {
+
+                    try {
+                        this.socket.setBroadcast(true)
+                    } catch (e) { }
+
+                    this.localPort = this.socket.address().port
+
+                    this.triggerOpen(this.socket)
+
+                    this.socket.removeListener('error', onError)
+
+                    resolve()
+                })
+            })
+        })
+    }
+
+    async close() {
+        if (!this.socket) return
+
+        return new Promise((resolve) => {
+            this.socket.close(() => {
+                this.isOpen = false
+                this.socket = null
+                this.triggerClose()
+                resolve()
+            })
+        })
+    }
+
+    send(data) {
+        if (!this.isOpen || !this.socket) {
+            throw new Error('UDP未打开')
+        }
+
+        return new Promise((resolve, reject) => {
+            this.socket.send(
+                data,
+                0,
+                data.length,
+                this.remotePort,
+                this.remoteHost,
+                (err) => {
+                    if (err) reject(err)
+                    else resolve()
+                }
+            )
+        })
+    }
+}
+
+module.exports = UdpChannel

package/src/device/core/CommDispatcher.js

@@ -0,0 +1,387 @@
+const EventEmitter = require('events');
+const Task = require('../model/Task');
+const InteractionPattern = require('../model/InteractionPattern');
+const SchedulingStrategy = require('../model/SchedulingStrategy');
+const hexUtils = require('../utils/hexUtils');
+
+/**
+ * 通信调度器
+ */
+class CommDispatcher extends EventEmitter {
+    constructor() {
+        super();
+        this.priorityQueue = [];
+        this.concurrentQueue = [];
+
+        this.currentTask = null;
+        this.lastReadBytes = null;
+        this.writeTimeout = 50;
+        this.responseTimeout = 500;
+        this.devices = new Set();
+
+        this.onAllTasksCompleted = null;
+        this.processing = false;
+
+        // 当前等待响应的 Promise resolve 函数
+        this._currentResolver = null;
+        // 销毁标记
+        this.isDisposed = false;
+    }
+
+    /**
+     * 动态添加设备实例（支持多设备挂载）
+     * @param {DeviceCore} device
+     */
+    setDevice(device) {
+        if (device) {
+            this.devices.add(device);
+        }
+    }
+
+    /**
+     * 移除设备
+     */
+    async removeDevice(device) {
+        if (!device) return;
+
+        this.devices.delete(device);
+
+        if (this.devices.size === 0) {
+            await this.dispose();
+        }
+    }
+
+    /**
+     * 是否还有设备挂载
+     */
+    hasDevice() {
+        return this.devices.size > 0;
+    }
+
+    // --- 抽象方法由子类实现 ---
+    getConnectionString() {
+        throw new Error('getConnectionString() 必须由子类实现');
+    }
+
+    isOpen() {
+        throw new Error('isOpen() 必须由子类实现');
+    }
+
+    async open() {
+        throw new Error('open() 必须由子类实现');
+    }
+
+    async close() {
+        throw new Error('close() 必须由子类实现');
+    }
+
+    async write(task) {
+        throw new Error('write() 必须由子类实现');
+    }
+
+    getCharset() {
+        throw new Error('getCharset() 必须由子类实现');
+    }
+
+    /**
+     * 入队操作
+     * @param {*} schedulingStrategy 队列策略
+     * @param {*} interactionPattern 交互模式
+     * @param {*} writeBytes 发送字节数组
+     * @param {*} priority 优先级
+     * @param {*} retryCount 重试次数
+     * @param {*} timeout 单条命令超时时间
+     * @param {*} callback 回调函数
+     * @returns
+     */
+    enqueue(schedulingStrategy, interactionPattern, writeBytes, priority, retryCount, timeout, callback) {
+        if (this.isDisposed) return;
+        if (!writeBytes || writeBytes.length === 0) return;
+
+        const task = new Task(
+            writeBytes,
+            priority,
+            retryCount,
+            callback,
+            timeout || this.responseTimeout,
+            interactionPattern
+        );
+
+        if (schedulingStrategy === SchedulingStrategy.PRIORITY) {
+            this.priorityQueue.push(task);
+            // 优先级排序：数值越小，优先级越大
+            this.priorityQueue.sort((a, b) => a.compareTo(b));
+        } else {
+            this.concurrentQueue.push(task);
+        }
+
+        // 触发调度循环
+        this.processNext().catch(err => {
+            console.error('[Dispatcher] 调度循环崩溃:', err);
+            this.processing = false;
+        });
+    }
+
+
+    /**
+     * 获取下一个任务
+     */
+    getNextTask() {
+        if (this.priorityQueue.length > 0) return this.priorityQueue.shift();
+        if (this.concurrentQueue.length > 0) return this.concurrentQueue.shift();
+        return null;
+    }
+
+    /**
+     * 核心调度循环
+     */
+    async processNext() {
+        if (this.processing || this.isDisposed) return;
+        this.processing = true;
+
+        try {
+            let task;
+            while ((task = this.getNextTask()) !== null) {
+                let initialRetry = task.retryCount;
+                let retries = initialRetry;
+                let success = false;
+                let responseData = null;
+                let lastError = null; // 用来记录该任务历次尝试中最后的异常原因
+
+                while (retries >= 0 && !this.isDisposed) {
+                    const currentAttempt = initialRetry - retries + 1;
+                    const isRetry = currentAttempt > 1;
+                    console.log(`[Dispatcher] 执行任务: ${hexUtils.bytesToHexString(task.writeBytes)} (尝试 ${currentAttempt}/${initialRetry + 1})${isRetry ? ' - 重试中' : ''}`);
+
+                    try {
+                        // 自动重连逻辑
+                        if (!this.isOpen()) {
+                            await this.open();
+                        }
+
+                        this.currentTask = task;
+                        this.lastReadBytes = null;
+
+                        // 执行写入
+                        await Promise.race([
+                            this.write(task),
+                            new Promise((_, reject) => setTimeout(() => reject(new Error('物理层写入卡死/超时')), this.writeTimeout))
+                        ]);
+                        // 等待响应
+                        if (task.interactionPattern === InteractionPattern.WAIT_RESPONSE) {
+                            try {
+
+                                await this.waitResponse(task.timeout);
+
+                                responseData = this.lastReadBytes;
+                                if (responseData && responseData.length > 0) {
+                                    success = true;
+                                } else {
+                                    success = false;
+                                    lastError = new Error('设备响应数据为空');
+                                }
+                            } catch (waitErr) {
+                                success = false;
+                                lastError = waitErr;
+                            }
+                        } else {
+                            success = true;
+                        }
+
+                        if (success) {
+                            lastError = null;
+                            break;
+                        }
+
+                    } catch (err) {
+
+                        console.error(`[Dispatcher] 物理层或指令写入异常 (剩余重试:${retries}):`, err.message);
+                        lastError = err;
+
+                        if (this._currentResolver) {
+
+                            this._currentResolver = null;
+                        }
+
+                        // 硬件异常时，触发断开重连机制
+                        try {
+                            await this.close();
+                        } catch (e) {
+                        }
+                    }
+
+                    retries--;
+                    if (!success && retries >= 0 && !this.isDisposed) {
+                        const backoff = 50 + (initialRetry - retries) * 30;
+                        await this.sleep(backoff);
+                    }
+                }
+
+                // 执行回调（透传第三个参数 lastError）
+                if (task.dataReceived && !this.isDisposed) {
+                    try {
+                        // 把最终收集到的错误（超时或硬件故障）原封不动扔给外部
+                        task.dataReceived(responseData, task.writeBytes, lastError);
+                    } catch (e) {
+                        console.error('[Dispatcher] 回调执行失败:', e.message);
+                    }
+                }
+
+                // 任务间隙间隔（取所有设备中最大的写入间隔）
+                let maxInterval = 0;
+                for (const device of this.devices) {
+                    if (device.writeIntervalTime > maxInterval) {
+                        maxInterval = device.writeIntervalTime;
+                    }
+                }
+
+                if (maxInterval > 0 && !this.isDisposed) {
+                    await this.sleep(maxInterval);
+                }
+
+                this.currentTask = null;
+                this.lastReadBytes = null;
+            }
+        } finally {
+            this.processing = false;
+            if (this.onAllTasksCompleted && !this.isDisposed) {
+                try {
+                    this.onAllTasksCompleted();
+                } catch (e) {
+                }
+            }
+        }
+    }
+
+    /**
+     * 等待响应的 Promise 封装
+     */
+    waitResponse(timeout) {
+        return new Promise((resolve, reject) => {
+            let done = false;
+
+            const timer = setTimeout(() => {
+                if (done) return;
+                done = true;
+
+                this._currentResolver = null;
+                reject(new Error('响应超时'));
+            }, timeout);
+
+            this._currentResolver = {
+                resolve: (data) => {
+                    if (done) return;
+                    done = true;
+                    clearTimeout(timer);
+                    this._currentResolver = null;
+                    resolve(data);
+                },
+                reject: (err) => {
+                    if (done) return;
+                    done = true;
+                    clearTimeout(timer);
+                    this._currentResolver = null;
+                    reject(err);
+                }
+            };
+        });
+    }
+
+    /**
+     * 接收数据入口
+     */
+    receive(readBytes) {
+        // 只要还有设备在使用此通道，就允许接收
+        if (this.isDisposed || this.devices.size === 0) return;
+
+        // 任选一个设备来做粘包拆包
+        const tempDevice = this.devices.values().next().value;
+
+        tempDevice.receive(readBytes, (completeFrame) => {
+            this.handleCompleteFrame(completeFrame);
+        });
+    }
+
+    /**
+     * 处理设备拼好的完整帧
+     */
+    handleCompleteFrame(frame) {
+        // 处理<请求-响应>任务
+        if (this.currentTask && this._currentResolver) {
+            // 遍历所有设备，看这帧响应属于谁（或者只要有一个匹配上就通过）
+            let matched = false;
+            for (const dev of this.devices) {
+                if (dev.isMatch(this.currentTask.writeBytes, frame)) {
+                    matched = true;
+                    break;
+                }
+            }
+
+            if (matched) {
+                this.lastReadBytes = frame;
+                this._currentResolver.resolve(frame);
+                this._currentResolver = null;
+                return;
+            }
+        }
+
+        // 处理<主动上报>
+        // 将数据帧广播给当前通道下的<所有>设备实例
+        for (const dev of this.devices) {
+            try {
+                dev.onAutoReport(frame);
+            } catch (e) {
+                console.error(`[Dispatcher] 广播设备主动上报异常:`, e.message);
+            }
+        }
+    }
+
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+
+    /**
+     * 资源释放
+     */
+    async dispose() {
+        if (this.isDisposed) {
+            return;
+        }
+
+        this.isDisposed = true;
+
+        // 唤醒等待中的任务
+        if (this._currentResolver) {
+            this._currentResolver.reject(new Error('Dispatcher disposed'));
+            this._currentResolver = null;
+        }
+
+        // 清空任务
+        this.priorityQueue.length = 0;
+        this.concurrentQueue.length = 0;
+        this.currentTask = null;
+        this.lastReadBytes = null;
+
+        // 解除所有设备与 Dispatcher 的关联
+        for (const device of this.devices) {
+            if (device.commDispatcher === this) {
+                device.commDispatcher = null;
+            }
+        }
+        this.devices.clear();
+
+        // 关闭通信链路
+        try {
+            if (this.isOpen()) {
+                await this.close();
+            }
+        } catch (e) {
+            console.error('[Dispatcher] 关闭失败:', e);
+        }
+
+        // 移除所有事件监听
+        this.removeAllListeners();
+    }
+}
+
+module.exports = CommDispatcher;

package/src/device/core/DeviceCore.js

@@ -0,0 +1,236 @@
+const InteractionPattern = require('../model/InteractionPattern')
+const SchedulingStrategy = require('../model/SchedulingStrategy')
+const HexUtils = require('../utils/HexUtils');
+
+/**
+ * 设备核心控制层
+ */
+class DeviceCore {
+    constructor() {
+        /** @type {CommDispatcher} 通信调度器 */
+        this.commDispatcher = null;
+        /** 写入间隔时间 (ms) */
+        this.writeIntervalTime = 50;
+        /** 接收缓冲区 */
+        this.receiveBuffer = Buffer.alloc(0);
+    }
+
+    /**
+     * 设置调度器并绑定生命周期回调
+     */
+    setCommDispatcher(commDispatcher) {
+        this.commDispatcher = commDispatcher;
+        if (this.commDispatcher) {
+            this.commDispatcher.onAllTasksCompleted = () => this.onAllTasksCompleted();
+        }
+    }
+
+    /**
+     * 获取连接字符串
+     */
+    getConnectionString() {
+        this.commDispatcher ? this.commDispatcher.getConnectionString() : '未知名称';
+    }
+
+    /**
+     * 设置写入间隔时间(ms)
+     * @param {*} interval
+     */
+    setWriteIntervalTime(interval) {
+        this.writeIntervalTime = interval;
+    }
+
+    /**
+     * 获取实例
+     * @returns
+     */
+    static instance() {
+        if (!this._instance) {
+            this._instance = new this();
+        }
+        return this._instance;
+    }
+
+    /**
+     * 获取字符集
+     * @returns
+     */
+    getCharset() {
+        return this.commDispatcher ? this.commDispatcher.getCharset() : 'utf8';
+    }
+
+    /**
+     * 打开设备连接
+     */
+    async open() {
+        if (!this.commDispatcher) throw new Error("Dispatcher 未设置");
+        await this.commDispatcher.open();
+    }
+
+    /**
+     * 关闭设备连接
+     */
+    async close() {
+        if (!this.commDispatcher) throw new Error("Dispatcher 未设置");
+        await this.commDispatcher.close();
+    }
+
+    /**
+     * 基础写入方法
+     */
+    _baseWrite(schedulingStrategy, interactionPattern, writeBytes, priority, retryCount, timeout, dataReceived) {
+        if (!this.commDispatcher) return;
+        this.commDispatcher.enqueue(
+            schedulingStrategy,
+            interactionPattern,
+            writeBytes,
+            priority,
+            retryCount,
+            timeout,
+            dataReceived
+        );
+    }
+
+    /**
+     * 发送字节数据，动态参数选项支持重试、超时和回调
+     */
+    sendBytes(bytes, options = {}) {
+        const {
+            schedulingStrategy = SchedulingStrategy.FIFO,
+            interactionPattern = InteractionPattern.WAIT_RESPONSE,
+            priority = 10,
+            retry = 0,
+            timeout = this.commDispatcher ? this.commDispatcher.responseTimeout : 1000,
+            callback = (r, w) => this.defaultCallback(r, w)
+        } = options;
+
+        this._baseWrite(schedulingStrategy, interactionPattern, bytes, priority, retry, timeout, callback);
+    }
+
+    /**
+     * 同步写入并等待结果
+     * @param {Buffer|Uint8Array} frameBytes
+     * @param {Object} options {priority, retry, timeout, parser}
+     */
+    async sendSync(frameBytes, { priority = 10, retry = 0, timeout = 1000, parser = (r, w) => r } = {}) {
+        return new Promise((resolve, reject) => {
+            this.sendBytes(frameBytes, {
+                schedulingStrategy: SchedulingStrategy.FIFO,
+                interactionPattern: InteractionPattern.WAIT_RESPONSE,
+                priority,
+                retry,
+                timeout,
+                callback: (readBytes, writeBytes, error) => {
+                    if (error || !readBytes) {
+                        return reject(error || new Error('设备响应超时（重试耗尽）'));
+                    }
+                    try {
+                        const result = parser(readBytes, writeBytes);
+                        resolve(result);
+                    } catch (e) {
+                        reject(e);
+                    }
+                }
+            });
+        });
+    }
+
+    /**
+     * 紧急发送 (插队) 并同步等待结果
+     * @param {Buffer|Uint8Array} frameBytes
+     * @param {Object} options {retry, timeout, parser}
+     */
+    async sendUrgentSync(frameBytes, { retry = 0, timeout = 1000, parser = (r, w) => r } = {}) {
+        return new Promise((resolve, reject) => {
+            this.sendBytes(frameBytes, {
+                schedulingStrategy: SchedulingStrategy.PRIORITY,
+                interactionPattern: InteractionPattern.WAIT_RESPONSE,
+                priority: 0,
+                retry,
+                timeout,
+                callback: (readBytes, writeBytes, error) => {
+                    if (error || !readBytes) {
+                        return reject(error || new Error('紧急指令响应超时'));
+                    }
+                    try {
+                        const result = parser(readBytes, writeBytes);
+                        resolve(result);
+                    } catch (e) {
+                        reject(e);
+                    }
+                }
+            });
+        });
+    }
+
+    /**
+     * 基础校验
+     */
+    validate(readBytes) {
+        return readBytes && readBytes.length > 0;
+    }
+
+    /**
+     * 帧匹配校验
+     */
+    isMatch(writeBytes, readBytes) {
+        return this.validate(readBytes);
+    }
+
+    /**
+     * 帧解析逻辑 - 基类默认实现 (不解决拆包粘包)
+     * 子类需重写此方法以实现特定协议的拆包
+     */
+    parseFrame(onFrameReady) {
+        // 默认实现：直接把当前收到的全部内容当成一帧抛出
+        if (this.receiveBuffer.length > 0) {
+            const frame = Buffer.from(this.receiveBuffer);
+            this.receiveBuffer = Buffer.alloc(0); // 清空
+            if (this.validate(frame)) {
+                onFrameReady(frame);
+            }
+        }
+    }
+
+    /**
+     * 主动上报处理接口
+     */
+    onAutoReport(frame) {
+        const now = new Date().toISOString().replace('T', ' ').substring(0, 19);
+        console.log(`[${now}] 主动上报帧: ${HexUtils.bytesToHexString(frame)}`);
+    }
+
+    /**
+     * 默认回调
+     */
+    defaultCallback(readBytes, writeBytes) {
+        console.log("--- 默认回调 ---");
+        console.log("发送:", HexUtils.bytesToHexString(writeBytes));
+        console.log("接收:", HexUtils.bytesToHexString(readBytes));
+    }
+
+    /**
+     * 队列清空通知
+     */
+    onAllTasksCompleted() {
+        // 子类重写
+    }
+
+    /**
+     * 接收入口
+     * @param {Buffer} rawBytes 接收到的的原始碎包
+     * @param {Function} onFrameReady 拼好完整包后的回调
+     */
+    receive(rawBytes, onFrameReady) {
+        // 拼接到缓冲区
+        this.receiveBuffer = Buffer.concat([
+            this.receiveBuffer,
+            Buffer.from(rawBytes)
+        ]);
+
+        // 调用解析逻辑 (支持拆包粘包)
+        this.parseFrame(onFrameReady);
+    }
+}
+
+module.exports = DeviceCore;