@tteja/node-red-dashboard-2-robot-arm 0.3.0

package/lib/normalize.js

@@ -0,0 +1,146 @@
+'use strict';
+
+/**
+ * Normalize joint / pose payloads into a canonical form:
+ *   { robot, joints: { name: number }, unit: 'rad'|'deg', source, ts }
+ *
+ * Accepts:
+ *  - ROS JointState-like: { name: string[], position: number[] }
+ *  - flat object of joint name → value
+ *  - msg.payload as array (positional; needs jointNames)
+ *  - already-canonical { joints, unit, ... }
+ */
+
+const DEFAULT_JOINT_NAMES = [
+  'shoulder_pan_joint',
+  'shoulder_lift_joint',
+  'elbow_joint',
+  'wrist_1_joint',
+  'wrist_2_joint',
+  'wrist_3_joint',
+  'finger_joint'
+];
+
+function isPlainObject(v) {
+  return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+
+function toNumberMap(obj) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    const n = Number(v);
+    if (Number.isFinite(n)) out[k] = n;
+  }
+  return out;
+}
+
+/**
+ * @param {*} payload - msg.payload or raw object
+ * @param {object} [opts]
+ * @param {string} [opts.robot]
+ * @param {string} [opts.unit] - 'rad' | 'deg'
+ * @param {string} [opts.source]
+ * @param {string[]} [opts.jointNames] - used when payload is a bare array
+ * @returns {{ robot: string, joints: Object.<string,number>, unit: string, source: string, ts: number }}
+ */
+function normalize(payload, opts = {}) {
+  const unit = opts.unit === 'deg' ? 'deg' : 'rad';
+  const robot = opts.robot || 'robot';
+  const source = opts.source || 'unknown';
+  const ts = Date.now();
+  const jointNames = Array.isArray(opts.jointNames) && opts.jointNames.length
+    ? opts.jointNames
+    : DEFAULT_JOINT_NAMES;
+
+  let joints = {};
+
+  if (payload == null) {
+    return { robot, joints: {}, unit, source, ts };
+  }
+
+  // Already canonical
+  if (isPlainObject(payload) && isPlainObject(payload.joints)) {
+    joints = toNumberMap(payload.joints);
+    return {
+      robot: payload.robot || robot,
+      joints,
+      unit: payload.unit === 'deg' || payload.unit === 'rad' ? payload.unit : unit,
+      source: payload.source || source,
+      ts: typeof payload.ts === 'number' ? payload.ts : ts
+    };
+  }
+
+  // ROS JointState-like
+  if (
+    isPlainObject(payload) &&
+    Array.isArray(payload.name) &&
+    Array.isArray(payload.position)
+  ) {
+    const n = Math.min(payload.name.length, payload.position.length);
+    for (let i = 0; i < n; i++) {
+      const name = String(payload.name[i]);
+      const val = Number(payload.position[i]);
+      if (name && Number.isFinite(val)) joints[name] = val;
+    }
+    return {
+      robot: payload.robot || robot,
+      joints,
+      unit: payload.unit === 'deg' || payload.unit === 'rad' ? payload.unit : unit,
+      source: payload.source || source,
+      ts
+    };
+  }
+
+  // Bare array → positional joints
+  if (Array.isArray(payload)) {
+    const n = Math.min(payload.length, jointNames.length);
+    for (let i = 0; i < n; i++) {
+      const val = Number(payload[i]);
+      if (Number.isFinite(val)) joints[jointNames[i]] = val;
+    }
+    return { robot, joints, unit, source, ts };
+  }
+
+  // Flat object of joint → value (ignore meta keys)
+  if (isPlainObject(payload)) {
+    const meta = new Set(['robot', 'unit', 'source', 'ts', 'name', 'position', 'velocity', 'effort', 'header']);
+    const raw = {};
+    for (const [k, v] of Object.entries(payload)) {
+      if (meta.has(k)) continue;
+      if (typeof v === 'number' || (typeof v === 'string' && v.trim() !== '' && Number.isFinite(Number(v)))) {
+        raw[k] = v;
+      }
+    }
+    joints = toNumberMap(raw);
+    return {
+      robot: payload.robot || robot,
+      joints,
+      unit: payload.unit === 'deg' || payload.unit === 'rad' ? payload.unit : unit,
+      source: payload.source || source,
+      ts
+    };
+  }
+
+  return { robot, joints: {}, unit, source, ts };
+}
+
+/**
+ * Convert joints between rad and deg (in place copy).
+ */
+function convertUnit(joints, fromUnit, toUnit) {
+  if (fromUnit === toUnit) return { ...joints };
+  const factor = fromUnit === 'deg' && toUnit === 'rad' ? Math.PI / 180
+    : fromUnit === 'rad' && toUnit === 'deg' ? 180 / Math.PI
+    : 1;
+  const out = {};
+  for (const [k, v] of Object.entries(joints)) {
+    out[k] = v * factor;
+  }
+  return out;
+}
+
+module.exports = {
+  normalize,
+  convertUnit,
+  DEFAULT_JOINT_NAMES
+};

package/lib/robot-runtime.js

@@ -0,0 +1,144 @@
+'use strict';
+
+const { normalize, convertUnit } = require('./normalize');
+
+/**
+ * Pure-ish runtime for one robot instance: joint state, priority policy,
+ * optional rosbridge publish callback. Used by the Node-RED `robot` node
+ * and by automated tests (no RED dependency).
+ */
+class RobotRuntime {
+  /**
+   * @param {object} opts
+   * @param {string} [opts.robotTag]
+   * @param {string} [opts.unit] - 'rad' | 'deg'
+   * @param {Array<{name:string, home?:number, unit?:string}>} opts.jointsMeta
+   * @param {function} [opts.onPublish] - (topic, type, msg) => void
+   * @param {string} [opts.publishTopic]
+   * @param {function} [opts.getRosbridgeStatus] - () => string
+   */
+  constructor(opts = {}) {
+    this.robotTag = (opts.robotTag || 'robot').trim() || 'robot';
+    this.unit = opts.unit === 'deg' ? 'deg' : 'rad';
+    this.jointsMeta = Array.isArray(opts.jointsMeta) ? opts.jointsMeta : [];
+    this.jointNames = this.jointsMeta.map((j) => j.name);
+    this.onPublish = typeof opts.onPublish === 'function' ? opts.onPublish : null;
+    this.publishTopic = (opts.publishTopic || '').trim();
+    this.getRosbridgeStatus = typeof opts.getRosbridgeStatus === 'function'
+      ? opts.getRosbridgeStatus
+      : () => 'disabled';
+
+    this.joints = {};
+    for (const j of this.jointsMeta) {
+      this.joints[j.name] = typeof j.home === 'number' ? j.home : 0;
+    }
+    this.source = 'init';
+    this.ts = Date.now();
+    this.manualArmed = false;
+    this.lastPendantTs = 0;
+    this.clients = new Set();
+  }
+
+  getPublicState(extra = {}) {
+    return {
+      robot: this.robotTag,
+      joints: { ...this.joints },
+      unit: this.unit,
+      source: this.source,
+      ts: this.ts,
+      rosbridge: this.getRosbridgeStatus(),
+      jointNames: this.jointNames.slice(),
+      jointsMeta: this.jointsMeta.slice(),
+      ...extra
+    };
+  }
+
+  broadcast() {
+    for (const cb of this.clients) {
+      try { cb(); } catch (_) { /* ignore */ }
+    }
+  }
+
+  /**
+   * @param {*} payload
+   * @param {string} [defaultSource]
+   * @returns {{ applied: boolean, out?: object, frozen?: boolean }}
+   */
+  applyCommand(payload, defaultSource) {
+    const src = (payload && payload.source) || defaultSource || 'input';
+    if (src === 'rosbridge' && this.manualArmed && Date.now() - this.lastPendantTs < 2000) {
+      return { applied: false };
+    }
+    if (src === 'pendant' || src === 'controller') {
+      this.lastPendantTs = Date.now();
+      if (payload && payload.manualArmed != null) {
+        this.manualArmed = !!payload.manualArmed;
+      } else {
+        this.manualArmed = true;
+      }
+    }
+    if (payload && payload.freeze === true) {
+      return { applied: false, frozen: true, out: this.getPublicState() };
+    }
+
+    const norm = normalize(payload, {
+      robot: this.robotTag,
+      unit: this.unit,
+      source: src,
+      jointNames: this.jointNames
+    });
+
+    let joints = norm.joints;
+    if (norm.unit !== this.unit && Object.keys(joints).length) {
+      const angular = {};
+      const linear = {};
+      for (const [k, v] of Object.entries(joints)) {
+        const meta = this.jointsMeta.find((j) => j.name === k);
+        if (meta && meta.unit === 'm') linear[k] = v;
+        else angular[k] = v;
+      }
+      joints = { ...convertUnit(angular, norm.unit, this.unit), ...linear };
+    }
+
+    Object.assign(this.joints, joints);
+    this.source = norm.source;
+    this.ts = norm.ts;
+
+    if (this.joints.finger_joint != null && this.joints.finger_joint_right == null) {
+      this.joints.finger_joint_right = this.joints.finger_joint;
+    }
+
+    this.broadcast();
+
+    const out = {
+      robot: this.robotTag,
+      joints: { ...this.joints },
+      unit: this.unit,
+      source: this.source,
+      ts: this.ts
+    };
+
+    if (this.onPublish && this.publishTopic && this.getRosbridgeStatus() === 'connected') {
+      const names = Object.keys(this.joints);
+      const positions = names.map((n) => {
+        let v = this.joints[n];
+        const meta = this.jointsMeta.find((j) => j.name === n);
+        const isLinear = meta && meta.unit === 'm';
+        if (!isLinear && this.unit === 'deg') {
+          v = v * Math.PI / 180;
+        }
+        return v;
+      });
+      this.onPublish(this.publishTopic, 'sensor_msgs/JointState', {
+        name: names,
+        position: positions,
+        velocity: [],
+        effort: []
+      });
+    }
+
+    return { applied: true, out };
+  }
+}
+
+module.exports = { RobotRuntime };

package/lib/rosbridge.js

@@ -0,0 +1,210 @@
+'use strict';
+
+const { EventEmitter } = require('events');
+const WebSocket = require('ws');
+
+/**
+ * Minimal rosbridge WebSocket client for Node-RED robot node.
+ * Supports connect, subscribe, advertise, publish, reconnect, and status events.
+ *
+ * Honest limit: needs a real (or mock) rosbridge endpoint on the configured URL
+ * (typically ws://host:9090). This is not a full ROS 2 client.
+ */
+class RosbridgeClient extends EventEmitter {
+  /**
+   * @param {object} opts
+   * @param {string} opts.url - e.g. ws://localhost:9090
+   * @param {number} [opts.reconnectMs=3000]
+   * @param {function} [opts.WebSocketImpl] - injectable WebSocket (for tests)
+   */
+  constructor(opts = {}) {
+    super();
+    this.url = opts.url || 'ws://localhost:9090';
+    this.reconnectMs = opts.reconnectMs != null ? opts.reconnectMs : 3000;
+    this._WS = opts.WebSocketImpl || WebSocket;
+    this._ws = null;
+    this._closed = false;
+    this._id = 0;
+    this._subs = new Map(); // topic -> { type, cb, id }
+    this._ads = new Map(); // topic -> { type, id }
+    this._reconnectTimer = null;
+    this.status = 'disconnected';
+  }
+
+  _setStatus(s) {
+    this.status = s;
+    this.emit('status', s);
+  }
+
+  _nextId() {
+    this._id += 1;
+    return `nra_${this._id}`;
+  }
+
+  connect() {
+    this._closed = false;
+    if (this._ws && (this._ws.readyState === this._WS.OPEN || this._ws.readyState === this._WS.CONNECTING)) {
+      return;
+    }
+    this._clearReconnect();
+    this._setStatus('connecting');
+    let ws;
+    try {
+      ws = new this._WS(this.url);
+    } catch (err) {
+      this._setStatus('error');
+      this.emit('error', err);
+      this._scheduleReconnect();
+      return;
+    }
+    this._ws = ws;
+
+    ws.on('open', () => {
+      this._setStatus('connected');
+      for (const [topic, ad] of this._ads.entries()) {
+        this._send({
+          op: 'advertise',
+          id: ad.id,
+          topic,
+          type: ad.type
+        });
+      }
+      for (const [topic, sub] of this._subs.entries()) {
+        this._send({
+          op: 'subscribe',
+          id: sub.id,
+          topic,
+          type: sub.type
+        });
+      }
+    });
+
+    ws.on('message', (data) => {
+      let msg;
+      try {
+        msg = JSON.parse(data.toString());
+      } catch (_) {
+        return;
+      }
+      if (msg.op === 'publish' && msg.topic && this._subs.has(msg.topic)) {
+        const sub = this._subs.get(msg.topic);
+        try {
+          sub.cb(msg.msg, msg.topic);
+        } catch (err) {
+          this.emit('error', err);
+        }
+      }
+    });
+
+    ws.on('close', () => {
+      this._ws = null;
+      if (!this._closed) {
+        this._setStatus('disconnected');
+        this._scheduleReconnect();
+      } else {
+        this._setStatus('closed');
+      }
+    });
+
+    ws.on('error', (err) => {
+      this.emit('error', err);
+    });
+  }
+
+  _send(obj) {
+    if (this._ws && this._ws.readyState === this._WS.OPEN) {
+      this._ws.send(JSON.stringify(obj));
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * @param {string} topic
+   * @param {string} type - ROS message type e.g. sensor_msgs/JointState
+   * @param {function} cb - (msg, topic) => void
+   */
+  subscribe(topic, type, cb) {
+    const id = this._nextId();
+    this._subs.set(topic, { type, cb, id });
+    this._send({ op: 'subscribe', id, topic, type });
+  }
+
+  unsubscribe(topic) {
+    const sub = this._subs.get(topic);
+    if (sub) {
+      this._send({ op: 'unsubscribe', id: sub.id, topic });
+      this._subs.delete(topic);
+    }
+  }
+
+  /**
+   * Advertise a topic before publishing (rosbridge protocol).
+   * @param {string} topic
+   * @param {string} type
+   */
+  advertise(topic, type) {
+    const id = this._nextId();
+    this._ads.set(topic, { type, id });
+    this._send({ op: 'advertise', id, topic, type });
+  }
+
+  unadvertise(topic) {
+    const ad = this._ads.get(topic);
+    if (ad) {
+      this._send({ op: 'unadvertise', id: ad.id, topic });
+      this._ads.delete(topic);
+    }
+  }
+
+  /**
+   * @param {string} topic
+   * @param {string} type
+   * @param {object} msg
+   */
+  publish(topic, type, msg) {
+    if (!this._ads.has(topic)) {
+      this.advertise(topic, type);
+    }
+    this._send({
+      op: 'publish',
+      topic,
+      msg,
+      type
+    });
+  }
+
+  _scheduleReconnect() {
+    if (this._closed || this.reconnectMs <= 0) return;
+    this._clearReconnect();
+    this._reconnectTimer = setTimeout(() => {
+      this._reconnectTimer = null;
+      if (!this._closed) this.connect();
+    }, this.reconnectMs);
+  }
+
+  _clearReconnect() {
+    if (this._reconnectTimer) {
+      clearTimeout(this._reconnectTimer);
+      this._reconnectTimer = null;
+    }
+  }
+
+  close() {
+    this._closed = true;
+    this._clearReconnect();
+    for (const topic of [...this._subs.keys()]) {
+      this.unsubscribe(topic);
+    }
+    for (const topic of [...this._ads.keys()]) {
+      this.unadvertise(topic);
+    }
+    if (this._ws) {
+      try { this._ws.close(); } catch (_) { /* ignore */ }
+      this._ws = null;
+    }
+    this._setStatus('closed');
+  }
+}
+
+module.exports = { RosbridgeClient };

package/models/ur5e/LICENSE

@@ -0,0 +1,33 @@
+Copyright (c) Universal Robots A/S and contributors.
+Source: UniversalRobots/Universal_Robots_ROS2_Description (rolling)
+        meshes/ur5e/collision/*.stl — converted to ASCII STL for GitHub Pages.
+
+BSD 3-Clause License
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+Note: UR5e meshes are BSD-3-Clause. The separate "Graphical Documentation"
+terms that apply to UR20/UR30/etc. do NOT apply to UR5e.

package/models/ur5e/README.md

@@ -0,0 +1,15 @@
+# UR5e (vendored)
+
+Browser-ready URDF + **visual** binary STL meshes for the Electronics Playground 6-DoF arm lab.
+
+| Item | Value |
+|------|--------|
+| Model | Universal Robots UR5e |
+| Source | [UniversalRobots/Universal_Robots_ROS2_Description](https://github.com/UniversalRobots/Universal_Robots_ROS2_Description) (rolling) |
+| License | **BSD-3-Clause** (see `LICENSE`) |
+| Meshes | Official **visual** DAE -> binary STL (thousands of tris/link; not collision proxies) |
+| Joints | `shoulder_pan_joint` ... `wrist_3_joint` (same names as ros2_control) |
+
+Regenerate locally: `npm run meshes` (needs `pip install trimesh pycollada numpy scipy fast_simplification`).
+
+Kinematics match `config/ur5e/default_kinematics.yaml`. Visual offsets match `config/ur5e/visual_parameters.yaml`.

package/models/ur5e/joints.json

@@ -0,0 +1,12 @@
+{
+  "name": "ur5e",
+  "urdf": "ur5e.urdf",
+  "joints": [
+    { "name": "shoulder_pan_joint", "label": "Base", "min": -6.2832, "max": 6.2832, "home": 0 },
+    { "name": "shoulder_lift_joint", "label": "Shoulder", "min": -6.2832, "max": 6.2832, "home": -1.57 },
+    { "name": "elbow_joint", "label": "Elbow", "min": -3.1416, "max": 3.1416, "home": 1.57 },
+    { "name": "wrist_1_joint", "label": "Wrist 1", "min": -6.2832, "max": 6.2832, "home": -1.57 },
+    { "name": "wrist_2_joint", "label": "Wrist 2", "min": -6.2832, "max": 6.2832, "home": -1.57 },
+    { "name": "wrist_3_joint", "label": "Wrist 3", "min": -6.2832, "max": 6.2832, "home": 0 }
+  ]
+}