node-red-contrib-omron-eip 0.2.0

package/nodes/omron-write.html

@@ -0,0 +1,416 @@
+<script type="text/javascript">
+  RED.nodes.registerType('omron-write', {
+    category: 'Omron',
+    color: '#f0a868',
+    defaults: {
+      name:        { value: '' },
+      plc:         { value: '', type: 'omron-plc', required: true },
+      valueSource: { value: 'msg' },
+      variables:   { value: [] },
+      verified:    { value: false },
+      pollMs:      { value: 0, validate: function (v) { return v === '' || v === undefined || !isNaN(Number(v)); } },
+      fireOnDeploy:{ value: false },
+    },
+    inputs: 1,
+    outputs: 2,
+    outputLabels: ['result', 'error'],
+    icon: 'font-awesome/fa-upload',
+    paletteLabel: 'omron write',
+    label: function () {
+      if (this.name) return this.name;
+      const names = (this.variables || []).map(v => v.name).filter(Boolean);
+      if (names.length === 0) return 'omron write';
+      if (names.length <= 2) return 'write: ' + names.join(', ');
+      return 'write: ' + names.length + ' tags';
+    },
+    oneditprepare: function () {
+      const node = this;
+
+      function buildRow(row, data) {
+        data = data || {};
+        $(row).css({ display: 'flex', 'align-items': 'center' });
+        const name = $('<input/>', { type: 'text', class: 'omron-var-name',
+          placeholder: 'variable name' }).css({ flex: 1, 'margin-right': '6px' }).appendTo(row);
+        name.val(data.name || '');
+        if (node._omronTags && node._omronTags.length) {
+          name[0].setAttribute('list', 'omron-tags-datalist');
+        }
+        $('<span/>', { class: 'omron-var-badge' }).css({ width: '18px', 'text-align': 'center' }).appendTo(row);
+        if ($('#node-input-valueSource').val() === 'fixed') {
+          const valWrap = $('<div/>').css({ flex: 1, 'margin-left': '6px' }).appendTo(row);
+          const valInput = $('<input/>', { type: 'text', class: 'omron-var-value' }).appendTo(valWrap);
+          valInput.typedInput({ default: data.valueType || 'num', types: ['num', 'bool', 'str', 'json'] });
+          valInput.typedInput('value', data.value !== undefined ? data.value : '');
+          valInput.typedInput('type', data.valueType || 'num');
+        }
+      }
+
+      function refreshList() {
+        const existing = [];
+        $('#node-input-variable-container').find('.omron-var-name').each(function () {
+          const r = { name: $(this).val() };
+          const vi = $(this).closest('li').find('.omron-var-value');
+          if (vi.length) { r.value = vi.typedInput('value'); r.valueType = vi.typedInput('type'); }
+          existing.push(r);
+        });
+        $('#node-input-variable-container').editableList('empty');
+        const seed = existing.length ? existing : (node.variables || []);
+        seed.forEach(v => $('#node-input-variable-container').editableList('addItem', v));
+      }
+
+      $('#node-input-variable-container').css('min-height', '120px').editableList({
+        addItem: function (row, index, data) { buildRow(row, data); },
+        removable: true, sortable: true,
+      });
+      (this.variables || []).forEach(v => $('#node-input-variable-container').editableList('addItem', v));
+
+      $('#node-input-valueSource').on('change', function () {
+        const isMsg = $(this).val() === 'msg';
+        $('#omron-msg-hint').toggle(isMsg);
+        $('#omron-injson-row').toggle(isMsg);
+        $('#omron-col-header').toggle(!isMsg);
+        refreshList();
+      }).trigger('change');
+
+      // ---- Data type reference table (toggle) ----
+      const TYPEREF_ROWS = [
+        ['number',  'SINT',  'integer', '-128 … 127'],
+        ['number',  'INT',   'integer', '-32,768 … 32,767'],
+        ['number',  'DINT',  'integer', '-2,147,483,648 … 2,147,483,647'],
+        ['number',  'LINT',  'integer (64-bit)', '±9.22e18 — see note on 64-bit'],
+        ['number',  'USINT', 'integer', '0 … 255'],
+        ['number',  'UINT',  'integer', '0 … 65,535'],
+        ['number',  'UDINT', 'integer', '0 … 4,294,967,295'],
+        ['number',  'ULINT', 'integer (64-bit)', '0 … 1.84e19 — see note on 64-bit'],
+        ['number',  'BYTE',  'integer (8-bit bit string)', '0 … 255'],
+        ['number',  'WORD',  'integer (16-bit bit string)', '0 … 65,535'],
+        ['number',  'DWORD', 'integer (32-bit bit string)', '0 … 4,294,967,295'],
+        ['number',  'LWORD', 'integer (64-bit bit string)', '0 … 1.84e19 — see note on 64-bit'],
+        ['number',  'REAL',  'float (single)', '~7 significant digits'],
+        ['number',  'LREAL', 'float (double)', '~15 significant digits'],
+        ['number',  'ENUM',  'integer (enum value)', '0 … 4,294,967,295'],
+        ['boolean', 'BOOL',  'true / false', ''],
+        ['string',  'STRING','text', 'up to 1986 characters (this controller)'],
+        ['json',    'ARRAY of any type', 'a JSON array, e.g. [1,2,3]', 'whole-array write'],
+        ['json',    'STRUCT (UDT)', 'a JSON object, e.g. {"Speed":100}', 'whole-structure write'],
+        ['json',    'UNION', 'a JSON object/array', 'layout is type-specific'],
+        ['number', 'DATE', 'nanoseconds since 1970 (a number)', 'reads back as a date; ms precision OK'],
+        ['number', 'DATE_AND_TIME', 'nanoseconds since 1970 (a number)', 'reads back as a date; ms precision OK'],
+        ['number', 'TIME', 'nanoseconds (a number)', 'duration; ms precision OK, see note'],
+        ['number', 'TIME_OF_DAY', 'nanoseconds (a number)', 'ms precision OK, see note'],
+      ];
+
+      function buildTypeRef() {
+        let html = '<table class="omron-typeref-table">';
+        html += '<tr><th>Node-RED type</th><th>Sysmac / Omron type</th><th>How to enter the value</th><th>Range / notes</th></tr>';
+        TYPEREF_ROWS.forEach(r => {
+          html += '<tr><td><code>' + r[0] + '</code></td><td><b>' + r[1] + '</b></td><td>' + r[2] + '</td><td>' + r[3] + '</td></tr>';
+        });
+        html += '</table>';
+        html += '<div class="omron-typeref-note">' +
+          '<b>How it works:</b> the value-type dropdown (number / boolean / string / JSON) is a ' +
+          '<i>Node-RED</i> type — it is not the PLC type. The library knows each tag\u2019s real ' +
+          'Omron type and encodes your value automatically. For every numeric Omron type, choose ' +
+          '<code>number</code>; for BOOL choose <code>boolean</code>; for STRING choose ' +
+          '<code>string</code>; for arrays and structures choose <code>JSON</code>.<br><br>' +
+          '<b>64-bit note (LINT / ULINT / LWORD):</b> these exceed JavaScript\u2019s safe integer ' +
+          'limit (about 9.0e15). Values within the safe range work as plain numbers; for values ' +
+          'beyond it, precision can be lost when entering them as a JS number — handle very large ' +
+          '64-bit values with care.<br><br>' +
+          '<b>Date &amp; time types (DATE, DATE_AND_TIME, TIME, TIME_OF_DAY):</b> send a ' +
+          '<code>number</code> of <i>nanoseconds</i>. DATE / DATE_AND_TIME use nanoseconds since ' +
+          '1970-01-01 UTC (epoch&nbsp;ms &times; 1,000,000) and read back as a date; TIME / ' +
+          'TIME_OF_DAY are a nanosecond duration. Verified to <b>millisecond</b> precision. ' +
+          'Because the nanosecond value is a very large (19-digit) integer, sub-millisecond ' +
+          'digits can be lost when sent as a plain number, so values are reliable down to the ' +
+          'millisecond. String input is not accepted for these types — send a number.<br><br>' +
+          '<b>Out-of-range values are rejected</b> with a clear error (e.g. a BYTE only accepts ' +
+          '0\u2013255).</div>';
+        return html;
+      }
+
+      $('#omron-typeref-btn').on('click', function () {
+        const box = $('#omron-typeref');
+        if (box.is(':empty')) box.html(buildTypeRef());
+        box.toggle();
+      });
+
+      // ---- Show input JSON (message mode) ----
+      function exampleValue(name) {
+        const types = node._omronTypes || {};
+        const base = name.split(/[.\[]/)[0];
+        const cat = types[name] || types[base];
+        const isIndexedOrMember = /[.\[]/.test(name);
+        switch (cat) {
+          case 'bool':     return false;
+          case 'float':    return 0.0;
+          case 'number':   return 0;
+          case 'string':   return '';
+          case 'datetime': return '<date/time>';
+          case 'array':    return isIndexedOrMember ? 0 : [];
+          case 'struct':   return isIndexedOrMember ? 0 : {};
+          default:         return '<value>';
+        }
+      }
+
+      function buildInputJson() {
+        const names = [];
+        $('#node-input-variable-container').find('.omron-var-name').each(function () {
+          const n = $(this).val().trim();
+          if (n) names.push(n);
+        });
+        const validated = node._omronTypes && Object.keys(node._omronTypes).length > 0;
+        if (names.length === 0) {
+          return '<div class="omron-typeref-note">Add one or more variables first.</div>';
+        }
+        let html = '';
+        let jsonText;
+        if (names.length === 1) {
+          // Single variable: bare value payload.
+          const v = exampleValue(names[0]);
+          jsonText = JSON.stringify(v, null, 2);
+          html += '<div class="omron-typeref-note">One variable — set <code>msg.payload</code> ' +
+            'to the value directly:</div>';
+          html += '<pre class="omron-json" style="background:#f4f4f4;color:#1a1a1a;border:1px solid #d0d0d0;border-radius:3px;padding:8px 10px;font-family:monospace;font-size:12px;line-height:1.45;white-space:pre;overflow-x:auto;margin:6px 0;">msg.payload = ' + jsonText + '</pre>';
+        } else {
+          // Multiple variables: object keyed by name.
+          const obj = {};
+          names.forEach(n => { obj[n] = exampleValue(n); });
+          jsonText = JSON.stringify(obj, null, 2);
+          html += '<div class="omron-typeref-note">Multiple variables — set ' +
+            '<code>msg.payload</code> to an object keyed by variable name:</div>';
+          html += '<pre class="omron-json" style="background:#f4f4f4;color:#1a1a1a;border:1px solid #d0d0d0;border-radius:3px;padding:8px 10px;font-family:monospace;font-size:12px;line-height:1.45;white-space:pre;overflow-x:auto;margin:6px 0;">' + jsonText + '</pre>';
+        }
+        if (!validated) {
+          html += '<div class="omron-typeref-note"><i class="fa fa-info-circle"></i> ' +
+            'Values shown are generic placeholders. Press <b>Test Connection, Load and ' +
+            'Validate Published Variables</b> to fill in the actual types ' +
+            '(numbers, booleans, strings, arrays, structures).</div>';
+        }
+        html += '<button type="button" class="red-ui-button red-ui-button-small omron-copy-btn">' +
+          '<i class="fa fa-copy"></i> Copy</button>';
+        return html;
+      }
+
+      $('#omron-injson-btn').on('click', function () {
+        const box = $('#omron-injson');
+        box.html(buildInputJson());
+        box.toggle();
+        box.find('.omron-copy-btn').on('click', function () {
+          let txt = box.find('pre.omron-json').first().text();
+          txt = txt.replace(/^msg\.payload = /, '');   // copy just the value/object
+          navigator.clipboard && navigator.clipboard.writeText(txt);
+          $(this).html('<i class="fa fa-check"></i> Copied');
+          setTimeout(() => $(this).html('<i class="fa fa-copy"></i> Copy'), 1500);
+        });
+      });
+
+      $('#omron-validate-btn').on('click', function () {
+        const cfgId = $('#node-input-plc').val();
+        const statusEl = $('#omron-validate-status');
+        if (!cfgId || cfgId === '_ADD_') {
+          statusEl.html('<i class="fa fa-exclamation-triangle"></i> Select & deploy a PLC config first.').css('color', '#b30000');
+          return;
+        }
+        statusEl.html('<i class="fa fa-spinner fa-spin"></i> Connecting…').css('color', '#888');
+        $.getJSON('omron-eip/' + cfgId + '/tags')
+          .done(function (data) {
+            const tags = data.tags || [];
+            statusEl.html('<i class="fa fa-check"></i> ' + tags.length + ' tags loaded').css('color', '#3a7d3a');
+            $('#node-input-variable-container').find('.omron-var-name').each(function () {
+              const base = $(this).val().split(/[.\[]/)[0];
+              const badge = $(this).siblings('.omron-var-badge');
+              if (!base) { badge.text(''); return; }
+              if (tags.indexOf(base) !== -1) badge.html('<i class="fa fa-check" style="color:#3a7d3a;" title="Green check: this tag name was found on the controller — it exists and can be written."></i>');
+              else badge.html('<i class="fa fa-times" style="color:#b30000;" title="Red X: this tag name was NOT found on the controller. Usually a spelling mistake, or the tag has not been shared to the network (in Sysmac Studio its Network Publish must be set to Publish Only)."></i>');
+            });
+            let dl = $('#omron-tags-datalist');
+            if (dl.length === 0) dl = $('<datalist id="omron-tags-datalist"></datalist>').appendTo('body');
+            dl.empty();
+            tags.forEach(t => dl.append($('<option>').attr('value', t)));
+            node._omronTags = tags;
+            node._omronTypes = data.types || {};
+            $('#node-input-variable-container').find('.omron-var-name').each(function () {
+              this.setAttribute('list', 'omron-tags-datalist');
+              this.dispatchEvent(new Event('input', { bubbles: true }));
+            });
+          })
+          .fail(function (xhr) {
+            const e = (xhr.responseJSON && xhr.responseJSON.error) || 'connection failed';
+            statusEl.html('<i class="fa fa-times"></i> ' + e).css('color', '#b30000');
+          });
+      });
+    },
+    oneditsave: function () {
+      const isFixed = $('#node-input-valueSource').val() === 'fixed';
+      const vars = [];
+      $('#node-input-variable-container').find('.omron-var-name').each(function () {
+        const name = $(this).val().trim();
+        if (!name) return;
+        if (isFixed) {
+          const vi = $(this).closest('li').find('.omron-var-value');
+          vars.push({ name, value: vi.typedInput('value'), valueType: vi.typedInput('type') });
+        } else {
+          vars.push({ name });
+        }
+      });
+      this.variables = vars;
+    },
+  });
+</script>
+
+<script type="text/html" data-template-name="omron-write">
+  <div class="omron-banner">
+    <i class="fa fa-info-circle"></i>
+    <b>Deploy after editing.</b> Writes run against the deployed flow. After adding/changing the
+    PLC config or variables, click <b>Deploy</b> before testing or using <b>Connect &amp; validate</b>.
+  </div>
+
+  <div class="omron-section-title">Connection</div>
+  <div class="form-row">
+    <label for="node-input-name">
+      <i class="fa fa-tag"></i> Name
+      <i class="fa fa-info-circle omron-info" title="A nickname for this write block, shown under its icon on the workspace (the editing canvas). It is purely cosmetic and only helps you tell blocks apart when you have several. Leave it blank and the block will simply label itself with the tag names it writes."></i>
+    </label>
+    <input type="text" id="node-input-name" placeholder="(optional label)">
+  </div>
+  <div class="form-row">
+    <label for="node-input-plc">
+      <i class="fa fa-server"></i> PLC
+      <i class="fa fa-info-circle omron-info" title="Which controller (PLC) this block writes to. A 'PLC connection' is a saved entry that holds the controller's network address; you set it up once and then every read and write block can share it, so you do not re-enter the address each time. Use the dropdown to pick one you already made, the pencil button to edit it, or the plus button to create a new one. This must be filled in — without a PLC chosen, the block cannot write anything."></i>
+    </label>
+    <input type="text" id="node-input-plc">
+  </div>
+
+  <div class="omron-section-title">Values</div>
+  <div class="form-row">
+    <label for="node-input-valueSource">
+      <i class="fa fa-pencil"></i> Source
+      <i class="fa fa-info-circle omron-info" title="Where the value to write comes from. FROM INCOMING MESSAGE: the value is supplied by whatever message arrives at this block — for example a slider on a screen, or an earlier block, sends the number to write. In this mode the rows below list only the tag names (no value box), because the value rides in on the message. FIXED VALUE(S) SET HERE: you type the exact value into this block, and it writes that same value every time it is triggered; the triggering message is only a 'go' signal and its contents are ignored. Rule of thumb: choose FIXED when the value never changes (testing, or forcing a constant), and FROM INCOMING MESSAGE when the value comes from somewhere else and changes."></i>
+    </label>
+    <select id="node-input-valueSource" style="width:68%;">
+      <option value="msg">From incoming message</option>
+      <option value="fixed">Fixed value(s) set here</option>
+    </select>
+  </div>
+  <div class="form-row" id="omron-msg-hint">
+    <label>&nbsp;</label>
+    <small class="form-tips" style="display:inline-block; width:68%; margin:0;">
+      One variable: send the value as <code>msg.payload</code>. Multiple: send
+      <code>msg.payload = { "VarName": value, ... }</code>. Whole array/struct: send an
+      array/object as that variable's value.
+    </small>
+  </div>
+  <div class="form-row">
+    <label>&nbsp;</label>
+    <button type="button" class="red-ui-button red-ui-button-small" id="omron-typeref-btn"
+      title="Click to open a reference table. For every Omron tag type (DINT, INT, REAL, BOOL, STRING, and so on — these are the data types you set in Sysmac Studio) it shows what kind of value to enter here and the range of values it allows. Useful when you are not sure what to type for a particular tag. This just opens a help table; it changes nothing.">
+      <i class="fa fa-table"></i> Data type reference
+    </button>
+    <i class="fa fa-info-circle omron-info" title="Important: the value-type dropdown (number / true-false / text / JSON) describes the kind of value YOU are typing here — it is not the PLC tag type. You do not need to match it to the exact Omron type; the system automatically converts your value to whatever the tag actually is. This table simply shows which choice to use for each Omron type."></i>
+    <div id="omron-typeref" style="display:none; margin-top:8px;"></div>
+  </div>
+
+  <div class="omron-section-title">Variables</div>
+  <div class="form-row" id="omron-col-header" style="display:none;">
+    <label>&nbsp;</label>
+    <div style="display:inline-block; width:68%; font-size:11px; color:#999;">
+      <span style="display:inline-block; width:48%;">variable name</span>
+      <span style="display:inline-block;">value to write</span>
+    </div>
+  </div>
+  <div class="form-row">
+    <label style="vertical-align:top;">
+      <i class="fa fa-list"></i> Variables
+      <i class="fa fa-info-circle omron-info" title="The tags you want to write — one per row. A tag (also called a variable) is a named piece of data inside the controller. Type the name exactly as it is spelled in your Sysmac Studio program (names are case-sensitive). Examples: Setpoint (a single value); MyArray[3] (item number 3 of a list — the number in brackets picks which item); MyArray (a whole list at once); MyStruct.Speed (one named field inside a group — the dot picks the field); MyStruct (a whole group at once). In FIXED mode each row also gets a box to type the value to write. Safety tip: writing a single field (MyStruct.Speed) is safer than writing a whole group at once, because writing the whole group replaces every field in it — including ones you did not mean to change. Tip: click Test Connection below for name suggestions as you type."></i>
+    </label>
+    <div style="display:inline-block; width:68%;">
+      <ol id="node-input-variable-container"></ol>
+      <div style="margin-top:6px;">
+        <button type="button" class="red-ui-button red-ui-button-small" id="omron-validate-btn"
+          title="Click to connect to the controller and pull in the full list of available tags. This turns on name suggestions as you type, and marks each tag you have entered with a green check if it exists on the controller or a red X if the name was not found. You must click Deploy first, because this talks to the live controller.">
+          <i class="fa fa-refresh"></i> Test Connection, Load and Validate Published Variables
+        </button>
+        <i class="fa fa-info-circle omron-info" title="What this button does: it connects to your controller and downloads the names of all tags that have been made available to the network (in Sysmac Studio, tags with Network Publish set to Publish Only or Input/Output). Those names then appear as you-type suggestions in the tag boxes, and each tag you have entered gets checked — a green check means it exists on the controller, a red X means the name was not found (usually a typo or a tag that is not published). Note: you must Deploy first, because the check happens against the live, running controller — not the editor."></i>
+        <span id="omron-validate-status" style="margin-left:8px; font-size:12px; color:#888;"></span>
+      </div>
+    </div>
+  </div>
+
+  <div class="form-row" id="omron-injson-row">
+    <label>&nbsp;</label>
+    <button type="button" class="red-ui-button red-ui-button-small" id="omron-injson-btn"
+      title="Click to see a preview of the message you need to send this node to write your tags, based on the tags you have added. Handy for setting up the inject or other node that feeds this one.">
+      <i class="fa fa-sign-in"></i> Show input JSON
+    </button>
+    <i class="fa fa-info-circle omron-info" title="Shows an example of the message to send this node so it knows what value to write (used when Source is From incoming message). If you first click the Test Connection button, the example fills in with the real kinds of values; otherwise it shows generic placeholders. The Copy button copies the example so you can paste it into an inject node."></i>
+    <div id="omron-injson" style="display:none; margin-top:8px;"></div>
+  </div>
+
+  <div class="omron-section-title">Options</div>
+  <div class="form-row">
+    <label>&nbsp;</label>
+    <label style="width:auto;">
+      <input type="checkbox" id="node-input-verified" style="width:auto; vertical-align:middle;">
+      Verified write
+      <i class="fa fa-info-circle omron-info" title="What it does: right after writing, this block reads the value back from the controller and checks it really matches what you sent — and reports an error if it does not. Why bother? Even a normal write already gets an 'accepted' or 'error' reply, which is enough almost every time. Verified write adds protection for the rarer case where the controller says 'accepted' but the stored value still is not what you wanted — for example the controller's own program limits it (you send 5000 but it caps at 4000), or another device changes that tag a split second later. Turn it on for important values like setpoints or recipe parameters where you want proof the value truly landed. Trade-off: one extra read per tag, so a little slower — leave it off for ordinary or very frequent writes. One limit: it only checks the instant right after writing, so a later change cannot be detected."></i>
+    </label>
+  </div>
+
+  <div class="omron-section-title">Trigger</div>
+  <div class="form-row">
+    <label for="node-input-pollMs">
+      <i class="fa fa-clock-o"></i> Repeat
+      <i class="fa fa-info-circle omron-info" title="Makes this block write by itself, repeatedly, on a timer — so you do not need anything wired into its input. Enter how often to write, in milliseconds: 1000 means once every second, 500 means twice a second. Combined with FIXED values, this can continuously hold a tag at a set value — for example a 'heartbeat' signal or keeping an enable switch on. Leave at 0 to write ONLY when something triggers it. Use this on purpose and sparingly: most writes should happen in response to an event (a button, a change), not constantly on a timer."></i>
+    </label>
+    <input type="text" id="node-input-pollMs" style="width:120px;" placeholder="0">
+    <span style="margin-left:6px;">ms (0 = trigger-driven only)</span>
+  </div>
+  <div class="form-row">
+    <label>&nbsp;</label>
+    <label style="width:auto;">
+      <input type="checkbox" id="node-input-fireOnDeploy" style="width:auto; vertical-align:middle;">
+      Write once shortly after deploy
+      <i class="fa fa-info-circle omron-info" title="When ticked, this block writes one time on its own, about 1.5 seconds after you click the Deploy button (or after Node-RED restarts). With FIXED values, it is a simple way to put a tag into a known starting state as soon as everything starts up, without needing anything wired into the input. Leave it unticked if you do not want an automatic write at startup. ('Deploy' is the button that saves and starts your flow running.)"></i>
+    </label>
+  </div>
+</script>
+
+<script type="text/html" data-help-name="omron-write">
+  <p>Writes one or more variables (tags) to an Omron NX/NJ controller over EtherNet/IP.</p>
+
+  <h3>Value source</h3>
+  <p><b>From incoming message:</b> values come from the message payload (see Input).<br>
+  <b>Fixed value(s) set here:</b> names <i>and</i> values are configured in the node; the
+  message only triggers the write. Good for testing/commissioning and forcing constants.</p>
+
+  <h3>Triggering</h3>
+  <p>A write fires when a message arrives. <b>Repeat</b> fires on a timer; <b>Write once after
+  deploy</b> fires once at startup. With a fixed value plus a timer/after-deploy trigger, the
+  node can write with nothing upstream.</p>
+
+  <h3>Variables &amp; nested data</h3>
+  <ul>
+    <li><code>Setpoint</code> — scalar</li>
+    <li><code>MyArray</code> (value = array) · <code>MyArray[3]</code> (value = element)</li>
+    <li><code>MyStruct</code> (value = object) · <code>MyStruct.Speed</code> (value = scalar)</li>
+    <li><code>MyStruct.History[2]</code>, <code>Machine.Axes[2].Position</code>, …</li>
+  </ul>
+  <p>Writing a whole array or structure in one row is the fastest way to push a lot of data.
+  Writing a single member is safer than read-modify-write of a whole structure.</p>
+
+  <h3>Input (From incoming message)</h3>
+  <dl class="message-properties">
+    <dt>payload <span class="property-type">object | any</span></dt>
+    <dd>
+      One variable — bare value: <pre>msg.payload = 1500</pre>
+      Multiple — object keyed by name: <pre>msg.payload = { "Setpoint": 1500, "Mode": 3 }</pre>
+      Whole structure/array as a value: <pre>msg.payload = { "Recipe": { "Speed": 100, "Steps": [1,2,3] } }</pre>
+    </dd>
+  </dl>
+
+  <h3>Outputs</h3>
+  <p><b>Port 1 (result):</b> message passes through with <code>msg.payload</code> = the map written.</p>
+  <p><b>Port 2 (error):</b> on failure; <code>msg.error</code> names the variable and reason,
+  <code>msg.errors</code> has per-variable detail. Also reaches Catch nodes.</p>
+</script>

package/nodes/omron-write.js

@@ -0,0 +1,163 @@
+'use strict';
+/**
+ * omron-write — writes one or more Omron tags.
+ *
+ * Value source (node-level switch):
+ *   - 'fixed': variable names AND values are configured in the node. The incoming message
+ *     is only a trigger; its payload is ignored. Good for testing/commissioning and for
+ *     setting a tag to a known constant.
+ *   - 'msg': values come from the incoming message payload.
+ *       single configured variable  -> msg.payload is the bare value
+ *       multiple configured variables-> msg.payload = { VarName: value, ... }
+ *
+ * Triggers: incoming message always fires a write. Optionally also self-fires on a timer
+ * and/or once shortly after deploy (useful for 'fixed' writes with nothing upstream).
+ *
+ * Output: two ports. Port 1 = success (passes the message through, payload = the map
+ * written), port 2 = error.
+ */
+const { buildWriteMap, coerceTypedValue, describeError } = require('./common');
+
+module.exports = function (RED) {
+  function OmronWriteNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+
+    node.plcConfig = RED.nodes.getNode(config.plc);
+    node.valueSource = config.valueSource || 'msg';        // 'msg' | 'fixed'
+    node.verified = !!config.verified;
+    node.pollMs = Number(config.pollMs) > 0 ? Number(config.pollMs) : 0;
+    node.fireOnDeploy = !!config.fireOnDeploy;
+
+    // Configured variable rows. Shape depends on value source:
+    //   fixed: [{ name, valueType, value }]
+    //   msg:   [{ name }]
+    node.rows = Array.isArray(config.variables) ? config.variables : [];
+    node.configuredNames = node.rows.map(r => r.name).filter(Boolean);
+
+    let pollTimer = null;
+    let deployTimer = null;
+
+    if (!node.plcConfig) {
+      node.status({ fill: 'red', shape: 'ring', text: 'no PLC config' });
+      return;
+    }
+
+    function idleStatus() {
+      if (node.plcConfig.connected) node.status({ fill: 'green', shape: 'dot', text: 'connected' });
+      else node.status({ fill: 'yellow', shape: 'ring', text: 'connecting…' });
+    }
+    node.plcConfig.on('plc-state', idleStatus);
+    idleStatus();
+
+    // Resolve the {name: value} map to write for this trigger.
+    function resolveWriteMap(msg) {
+      if (node.valueSource === 'fixed') {
+        const fixedPairs = node.rows
+          .filter(r => r.name)
+          .map(r => {
+            // For msg/flow/global typed values, resolve against the (trigger) message context.
+            let raw = r.value;
+            if (r.valueType === 'msg' || r.valueType === 'flow' || r.valueType === 'global') {
+              raw = RED.util.evaluateNodeProperty(r.value, r.valueType, node, msg || {});
+              return { name: r.name, value: raw };
+            }
+            return { name: r.name, value: coerceTypedValue(r.value, r.valueType) };
+          });
+        return buildWriteMap({ source: 'fixed', fixedPairs });
+      }
+      // 'msg'
+      const payload = msg ? msg.payload : undefined;
+      return buildWriteMap({ source: 'msg', configuredNames: node.configuredNames, payload });
+    }
+
+    async function doWrite(msg, send, done) {
+      const controller = node.plcConfig.getController();
+      let map;
+      try {
+        map = resolveWriteMap(msg);
+      } catch (err) {
+        finishError(err, null, msg, send, done);
+        return;
+      }
+
+      const names = Object.keys(map);
+      node.status({ fill: 'blue', shape: 'dot', text: `writing ${names.length}…` });
+      try {
+        await node.plcConfig.whenReady();
+        // Write each tag. verifiedWriteVariable writes then reads back to confirm.
+        const errors = {};
+        let anyErr = false;
+        for (const name of names) {
+          try {
+            if (node.verified) await controller.verifiedWriteVariable(name, map[name]);
+            else await controller.writeVariable(name, map[name]);
+          } catch (err) {
+            anyErr = true;
+            errors[name] = describeError(err, name);
+          }
+        }
+
+        if (anyErr) {
+          const out = msg ? RED.util.cloneMessage(msg) : {};
+          // Build a specific message: name each failed variable and why.
+          const failedNames = Object.keys(errors);
+          const detail = failedNames.map(n => `${n}: ${errors[n]}`).join('; ');
+          const summary = failedNames.length === 1
+            ? `Write failed — ${detail}`
+            : `Write failed for ${failedNames.length} of ${names.length} variables — ${detail}`;
+          out.error = summary;
+          out.errors = errors;
+          out.payload = map;
+          // Status badge: name the variable when only one failed, else a count.
+          const badge = failedNames.length === 1
+            ? `write failed: ${failedNames[0]}`.slice(0, 32)
+            : `write failed: ${failedNames.length}/${names.length}`;
+          node.status({ fill: 'red', shape: 'dot', text: badge });
+          send([null, out]);
+          if (done) done(new Error(summary));
+          else node.error(summary, out);
+          return;
+        }
+
+        const out = msg ? RED.util.cloneMessage(msg) : {};
+        out.payload = map;     // echo what was written
+        node.status({ fill: 'green', shape: 'dot', text: `wrote ${names.length} ok` });
+        send([out, null]);
+        if (done) done();
+      } catch (err) {
+        finishError(err, names[0], msg, send, done);
+      }
+    }
+
+    function finishError(err, varName, msg, send, done) {
+      const text = describeError(err, varName);
+      node.status({ fill: 'red', shape: 'dot', text: text.slice(0, 32) });
+      const errMsg = msg ? RED.util.cloneMessage(msg) : {};
+      errMsg.error = text;
+      send([null, errMsg]);
+      if (done) done(err);
+      else node.error(text, errMsg);
+    }
+
+    node.on('input', function (msg, send, done) {
+      send = send || function (...a) { node.send(...a); };
+      doWrite(msg, send, done);
+    });
+
+    if (node.pollMs > 0) {
+      pollTimer = setInterval(() => doWrite(null, (arr) => node.send(arr), null), node.pollMs);
+    }
+    if (node.fireOnDeploy) {
+      deployTimer = setTimeout(() => doWrite(null, (arr) => node.send(arr), null), 1500);
+    }
+
+    node.on('close', function () {
+      if (pollTimer) clearInterval(pollTimer);
+      if (deployTimer) clearTimeout(deployTimer);
+      node.plcConfig.removeListener('plc-state', idleStatus);
+    });
+  }
+
+  RED.nodes.registerType('omron-write', OmronWriteNode);
+};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "node-red-contrib-omron-eip",
+  "version": "0.2.0",
+  "description": "Node-RED nodes for reading and writing Omron NX/NJ Sysmac controller tags over EtherNet/IP, built on the omron-eip library.",
+  "keywords": [
+    "node-red",
+    "omron",
+    "ethernet-ip",
+    "ethernet/ip",
+    "cip",
+    "plc",
+    "nx102",
+    "nx1p2",
+    "nx502",
+    "nj101",
+    "sysmac",
+    "automation"
+  ],
+  "license": "GPL-2.0",
+  "author": "ucsballen",
+  "homepage": "https://github.com/ucsballen/omron-eip#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ucsballen/omron-eip.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ucsballen/omron-eip/issues"
+  },
+  "node-red": {
+    "version": ">=3.0.0",
+    "nodes": {
+      "omron-plc": "nodes/omron-plc.js",
+      "omron-read": "nodes/omron-read.js",
+      "omron-write": "nodes/omron-write.js"
+    }
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "dependencies": {
+    "omron-eip": "^0.2.6"
+  },
+  "files": [
+    "nodes/",
+    "README.md",
+    "MANUAL.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node test/parse.test.js"
+  }
+}