node-red-contrib-v430-barcode 0.2.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nicholas Cifuni
+
+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,78 @@
+# V430 WebSocket Barcode Node
+
+Node-RED node for streaming barcode reads from an Omron V430 over websocket.
+
+## Behavior
+
+- Connects to `websocket` 
+- translates incoming data packets into Json data 
+- outputs data into 2 nodes 
+  - output 1 being just the barcode being read 
+  - output 2 being the metadata found in Json formatting 
+- Starts the websocket client only when `Enabled` is checked.
+
+## Outputs
+
+Output 1 sends the barcode read:
+
+```json
+{
+  "topic": "v430/barcode",
+  "payload": {
+    "barcode": "0041199006794",
+    "symbology": "EAN13",
+    "host": "192.168.250.2",
+    "port": 50502,
+    "path": "/",
+    "cycle_id": "0x000000e6",
+    "read_time_ms": 86,
+    "cycle_time_ms": 485,
+    "received_at": "2026-07-06T14:30:00.000Z"
+  }
+}
+```
+
+Output 2 sends the metadata JSON:
+
+```json
+{
+  "topic": "v430/barcode/metadata",
+  "payload": {
+    "barcode": "0041199006794",
+    "symbology": "EAN13",
+    "cycle_id": "0x000000e6",
+    "read_time_ms": 86,
+    "cycle_time_ms": 485,
+    "received_at": "2026-07-06T14:30:00.000Z",
+    "frame_format": "text",
+    "decoded_type": "string",
+    "source": {
+      "host": "192.168.250.2",
+      "port": 50502,
+      "path": "/",
+      "websocket_url": "ws://192.168.250.2:50502/"
+    },
+    "event": "<cycleReport ... />"
+  }
+}
+```
+
+For compatibility, Output 1 still includes the decoded frame on `msg.raw_event`.
+
+## Files
+
+- `package.json`: Node-RED package manifest
+- `V430_barcode_reader.js`: runtime node implementation
+- `V430_barcode_reader.html`: Node-RED editor UI
+
+## Local Use
+
+1. Run `npm.cmd install` in this folder.
+2. In your Node-RED user directory, run `npm.cmd install <path-to-this-folder>`.
+3. Restart Node-RED.
+4. Add `V430 Barcode` to a flow.
+
+## Notes
+
+- Uncheck `Enabled` in the node editor to keep the node loaded in the flow without opening a websocket connection.
+- If the V430 payload uses different barcode or symbology field names, update `BARCODE_VALUE_KEYS` or `SYMBOLOGY_KEYS` in `V430_barcode_reader.js`.

package/V430_barcode_reader.html

@@ -0,0 +1,67 @@
+<script type="text/javascript">
+  (() => {
+    const nodeType = "v430-websocket-barcode";
+    const nodeDisplayName = "V430 Barcode";
+
+    RED.nodes.registerType(nodeType, {
+      category: "omron",
+      color: "#cfe8ff",
+      defaults: {
+        name: { value: "" },
+        host: { value: "192.168.250.2", required: true },
+        websocketPort: { value: 50502, required: true, validate: RED.validators.number() },
+        websocketPath: { value: "/", required: true },
+        enabled: { value: true },
+        receiveTimeoutMs: { value: 5000, required: true, validate: RED.validators.number() },
+        reconnectDelayMs: { value: 3000, required: true, validate: RED.validators.number() }
+      },
+      inputs: 0,
+      outputs: 2,
+      outputLabels: ["barcode json", "metadata json"],
+      icon: "bridge.svg",
+      paletteLabel: nodeDisplayName,
+      label: function () {
+        return this.name || nodeDisplayName;
+      }
+    });
+  })();
+</script>
+
+<script type="text/html" data-template-name="v430-websocket-barcode">
+  <div class="form-row">
+    <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+    <input type="text" id="node-input-name" placeholder="V430 barcode">
+  </div>
+  <div class="form-row">
+    <label for="node-input-host"><i class="fa fa-globe"></i> Host / IP</label>
+    <input type="text" id="node-input-host" placeholder="192.168.250.2">
+  </div>
+  <div class="form-row">
+    <label for="node-input-websocketPort"><i class="fa fa-plug"></i> Port</label>
+    <input type="text" id="node-input-websocketPort" placeholder="50502">
+  </div>
+  <div class="form-row">
+    <label for="node-input-websocketPath"><i class="fa fa-link"></i> Path</label>
+    <input type="text" id="node-input-websocketPath" placeholder="/">
+  </div>
+  <div class="form-row">
+    <label for="node-input-enabled"><i class="fa fa-power-off"></i> Enabled</label>
+    <input type="checkbox" id="node-input-enabled" style="display:inline-block; width:auto; vertical-align:middle;">
+  </div>
+  <div class="form-row">
+    <label for="node-input-receiveTimeoutMs"><i class="fa fa-clock-o"></i> Timeout ms</label>
+    <input type="text" id="node-input-receiveTimeoutMs">
+  </div>
+  <div class="form-row">
+    <label for="node-input-reconnectDelayMs"><i class="fa fa-refresh"></i> Reconnect ms</label>
+    <input type="text" id="node-input-reconnectDelayMs">
+  </div>
+</script>
+
+<script type="text/html" data-help-name="v430-websocket-barcode">
+  <p>Connects to an Omron V430 websocket endpoint at <code>ws://&lt;host&gt;:&lt;port&gt;&lt;path&gt;</code> and emits decoded barcode data.</p>
+  <p>The default V430 data stream is <code>ws://192.168.250.2:50502/</code>.</p>
+  <p>Disable the node with the <code>Enabled</code> checkbox to prevent websocket handshakes and reconnect attempts.</p>
+  <p>The node accepts both text websocket frames and binary MessagePack websocket frames.</p>
+  <p>Output 1 sends the barcode payload. Output 2 sends the full metadata JSON, including source details and the decoded event.</p>
+</script>

package/V430_barcode_reader.js

@@ -0,0 +1,393 @@
+"use strict";
+
+const { decode } = require("@msgpack/msgpack");
+const WebSocket = require("ws");
+
+const NODE_TYPE = "v430-websocket-barcode";
+const DEFAULTS = {
+  host: "192.168.250.2",
+  websocketPort: 50502,
+  websocketPath: "/",
+  receiveTimeoutMs: 5000,
+  reconnectDelayMs: 3000
+};
+
+const BARCODE_VALUE_KEYS = new Set([
+  "datautf8",
+  "data_utf8",
+  "decodeddata",
+  "decode_data",
+  "decoded_data",
+  "decode",
+  "barcode",
+  "code",
+  "data",
+  "text",
+  "value"
+].map(normalizeKey));
+
+const SYMBOLOGY_KEYS = new Set([
+  "symbology",
+  "symbologyname",
+  "symbol",
+  "type",
+  "decodetype",
+  "codelabel"
+].map(normalizeKey));
+
+module.exports = function (RED) {
+  function V430WebsocketBarcodeNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+
+    node.host = String(config.host || DEFAULTS.host).trim() || DEFAULTS.host;
+    node.websocketPort = Number(config.websocketPort) || DEFAULTS.websocketPort;
+    node.websocketPath = normalizeWebsocketPath(config.websocketPath);
+    node.enabled = config.enabled !== false;
+    node.receiveTimeoutMs = Number(config.receiveTimeoutMs) || DEFAULTS.receiveTimeoutMs;
+    node.reconnectDelayMs = Number(config.reconnectDelayMs) || DEFAULTS.reconnectDelayMs;
+    node.ws = null;
+    node.reconnectTimer = null;
+    node.isClosing = false;
+
+    const wsUrl = `ws://${node.host}:${node.websocketPort}${node.websocketPath}`;
+
+    function setStatus(fill, shape, text) {
+      node.status({ fill, shape, text });
+    }
+
+    function scheduleReconnect(reason) {
+      if (node.isClosing || !node.enabled || node.reconnectTimer) {
+        return;
+      }
+
+      setStatus("yellow", "ring", `reconnecting: ${reason}`);
+      node.reconnectTimer = setTimeout(() => {
+        node.reconnectTimer = null;
+        connect();
+      }, node.reconnectDelayMs);
+    }
+
+    function cleanupSocket() {
+      if (!node.ws) {
+        return;
+      }
+
+      try {
+        node.ws.removeAllListeners();
+        node.ws.terminate();
+      } catch {
+        // Ignore shutdown errors.
+      }
+
+      node.ws = null;
+    }
+
+    function emitRead(frameInfo, barcodeData) {
+      const receivedAt = new Date().toISOString();
+      const source = {
+        host: node.host,
+        port: node.websocketPort,
+        path: node.websocketPath,
+        websocket_url: wsUrl
+      };
+
+      const barcodeMessage = {
+        topic: "v430/barcode",
+        payload: {
+          barcode: barcodeData.barcode,
+          symbology: barcodeData.symbology,
+          host: source.host,
+          port: source.port,
+          path: source.path,
+          cycle_id: barcodeData.cycle_id,
+          read_time_ms: barcodeData.read_time_ms,
+          cycle_time_ms: barcodeData.cycle_time_ms,
+          received_at: receivedAt
+        },
+        raw_event: frameInfo.decoded,
+        websocket_url: wsUrl
+      };
+
+      const metadataMessage = {
+        topic: "v430/barcode/metadata",
+        payload: {
+          barcode: barcodeData.barcode,
+          symbology: barcodeData.symbology,
+          cycle_id: barcodeData.cycle_id,
+          read_time_ms: barcodeData.read_time_ms,
+          cycle_time_ms: barcodeData.cycle_time_ms,
+          received_at: receivedAt,
+          frame_format: frameInfo.frameFormat,
+          decoded_type: frameInfo.decodedType,
+          source,
+          event: frameInfo.decoded
+        }
+      };
+
+      node.send([barcodeMessage, metadataMessage]);
+      setStatus("green", "dot", barcodeData.barcode);
+    }
+
+    function handleFrame(frame, isBinary) {
+      const frameInfo = decodeFrame(frame, isBinary);
+      if (!frameInfo) {
+        return;
+      }
+
+      const barcodeData = extractBarcodeData(frameInfo.decoded);
+      if (!barcodeData) {
+        return;
+      }
+
+      emitRead(frameInfo, barcodeData);
+    }
+
+    function connect() {
+      if (node.isClosing || !node.enabled) {
+        setStatus("grey", "ring", "disabled");
+        return;
+      }
+
+      cleanupSocket();
+      setStatus("yellow", "ring", "connecting");
+
+      const ws = new WebSocket(wsUrl, {
+        handshakeTimeout: node.receiveTimeoutMs
+      });
+      node.ws = ws;
+
+      ws.on("open", () => {
+        setStatus("green", "ring", "connected");
+      });
+
+      ws.on("message", (data, isBinary) => {
+        try {
+          handleFrame(data, isBinary);
+        } catch (error) {
+          node.warn(`Frame handling error: ${error.message}`);
+          setStatus("red", "ring", "frame error");
+        }
+      });
+
+      ws.on("error", (error) => {
+        node.warn(`WebSocket error: ${error.message}`);
+      });
+
+      ws.on("close", (code, reason) => {
+        cleanupSocket();
+        scheduleReconnect(String(reason || code || "closed"));
+      });
+    }
+
+    if (node.enabled) {
+      connect();
+    } else {
+      setStatus("grey", "ring", "disabled");
+    }
+
+    node.on("close", function (removed, done) {
+      node.isClosing = true;
+      if (node.reconnectTimer) {
+        clearTimeout(node.reconnectTimer);
+        node.reconnectTimer = null;
+      }
+      cleanupSocket();
+      setStatus("grey", "ring", removed ? "removed" : "closed");
+      done();
+    });
+  }
+
+  RED.nodes.registerType(NODE_TYPE, V430WebsocketBarcodeNode);
+};
+
+function normalizeWebsocketPath(value) {
+  const trimmed = String(value || "").trim();
+  if (!trimmed) {
+    return DEFAULTS.websocketPath;
+  }
+  return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+
+function decodeFrame(frame, isBinary) {
+  const decoded = isBinary ? decodeBinaryFrame(frame) : parseTextFrame(frame);
+  if (decoded == null) {
+    return null;
+  }
+
+  return {
+    decoded,
+    frameFormat: isBinary ? "msgpack" : "text",
+    decodedType: Array.isArray(decoded) ? "array" : typeof decoded
+  };
+}
+
+function parseTextFrame(frame) {
+  const text = String(frame).trim();
+  if (!text) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+function decodeBinaryFrame(frame) {
+  const binary = frame instanceof Uint8Array ? frame : new Uint8Array(frame);
+  return decode(binary, { useBigInt64: false });
+}
+
+function extractBarcodeData(decoded) {
+  if (typeof decoded === "string") {
+    return extractBarcodeFromString(decoded);
+  }
+
+  if (decoded == null) {
+    return null;
+  }
+
+  const barcode = findFieldValue(decoded, BARCODE_VALUE_KEYS);
+  if (!barcode) {
+    return null;
+  }
+
+  return {
+    barcode,
+    symbology: findFieldValue(decoded, SYMBOLOGY_KEYS),
+    cycle_id: null,
+    read_time_ms: null,
+    cycle_time_ms: null
+  };
+}
+
+function extractBarcodeFromString(text) {
+  const cycleReport = extractCycleReport(text);
+  if (cycleReport) {
+    return cycleReport;
+  }
+
+  const barcode = text.trim();
+  if (!barcode || barcode.startsWith("<")) {
+    return null;
+  }
+
+  return {
+    barcode,
+    symbology: null,
+    cycle_id: null,
+    read_time_ms: null,
+    cycle_time_ms: null
+  };
+}
+
+function extractCycleReport(text) {
+  if (!text.startsWith("<cycleReport")) {
+    return null;
+  }
+
+  const barcode = matchValue(text, /<outData>([\s\S]*?)<\/outData>/i, decodeXmlEntities);
+  if (!barcode) {
+    return null;
+  }
+
+  return {
+    barcode,
+    symbology: null,
+    cycle_id: matchValue(text, /\bcycleId="([^"]+)"/i),
+    read_time_ms: toNumberOrNull(matchValue(text, /\breadTime="([^"]+)"/i)),
+    cycle_time_ms: toNumberOrNull(matchValue(text, /\bcycleTime="([^"]+)"/i))
+  };
+}
+
+function matchValue(text, regex, transform = (value) => value) {
+  const match = text.match(regex);
+  if (!match) {
+    return null;
+  }
+
+  const value = transform(match[1]).trim();
+  return value || null;
+}
+
+function decodeXmlEntities(value) {
+  return String(value || "")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&amp;/g, "&")
+    .replace(/&quot;/g, "\"")
+    .replace(/&apos;/g, "'");
+}
+
+function findFieldValue(rootValue, candidateKeys) {
+  const visited = new Set();
+  const queue = [rootValue];
+
+  while (queue.length > 0) {
+    const value = queue.shift();
+    if (value == null) {
+      continue;
+    }
+
+    if (typeof value === "object") {
+      if (visited.has(value)) {
+        continue;
+      }
+      visited.add(value);
+    }
+
+    if (Array.isArray(value)) {
+      queue.push(...value);
+      continue;
+    }
+
+    if (!isPlainObject(value)) {
+      continue;
+    }
+
+    for (const [key, nestedValue] of Object.entries(value)) {
+      if (candidateKeys.has(normalizeKey(key))) {
+        const candidate = asBarcodeString(nestedValue);
+        if (candidate != null) {
+          return candidate;
+        }
+      }
+      queue.push(nestedValue);
+    }
+  }
+
+  return null;
+}
+
+function normalizeKey(value) {
+  return String(value || "").replace(/[^a-z0-9]+/gi, "").toLowerCase();
+}
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function asBarcodeString(value) {
+  if (value == null) {
+    return null;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed || null;
+  }
+  if (typeof value === "number" || typeof value === "bigint") {
+    return String(value);
+  }
+  return null;
+}
+
+function toNumberOrNull(value) {
+  if (value == null) {
+    return null;
+  }
+
+  const number = Number(value);
+  return Number.isFinite(number) ? number : null;
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "node-red-contrib-v430-barcode",
+  "version": "0.2.6",
+  "description": "Node-RED node for streaming barcode data from an Omron V430 websocket endpoint.",
+  "main": "V430_barcode_reader.js",
+  "author": "Nicholas Cifuni",
+  "license": "MIT",
+  "keywords": [
+    "node-red",
+    "omron",
+    "v430",
+    "barcode",
+    "websocket",
+    "msgpack"
+  ],
+  "files": [
+    "LICENSE",
+    "README.md",
+    "V430_barcode_reader.html",
+    "V430_barcode_reader.js"
+  ],
+  "node-red": {
+    "version": ">=3.0.0",
+    "nodes": {
+      "v430-websocket-barcode": "V430_barcode_reader.js"
+    }
+  },
+  "scripts": {
+    "test": "node --check V430_barcode_reader.js",
+    "prepublishOnly": "npm test"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@msgpack/msgpack": "^3.1.2",
+    "ws": "^8.18.3"
+  }
+}