node-zserial 1.0.0

package/README.md

@@ -0,0 +1,102 @@
+node-red-node-serialport
+========================
+
+<a href="http://nodered.org" target="noderedinfo">Node-RED</a> nodes to talk to
+hardware serial ports.
+
+## Install
+
+To install the stable version use the `Menu - Manage palette - Install` option and search for node-red-node-serialport, or run the following command in your Node-RED user directory, typically `~/.node-red`
+
+        npm i node-red-node-serialport
+
+During install there may be multiple messages about optional compilation.
+These may look like failures... as they report as failure to compile errors -
+but often are warnings and the node will continue to install and, assuming nothing else
+failed, you should be able to use it. Occasionally some platforms *will* require
+you to install the full set of tools in order to compile the underlying package.
+
+## Usage
+
+Provides four nodes - one to receive messages, and one to send, a request node which can send then wait for a response, and a control node that allows dynamic control of the ports in use.
+
+### Input
+
+Reads data from a local serial port.
+
+Clicking on the search icon will attempt to autodetect serial ports attached to
+the device, however you many need to manually specify it. COM1, /dev/ttyUSB0, etc
+
+It can either
+
+ - wait for a "split" character (default \n). Also accepts hex notation (0x0a).
+ - wait for a timeout in milliseconds from the first character received
+ - wait to fill a fixed sized buffer
+
+It then outputs `msg.payload` as either a UTF8 ascii string or a binary Buffer object.
+
+If no split character is specified, or a timeout or buffer size of 0, then a stream
+of single characters is sent - again either as ascii chars or size 1 binary buffers.
+
+### Output
+
+Provides a connection to an outbound serial port.
+
+Only the `msg.payload` is sent.
+
+Optionally the character used to split the input can be appended to every message sent out to the serial port.
+
+### Request
+
+Provides a connection to a request/response serial port.
+
+This node behaves as a tightly coupled combination of serial in and serial out nodes, with which it shares the configuration.
+
+Send the request message in `msg.payload` as you would do with a serial out node. The message will be forwarded to the serial port following a strict FIFO (First In, First Out) queue, waiting for a single response before transmitting the next request. Once a response is received (with the same logic of a serial in node), or after a timeout occurs, a message is produced on the output, with msg.payload containing the received response (or missing in case if timeout), msg.status containing relevant info, and all other fields preserved.
+
+For consistency with the serial in node, msg.port is also set to the name of the port selected.
+
+### Control
+
+When the node-red starts, the flow(program) picks up the pre-programmed serial port, open it, and starts the communication. But there are some cases the port needs to switch to a different port, stop, and start again. For example, in order to upload a new binary for Arduino, the serial port needs to be stopped relased from the nodered, and start it again after uploading. Or when the FTDI device re-connects after disconnecting for any reason, it may be possible that the port number changes, and the end user of the flow can't change the port.
+
+This node provides the ability to:
+
+  1. change the serial port and its configuration on the run time programatically.
+  2. stop the communication and release the serial port.
+  3. reopen the port and restart the communications.
+
+In order to control the communication, send a **msg.payload** to the control node.
+
+    {
+        "serialport": "/dev/ttyUSB0",
+        "serialbaud": 115200,
+        "databits": 8,
+        "parity": "none",
+        "stopbits": 1,
+        "enabled": true
+    }
+
+changes the serial port and the configuration on the fly.  
+
+The following optional parameters will change the configuration only if they are present.
+Any combination of them can be passed to change/control the serial communication
+
+ - serialport
+ - serialbaud
+ - databits
+ - parity
+ - stopbits
+ - dtr
+ - rts
+ - cts
+ - dsr
+ - enabled
+
+If the `enabled` property is not present, it will default to `true`.
+
+`{"enabled":true}` or `{"enabled":false}` will start or stop the communication.
+
+If `enabled` is passed along with other parameters, the configuration will be changed and the port will be either started or remain stopped, ready to be started later depending on its value.
+
+Any input message will cause the node to output the current port configuration.

package/locales/en-US/zserial.html

@@ -0,0 +1,84 @@
+
+<script type="text/html" data-help-name="zserial in">
+    <p>从本地串口读取数据。</p>
+    <h3>输出</h3>
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">string | buffer</span></dt>
+        <dd>通过串口接收到的数据</dd>
+        <dt>port <span class="property-type">string</span></dt>
+        <dd>串口名称</dd>
+    </dl>
+    <p>该节点可以
+        <ul>
+            <li>等待一个“分隔”字符（默认 \n）。也接受转义快捷方式（如 \n）或十六进制表示（0x0d）。</li>
+            <li>从接收到第一个字符开始，等待指定的超时时间（毫秒）。</li>
+            <li>在接收到最后一个字符后，等待指定的静默时间（毫秒）。</li>
+            <li>等待填满固定大小的缓冲区。</li>
+        </ul>
+    </p>
+    <p>然后输出 <code>msg.payload</code>，类型为 UTF-8 ASCII 字符串或二进制缓冲区对象。</p>
+    <p><code>msg.port</code> 设置为所选串口的名称。</p>
+    <p>如果未指定分隔字符，或超时时间或缓冲区大小为 0，
+       则会以单字符流的方式发送数据——同样可以是 ASCII 字符或长度为 1 的二进制缓冲区。</p>
+</script>
+
+<script type="text/html" data-help-name="zserial out">
+    <p>通过本地串口发送数据。</p>
+    <h3>输入</h3>
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">string | buffer</span></dt>
+        <dd>要通过串口发送的数据</dd>
+        <dt class="optional">baudrate <span class="property-type">string</span></dt>
+        <dd>串口波特率（可选）</dd>
+    </dl>
+    <p>仅发送 <code>msg.payload</code>。</p>
+    <p>可以通过 <code>msg.baudrate</code> 可选地更改波特率。</p>
+    <p>可选地，每条发送到串口的消息都可以自动追加用于分隔输入的新行字符。</p>
+    <p>可以通过缓冲区对象发送二进制数据。</p>
+</script>
+
+<script type="text/html" data-help-name="zserial request">
+    <p>提供一个请求/响应串口的连接。</p>
+    <p>该节点的行为类似于 <code>serial in</code> 和 <code>serial out</code> 节点的紧密结合，并共享其配置。</p>
+    <p>像使用 <code>serial out</code> 节点一样，将请求消息放在 <code>msg.payload</code> 中发送。
+       消息将按照严格的 FIFO（先进先出）队列转发到串口，每次等待一个响应后才发送下一个请求。
+       一旦收到响应（与 <code>serial in</code> 节点的逻辑相同），或发生超时，
+       将向输出发送一条消息（见下方输出），
+       <code>msg.payload</code> 包含收到的响应（如超时则无），
+       其他属性保持不变。</p>
+    <p>为与 <code>serial in</code> 节点一致，<code>msg.port</code> 设置为所选串口的名称。</p>
+    <h3>输入</h3>
+    <ul>
+        <li><code>msg.timeout</code> 为超时时间（毫秒），超时后将带 <code>msg.status</code> 为 <code>"ERR_TIMEOUT"</code> 且无 payload 的消息输出。
+            如果未设置，默认值为 10000（10 秒）。</li>
+        <li><code>msg.count</code> 如果设置，将覆盖配置的字符数，只要小于配置值。</li>
+        <li><code>msg.waitfor</code> 必须为单个字符、转义码或十六进制码。
+            如果设置，节点将在数据流中匹配到该字符后开始输出。</li>
+        <li>可选地通过 <code>msg.baudrate</code> 更改波特率。</li>
+    </ul>
+    <h3>输出</h3>
+    <ul>
+        <li><code>msg.payload</code> 为响应内容。如无响应则该属性被移除。</li>
+        <li><code>msg.status</code> 为 <code>"OK"</code>（收到响应）或 <code>"ERR_TIMEOUT"</code>（超时）。</li>
+        <li>输入消息的其他属性将被保留。</li>
+    </ul>
+</script>
+
+<script type="text/html" data-help-name="zserial-port">
+    <p>本地串口的配置选项。</p>
+    <p>点击搜索按钮可返回可用串口列表，或可直接输入已知串口位置。</p>
+    <p>DTR、RTS、CTS 和 DSR 开关可用于永久拉高或拉低相应的流控引脚，例如通过这些引脚为设备供电。</p>
+    <p>节点可选地等待匹配预定义字符。</p>
+    <p>串口数据接收方式可以
+        <ul>
+            <li>等待一个“分隔”字符（默认 \n）。也接受转义快捷方式（如 \n）或十六进制表示（0x0d）。</li>
+            <li>从接收到第一个字符开始，等待指定的超时时间（毫秒）。</li>
+            <li>在接收到最后一个字符后，等待指定的静默时间（毫秒）。</li>
+            <li>等待填满固定大小的缓冲区。</li>
+        </ul>
+    </p>
+    <p>然后输出接收到的数据，类型为 UTF-8 ASCII 字符串或二进制缓冲区对象。</p>
+    <p>如果未指定分隔字符，或超时时间或缓冲区大小为 0，则会以单字符流的方式发送数据——同样可以是 ASCII 字符或长度为 1 的二进制缓冲区。</p>
+    <p>可选地，每条发送到串口的消息都可以自动追加用于分隔输入的新行字符。</p>
+</script>
+

package/locales/en-US/zserial.json

@@ -0,0 +1,75 @@
+{
+    "serial": {
+        "status": {
+            "waiting": "waiting",
+            "timeout": "timeout",
+            "stopped": "stopped"
+        },
+        "label": {
+            "serialport": "Serial Port",
+            "settings": "Settings",
+            "baudrate": "Baud Rate",
+            "databits": "Data Bits",
+            "parity": "Parity",
+            "stopbits": "Stop Bits",
+            "input": "Input",
+            "split": "Split input",
+            "deliver": "and deliver",
+            "output": "Output",
+            "request": "Request",
+            "responsetimeout": "Default response timeout",
+            "ms": "ms",
+            "serial": "serial",
+            "none": "none",
+            "start": "Optionally wait for a start character of",
+            "startor": ", then"
+        },
+        "placeholder": {
+            "serialport": "for example: /dev/ttyUSB0/"
+        },
+        "parity": {
+            "none": "None",
+            "even": "Even",
+            "mark": "Mark",
+            "odd": "Odd",
+            "space": "Space"
+        },
+        "linestates": {
+            "none": "auto",
+            "high": "High",
+            "low": "Low"
+        },
+        "split": {
+            "character": "on the character",
+            "timeout": "after a timeout of",
+            "silent": "after a silence of",
+            "lengths": "into fixed lengths of"
+        },
+        "output": {
+            "ascii": "ASCII strings",
+            "binary": "binary buffers"
+        },
+        "addsplit": "Add character to output messages",
+        "tip": {
+            "responsetimeout": "Tip: The default response timeout can be overridden by setting msg.timeout.",
+            "split": "Tip: the \"Split on\" character is used to split the input into separate messages. Can accept chars ($), escape codes (\\n), or hex codes (0x03).",
+            "silent": "Tip: In line-silent mode timeout is restarted upon arrival of any character (i.e. inter-byte timeout).",
+            "timeout": "Tip: In timeout mode timeout starts from arrival of first character.",
+            "count": "Tip: In count mode msg.count can override the configured count as long as it smaller than the configured value.",
+            "waitfor": "Tip: Optional. Leave blank to receive all data. Can accept chars ($), escape codes (\\n), or hex codes (0x02)." ,
+            "addchar": "Tip: This character is added to every message sent out to the serial port. Usually \\r or \\n."
+        },
+        "onopen": "serial port __port__ opened at __baud__ baud __config__",
+        "errors": {
+            "missing-conf": "missing serial config",
+            "serial-port": "serial port",
+            "error": "serial port __port__ error: __error__",
+            "unexpected-close": "serial port __port__ closed unexpectedly",
+            "disconnected": "serial port __port__ disconnected",
+            "closed": "serial port __port__ closed",
+            "list": "Failed to list ports. Please enter manually.",
+            "badbaudrate": "Baudrate is invalid"
+        },
+        "stopped": "__port__ stopped"
+    }
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+    "name": "node-zserial",
+    "version": "1.0.0",
+    "description": "Node-RED nodes to talk to serial ports",
+    "dependencies": {
+        "serialport": "^12.0.0"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/bensonzhow/node-red-zserialport.git"
+    },
+    "keywords": [
+        "node-red",
+        "serial"
+    ],
+    "node-red": {
+        "version": ">=3.0.0",
+        "nodes": {
+            "zserial": "zserial.js"
+        }
+    },
+    "engines": {
+        "node": ">=16.0.0"
+    },
+    "contributors": []
+}

package/zserial.html

@@ -0,0 +1,101 @@
+<script type="text/html" data-template-name="zserial request">
+    <div class="form-row">
+        <label for="node-inputoutput-name"><i class="fa fa-tag"></i> <span data-i18n="node-red:common.label.name"></span></label>
+        <input type="text" id="node-input-name" data-i18n="[placeholder]node-red:common.label.name">
+    </div>
+</script>
+
+<script type="text/javascript">
+    RED.nodes.registerType('zserial request',{
+        category: 'zutils',
+        defaults: {
+            name: {name:""}
+        },
+        color:"BurlyWood",
+        inputs:1,
+        outputs:1,
+        icon: "serial.png",
+        align: "left",
+        label: function() {
+            return this.name || "zserial request";
+        }
+    });
+</script>
+
+
+
+<script type="text/html" data-template-name="zserial in">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> <span data-i18n="node-red:common.label.name"></span></label>
+        <input type="text" id="node-input-name" data-i18n="[placeholder]node-red:common.label.name">
+    </div>
+</script>
+
+<script type="text/javascript">
+    RED.nodes.registerType('zserial in',{
+        category: 'zutils',
+        defaults: {
+            name: {name:""}
+        },
+        color:"BurlyWood",
+        inputs:1,
+        outputs:1,
+        icon: "serial.png",
+        label: function() {
+            return this.name || "zserial in";
+        }
+    });
+</script>
+
+
+
+
+<script type="text/html" data-template-name="zserial out">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> <span data-i18n="node-red:common.label.name"></span></label>
+        <input type="text" id="node-input-name" data-i18n="[placeholder]node-red:common.label.name">
+    </div>
+</script>
+
+<script type="text/javascript">
+    RED.nodes.registerType('zserial out',{
+        category: 'zutils',
+        defaults: {
+            name: {name:""}
+        },
+        color:"BurlyWood",
+        inputs:1,
+        outputs:0,
+        icon: "serial.png",
+        align: "right",
+        label: function() {
+            return this.name || "zserial out";
+        }
+    });
+</script>
+
+
+
+<script type="text/html" data-template-name="zserial closeAll">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> <span data-i18n="node-red:common.label.name"></span></label>
+        <input type="text" id="node-input-name" data-i18n="[placeholder]node-red:common.label.name">
+    </div>
+</script>
+
+<script type="text/javascript">
+    RED.nodes.registerType('zserial closeAll',{
+        category: 'zutils',
+        defaults: {
+            name: {name:""}
+        },
+        color:"BurlyWood",
+        inputs:1,
+        outputs:1,
+        icon: "serial.png",
+        align: "right",
+        label: function() {
+            return this.name || "zserial closeAll";
+        }
+    });
+</script>

package/zserial.js

@@ -0,0 +1,630 @@
+
+module.exports = function (RED) {
+    /*jshint -W082 */
+    "use strict";
+    var settings = RED.settings;
+    var events = require("events");
+    const { SerialPort } = require('serialport');
+    var bufMaxSize = 32768;  // Max serial buffer size, for inputs...
+    const serialReconnectTime = settings.serialReconnectTime || 15000;
+
+
+    function SerialCloseAllNode(n) {
+        RED.nodes.createNode(this, n);
+        var node = this;
+
+        function onMsg(msg, send, done){
+            if (msg.serialConfig) {
+                serialPool.close(msg.serialConfig.serialport,(err) => {
+                    if (err) {
+                        msg.status="Close Error"
+                    }else{  
+                        msg.status="Closed Ok"
+                    }
+                    node.send(msg);
+                    done();
+                },node);
+            }else{
+                serialPool.closeAll(() => {
+                    node.send(msg);
+                    done();
+                },node);
+            }
+        }
+        this.on("input", function (msg, send, done) {
+            onMsg(msg, send, done);
+        })
+
+    }
+    RED.nodes.registerType("zserial closeAll", SerialCloseAllNode);
+    function SerialOutNode(n) {
+        RED.nodes.createNode(this, n);
+        var node = this;
+        function onMsg(msg, send, done) {
+
+            if (!msg.serialConfig) {
+                node.error('msg.serialConfig 没有定义,已创建更新波特率使用 msg.baudrate');
+                msg.status = "NO_SERIAL_CONFIG";
+                node.send(msg);
+                return;
+            }
+            let curPort = serialPool.get(msg.serialConfig);
+
+            if (msg.hasOwnProperty("baudrate")) {
+                var baud = parseInt(msg.baudrate);
+                if (isNaN(baud)) {
+                    node.error(RED._("serial.errors.badbaudrate"), msg);
+                } else {
+                    curPort.update({ baudRate: baud }, function (err, res) {
+                        if (err) {
+                            node.error(err);
+                        }
+                    });
+                }
+            }
+            if (!msg.hasOwnProperty("payload")) {
+                node.warn(RED._("serial.errors.nopayload"));
+                return;
+            } // do nothing unless we have a payload
+
+            setCallback(msg);
+
+            // 是否队列发送
+            if (msg.hasOwnProperty("queueSend") && msg.queueSend === true) {
+                curPort.enqueue(msg, node, function (err, res) {
+                    if (err) {
+                        node.error(err);
+                    }
+                });
+            } else {
+                var payload = curPort.encodePayload(msg.payload);
+                curPort.write(payload, function (err, res) {
+                    if (err) {
+                        node.error(err);
+                        msg.status = "ERR_WRITE";
+                    } else {
+                        msg.status = "OK";
+                    }
+                });
+            }
+        }
+
+        function setCallback(msg) {
+            let curPort = serialPool.get(msg.serialConfig);
+            // 确保只绑定一次事件
+            if (curPort._isBindOnOutEventInit) {
+                // if (done) done();
+                return;
+            }
+            curPort._isBindOnOutEventInit = true;
+
+            curPort.on('ready', function () {
+                node.status({ fill: "green", shape: "dot", text: "node-red:common.status.connected" });
+            });
+            curPort.on('closed', function () {
+                node.status({ fill: "red", shape: "ring", text: "node-red:common.status.not-connected" });
+            });
+            curPort.on('stopped', function () {
+                node.status({ fill: "grey", shape: "ring", text: "serial.status.stopped" });
+            });
+        }
+
+
+        this.on("input", function (msg, send, done) {
+            onMsg(msg, send, done);
+        })
+
+
+    }
+    RED.nodes.registerType("zserial out", SerialOutNode);
+
+    function SerialInNode(n) {
+        RED.nodes.createNode(this, n);
+        var node = this;
+        function onMsg(msg, send, done) {
+            setCallback();
+        }
+
+        this.on("input", function (msg, send, done) {
+            onMsg(msg, send, done);
+        })
+
+
+
+        function setCallback() {
+            let conns = serialPool.curConnections();
+            let connKeys = Object.keys(conns) || [];
+            // node.warn(connKeys);
+            node.status({ fill: "green", shape: "dot", text: "当前连接数：" + connKeys.length });
+
+            connKeys.forEach(function (key) {
+                let curPort = conns[key];
+                if (!curPort) {
+                    return;
+                }
+                // 确保只绑定一次事件
+                if (curPort._isBindOnInEventInit) {
+                    // if (done) done();
+                    return;
+                }
+                curPort._isBindOnInEventInit = true;
+                curPort.on('data', function (msgout) {
+                    node.send(msgout);
+                });
+                curPort.on('ready', function () {
+                    node.status({ fill: "green", shape: "dot", text: "node-red:common.status.connected" });
+                });
+                curPort.on('closed', function () {
+                    node.status({ fill: "red", shape: "ring", text: "node-red:common.status.not-connected" });
+                });
+                curPort.on('stopped', function () {
+                    node.status({ fill: "grey", shape: "ring", text: "serial.status.stopped" });
+                });
+            });
+        }
+        let connNumChange = function () {
+            // node.warn('connNumChange');
+            setCallback();
+        };
+        try {
+            serialPool.on('connNumChange', connNumChange);
+        } catch (error) {
+            node.error("绑定事件监听器时出错: " + error.toString());
+        }
+
+        this.on("close", function (done) {
+            try {
+                serialPool.off('connNumChange', connNumChange);
+                serialPool.closeAll(done, node);
+            } catch (error) {
+                // node.warn("移除事件监听器时出错: " + error.toString());
+                done();
+            }
+        });
+
+
+    }
+    RED.nodes.registerType("zserial in", SerialInNode);
+
+
+    // request data and waits for reply
+    function SerialRequestNode(n) {
+        RED.nodes.createNode(this, n);
+        var node = this;
+        function onMsg(msg, send, done) {
+
+            if (!msg.serialConfig) {
+                node.error('msg.serialConfig 没有定义,已创建更新波特率使用 msg.baudrate');
+                return;
+            }
+            let curPort = serialPool.get(msg.serialConfig);
+
+            if (msg.hasOwnProperty("baudrate")) {
+                var baud = parseInt(msg.baudrate);
+                if (isNaN(baud)) {
+                    node.error(RED._("serial.errors.badbaudrate"), msg);
+                } else {
+                    curPort.update({ baudRate: baud }, function (err, res) {
+                        if (err) {
+                            var errmsg = err.toString().replace("Serialport", "Serialport " + curPort.serial.path);
+                            node.error(errmsg, msg);
+                        }
+                    });
+                }
+            }
+            if (!msg.hasOwnProperty("payload")) { return; } // do nothing unless we have a payload
+            if (msg.hasOwnProperty("count") && (typeof msg.count === "number") && (msg.serialConfig.out === "count")) {
+                msg.serialConfig.newline = msg.count;
+            }
+            if (msg.hasOwnProperty("flush") && msg.flush === true) { curPort.serial.flush(); }
+            let statusText = `waiting：${curPort.serial.path}`
+            node.status({ fill: "yellow", shape: "dot", text: "serial.status.waiting:" + curPort.serial.path });
+            curPort.enqueue(msg, node, function (err, res) {
+                if (err) {
+                    node.error(err)
+                }
+            });
+
+            setCallback(msg, done);
+        }
+        function setCallback(msg, done) {
+            let curPort = serialPool.get(msg.serialConfig);
+            // 确保只绑定一次事件
+            if (curPort._isBindEventInit) {
+                // if (done) done();
+                return;
+            }
+            // node.warn("setCallback called for " + curPort.serial.path);
+            curPort._isBindEventInit = true;
+
+            curPort.on('data', function (msgout, sender) {
+                // node.warn("对象绑定：："+ node == sender);
+                // serial request will only process incoming data pertaining to its own request (i.e. when it's at the head of the queue)
+                if (sender !== node) { return; }
+                node.status({ fill: "green", shape: "dot", text: "node-red:common.status.ok" });
+                msgout.status = "OK";
+                node.send(msgout);
+                // if (done) done();
+            });
+            curPort.on('timeout', function (msgout, sender) {
+                if (sender !== node) { return; }
+                msgout.status = "ERR_TIMEOUT";
+                node.status({ fill: "red", shape: "ring", text: "serial.status.timeout" });
+                node.send(msgout);
+                // if (done) done();
+            });
+            curPort.on('ready', function () {
+                node.status({ fill: "green", shape: "dot", text: "node-red:common.status.connected" });
+            });
+            curPort.on('closed', function () {
+                node.status({ fill: "red", shape: "ring", text: "node-red:common.status.not-connected" });
+            });
+            curPort.on('stopped', function () {
+                node.status({ fill: "grey", shape: "ring", text: "serial.status.stopped" });
+            });
+        }
+
+        this.on("input", function (msg, send, done) {
+            onMsg(msg, send, done);
+        })
+        this.on("close", function (done) {
+            // node.warn("close serial in node")
+            try {
+                serialPool.closeAll(done, node);
+            } catch (error) {
+                done();
+            }
+
+        });
+    }
+    RED.nodes.registerType("zserial request", SerialRequestNode);
+
+    var serialPool = (function () {
+        var connections = {};
+        var _zemitter = new events.EventEmitter();
+
+        return {
+            on: function (event, callback) { _zemitter.on(event, callback); },
+            off: function (event, callback) { _zemitter.off(event, callback); },
+            curConnections: function () { return connections; },
+            get: function (serialConfig, node) {
+                // make local copy of configuration -- perhaps not needed?
+                var port = serialConfig.serialport,
+                    baud = serialConfig.serialbaud || 57600,
+                    databits = serialConfig.databits || 8,
+                    parity = serialConfig.parity || 'none',
+                    stopbits = serialConfig.stopbits || 1,
+                    dtr = serialConfig.dtr || 'none',
+                    rts = serialConfig.rts || 'none',
+                    cts = serialConfig.cts || 'none',
+                    dsr = serialConfig.dsr || 'none',
+                    newline = "" + (serialConfig.newline || '\\n'),
+                    spliton = serialConfig.out || 'char',
+                    waitfor = serialConfig.waitfor || '',
+                    binoutput = serialConfig.bin || 'false',
+                    addchar = serialConfig.addchar || '',
+                    responsetimeout = serialConfig.responsetimeout || 10000;
+                var id = port;
+                // just return the connection object if already have one
+                // key is the port (file path)
+                if (connections[id]) { return connections[id]; }
+
+                // State variables to be used by the on('data') handler
+                var i = 0; // position in the buffer
+                // .newline is misleading as its meaning depends on the split input policy:
+                //   "char"  : a msg will be sent after a character with value .newline is received
+                //   "time"  : a msg will be sent after .newline milliseconds
+                //   "count" : a msg will be sent after .newline characters
+                // if we use "count", we already know how big the buffer will be
+                var bufSize = (spliton === "count") ? Number(newline) : bufMaxSize;
+
+                waitfor = waitfor.replace("\\n", "\n").replace("\\r", "\r")
+                    .replace("\\t", "\t").replace("\\e", "\e")
+                    .replace("\\f", "\f").replace("\\0", "\0"); // jshint ignore:line
+                if (waitfor.substr(0, 2) == "0x") { waitfor = parseInt(waitfor, 16); }
+                if (waitfor.length === 1) { waitfor = waitfor.charCodeAt(0); }
+                var active = (waitfor === "") ? true : false;
+                var buf = new Buffer.alloc(bufSize);
+
+                var splitc; // split character
+                // Parse the split character onto a 1-char buffer we can immediately compare against
+                if (newline.substr(0, 2) == "0x") {
+                    splitc = new Buffer.from([newline]);
+                }
+                else {
+                    splitc = new Buffer.from(newline.replace("\\n", "\n").replace("\\r", "\r").replace("\\t", "\t").replace("\\e", "\e").replace("\\f", "\f").replace("\\0", "\0")); // jshint ignore:line
+                }
+                if (addchar === true) { addchar = splitc; }
+                addchar = addchar.replace("\\n", "\n").replace("\\r", "\r").replace("\\t", "\t").replace("\\e", "\e").replace("\\f", "\f").replace("\\0", "\0"); // jshint ignore:line
+
+                if (addchar.substr(0, 2) == "0x") { addchar = new Buffer.from([addchar]); }
+                connections[id] = (function () {
+                    var obj = {
+                        _emitter: new events.EventEmitter(),
+                        _isBindEventInit: false,
+                        serial: null,
+                        _closing: false,
+                        tout: null,
+                        queue: [],
+                        on: function (a, b) { this._emitter.on(a, b); },
+                        once: function (a, b) { this._emitter.once(a, b); },
+                        close: function (cb) {
+                            this.serial.close(cb);
+                        },
+                        encodePayload: function (payload) {
+                            if (!Buffer.isBuffer(payload)) {
+                                if (typeof payload === "object") {
+                                    payload = JSON.stringify(payload);
+                                }
+                                else {
+                                    payload = payload.toString();
+                                }
+                                if (addchar !== "") { payload += addchar; }
+                            }
+                            else if (addchar !== "") {
+                                payload = Buffer.concat([payload, Buffer.from(addchar)]);
+                            }
+                            return payload;
+                        },
+                        write: function (m, cb) { this.serial.write(m, cb); },
+                        update: function (m, cb) { this.serial.update(m, cb); },
+                        enqueue: function (msg, sender, cb) {
+                            var payload = this.encodePayload(msg.payload);
+                            var qobj = {
+                                sender: sender,
+                                msg: msg,
+                                payload: payload,
+                                cb: cb,
+                            }
+                            this.queue.push(qobj);
+
+                            // If we're enqueing the first message in line,
+                            // we shall send it right away
+                            if (this.queue.length === 1) {
+                                this.writehead();
+                            }
+                        },
+                        writehead: function () {
+                            if (!this.queue.length) { return; }
+                            var qobj = this.queue[0];
+                            this.write(qobj.payload, qobj.cb);
+                            var msg = qobj.msg;
+                            var timeout = msg.timeout || responsetimeout;
+                            this.tout = setTimeout(function () {
+                                this.tout = null;
+                                var msgout = obj.dequeue() || {};
+                                msgout.port = port;
+                                // if we have some leftover stuff, just send it
+                                if (i !== 0) {
+                                    var m = buf.slice(0, i);
+                                    m = Buffer.from(m);
+                                    i = 0;
+                                    if (binoutput !== "bin") { m = m.toString(); }
+                                    msgout.payload = m;
+                                }
+                                /* Notify the sender that a timeout occurred */
+                                obj._emitter.emit('timeout', msgout, qobj.sender);
+                            }, timeout);
+                        },
+                        dequeue: function () {
+                            // if we are trying to dequeue stuff from an
+                            // empty queue, that's an unsolicited message
+                            if (!this.queue.length) { return null; }
+                            var msg = Object.assign({}, this.queue[0].msg);
+                            msg = Object.assign(msg, {
+                                request_payload: msg.payload,
+                                request_msgid: msg._msgid,
+                            });
+                            delete msg.payload;
+                            if (this.tout) {
+                                clearTimeout(obj.tout);
+                                obj.tout = null;
+                            }
+                            this.queue.shift();
+                            this.writehead();
+                            return msg;
+                        },
+                    }
+                    //newline = newline.replace("\\n","\n").replace("\\r","\r");
+                    obj._emitter.setMaxListeners(50);
+                    var olderr = "";
+                    var setupSerial = function () {
+                        obj.serial = new SerialPort({
+                            path: port,
+                            baudRate: baud,
+                            dataBits: databits,
+                            parity: parity,
+                            stopBits: stopbits,
+                            //parser: serialp.parsers.raw,
+                            autoOpen: true
+                        }, function (err, results) {
+                            if (err) {
+                                if (err.toString() !== olderr) {
+                                    olderr = err.toString();
+                                    RED.log.error("Err1:[serialconfig:" + serialConfig.id + "] " + RED._("serial.errors.error", { port: port, error: olderr }), {});
+                                }
+                                obj.tout = setTimeout(function () {
+                                    setupSerial();
+                                }, serialReconnectTime);
+                            }
+                            // RED.log.error("init:::::::::::::::::connNumChange");
+                            _zemitter.emit('connNumChange', Object.keys(connections).length)
+                        });
+                        obj.serial.on('error', function (err) {
+                            RED.log.error("Err2:[serialconfig:" + serialConfig.id + "] " + RED._("serial.errors.error", { port: port, error: err.toString() }), {});
+                            obj._emitter.emit('closed');
+                            if (obj.tout) { clearTimeout(obj.tout); }
+                            obj.tout = setTimeout(function () {
+                                setupSerial();
+                            }, serialReconnectTime);
+                        });
+                        obj.serial.on('close', function () {
+                            if (!obj._closing) {
+                                if (olderr !== "unexpected") {
+                                    olderr = "unexpected";
+                                    RED.log.error("Err3:[serialconfig:" + serialConfig.id + "] " + RED._("serial.errors.unexpected-close", { port: port }), {});
+                                }
+                                obj._emitter.emit('closed');
+                                if (obj.tout) { clearTimeout(obj.tout); }
+                                obj.tout = setTimeout(function () {
+                                    setupSerial();
+                                }, serialReconnectTime);
+                            }
+                            else {
+                                obj._emitter.emit('stopped');
+                            }
+                        });
+                        obj.serial.on('open', function () {
+                            olderr = "";
+                            RED.log.info("[serialconfig:" + serialConfig.id + "] " + RED._("serial.onopen", { port: port, baud: baud, config: databits + "" + parity.charAt(0).toUpperCase() + stopbits }));
+                            // Set flow control pins if necessary. Must be set all in same command.
+                            var flags = {};
+                            if (dtr != "none") { flags.dtr = (dtr != "low"); }
+                            if (rts != "none") { flags.rts = (rts != "low"); }
+                            if (cts != "none") { flags.cts = (cts != "low"); }
+                            if (dsr != "none") { flags.dsr = (dsr != "low"); }
+                            if (dtr != "none" || rts != "none" || cts != "none" || dsr != "none") { obj.serial.set(flags); }
+                            if (obj.tout) { clearTimeout(obj.tout); obj.tout = null; }
+                            //obj.serial.flush();
+                            obj._emitter.emit('ready');
+                        });
+
+                        obj.serial.on('data', function (d) {
+                            RED.log.info("data::::" + d);
+                            function emitData(data) {
+
+                                if (active === true) {
+                                    var m = Buffer.from(data);
+                                    var last_sender = null;
+                                    if (obj.queue.length) { last_sender = obj.queue[0].sender; }
+                                    if (binoutput !== "bin") { m = m.toString(); }
+                                    var msgout = obj.dequeue() || {};
+                                    msgout.payload = m;
+                                    msgout.port = port;
+                                    obj._emitter.emit('data', msgout, last_sender);
+                                }
+                                active = (waitfor === "") ? true : false;
+                            }
+
+                            for (var z = 0; z < d.length; z++) {
+                                var c = d[z];
+                                if (c === waitfor) { active = true; }
+                                if (!active) { continue; }
+                                // handle the trivial case first -- single char buffer
+                                if ((newline === 0) || (newline === "")) {
+                                    emitData(new Buffer.from([c]));
+                                    continue;
+                                }
+
+                                // save incoming data into local buffer
+                                buf[i] = c;
+                                i += 1;
+
+                                // do the timer thing
+                                if (spliton === "time" || spliton === "interbyte") {
+                                    // start the timeout at the first character in case of regular timeout
+                                    // restart it at the last character of the this event in case of interbyte timeout
+                                    if ((spliton === "time" && i === 1) ||
+                                        (spliton === "interbyte" && z === d.length - 1)) {
+                                        // if we had a response timeout set, clear it:
+                                        // we'll emit at least 1 character at some point anyway
+                                        if (obj.tout) {
+                                            clearTimeout(obj.tout);
+                                            obj.tout = null;
+                                        }
+                                        obj.tout = setTimeout(function () {
+                                            obj.tout = null;
+                                            emitData(buf.slice(0, i));
+                                            i = 0;
+                                        }, newline);
+                                    }
+                                }
+                                // count bytes into a buffer...
+                                else if (spliton === "count") {
+                                    newline = serialConfig.newline;
+                                    if (i >= parseInt(newline)) {
+                                        emitData(buf.slice(0, i));
+                                        i = 0;
+                                    }
+                                }
+                                // look to match char...
+                                else if (spliton === "char") {
+                                    if ((c === splitc[0]) || (i === bufMaxSize)) {
+                                        emitData(buf.slice(0, i));
+                                        i = 0;
+                                    }
+                                }
+                            }
+                        });
+                        // obj.serial.on("disconnect",function() {
+                        //     RED.log.error(RED._("serial.errors.disconnected",{port:port}));
+                        // });
+                    }
+                    setupSerial();
+                    return obj;
+                }());
+                return connections[id];
+            },
+            close: function (port, done, node) {
+                if (connections[port]) {
+                    if (connections[port].tout != null) {
+                        clearTimeout(connections[port].tout);
+                    }
+                    connections[port]._closing = true;
+                    connections[port]._isBindOnOutEventInit = false;
+                    connections[port]._isBindOnInEventInit = false;
+                    connections[port]._isBindEventInit = false;
+                    serialPool.zlog(node, "开始执行关闭");
+                    try {
+                        connections[port].close(function () {
+                            serialPool.zlog(node, "关闭成功");
+                            RED.log.info(RED._("serial.errors.closed", { port: port }), {});
+                            done();
+                        });
+                    }
+                    catch (err) {
+                        done(err);
+                    }
+                    delete connections[port];
+                    // RED.log.error("close:::::::::::::::::connNumChange");
+                    _zemitter.emit('connNumChange', Object.keys(connections).length)
+                }
+                else {
+                    done();
+                }
+            },
+            closeAll(done, node) {
+                serialPool.zlog(node, "开始关闭所有串口连接");
+                serialPool.zlog(node, connections);
+                var keys = Object.keys(connections), total = keys.length;
+                serialPool.zlog(node, "需要关闭的连接数: " + total);
+
+                // 如果没有连接需要关闭，立即完成
+                if (keys.length === 0) {
+                    serialPool.zlog(node, "没有串口连接需要关闭");
+                    done();
+                    return;
+                }
+                try {
+                    for (var i = 0; i < keys.length; i++) {
+                        serialPool.close(keys[i], function (err) {
+                            total--;
+                            if (total <= 0) {
+                                done();
+                                serialPool.zlog(node, "全部关闭完成");
+                            }
+                        }, node);
+                    }
+                } catch (error) {
+                    done(error);
+                }
+
+            },
+            zlog(node, msg) {
+                // node && node.warn(msg);
+            }
+        }
+    }());
+
+
+}