node-red-contrib-fanuc-focas 0.0.1

package/README.md

@@ -0,0 +1,209 @@
+# node-red-contrib-fanuc-focas
+
+A Node-RED node for collecting telemetry from **FANUC CNC controllers** via the **FOCAS2 TCP protocol**.
+
+Pure Node.js — no Python, no native libraries, no FANUC SDK required. Works on any platform including **Raspberry Pi (aarch64/arm64)**.
+
+---
+
+## Features
+
+- Connects directly to FANUC controllers over Ethernet using the FOCAS2 wire protocol
+- Selectable **Function** — poll only the data you need per node instance
+- Sub-type selector for **Axes Data** (position, servo/spindle load, feedrate)
+- Configurable **Parameter** and **Macro** variable reads by number
+- Sub-second timer resolution (millisecond companion parameters)
+- Correct run-state decoding for Series 16/18/21/0i/30i controllers
+- Series 15/15i support via config selector
+- Status indicator on each node (blue = polling, green = ok, red = error)
+
+---
+
+## Supported Controllers
+
+| Series | Examples |
+|--------|---------|
+| Series 0i-D / 0i-F | 0i-D T (lathe), 0i-D M (mill) |
+| Series 16i / 18i / 21i | 16i-T, 18i-M |
+| Series 30i / 31i / 32i | 30i-B |
+| Series 15 / 15i | (select Series 15 in config) |
+
+Requires the **FOCAS Ethernet option** to be enabled on the controller (option code `A02B-0207-J732` or equivalent). Default TCP port is **8193**.
+
+---
+
+## Installation
+
+### From Node-RED Palette Manager
+
+Search for `fanuc-focas` in **Menu → Manage Palette → Install**.
+
+### From command line
+
+```bash
+cd ~/.node-red
+npm install node-red-contrib-fanuc-focas
+```
+
+---
+
+## Usage
+
+1. Drag a **fanuc focas** node onto your flow (found under the *input* category).
+2. Double-click it and create a new **FANUC Controller** config:
+   - **IP Address** — controller Ethernet IP (e.g. `192.168.0.100`)
+   - **FOCAS Port** — default `8193`
+   - **CNC Series** — `16/18/21/0i/30i` for most modern controllers
+3. Select a **Function** from the dropdown.
+4. Wire an **Inject** node (e.g. repeat every 2 seconds) to trigger polling.
+5. `msg.payload` contains the result for the selected function.
+
+---
+
+## Functions
+
+| Function | Description | `msg.payload` fields |
+|----------|-------------|----------------------|
+| **All Data** | Full combined snapshot | `controller`, `machine_state`, `active_program`, `timers`, `part_count`, `feedrate_spindle`, `active_alarms` |
+| **Status Info** | Machine run state | `mode`, `run_state`, `motion`, `mstb`, `emergency`, `alarm`, `edit` |
+| **System Info** | Controller identity | `cnc_type`, `mt_type`, `series`, `version`, `axes` |
+| **Timers** | Accumulated time counters | `power_on_time`, `auto_operation_time`, `cutting_time`, `cycle_time` |
+| **Axes Data** | Position / load / feed | See sub-types below |
+| **Parameters** | Raw CNC parameters | `{ [param_number]: value, … }` |
+| **Program Number** | Active program | `running_program`, `main_program`, `running_comment`, `main_comment` |
+| **Part Count** | Parts produced | `required_parts`, `lifetime_total` |
+| **Alarm Messages** | Active alarms | Array of `{ type, code, axis, text }` |
+| **Macro** | Custom macro variables | `{ [macro_number]: value, … }` |
+
+### Axes Data sub-types
+
+| Sub-type | Description |
+|----------|-------------|
+| Absolute position | Axis positions in absolute coordinates |
+| Machine position | Axis positions in machine coordinates |
+| Relative position | Axis positions relative to last reset |
+| Distance to go | Remaining distance in current block |
+| Servo load meter | Per-axis servo load (%) |
+| Spindle load meter | Spindle load (%) |
+| Spindle motor speed | Actual spindle RPM |
+| Actual feedrate | Feedrate in mm/min |
+
+### Timer format
+
+Each timer returns both a machine-readable value and a formatted string:
+
+```json
+"cutting_time": {
+  "total_seconds": 53594.237,
+  "formatted": "14h 53m 14.237s"
+}
+```
+
+---
+
+## Example Payload — All Data
+
+```json
+{
+  "controller": {
+    "cnc_type": "0",
+    "mt_type": "T",
+    "series": "D6G3",
+    "version": "29.0",
+    "axes": 32
+  },
+  "machine_state": {
+    "mode": "MEMory",
+    "run_state": "STaRt",
+    "motion": "Moving",
+    "mstb": "Inactive",
+    "emergency": null,
+    "alarm": null,
+    "edit": "Inactive"
+  },
+  "active_program": {
+    "running_program": "O8888",
+    "main_program": "O8888",
+    "running_comment": "DRIVING BAND TURNING",
+    "main_comment": "DRIVING BAND TURNING"
+  },
+  "timers": {
+    "power_on_time":       { "total_seconds": 810844,    "formatted": "225h 14m" },
+    "auto_operation_time": { "total_seconds": 183989.237,"formatted": "51h 06m 29.237s" },
+    "cutting_time":        { "total_seconds": 53594.237, "formatted": "14h 53m 14.237s" },
+    "cycle_time":          { "total_seconds": 47.123,    "formatted": "0h 00m 47.123s" }
+  },
+  "part_count": {
+    "required_parts": 500,
+    "lifetime_total": 488584
+  },
+  "feedrate_spindle": {
+    "actual_feedrate_mm_min": 24000,
+    "actual_spindle_rpm": 101
+  },
+  "active_alarms": [],
+  "timestamp": "2026-05-28T07:35:23.213Z"
+}
+```
+
+---
+
+## Dynamic Override
+
+You can override the configured function at runtime by setting properties on the incoming message:
+
+| Property | Description | Example |
+|----------|-------------|---------|
+| `msg.function` | Override function | `"status_info"` |
+| `msg.subtype` | Override axes sub-type | `"abs_pos"` |
+| `msg.params` | Override parameter/macro numbers | `"6711,6712"` |
+
+---
+
+## run_state Values
+
+| Value | Series 16/18/21/0i/30i | Series 15/15i |
+|-------|------------------------|---------------|
+| `****` | Reset / not in auto | — |
+| `STOP` | Stopped in auto | Stopped |
+| `HOLD` | Feed hold | Feed hold |
+| `STaRt` | Auto running ✓ | Auto running |
+| `MSTR` | Tool retract / MDI exec | M/S/T executing |
+
+> **Note:** Series 16/18/21/0i/30i `run=0` means reset (not running), not STOP. Using the wrong table is a common source of misclassified machine states.
+
+---
+
+## Multiple Machines
+
+Create one **FANUC Controller** config node per machine, each with its own IP address. Wire separate polling chains independently:
+
+```
+[Inject 2s] → [fanuc-focas · Lathe 1] → [OPC UA out]
+[Inject 2s] → [fanuc-focas · Lathe 2] → [OPC UA out]
+```
+
+---
+
+## Requirements
+
+- Node.js ≥ 14.0.0
+- Node-RED ≥ 2.0.0
+- FOCAS Ethernet option enabled on the controller
+- Network access to the controller on its FOCAS port (default 8193)
+
+No additional npm dependencies — uses only Node.js built-ins (`net`, `Buffer`).
+
+---
+
+## Technical Notes
+
+- **FOCAS is strictly sequential.** Each request must complete before the next is sent on the same TCP connection. This node correctly awaits each response before proceeding.
+- **Connection per poll.** A new TCP connection is opened and cleanly closed for each poll cycle, matching the FOCAS session model.
+- The FOCAS wire protocol is reverse-engineered from [`diohpix/pyfanuc`](https://github.com/diohpix/pyfanuc) with several bug fixes applied (valtype-2 unpack, readparam3 fallback guard, statinfo cnctype matching).
+
+---
+
+## License
+
+MIT

package/fanuc-focas.html

@@ -0,0 +1,211 @@
+<!-- ── FANUC Config Node ─────────────────────────────────────────────────── -->
+<script type="text/javascript">
+    RED.nodes.registerType('fanuc-config', {
+        category: 'config',
+        defaults: {
+            name:       { value: '' },
+            host:       { value: '192.168.0.100', required: true },
+            port:       { value: '8193',          required: true },
+            cnc_series: { value: '16',            required: true },
+        },
+        label: function() {
+            return this.name || `${this.host}:${this.port}`;
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="fanuc-config">
+    <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" placeholder="e.g. Lathe 1">
+    </div>
+    <div class="form-row">
+        <label for="node-config-input-host"><i class="fa fa-globe"></i> IP Address</label>
+        <input type="text" id="node-config-input-host" placeholder="192.168.0.100">
+    </div>
+    <div class="form-row">
+        <label for="node-config-input-port"><i class="fa fa-plug"></i> FOCAS Port</label>
+        <input type="text" id="node-config-input-port" placeholder="8193">
+    </div>
+    <div class="form-row">
+        <label for="node-config-input-cnc_series"><i class="fa fa-microchip"></i> CNC Series</label>
+        <select id="node-config-input-cnc_series">
+            <option value="16">Series 16 / 18 / 21 / 0i / 30i  (most machines)</option>
+            <option value="15">Series 15 / 15i</option>
+        </select>
+    </div>
+</script>
+
+
+<!-- ── FANUC Poll Node ───────────────────────────────────────────────────── -->
+<script type="text/javascript">
+
+    // Axes Data sub-types (mirrors the screenshot)
+    const FANUC_AXIS_TYPES = [
+        { group: 'Position', options: [
+            { v: 'abs_pos',    l: 'Absolute position' },
+            { v: 'machine_pos',l: 'Machine position' },
+            { v: 'rel_pos',    l: 'Relative position' },
+            { v: 'dist_to_go', l: 'Distance to go' },
+        ]},
+        { group: 'Servo', options: [
+            { v: 'servo_load', l: 'Servo load meter (percentage)' },
+        ]},
+        { group: 'Spindle', options: [
+            { v: 'spindle_load',  l: 'Spindle load meter (percentage)' },
+            { v: 'spindle_speed', l: 'Spindle motor speed (rpm)' },
+        ]},
+        { group: 'Feed', options: [
+            { v: 'feedrate', l: 'Actual feedrate (mm/min)' },
+        ]},
+    ];
+
+    // Functions that need no extra config
+    const FANUC_SIMPLE_FNS = new Set([
+        'status_info','system_info','timers','program_number',
+        'part_count','alarm_messages','all'
+    ]);
+
+    RED.nodes.registerType('fanuc-focas', {
+        category:    'input',
+        color:       '#f5d128',
+        defaults: {
+            name:    { value: '' },
+            server:  { value: '', type: 'fanuc-config', required: true },
+            fn:      { value: 'all' },
+            subtype: { value: 'feedrate' },
+            params:  { value: '' },
+        },
+        inputs:  1,
+        outputs: 1,
+        icon:    'inject.png',
+        label: function() {
+            const cfg = RED.nodes.node(this.server);
+            const host = cfg ? cfg.label() : '';
+            const fnLabel = {
+                all:            'All Data',
+                status_info:    'Status Info',
+                system_info:    'System Info',
+                timers:         'Timers',
+                axes_data:      'Axes Data',
+                parameters:     'Parameters',
+                program_number: 'Program Number',
+                part_count:     'Part Count',
+                alarm_messages: 'Alarm Messages',
+                macro:          'Macro',
+            }[this.fn] || this.fn;
+            return this.name || (host ? `${host} · ${fnLabel}` : fnLabel);
+        },
+        paletteLabel: 'fanuc focas',
+
+        oneditprepare: function() {
+            const node = this;
+
+            // Build axes sub-type select with optgroups
+            const $axisType = $('#node-input-subtype');
+            $axisType.empty();
+            FANUC_AXIS_TYPES.forEach(group => {
+                const $g = $('<optgroup>').attr('label', group.group);
+                group.options.forEach(o => {
+                    $g.append($('<option>').val(o.v).text(o.l));
+                });
+                $axisType.append($g);
+            });
+
+            function updateVisibility() {
+                const fn = $('#node-input-fn').val();
+                $('#fanuc-row-subtype').toggle(fn === 'axes_data');
+                $('#fanuc-row-params').toggle(fn === 'parameters' || fn === 'macro');
+                // Update params label
+                if (fn === 'macro') {
+                    $('#fanuc-params-label').text('Macro variables');
+                    $('#fanuc-params-hint').text('Comma-separated macro numbers e.g. 3901,3902');
+                } else {
+                    $('#fanuc-params-label').text('Parameter numbers');
+                    $('#fanuc-params-hint').text('Comma-separated param numbers e.g. 6711,6712');
+                }
+            }
+
+            $('#node-input-fn').on('change', updateVisibility);
+
+            // Restore saved values
+            $('#node-input-fn').val(node.fn || 'all');
+            $axisType.val(node.subtype || 'feedrate');
+            $('#node-input-params').val(node.params || '');
+
+            updateVisibility();
+        },
+    });
+</script>
+
+<script type="text/html" data-template-name="fanuc-focas">
+    <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="fanuc-focas">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-server"><i class="fa fa-server"></i> Endpoint</label>
+        <input type="text" id="node-input-server">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-fn"><i class="fa fa-cog"></i> Function</label>
+        <select id="node-input-fn" style="width:70%">
+            <option value="all">All Data (combined payload)</option>
+            <optgroup label="────────────────">
+            <option value="status_info">Status Info</option>
+            <option value="system_info">System Info</option>
+            <option value="timers">Timers</option>
+            <option value="axes_data">Axes Data</option>
+            <option value="parameters">Parameters</option>
+            <option value="program_number">Program Number</option>
+            <option value="part_count">Part Count</option>
+            <option value="alarm_messages">Alarm Messages</option>
+            <option value="macro">Macro</option>
+            </optgroup>
+        </select>
+    </div>
+
+    <!-- Axes sub-type — shown only when fn=axes_data -->
+    <div class="form-row" id="fanuc-row-subtype" style="display:none">
+        <label for="node-input-subtype"><i class="fa fa-list"></i> Type</label>
+        <select id="node-input-subtype" style="width:70%"></select>
+    </div>
+
+    <!-- Param / macro numbers — shown only when fn=parameters or fn=macro -->
+    <div class="form-row" id="fanuc-row-params" style="display:none">
+        <label for="node-input-params">
+            <i class="fa fa-hashtag"></i>
+            <span id="fanuc-params-label">Parameter numbers</span>
+        </label>
+        <input type="text" id="node-input-params" placeholder="6711,6712" style="width:70%">
+        <div class="form-tips" id="fanuc-params-hint" style="margin-top:4px">
+            Comma-separated param numbers e.g. 6711,6712
+        </div>
+    </div>
+</script>
+
+<script type="text/html" data-help-name="fanuc-focas">
+    <p>Polls a FANUC CNC controller via FOCAS2 TCP and outputs <code>msg.payload</code>.</p>
+
+    <h3>Function</h3>
+    <dl class="message-properties">
+        <dt>All Data</dt><dd>Full combined payload (controller, state, timers, program, alarms)</dd>
+        <dt>Status Info</dt><dd>mode, run_state, motion, alarm, emergency, edit</dd>
+        <dt>System Info</dt><dd>cnc_type, mt_type, series, version, axes</dd>
+        <dt>Timers</dt><dd>power_on, auto_operation, cutting, cycle — with total_seconds and formatted</dd>
+        <dt>Axes Data</dt><dd>Position, servo/spindle load, feedrate — select sub-type</dd>
+        <dt>Parameters</dt><dd>Raw parameter values by number</dd>
+        <dt>Program Number</dt><dd>Running and main program numbers with comments</dd>
+        <dt>Part Count</dt><dd>Required and lifetime total parts</dd>
+        <dt>Alarm Messages</dt><dd>Active alarms with type, code, axis, text</dd>
+        <dt>Macro</dt><dd>Custom macro variable values by number</dd>
+    </dl>
+
+    <h3>Dynamic override</h3>
+    <p>Set <code>msg.function</code>, <code>msg.subtype</code>, or <code>msg.params</code> to override the configured values at runtime.</p>
+
+    <h3>Notes</h3>
+    <p>FOCAS is strictly sequential. Each node maintains its own TCP connection per poll cycle.</p>
+</script>

package/fanuc-focas.js

@@ -0,0 +1,279 @@
+'use strict';
+let Focas, ALLAXIS;
+try {
+    const m = require('./focas');
+    Focas   = m.Focas;
+    ALLAXIS = m.ALLAXIS;
+    if (typeof Focas !== 'function') {
+        throw new Error(
+            `focas.js exported Focas as '${typeof Focas}' (expected a class). ` +
+            `Ensure focas.js is in the same directory as fanuc-focas.js.`
+        );
+    }
+} catch (e) {
+    throw new Error(`node-red-contrib-fanuc-focas: failed to load focas.js — ${e.message}`);
+}
+
+
+// ── Lookup tables ─────────────────────────────────────────────────────────────
+const AUT_MODES = {
+    0:'MDI', 1:'MEMory', 2:'****', 3:'EDIT', 4:'HaNDle',
+    5:'JOG', 6:'Teach in JOG', 7:'Teach in HaNDle',
+    8:'INC feed', 9:'REFerence', 10:'ReMoTe',
+};
+const RUN_MODES_16 = { 0:'****', 1:'STOP', 2:'HOLD', 3:'STaRt', 4:'MSTR' };
+const RUN_MODES_15 = {
+    0:'STOP', 1:'HOLD', 2:'STaRt', 3:'MSTR', 4:'ReSTaRt',
+    5:'PRSR', 6:'NSRC', 7:'ReSTaRt*', 8:'ReSET', 13:'HPCC',
+};
+const EMG_STATES = { 0:null, 1:'EMERGENCY', 2:'RESET', 3:'WAIT' };
+const ALM_STATES = {
+    0:null, 1:'ALARM', 2:'BATTERY LOW', 3:'FAN',
+    4:'PS WARNING', 5:'FSSB WARNING', 6:'INSULATE WARNING',
+    7:'ENCODER WARNING', 8:'PMC ALARM',
+};
+const ALARM_TYPES = {
+    0:'BG', 1:'TH', 2:'RS', 4:'SV', 8:'SW',
+    16:'IO', 32:'PS', 64:'OT', 128:'OH',
+};
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function readParamVal(paramMap, key) {
+    return (paramMap && paramMap[key]) ? paramMap[key].data[0] : null;
+}
+
+function buildTimer(minVal, msVal = null) {
+    if (minVal === null || minVal === undefined)
+        return { total_seconds: null, formatted: null };
+    const ms       = (msVal !== null && msVal !== undefined) ? msVal : 0;
+    const totalSec = minVal * 60 + ms / 1000;
+    const h        = Math.floor(totalSec / 3600);
+    const rem      = Math.floor(totalSec % 3600);
+    const m        = Math.floor(rem / 60);
+    const s        = Math.floor(rem % 60);
+    const frac     = Math.round(totalSec * 1000) % 1000;
+    const formatted = msVal !== null
+        ? `${h}h ${String(m).padStart(2,'0')}m ${String(s).padStart(2,'0')}.${String(frac).padStart(3,'0')}s`
+        : `${h}h ${String(m).padStart(2,'0')}m`;
+    return { total_seconds: Math.round(totalSec * 1000) / 1000, formatted };
+}
+
+// ── Function implementations ──────────────────────────────────────────────────
+
+async function fnStatusInfo(focas, runModes) {
+    const state = await focas.statinfo();
+    if (!state) return null;
+    return {
+        mode:      state.aut in AUT_MODES ? AUT_MODES[state.aut] : String(state.aut),
+        run_state: state.run in runModes ? runModes[state.run] : String(state.run),
+        motion:    state.motion ? 'Moving' : 'Stopped',
+        mstb:      state.mstb   ? 'Active' : 'Inactive',
+        emergency: (state.emegency in EMG_STATES) ? EMG_STATES[state.emegency] : `UNKNOWN(${state.emegency})`,
+        alarm:     (state.alarm    in ALM_STATES) ? ALM_STATES[state.alarm]    : `ALARM(${state.alarm})`,
+        edit:      state.edit   ? 'Active' : 'Inactive',
+    };
+}
+
+async function fnSystemInfo(focas) {
+    const si = focas.sysinfo;
+    return {
+        cnc_type: si.cnctype.trim(),
+        mt_type:  si.mttype.trim(),
+        series:   si.series.trim(),
+        version:  si.version.trim(),
+        axes:     si.maxaxis,
+    };
+}
+
+async function fnTimers(focas) {
+    // FOCAS is strictly sequential — no Promise.all on a single socket
+    const p6750 = await focas.readparam3(ALLAXIS, 6750);
+    const p6751 = await focas.readparam3(ALLAXIS, 6751);
+    const p6752 = await focas.readparam3(ALLAXIS, 6752);
+    const p6753 = await focas.readparam3(ALLAXIS, 6753);
+    const p6754 = await focas.readparam3(ALLAXIS, 6754);
+    const p6757 = await focas.readparam3(ALLAXIS, 6757);
+    const p6758 = await focas.readparam3(ALLAXIS, 6758);
+    return {
+        power_on_time:       buildTimer(readParamVal(p6750, 6750)),
+        auto_operation_time: buildTimer(readParamVal(p6752, 6752), readParamVal(p6751, 6751)),
+        cutting_time:        buildTimer(readParamVal(p6754, 6754), readParamVal(p6753, 6753)),
+        cycle_time:          buildTimer(readParamVal(p6758, 6758), readParamVal(p6757, 6757)),
+    };
+}
+
+async function fnProgramNumber(focas) {
+    const prognum = await focas.readprognum();
+    if (!prognum) return null;
+    const runNum   = prognum.run;
+    const mainNum  = prognum.main;
+    const progList = await focas.listprog(Math.min(runNum, mainNum));
+    const cmt = (n) => (progList && progList[n]) ? (progList[n].comment.trim() || null) : null;
+    return {
+        running_program:  `O${runNum}`,
+        main_program:     `O${mainNum}`,
+        running_comment:  cmt(runNum),
+        main_comment:     cmt(mainNum),
+    };
+}
+
+async function fnPartCount(focas) {
+    const p6711 = await focas.readparam3(ALLAXIS, 6711);
+    const p6712 = await focas.readparam3(ALLAXIS, 6712);
+    return {
+        required_parts:  readParamVal(p6711, 6711),
+        lifetime_total:  readParamVal(p6712, 6712),
+    };
+}
+
+async function fnAlarmMessages(focas) {
+    const alarms = await focas.readalarmcode(1, 1, 10, 32);
+    return (alarms || []).map(a => ({
+        type: a.alarmtype in ALARM_TYPES ? ALARM_TYPES[a.alarmtype] : String(a.alarmtype),
+        code: a.alarmcode,
+        axis: a.axis,
+        text: a.text,
+    }));
+}
+
+async function fnAxesData(focas, axisType) {
+    // axisType maps to the what bitmask used in readaxes()
+    // Implemented directly via _reqSingle for the data types we need
+    switch (axisType) {
+        case 'feedrate':
+            return { actual_feedrate_mm_min: await focas.readactfeed() };
+        case 'spindle_speed':
+            return { actual_spindle_rpm: await focas.readactspindlespeed() };
+        case 'spindle_load':
+            return { spindle_load_percent: await focas.readspindleload() };
+        case 'servo_load':
+            return { servo_load_percent: await focas.readservoload() };
+        case 'abs_pos':
+            return { absolute_position: await focas.readaxes(1) };
+        case 'rel_pos':
+            return { relative_position: await focas.readaxes(2) };
+        case 'dist_to_go':
+            return { distance_to_go: await focas.readaxes(16) };
+        case 'machine_pos':
+            return { machine_position: await focas.readaxes(4) };
+        default:
+            return null;
+    }
+}
+
+async function fnParameters(focas, paramNums) {
+    // paramNums is a comma-separated string of parameter numbers
+    const nums = String(paramNums).split(',').map(s => parseInt(s.trim())).filter(n => !isNaN(n));
+    const result = {};
+    for (const n of nums) {
+        const r = await focas.readparam3(ALLAXIS, n);
+        if (r && r[n]) result[n] = r[n].data[0];
+    }
+    return result;
+}
+
+async function fnMacro(focas, macroNums) {
+    const nums = String(macroNums).split(',').map(s => parseInt(s.trim())).filter(n => !isNaN(n));
+    const result = {};
+    for (const n of nums) {
+        const r = await focas.readmacro(n);
+        if (r && r[n] !== undefined) result[n] = r[n];
+    }
+    return result;
+}
+
+// ── All-in-one (legacy behaviour) ────────────────────────────────────────────
+async function fnAll(focas, runModes) {
+    const [status, sysinfo, timers, program, parts, alarms] = [
+        await fnStatusInfo(focas, runModes),
+        await fnSystemInfo(focas),
+        await fnTimers(focas),
+        await fnProgramNumber(focas),
+        await fnPartCount(focas),
+        await fnAlarmMessages(focas),
+    ];
+    const feed    = await focas.readactfeed();
+    const spindle = await focas.readactspindlespeed();
+    return {
+        controller:       sysinfo,
+        machine_state:    status,
+        active_program:   program,
+        timers,
+        part_count:       parts,
+        feedrate_spindle: { actual_feedrate_mm_min: feed, actual_spindle_rpm: spindle },
+        active_alarms:    alarms,
+    };
+}
+
+// ── Main dispatcher ───────────────────────────────────────────────────────────
+async function collect(ip, port, cnc_series, fn, subtype, params) {
+    const focas    = new Focas(ip, port);
+    const runModes = cnc_series === '15' ? RUN_MODES_15 : RUN_MODES_16;
+
+    await focas.connect();
+    let result;
+    try {
+        switch (fn) {
+            case 'status_info':    result = await fnStatusInfo(focas, runModes);   break;
+            case 'system_info':    result = await fnSystemInfo(focas);             break;
+            case 'timers':         result = await fnTimers(focas);                 break;
+            case 'program_number': result = await fnProgramNumber(focas);          break;
+            case 'part_count':     result = await fnPartCount(focas);              break;
+            case 'alarm_messages': result = await fnAlarmMessages(focas);          break;
+            case 'axes_data':      result = await fnAxesData(focas, subtype);      break;
+            case 'parameters':     result = await fnParameters(focas, params);     break;
+            case 'macro':          result = await fnMacro(focas, params);          break;
+            case 'all':
+            default:               result = await fnAll(focas, runModes);          break;
+        }
+        result = { ...result, timestamp: new Date().toISOString() };
+    } finally {
+        await focas.disconnect();
+    }
+    return result;
+}
+
+// ── Node-RED registration ─────────────────────────────────────────────────────
+module.exports = function(RED) {
+
+    function FanucConfigNode(config) {
+        RED.nodes.createNode(this, config);
+        this.host       = config.host       || '192.168.0.100';
+        this.port       = parseInt(config.port) || 8193;
+        this.cnc_series = config.cnc_series || '16';
+    }
+    RED.nodes.registerType('fanuc-config', FanucConfigNode);
+
+    function FanucFocasNode(config) {
+        RED.nodes.createNode(this, config);
+        const node   = this;
+        const server = RED.nodes.getNode(config.server);
+
+        if (!server) {
+            node.error('No FANUC config node selected');
+            return;
+        }
+
+        node.on('input', async function(msg, send, done) {
+            // Allow overriding function/subtype/params via msg
+            const fn      = msg.function  || config.fn      || 'all';
+            const subtype = msg.subtype   || config.subtype || 'feedrate';
+            const params  = msg.params    || config.params  || '';
+
+            node.status({ fill:'blue', shape:'dot', text: fn });
+            try {
+                msg.payload = await collect(server.host, server.port, server.cnc_series, fn, subtype, params);
+                node.status({ fill:'green', shape:'dot', text:'ok' });
+                send(msg);
+                done();
+            } catch (err) {
+                node.status({ fill:'red', shape:'ring', text: err.message });
+                node.error(err.message, msg);
+                done(err);
+            }
+        });
+
+        node.on('close', () => node.status({}));
+    }
+    RED.nodes.registerType('fanuc-focas', FanucFocasNode);
+};

package/focas.js

@@ -0,0 +1,416 @@
+'use strict';
+/**
+ * focas.js — Pure Node.js FOCAS2 TCP client
+ * Port of diohpix/pyfanuc with all known bug-fixes applied.
+ *
+ * Protocol constants match pyfanuc.py exactly.
+ * All methods return Promises.
+ */
+const net = require('net');
+
+// ── Frame type constants ──────────────────────────────────────────────────────
+const FTYPE_OPN_REQU = 0x0101;
+const FTYPE_OPN_RESP = 0x0102;
+const FTYPE_VAR_REQU = 0x2101;
+const FTYPE_VAR_RESP = 0x2102;
+const FTYPE_CLS_REQU = 0x0201;
+const FTYPE_CLS_RESP = 0x0202;
+
+const FRAMEHEAD = Buffer.from([0xa0, 0xa0, 0xa0, 0xa0]);
+const FRAME_DST = Buffer.from([0x00, 0x02]);
+const ALLAXIS   = -1;
+
+// ── Low-level framing ─────────────────────────────────────────────────────────
+function encap(ftype, payload, fvers = 1) {
+    if (ftype === FTYPE_VAR_REQU) {
+        if (Array.isArray(payload)) {
+            const parts = payload.map(p => {
+                const lenBuf = Buffer.alloc(2);
+                lenBuf.writeUInt16BE(p.length + 2);
+                return Buffer.concat([lenBuf, p]);
+            });
+            const countBuf = Buffer.alloc(2);
+            countBuf.writeUInt16BE(parts.length);
+            payload = Buffer.concat([countBuf, ...parts]);
+        } else {
+            const hdr = Buffer.alloc(4);
+            hdr.writeUInt16BE(1, 0);
+            hdr.writeUInt16BE(payload.length + 2, 2);
+            payload = Buffer.concat([hdr, payload]);
+        }
+    }
+    const hdr = Buffer.alloc(6);
+    hdr.writeUInt16BE(fvers,         0);
+    hdr.writeUInt16BE(ftype,         2);
+    hdr.writeUInt16BE(payload.length, 4);
+    return Buffer.concat([FRAMEHEAD, hdr, payload]);
+}
+
+function decap(data) {
+    if (data.length < 10) return { len: -1 };
+    if (data[0] !== 0xa0 || data[1] !== 0xa0 || data[2] !== 0xa0 || data[3] !== 0xa0)
+        return { len: -1 };
+    const fvers = data.readUInt16BE(4);
+    const ftype = data.readUInt16BE(6);
+    const len1  = data.readUInt16BE(8);
+    if (len1 + 10 !== data.length) return { len: -1 };
+    if (len1 === 0) return { len: 0, ftype, fvers, data: Buffer.from([0x30]) };
+
+    const body = data.slice(10);
+    if (ftype === FTYPE_VAR_RESP) {
+        const qu = body.readUInt16BE(0);
+        let n = 2, re = [];
+        for (let t = 0; t < qu; t++) {
+            const le = body.readUInt16BE(n);
+            re.push(body.slice(n + 2, n + le));
+            n += le;
+        }
+        return { len: len1, ftype, fvers, data: re };
+    }
+    return { len: len1, ftype, fvers, data: body };
+}
+
+// ── Build sub-command buffer (for _req_rdmulti) ───────────────────────────────
+function reqSub(c1, c2, c3, v1=0, v2=0, v3=0, v4=0, v5=0) {
+    const b = Buffer.alloc(6 + 5*4);
+    b.writeUInt16BE(c1, 0);
+    b.writeUInt16BE(c2, 2);
+    b.writeUInt16BE(c3, 4);
+    b.writeInt32BE(v1,  6);
+    b.writeInt32BE(v2, 10);
+    b.writeInt32BE(v3, 14);
+    b.writeInt32BE(v4, 18);
+    b.writeInt32BE(v5, 22);
+    return b;
+}
+
+// ── Decode 8-byte value (feedrate/spindle) ────────────────────────────────────
+function decode8(val) {
+    const flag = val[5];
+    if (flag === 2 || flag === 10) {
+        if (val[6] === 0xff && val[7] === 0xff) return null;
+        const raw = val.readInt32BE(0);
+        return raw / Math.pow(flag, val[7]);
+    }
+    return null;
+}
+
+// ── Parse param/diag response body ───────────────────────────────────────────
+function parseParamBody(data, maxaxis, mode = 'param3') {
+    const stride = maxaxis * 4 + 8;
+    const r = {};
+    for (let pos = 0; pos + 8 <= data.length; pos += stride) {
+        const varname  = data.readUInt32BE(pos);
+        const axiscount = data.readInt16BE(pos + 4);
+        const valtype   = data.readUInt16BE(pos + 6);
+        const values    = { type: valtype, axis: axiscount, data: [] };
+
+        for (let n = pos + 8; n < pos + stride; n += 4) {
+            const chunk = data.slice(n, n + 4);
+            let value;
+            if (mode === 'param3') {
+                if      (valtype === 0) value = chunk[3];
+                else if (valtype === 1) { const b = chunk[3]; value = [7,6,5,4,3,2,1,0].map(i => (b>>i)&1); }
+                else if (valtype === 2) value = chunk.readInt16BE(2);   // fix: last 2 bytes
+                else if (valtype === 3) value = chunk.readInt32BE(0);
+            } else { // diag
+                if      (valtype === 4 || valtype === 0) value = chunk[3];
+                else if (valtype === 1) value = chunk.readInt16BE(2);
+                else if (valtype === 2) value = chunk.readInt32BE(0);
+                else if (valtype === 3) { const b = chunk[3]; value = [7,6,5,4,3,2,1,0].map(i => (b>>i)&1); }
+            }
+            if (axiscount !== -1) { values.data.push(value); break; }
+            else                    values.data.push(value);
+        }
+        r[varname] = values;
+    }
+    return r;
+}
+
+// ── Main client class ─────────────────────────────────────────────────────────
+class Focas {
+    constructor(ip, port = 8193, timeout = 5000) {
+        this.ip      = ip;
+        this.port    = port;
+        this.timeout = timeout;
+        this.socket  = null;
+        this.sysinfo = null;
+    }
+
+    // ── Socket helpers ────────────────────────────────────────────────────────
+    _send(buf) {
+        return new Promise((resolve, reject) => {
+            this.socket.write(buf, err => err ? reject(err) : resolve());
+        });
+    }
+
+    _recv() {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error('FOCAS recv timeout')), this.timeout);
+            let buf = Buffer.alloc(0);
+
+            const onData = chunk => {
+                buf = Buffer.concat([buf, chunk]);
+                if (buf.length < 10) return;
+                const expected = buf.readUInt16BE(8) + 10;
+                if (buf.length >= expected) {
+                    clearTimeout(timer);
+                    this.socket.removeListener('data', onData);
+                    this.socket.removeListener('error', onErr);
+                    resolve(buf.slice(0, expected));
+                }
+            };
+            const onErr = err => { clearTimeout(timer); reject(err); };
+            this.socket.on('data', onData);
+            this.socket.on('error', onErr);
+        });
+    }
+
+    // ── Connect / disconnect ──────────────────────────────────────────────────
+    connect() {
+        return new Promise((resolve, reject) => {
+            this.socket = new net.Socket();
+            this.socket.setTimeout(this.timeout);
+            this.socket.connect(this.port, this.ip, async () => {
+                try {
+                    await this._send(encap(FTYPE_OPN_REQU, FRAME_DST));
+                    const raw = await this._recv();
+                    const res = decap(raw);
+                    if (res.ftype !== FTYPE_OPN_RESP) return reject(new Error('Open handshake failed'));
+                    await this._getsysinfo();
+                    resolve();
+                } catch (e) { reject(e); }
+            });
+            this.socket.on('error', reject);
+            this.socket.on('timeout', () => reject(new Error('Connection timeout')));
+        });
+    }
+
+    async disconnect() {
+        if (!this.socket) return;
+        try {
+            await this._send(encap(FTYPE_CLS_REQU, Buffer.alloc(0)));
+            await this._recv();
+        } catch (_) {}
+        this.socket.destroy();
+        this.socket = null;
+    }
+
+    // ── Request primitives ────────────────────────────────────────────────────
+    async _reqSingle(c1, c2, c3, v1=0, v2=0, v3=0, v4=0, v5=0, pl=Buffer.alloc(0)) {
+        const cmd = Buffer.alloc(6);
+        cmd.writeUInt16BE(c1, 0); cmd.writeUInt16BE(c2, 2); cmd.writeUInt16BE(c3, 4);
+        const args = Buffer.alloc(20);
+        args.writeInt32BE(v1,  0); args.writeInt32BE(v2,  4);
+        args.writeInt32BE(v3,  8); args.writeInt32BE(v4, 12); args.writeInt32BE(v5, 16);
+        await this._send(encap(FTYPE_VAR_REQU, Buffer.concat([cmd, args, pl])));
+        const raw = await this._recv();
+        const t   = decap(raw);
+        if (t.len === 0) return { len: -1 };
+        if (t.ftype !== FTYPE_VAR_RESP) return { len: -1 };
+        const d = t.data[0];
+        if (d.slice(0, 6).equals(cmd) && d[6] === 0 && d[7] === 0 && d[8] === 0 && d[9] === 0 && d[10] === 0 && d[11] === 0) {
+            return { len: d.readUInt16BE(12), data: d.slice(14) };
+        }
+        if (d.slice(0, 6).equals(cmd)) {
+            return { len: 0, data: d.slice(6), error: d.readInt16BE(6) };
+        }
+        return { len: -1 };
+    }
+
+    async _reqMulti(list) {
+        await this._send(encap(FTYPE_VAR_REQU, list));
+        const raw = await this._recv();
+        const t   = decap(raw);
+        if (t.len === 0 || t.ftype !== FTYPE_VAR_RESP) return { len: -1 };
+        if (list.length !== t.data.length) return { len: -1 };
+        for (let x = 0; x < t.data.length; x++) {
+            if (t.data[x].slice(0, 6).equals(list[x].slice(0, 6))) {
+                const zeros = t.data[x].slice(6, 12).every(b => b === 0);
+                t.data[x] = zeros
+                    ? [0, t.data[x].slice(12)]
+                    : [t.data[x].readInt16BE(0), t.data[x].slice(12)];
+            } else {
+                return { len: -1 };
+            }
+        }
+        return t;
+    }
+
+    // ── Public API ────────────────────────────────────────────────────────────
+
+    async _getsysinfo() {
+        const st = await this._reqSingle(1, 1, 0x18);
+        if (st.len !== 0x12) throw new Error('getsysinfo: unexpected response length');
+        this.sysinfo = {
+            addinfo: st.data.readUInt16BE(0),
+            maxaxis: st.data.readUInt16BE(2),
+            cnctype: st.data.slice(4,  6).toString('ascii'),
+            mttype:  st.data.slice(6,  8).toString('ascii'),
+            series:  st.data.slice(8,  12).toString('ascii'),
+            version: st.data.slice(12, 16).toString('ascii'),
+            axes:    st.data.slice(16, 18).toString('ascii'),
+        };
+    }
+
+    async statinfo() {
+        const st = await this._reqSingle(1, 1, 0x19, 0);
+        const t  = this.sysinfo.cnctype.trim();
+        const is16 = ['16','31','18','0i','30',' 0','0 '].includes(t) ||
+                     t === '0';   // 0i-D returns bare '0'
+        if (is16 && st.len === 0x0e) {
+            const d = st.data;
+            return {
+                hdck:      d.readUInt16BE(0),
+                tmmode:    d.readUInt16BE(2),  // actually: aut at offset 0 per ODBST layout...
+                aut:       d.readUInt16BE(0),
+                run:       d.readUInt16BE(2),
+                motion:    d.readUInt16BE(4),
+                mstb:      d.readUInt16BE(6),
+                emegency:  d.readUInt16BE(8),
+                alarm:     d.readUInt16BE(10),
+                edit:      d.readUInt16BE(12),
+            };
+        }
+        return null;
+    }
+
+    async readprognum() {
+        const st = await this._reqSingle(1, 1, 0x1c);
+        if (st.len < 8) return null;
+        return {
+            run:  st.data.readInt32BE(0),
+            main: st.data.readInt32BE(4),
+        };
+    }
+
+    async listprog(start = 1) {
+        const ret = {};
+        while (true) {
+            const st = await this._reqSingle(1, 1, 0x06, start, 0x13, 2);
+            if (st.len < -1) return null;
+            if (st.len === 0) return ret;
+            for (let t = 0; t + 72 <= st.len; t += 72) {
+                const number  = st.data.readUInt32BE(t);
+                // size       = st.data.readUInt32BE(t+4);
+                let comment   = st.data.slice(t + 8, t + 72);
+                const nullIdx = comment.indexOf(0);
+                if (nullIdx !== -1) comment = comment.slice(0, nullIdx);
+                ret[number] = { comment: comment.toString('ascii') };
+                start = number + 1;
+            }
+        }
+    }
+
+    async readparam3(axis, first, last = 0) {
+        if (last === 0) last = first;
+        // Try 0x8d (0i/30i), fall back to 0x0e (16/18/21i) if response empty
+        let st = await this._reqSingle(1, 1, 0x8d, first, last, axis);
+        if (st.len <= 0) {
+            st = await this._reqSingle(1, 1, 0x0e, first, last, axis);
+        }
+        if (st.len <= 0) return null;
+        return parseParamBody(st.data, this.sysinfo.maxaxis, 'param3');
+    }
+
+    async readactfeed() {
+        const st = await this._reqSingle(1, 1, 0x24);
+        return (st.len === 8) ? decode8(st.data) : null;
+    }
+
+    async readactspindlespeed() {
+        const st = await this._reqSingle(1, 1, 0x25);
+        return (st.len === 8) ? decode8(st.data) : null;
+    }
+
+    async readalarmcode(type, withtext = 1, maxmsgs = -1, textlength = 32) {
+        if (maxmsgs <= 0) maxmsgs = parseInt(this.sysinfo.axes) || 32;
+        const st = await this._reqSingle(1, 1, 0x23, type, maxmsgs, withtext, textlength);
+        if (st.len <= 0) return [];
+        const stride = 4 * 4 + textlength;
+        const ret = [];
+        for (let pos = 0; pos + stride <= st.len; pos += stride) {
+            const entry = {
+                alarmcode: st.data.readInt32BE(pos),
+                alarmtype: st.data.readInt32BE(pos + 4),
+                axis:      st.data.readInt32BE(pos + 8),
+            };
+            const txlen = st.data.readInt32BE(pos + 12);
+            if (txlen > 0 && withtext > 0) {
+                let text = st.data.slice(pos + 16, pos + 16 + textlength);
+                const nullIdx = text.indexOf(0);
+                if (nullIdx !== -1) text = text.slice(0, nullIdx);
+                entry.text = text.toString('ascii').trim();
+            } else {
+                entry.text = '';
+            }
+            ret.push(entry);
+        }
+        return ret;
+    }
+
+    // ── Axes position data ────────────────────────────────────────────────────
+    // what bitmask: ABS=1, REL=2, REF=4 (machine pos), DIST=16
+    async readaxes(what = 1, axis = ALLAXIS) {
+        const axvalues = [
+            { name:'ABS',  flag:1,  sub:4 },
+            { name:'REL',  flag:2,  sub:6 },
+            { name:'REF',  flag:4,  sub:1 },
+            { name:'SKIP', flag:8,  sub:8 },
+            { name:'DIST', flag:16, sub:7 },
+        ];
+        const cmds = axvalues
+            .filter(a => what & a.flag)
+            .map(a => {
+                const b = Buffer.alloc(26);
+                b.writeUInt16BE(1, 0); b.writeUInt16BE(1, 2); b.writeUInt16BE(0x26, 4);
+                b.writeInt32BE(a.sub, 6); b.writeInt32BE(axis, 10);
+                return b;
+            });
+        if (cmds.length === 0) return null;
+        const st = await this._reqMulti(cmds);
+        if (!st || st.len < 0) return null;
+        const result = {};
+        let idx = 0;
+        for (const a of axvalues) {
+            if (!(what & a.flag)) continue;
+            const d = st.data[idx++];
+            if (!d || d[0] !== 0) { result[a.name] = null; continue; }
+            const body = d[1];
+            const count = body.readUInt16BE(0);
+            const vals = [];
+            for (let p = 2; p < count * 8 + 2; p += 8) vals.push(decode8(body.slice(p, p + 8)));
+            result[a.name] = vals;
+        }
+        return result;
+    }
+
+    // ── Macro variables ───────────────────────────────────────────────────────
+    async readmacro(first, last = 0) {
+        if (last === 0) last = first;
+        const st = await this._reqSingle(1, 1, 0x15, first, last);
+        if (st.len <= 0) return null;
+        const r = {};
+        let n = first;
+        for (let pos = 0; pos + 8 <= st.len; pos += 8) {
+            r[n++] = decode8(st.data.slice(pos, pos + 8));
+        }
+        return r;
+    }
+
+    // ── Servo load (diag 400, per-axis percentage) ────────────────────────────
+    async readservoload() {
+        const st = await this._reqSingle(1, 1, 0x30, 400, 400, ALLAXIS);
+        if (st.len <= 0) return null;
+        const r400 = parseParamBody(st.data, this.sysinfo.maxaxis, 'diag')[400]; return r400 ? r400.data : null;
+    }
+
+    // ── Spindle load (diag 300, percentage) ──────────────────────────────────
+    async readspindleload() {
+        const st = await this._reqSingle(1, 1, 0x30, 300, 300, ALLAXIS);
+        if (st.len <= 0) return null;
+        const r300 = parseParamBody(st.data, this.sysinfo.maxaxis, 'diag')[300]; return r300 ? r300.data : null;
+    }
+}
+
+module.exports = { Focas, ALLAXIS };

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "node-red-contrib-fanuc-focas",
+  "version": "0.0.1",
+  "description": "Node-RED node for FANUC CNC data collection via FOCAS2 protocol (pure Node.js, no native libraries, adapted from pyfanuc)",
+  "keywords": ["node-red", "fanuc", "focas", "cnc", "iot", "focas2"],
+  "author": "zhide loh",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zhideloh/node-red-contrib-fanuc-focas"
+  },
+  "node-red": {
+    "version": ">=2.0.0",
+    "nodes": {
+      "fanuc-focas": "fanuc-focas.js"
+    }
+  },
+  "engines": { "node": ">=14.0.0" }
+}