@fa_yoshinobu/node-red-contrib-plc-comm-slmp 0.2.1

package/lib/slmp/index.js

@@ -0,0 +1,10 @@
+"use strict";
+
+module.exports = {
+  ...require("./constants"),
+  ...require("./errors"),
+  ...require("./core"),
+  ...require("./client"),
+  ...require("./high-level"),
+};
+

package/nodes/slmp-connection.html

@@ -0,0 +1,142 @@
+<script type="text/javascript">
+  function slmpValidateIntegerInRange(value, min, max, options) {
+    const text = String(value == null ? "" : value).trim();
+    const base = options && options.base ? options.base : 10;
+    if (!text) {
+      return false;
+    }
+    if (base === 16 && !/^(?:0x)?[0-9a-f]+$/i.test(text)) {
+      return false;
+    }
+    if (base === 10 && !/^\d+$/.test(text)) {
+      return false;
+    }
+    const parsed = Number.parseInt(text, base);
+    return Number.isInteger(parsed) && parsed >= min && parsed <= max;
+  }
+
+  RED.nodes.registerType("slmp-connection", {
+    category: "config",
+    defaults: {
+      name: { value: "" },
+      host: { value: "", required: true },
+      port: {
+        value: 5000,
+        required: true,
+        validate: function (value) {
+          return slmpValidateIntegerInRange(value, 1, 65535);
+        }
+      },
+      transport: { value: "tcp", required: true },
+      timeout: {
+        value: 3000,
+        required: true,
+        validate: function (value) {
+          return slmpValidateIntegerInRange(value, 1, 2147483647);
+        }
+      },
+      plcSeries: { value: "ql", required: true },
+      frameType: { value: "4e", required: true },
+      monitoringTimer: {
+        value: 16,
+        required: true,
+        validate: function (value) {
+          return slmpValidateIntegerInRange(value, 0, 65535);
+        }
+      },
+      network: {
+        value: "0",
+        validate: function (value) {
+          return slmpValidateIntegerInRange(value, 0, 255);
+        }
+      },
+      station: {
+        value: "255",
+        validate: function (value) {
+          return slmpValidateIntegerInRange(value, 0, 255);
+        }
+      },
+      moduleIO: {
+        value: "03FF",
+        validate: function (value) {
+          return slmpValidateIntegerInRange(value, 0, 65535, { base: 16 });
+        }
+      },
+      multidrop: {
+        value: "0",
+        validate: function (value) {
+          return slmpValidateIntegerInRange(value, 0, 255);
+        }
+      }
+    },
+    label: function () {
+      return this.name || this.host + ":" + this.port;
+    }
+  });
+</script>
+
+<script type="text/html" data-template-name="slmp-connection">
+  <div class="form-row">
+    <label for="node-config-input-name"><i class="fa fa-tag"></i> Name</label>
+    <input type="text" id="node-config-input-name" />
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-host"><i class="fa fa-globe"></i> Host</label>
+    <input type="text" id="node-config-input-host" placeholder="192.168.0.10" />
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-port"><i class="fa fa-plug"></i> Port</label>
+    <input type="text" id="node-config-input-port" placeholder="1025" />
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-transport"><i class="fa fa-random"></i> Transport</label>
+    <select id="node-config-input-transport">
+      <option value="tcp">TCP</option>
+      <option value="udp">UDP</option>
+    </select>
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-timeout"><i class="fa fa-clock-o"></i> Timeout ms</label>
+    <input type="text" id="node-config-input-timeout" placeholder="3000" />
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-plcSeries"><i class="fa fa-cog"></i> PLC series</label>
+    <select id="node-config-input-plcSeries">
+      <option value="ql">Q/L compatible</option>
+      <option value="iqr">iQ-R/iQ-L compatible</option>
+    </select>
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-frameType"><i class="fa fa-code"></i> Frame type</label>
+    <select id="node-config-input-frameType">
+      <option value="4e">4E binary</option>
+      <option value="3e">3E binary</option>
+    </select>
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-monitoringTimer"><i class="fa fa-hourglass-half"></i> Monitor timer</label>
+    <input type="text" id="node-config-input-monitoringTimer" placeholder="16" />
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-network"><i class="fa fa-sitemap"></i> Network</label>
+    <input type="text" id="node-config-input-network" placeholder="0" />
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-station"><i class="fa fa-sitemap"></i> Station</label>
+    <input type="text" id="node-config-input-station" placeholder="255" />
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-moduleIO"><i class="fa fa-sitemap"></i> Module I/O</label>
+    <input type="text" id="node-config-input-moduleIO" placeholder="03FF" />
+  </div>
+  <div class="form-row">
+    <label for="node-config-input-multidrop"><i class="fa fa-sitemap"></i> Multidrop</label>
+    <input type="text" id="node-config-input-multidrop" placeholder="0" />
+  </div>
+</script>
+
+<script type="text/html" data-help-name="slmp-connection">
+  <p>Reusable SLMP connection profile for Mitsubishi PLC access over binary 3E or 4E frames.</p>
+  <p>Choose the same frame type and PLC series you would use with <code>plc-comm-slmp-python</code>.</p>
+  <p><code>slmp-read</code> and <code>slmp-write</code> can send <code>connect</code>, <code>disconnect</code>, and <code>reinitialize</code> control messages through this shared connection.</p>
+</script>

package/nodes/slmp-connection.js

@@ -0,0 +1,78 @@
+"use strict";
+
+const { SlmpClient } = require("../lib/slmp");
+
+module.exports = function registerSlmpConnection(RED) {
+  function SlmpConnectionNode(config) {
+    RED.nodes.createNode(this, config);
+
+    this.name = config.name;
+    this.host = config.host;
+    this.port = Number(config.port || 5000);
+    this.transport = config.transport || "tcp";
+    this.timeout = Number(config.timeout || 3000);
+    this.plcSeries = config.plcSeries || "ql";
+    this.frameType = config.frameType || "4e";
+    this.monitoringTimer = Number(config.monitoringTimer || 0x0010);
+    this.target = {
+      network: config.network,
+      station: config.station,
+      moduleIO: config.moduleIO,
+      multidrop: config.multidrop,
+    };
+
+    this.client = new SlmpClient({
+      host: this.host,
+      port: this.port,
+      transport: this.transport,
+      timeout: this.timeout,
+      plcSeries: this.plcSeries,
+      frameType: this.frameType,
+      monitoringTimer: this.monitoringTimer,
+      defaultTarget: this.target,
+    });
+
+    this._setState = (fill, shape, text) => {
+      this.status({ fill, shape, text });
+    };
+    this.getClient = () => this.client;
+    this.getProfile = () => ({
+      host: this.host,
+      port: this.port,
+      transport: this.transport,
+      frameType: this.client.frameType,
+      plcSeries: this.client.plcSeries,
+      target: this.client.defaultTarget,
+    });
+    this.connect = async () => {
+      this._setState("yellow", "ring", "connecting");
+      await this.client.connect();
+      this._setState("green", "dot", "connected");
+    };
+    this.disconnect = async () => {
+      this._setState("yellow", "ring", "disconnecting");
+      await this.client.close();
+      this._setState("red", "ring", "disconnected");
+    };
+    this.reinitialize = async () => {
+      this._setState("yellow", "ring", "reinitializing");
+      await this.client.close();
+      await this.client.connect();
+      this._setState("green", "dot", "connected");
+    };
+
+    this._setState("grey", "ring", "ready");
+
+    this.on("close", (_removed, done) => {
+      this.client
+        .close()
+        .catch(() => undefined)
+        .finally(() => {
+          this._setState("grey", "ring", "closed");
+          done();
+        });
+    });
+  }
+
+  RED.nodes.registerType("slmp-connection", SlmpConnectionNode);
+};

package/nodes/slmp-read.html

@@ -0,0 +1,274 @@
+<script type="text/javascript">
+  const SLMP_ADDRESS_TOKEN_RE = /[A-Z][A-Z0-9]*(?:\.[0-9A-F]+|:[A-Z]+)?(?:,\d+)?/iy;
+
+  function slmpGetCurrentType(typeSelector, fallback) {
+    const field = $(typeSelector);
+    if (field.length > 0 && field.val()) {
+      return field.val();
+    }
+    return fallback || "str";
+  }
+
+  function slmpValidateReferencePath(value, allowEmpty) {
+    const text = String(value == null ? "" : value).trim();
+    return allowEmpty ? true : Boolean(text);
+  }
+
+  function slmpTokenizeAddressList(text) {
+    const result = [];
+    let index = 0;
+    const source = String(text || "");
+
+    while (index < source.length) {
+      while (index < source.length && /[\s,;]+/.test(source[index])) {
+        index += 1;
+      }
+      if (index >= source.length) {
+        break;
+      }
+      SLMP_ADDRESS_TOKEN_RE.lastIndex = index;
+      const match = SLMP_ADDRESS_TOKEN_RE.exec(source);
+      if (!match || match.index !== index) {
+        return null;
+      }
+      result.push(match[0].trim());
+      index = SLMP_ADDRESS_TOKEN_RE.lastIndex;
+    }
+
+    return result;
+  }
+
+  function slmpValidateAddressLiteral(value) {
+    const text = String(value == null ? "" : value).trim();
+    if (!text) {
+      return true;
+    }
+    return Array.isArray(slmpTokenizeAddressList(text));
+  }
+
+  function slmpValidateIntegerString(value, min, max, base) {
+    const text = String(value == null ? "" : value).trim();
+    if (base === 16 && !/^(?:0x)?[0-9a-f]+$/i.test(text)) {
+      return false;
+    }
+    if (base !== 16 && !/^\d+$/.test(text)) {
+      return false;
+    }
+    const parsed = Number.parseInt(text, base || 10);
+    return Number.isInteger(parsed) && parsed >= min && parsed <= max;
+  }
+
+  function slmpValidateTargetLiteral(value) {
+    const text = String(value == null ? "" : value).trim();
+    if (!text) {
+      return true;
+    }
+    try {
+      const parsed = JSON.parse(text);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return false;
+      }
+      const keys = Object.keys(parsed);
+      if (keys.length === 0) {
+        return true;
+      }
+      const allowed = new Set(["network", "station", "moduleIO", "module_io", "multidrop"]);
+      for (const key of keys) {
+        if (!allowed.has(key)) {
+          return false;
+        }
+      }
+      if (parsed.network !== undefined && !slmpValidateIntegerString(parsed.network, 0, 255)) {
+        return false;
+      }
+      if (parsed.station !== undefined && !slmpValidateIntegerString(parsed.station, 0, 255)) {
+        return false;
+      }
+      const moduleIO = parsed.moduleIO !== undefined ? parsed.moduleIO : parsed.module_io;
+      if (moduleIO !== undefined && !slmpValidateIntegerString(moduleIO, 0, 65535, 16)) {
+        return false;
+      }
+      if (parsed.multidrop !== undefined && !slmpValidateIntegerString(parsed.multidrop, 0, 255)) {
+        return false;
+      }
+      return true;
+    } catch (_error) {
+      return false;
+    }
+  }
+
+  function slmpValidateSourceField(value, typeSelector, literalValidator, fallbackType) {
+    const type = slmpGetCurrentType(typeSelector, fallbackType);
+    if (!type || type === "str") {
+      return literalValidator(value);
+    }
+    return slmpValidateReferencePath(value, false);
+  }
+
+  function setupSlmpSourceField(sourceId, typeId, literalId, hiddenId) {
+    const sourceField = $(sourceId);
+    const typeField = $(typeId);
+    const literalField = $(literalId);
+    const literalRow = literalField.closest(".form-row");
+
+    sourceField.typedInput({
+      default: "str",
+      typeField: typeField,
+      types: ["msg", "flow", "global", "env", "str"]
+    });
+
+    const refresh = function () {
+      const type = sourceField.typedInput("type");
+      const isLiteral = type === "str";
+      literalRow.toggle(isLiteral);
+      if (isLiteral) {
+        sourceField.typedInput("value", literalField.val());
+      }
+      $(hiddenId).val(isLiteral ? literalField.val() : sourceField.typedInput("value"));
+    };
+
+    sourceField.on("change", refresh);
+    literalField.on("change keyup", refresh);
+    refresh();
+    return refresh;
+  }
+
+  RED.nodes.registerType("slmp-read", {
+    category: "SLMP",
+    color: "#D9EAD3",
+    defaults: {
+      name: { value: "" },
+      connection: { value: "", type: "slmp-connection", required: true },
+      addresses: {
+        value: "",
+        validate: function (value) {
+          return slmpValidateSourceField(value, "#node-input-addressesType", slmpValidateAddressLiteral, this && this.addressesType);
+        }
+      },
+      addressesType: { value: "str", required: true },
+      routeTarget: {
+        value: "",
+        validate: function (value) {
+          return slmpValidateSourceField(value, "#node-input-routeTargetType", slmpValidateTargetLiteral, this && this.routeTargetType);
+        }
+      },
+      routeTargetType: { value: "str", required: true },
+      outputMode: { value: "object", required: true },
+      metadataMode: { value: "full", required: true },
+      errorHandling: { value: "throw", required: true },
+      outputs: { value: 1 }
+    },
+    inputs: 1,
+    outputs: 1,
+    icon: "font-awesome/fa-download",
+    label: function () {
+      return this.name || "slmp read";
+    },
+    oneditprepare: function () {
+      const sourceField = $("#node-input-addressesSource");
+      const literalField = $("#node-input-addressesLiteral");
+      literalField.val(this.addresses || "");
+      sourceField.val(this.addresses || "");
+      $("#node-input-addressesType").val(this.addressesType || "str");
+      const refreshAddresses = setupSlmpSourceField(
+        "#node-input-addressesSource",
+        "#node-input-addressesType",
+        "#node-input-addressesLiteral",
+        "#node-input-addresses"
+      );
+      const routeField = $("#node-input-routeTargetSource");
+      const routeLiteral = $("#node-input-routeTargetLiteral");
+      routeLiteral.val(this.routeTarget || "");
+      routeField.val(this.routeTarget || "");
+      $("#node-input-routeTargetType").val(this.routeTargetType || "str");
+      const refreshRoute = setupSlmpSourceField(
+        "#node-input-routeTargetSource",
+        "#node-input-routeTargetType",
+        "#node-input-routeTargetLiteral",
+        "#node-input-routeTarget"
+      );
+      refreshAddresses();
+      refreshRoute();
+    },
+    oneditsave: function () {
+      const sourceField = $("#node-input-addressesSource");
+      const type = sourceField.typedInput("type");
+      $("#node-input-addressesType").val(type);
+      $("#node-input-addresses").val(type === "str" ? $("#node-input-addressesLiteral").val() : sourceField.typedInput("value"));
+      const routeField = $("#node-input-routeTargetSource");
+      const routeType = routeField.typedInput("type");
+      $("#node-input-routeTargetType").val(routeType);
+      $("#node-input-routeTarget").val(
+        routeType === "str" ? $("#node-input-routeTargetLiteral").val() : routeField.typedInput("value")
+      );
+      this.outputs = $("#node-input-errorHandling").val() === "output2" ? 2 : 1;
+    }
+  });
+</script>
+
+<script type="text/html" data-template-name="slmp-read">
+  <div class="form-row">
+    <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+    <input type="text" id="node-input-name" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-connection"><i class="fa fa-link"></i> Connection</label>
+    <input type="text" id="node-input-connection" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-addressesSource"><i class="fa fa-sign-in"></i> Source</label>
+    <input type="hidden" id="node-input-addressesType" />
+    <input type="text" id="node-input-addressesSource" style="width: 70%;" />
+    <input type="hidden" id="node-input-addresses" />
+  </div>
+  <div class="form-row" id="node-input-addressesLiteralRow">
+    <label for="node-input-addressesLiteral"><i class="fa fa-list"></i> Addresses</label>
+    <textarea id="node-input-addressesLiteral" style="height: 140px;" placeholder="D100&#10;D100,10&#10;D200:F,4&#10;D100:STR,10"></textarea>
+  </div>
+  <div class="form-row">
+    <label for="node-input-routeTargetSource"><i class="fa fa-sitemap"></i> Route</label>
+    <input type="hidden" id="node-input-routeTargetType" />
+    <input type="text" id="node-input-routeTargetSource" style="width: 70%;" />
+    <input type="hidden" id="node-input-routeTarget" />
+  </div>
+  <div class="form-row" id="node-input-routeTargetLiteralRow">
+    <label for="node-input-routeTargetLiteral"><i class="fa fa-code"></i> Route JSON</label>
+    <textarea id="node-input-routeTargetLiteral" style="height: 90px;" placeholder="{&quot;network&quot;:0,&quot;station&quot;:255,&quot;moduleIO&quot;:&quot;03FF&quot;,&quot;multidrop&quot;:0}"></textarea>
+  </div>
+  <div class="form-row">
+    <label for="node-input-outputMode"><i class="fa fa-sign-out"></i> Output</label>
+    <select id="node-input-outputMode">
+      <option value="object">Object payload</option>
+      <option value="array">Array in address order</option>
+      <option value="value">Single value when one address</option>
+    </select>
+  </div>
+  <div class="form-row">
+    <label for="node-input-metadataMode"><i class="fa fa-database"></i> Metadata</label>
+    <select id="node-input-metadataMode">
+      <option value="full">Full msg.slmp</option>
+      <option value="minimal">Minimal msg.slmp</option>
+      <option value="off">Do not modify msg.slmp</option>
+    </select>
+  </div>
+  <div class="form-row">
+    <label for="node-input-errorHandling"><i class="fa fa-exclamation"></i> Errors</label>
+    <select id="node-input-errorHandling">
+      <option value="throw">Throw</option>
+      <option value="msg">msg.error</option>
+      <option value="output2">Second output</option>
+    </select>
+  </div>
+</script>
+
+<script type="text/html" data-help-name="slmp-read">
+  <p>Reads one or more SLMP addresses and writes the result to <code>msg.payload</code>.</p>
+  <p>Supported forms include <code>D100</code>, <code>D100,10</code>, <code>D200:F</code>, <code>D200:F,4</code>, <code>D50.3</code>, <code>M1000</code>, <code>M1000,8</code>, <code>D100:STR,10</code>, and <code>DSTR100,10</code>.</p>
+  <p><code>,count</code> returns arrays for numeric and direct-bit reads. String reads use UTF-8 bytes packed two per word.</p>
+  <p>Output can be an object keyed by address, an array in address order, or a single scalar when exactly one address is requested.</p>
+  <p>Metadata can emit full <code>msg.slmp</code>, a minimal object with only the effective target and item count, or leave <code>msg.slmp</code> unchanged.</p>
+  <p>The configured source can be literal text, <code>msg</code>, <code>flow</code>, <code>global</code>, or <code>env</code>. At runtime, <code>msg.addresses</code> or a string/array in <code>msg.payload</code> still take priority.</p>
+  <p>Per-request routing can be supplied as <code>msg.target</code>, <code>msg.slmp.target</code>, or a configured route source. Route objects can include <code>network</code>, <code>station</code>, <code>moduleIO</code>, and <code>multidrop</code>.</p>
+  <p>Send <code>msg.connect</code>, <code>msg.disconnect</code>, or <code>msg.reinitialize</code> as <code>true</code>, or send the same words in <code>msg.topic</code>, to control the shared connection.</p>
+  <p>Error handling can throw, attach the error to <code>msg.error</code>, or emit the failed message on the second output.</p>
+</script>