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

package/nodes/controller.js

@@ -0,0 +1,237 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const { DEFAULT_JOINT_NAMES } = require('../lib/normalize');
+
+const PKG_ROOT = path.join(__dirname, '..');
+
+/** @type {Map<string, object>} */
+const controllers = new Map();
+
+module.exports = function (RED) {
+  let httpMounted = false;
+
+  function ensureHttpRoutes() {
+    if (httpMounted) return;
+    httpMounted = true;
+    const express = RED.httpNode;
+    const resourcesDir = path.join(PKG_ROOT, 'resources');
+
+    express.get('/robot-arm/controller/:id', function (req, res) {
+      const id = req.params.id;
+      const inst = controllers.get(id);
+      if (!inst) {
+        res.status(404).send('Unknown controller node id. Deploy the flow first.');
+        return;
+      }
+      const htmlPath = path.join(resourcesDir, 'controller.html');
+      let html = fs.readFileSync(htmlPath, 'utf8');
+      html = html
+        .replace(/__NODE_ID__/g, id)
+        .replace(/__UNIT__/g, inst.unit || 'rad')
+        .replace(/__ROBOT__/g, inst.robotTag || 'robot');
+      res.type('html').send(html);
+    });
+
+    express.get('/robot-arm/api/controller/:id/meta', function (req, res) {
+      const id = req.params.id;
+      const inst = controllers.get(id);
+      if (!inst) {
+        res.status(404).json({ error: 'unknown' });
+        return;
+      }
+      res.json(inst.getMeta());
+    });
+
+    function readJson(req, cb) {
+      if (req.body && typeof req.body === 'object' && !Buffer.isBuffer(req.body)) {
+        cb(null, req.body);
+        return;
+      }
+      let raw = '';
+      req.setEncoding('utf8');
+      req.on('data', (c) => { raw += c; });
+      req.on('end', () => {
+        if (!raw) return cb(null, {});
+        try { cb(null, JSON.parse(raw)); }
+        catch (e) { cb(e); }
+      });
+    }
+
+    express.post('/robot-arm/api/controller/:id/command', function (req, res) {
+      const id = req.params.id;
+      const inst = controllers.get(id);
+      if (!inst) {
+        res.status(404).json({ error: 'unknown' });
+        return;
+      }
+      readJson(req, (err, body) => {
+        if (err) {
+          res.status(400).json({ error: 'invalid json' });
+          return;
+        }
+        inst.emitCommand(body || {});
+        res.json({ ok: true });
+      });
+    });
+  }
+
+  function loadPresetJoints(preset) {
+    const metaPath = path.join(PKG_ROOT, 'models', preset || 'ur5e', 'joints.json');
+    try {
+      if (fs.existsSync(metaPath)) {
+        return JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+      }
+    } catch (_) { /* ignore */ }
+    return {
+      joints: DEFAULT_JOINT_NAMES.map((n) => ({
+        name: n,
+        label: n,
+        min: -3.14,
+        max: 3.14,
+        home: 0
+      }))
+    };
+  }
+
+  function ControllerNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+    ensureHttpRoutes();
+
+    node.name = config.name || '';
+    node.robotTag = (config.robotTag || 'robot').trim() || 'robot';
+    node.modelPreset = config.modelPreset || 'ur5e';
+    node.unit = config.unit === 'deg' ? 'deg' : 'rad';
+    node.stepSize = Number(config.stepSize) || 0.01;
+
+    const meta = loadPresetJoints(node.modelPreset);
+    let jointsDef = meta.joints || [];
+
+    if (config.jointList && String(config.jointList).trim()) {
+      const names = String(config.jointList).split(',').map((s) => s.trim()).filter(Boolean);
+      jointsDef = names.map((n) => {
+        const found = (meta.joints || []).find((j) => j.name === n);
+        return found || { name: n, label: n, min: -3.14, max: 3.14, home: 0 };
+      });
+    }
+
+    if (node.unit === 'deg') {
+      jointsDef = jointsDef.map((j) => {
+        if (j.unit === 'm') return { ...j };
+        const f = 180 / Math.PI;
+        return {
+          ...j,
+          min: j.min * f,
+          max: j.max * f,
+          home: (j.home || 0) * f
+        };
+      });
+    }
+
+    const current = {};
+    for (const j of jointsDef) {
+      current[j.name] = typeof j.home === 'number' ? j.home : 0;
+    }
+
+    let frozen = false;
+    let manualArmed = true;
+    let lastEmit = 0;
+    const rateMs = 50;
+
+    const viewUrl = `/robot-arm/controller/${node.id}`;
+
+    function getMeta() {
+      return {
+        id: node.id,
+        name: node.name,
+        robot: node.robotTag,
+        unit: node.unit,
+        stepSize: node.stepSize,
+        joints: jointsDef,
+        current: { ...current },
+        frozen,
+        manualArmed,
+        controllerUrl: viewUrl
+      };
+    }
+
+    function emitCommand(body) {
+      if (body.freeze != null) frozen = !!body.freeze;
+      if (body.manualArmed != null) manualArmed = !!body.manualArmed;
+
+      if (body.home) {
+        for (const j of jointsDef) {
+          current[j.name] = typeof j.home === 'number' ? j.home : 0;
+        }
+      }
+
+      if (body.joints && typeof body.joints === 'object') {
+        for (const [k, v] of Object.entries(body.joints)) {
+          const n = Number(v);
+          if (Number.isFinite(n)) current[k] = n;
+        }
+      }
+
+      if (current.finger_joint != null) {
+        current.finger_joint_right = current.finger_joint;
+      }
+
+      const now = Date.now();
+      if (!body.force && now - lastEmit < rateMs) {
+        node.status({ fill: 'blue', shape: 'ring', text: viewUrl });
+        return;
+      }
+      lastEmit = now;
+
+      const payload = {
+        robot: node.robotTag,
+        joints: { ...current },
+        unit: node.unit,
+        source: 'pendant',
+        manualArmed,
+        freeze: frozen,
+        ts: now
+      };
+
+      node.send({ payload, topic: frozen ? 'freeze' : 'joints' });
+      node.status({
+        fill: frozen ? 'red' : (manualArmed ? 'green' : 'yellow'),
+        shape: 'dot',
+        text: frozen ? 'FREEZE ' + viewUrl : viewUrl
+      });
+    }
+
+    controllers.set(node.id, {
+      unit: node.unit,
+      robotTag: node.robotTag,
+      getMeta,
+      emitCommand
+    });
+
+    node.status({ fill: 'blue', shape: 'dot', text: viewUrl });
+
+    node.on('input', function (msg, send, done) {
+      try {
+        const p = msg.payload;
+        if (p === 'home' || (p && p.home)) {
+          emitCommand({ home: true, force: true });
+        } else if (p && typeof p === 'object') {
+          emitCommand(Object.assign({ force: true }, p));
+        }
+        if (done) done();
+      } catch (err) {
+        if (done) done(err);
+        else node.error(err, msg);
+      }
+    });
+
+    node.on('close', function (removed, done) {
+      controllers.delete(node.id);
+      if (done) done();
+    });
+  }
+
+  RED.nodes.registerType('robot-arm-controller', ControllerNode);
+};

package/nodes/robot.html

@@ -0,0 +1,109 @@
+<script type="text/javascript">
+  RED.nodes.registerType('robot-arm', {
+    category: 'robotics',
+    color: '#3D7EA6',
+    defaults: {
+      name: { value: '' },
+      robotTag: { value: 'robot' },
+      modelPreset: { value: 'ur5e' },
+      urdfPath: { value: '' },
+      unit: { value: 'rad' },
+      rosbridgeEnable: { value: false },
+      rosbridgeUrl: { value: 'ws://localhost:9090' },
+      jointStatesTopic: { value: '/joint_states' },
+      publishTopic: { value: '' }
+    },
+    inputs: 1,
+    outputs: 1,
+    icon: 'font-awesome/fa-android',
+    label: function () {
+      return this.name || 'robot-arm';
+    },
+    labelStyle: function () {
+      return this.name ? 'node_label_italic' : '';
+    },
+    paletteLabel: 'robot-arm',
+    oneditprepare: function () {
+      function toggleRos() {
+        var on = $('#node-input-rosbridgeEnable').is(':checked');
+        $('.rosbridge-opt').toggle(on);
+      }
+      $('#node-input-rosbridgeEnable').on('change', toggleRos);
+      toggleRos();
+    }
+  });
+</script>
+
+<script type="text/html" data-template-name="robot-arm">
+  <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="Name">
+  </div>
+  <div class="form-row">
+    <label for="node-input-robotTag"><i class="fa fa-robot"></i> Robot tag</label>
+    <input type="text" id="node-input-robotTag" placeholder="robot">
+  </div>
+  <div class="form-row">
+    <label for="node-input-modelPreset"><i class="fa fa-cube"></i> Model</label>
+    <select id="node-input-modelPreset">
+      <option value="ur5e">UR5e (STL meshes)</option>
+      <option value="ur5e-gripper">UR5e + simple gripper</option>
+    </select>
+  </div>
+  <div class="form-row">
+    <label for="node-input-urdfPath"><i class="fa fa-file"></i> URDF override</label>
+    <input type="text" id="node-input-urdfPath" placeholder="optional (unused — use preset)">
+  </div>
+  <div class="form-row">
+    <label for="node-input-unit"><i class="fa fa-ruler"></i> Unit</label>
+    <select id="node-input-unit">
+      <option value="rad">radians</option>
+      <option value="deg">degrees</option>
+    </select>
+  </div>
+  <hr>
+  <div class="form-row">
+    <label for="node-input-rosbridgeEnable"><i class="fa fa-plug"></i> ROS2</label>
+    <input type="checkbox" id="node-input-rosbridgeEnable" style="display:inline-block; width:auto; vertical-align:baseline;">
+    <span> Enable rosbridge WebSocket</span>
+  </div>
+  <div class="form-row rosbridge-opt">
+    <label for="node-input-rosbridgeUrl"><i class="fa fa-link"></i> URL</label>
+    <input type="text" id="node-input-rosbridgeUrl" placeholder="ws://host:9090">
+  </div>
+  <div class="form-row rosbridge-opt">
+    <label for="node-input-jointStatesTopic"><i class="fa fa-arrow-down"></i> Subscribe</label>
+    <input type="text" id="node-input-jointStatesTopic" placeholder="/joint_states">
+  </div>
+  <div class="form-row rosbridge-opt">
+    <label for="node-input-publishTopic"><i class="fa fa-arrow-up"></i> Publish</label>
+    <input type="text" id="node-input-publishTopic" placeholder="optional /joint_command">
+  </div>
+  <div class="form-tips">
+    After deploy, open the 3D view URL on the node status
+    (<code>/robot-arm/view/&lt;node-id&gt;</code>). For Dashboard 2, place
+    <b>ui-ur5e-arm</b> + <b>ui-ur5e-controller</b> on the same page and select this robot-arm node.
+  </div>
+</script>
+
+<script type="text/html" data-help-name="robot-arm">
+  <p>Robot arm node: loads a UR5e URDF with STL meshes, shows a Three.js 3D view, accepts joint commands on the input, and optionally mirrors ROS2 <code>JointState</code> via rosbridge.</p>
+  <h3>Inputs</h3>
+  <dl class="message-properties">
+    <dt>payload <span class="property-type">object | array</span></dt>
+    <dd>Canonical <code>{ joints, unit, source }</code>, ROS JointState-like <code>{ name, position }</code>, flat joint map, or positional array.</dd>
+  </dl>
+  <h3>Outputs</h3>
+  <dl class="message-properties">
+    <dt>payload <span class="property-type">object</span></dt>
+    <dd>Current joint state: <code>{ robot, joints, unit, source, ts }</code>.</dd>
+  </dl>
+  <h3>3D view</h3>
+  <p>Self-contained viewer at <code>/robot-arm/view/&lt;id&gt;</code>. Dashboard 2 users can embed via <b>ui-ur5e-arm</b>.</p>
+  <h3>Priority</h3>
+  <p>Last-writer wins with source tags. Pendant/controller with manual armed briefly preferred over rosbridge (~2 s).</p>
+  <h3>Safety</h3>
+  <p><b>NOT SIL-rated.</b> Simulation / soft UI only. Do not use as a safety controller for real hardware.</p>
+  <h3>More</h3>
+  <p><a href="https://github.com/t-teja/node-red-contrib-robot-arm#readme" target="_blank">Usage guide on GitHub</a></p>
+</script>

package/nodes/robot.js

@@ -0,0 +1,347 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const { DEFAULT_JOINT_NAMES } = require('../lib/normalize');
+const { RosbridgeClient } = require('../lib/rosbridge');
+const { RobotRuntime } = require('../lib/robot-runtime');
+
+const PKG_ROOT = path.join(__dirname, '..');
+const MODEL_PRESETS = {
+  ur5e: {
+    dir: path.join(PKG_ROOT, 'models', 'ur5e'),
+    urdf: 'ur5e.urdf',
+    jointsMeta: 'joints.json'
+  },
+  'ur5e-gripper': {
+    dir: path.join(PKG_ROOT, 'models', 'ur5e-gripper'),
+    urdf: 'ur5e_gripper.urdf',
+    jointsMeta: 'joints.json'
+  }
+};
+
+/** @type {Map<string, object>} */
+const instances = new Map();
+
+function listRobotInstances() {
+  const out = [];
+  for (const [id, inst] of instances.entries()) {
+    out.push({
+      id,
+      name: inst.name || '',
+      robotTag: inst.robotTag || 'robot',
+      modelPreset: inst.modelPreset,
+      viewUrl: `/robot-arm/view/${id}`,
+      pendantUrl: `/robot-arm/pendant/${id}`
+    });
+  }
+  return out;
+}
+
+function getInstance(id) {
+  return instances.get(id) || null;
+}
+
+module.exports = function (RED) {
+  let httpMounted = false;
+
+  function ensureHttpRoutes() {
+    if (httpMounted) return;
+    httpMounted = true;
+
+    const express = RED.httpNode;
+    const resourcesDir = path.join(PKG_ROOT, 'resources');
+    const modelsDir = path.join(PKG_ROOT, 'models');
+
+    function allowEmbed(res) {
+      // Permit same-origin Dashboard 2 iframes; do not set X-Frame-Options: DENY.
+      res.removeHeader('X-Frame-Options');
+      res.setHeader('Content-Security-Policy', "frame-ancestors 'self'");
+    }
+
+    express.get('/robot-arm/static/:file', function (req, res) {
+      const file = path.basename(req.params.file);
+      const full = path.join(resourcesDir, file);
+      if (!full.startsWith(resourcesDir) || !fs.existsSync(full)) {
+        res.status(404).send('Not found');
+        return;
+      }
+      res.sendFile(full);
+    });
+
+    // Nested model assets: /robot-arm/models/ur5e/ur5e.urdf and .../meshes/base.stl
+    express.get(/^\/robot-arm\/models\/([^/]+)\/(.+)$/, function (req, res) {
+      const preset = path.basename(req.params[0]);
+      const rel = String(req.params[1] || '').replace(/^\/+/, '');
+      if (!rel || rel.split('/').some((p) => p === '..')) {
+        res.status(400).send('Bad path');
+        return;
+      }
+      const base = path.join(modelsDir, preset);
+      const full = path.normalize(path.join(base, rel));
+      if (!full.startsWith(base) || !fs.existsSync(full) || !fs.statSync(full).isFile()) {
+        res.status(404).send('Not found');
+        return;
+      }
+      if (/\.urdf$/i.test(rel) || /\.xml$/i.test(rel)) {
+        res.type('application/xml');
+      } else if (/\.json$/i.test(rel)) {
+        res.type('application/json');
+      } else if (/\.stl$/i.test(rel)) {
+        res.type('model/stl');
+      }
+      res.sendFile(full);
+    });
+
+    express.get('/robot-arm/view/:id', function (req, res) {
+      const id = req.params.id;
+      const inst = instances.get(id);
+      if (!inst) {
+        res.status(404).send('Unknown robot node id. Deploy the flow first.');
+        return;
+      }
+      const htmlPath = path.join(resourcesDir, 'viewer.html');
+      let html = fs.readFileSync(htmlPath, 'utf8');
+      const preset = MODEL_PRESETS[inst.modelPreset] || MODEL_PRESETS.ur5e;
+      html = html
+        .replace(/__NODE_ID__/g, id)
+        .replace(/__PRESET__/g, inst.modelPreset || 'ur5e')
+        .replace(/__URDF__/g, preset.urdf)
+        .replace(/__UNIT__/g, inst.unit || 'rad');
+      allowEmbed(res);
+      res.type('html').send(html);
+    });
+
+    // Robot-bound teach pendant (used by Dashboard 2 ui-ur5e-controller iframe)
+    express.get('/robot-arm/pendant/:id', function (req, res) {
+      const id = req.params.id;
+      const inst = instances.get(id);
+      if (!inst) {
+        res.status(404).send('Unknown robot node id. Deploy the flow first.');
+        return;
+      }
+      const htmlPath = path.join(resourcesDir, 'pendant.html');
+      let html = fs.readFileSync(htmlPath, 'utf8');
+      html = html
+        .replace(/__NODE_ID__/g, id)
+        .replace(/__UNIT__/g, inst.unit || 'rad')
+        .replace(/__ROBOT__/g, inst.robotTag || 'robot');
+      allowEmbed(res);
+      res.type('html').send(html);
+    });
+
+    express.get('/robot-arm/api/robots', function (req, res) {
+      res.json({ robots: listRobotInstances() });
+    });
+
+    express.get('/robot-arm/api/:id/state', function (req, res) {
+      const id = req.params.id;
+      const inst = instances.get(id);
+      if (!inst) {
+        res.status(404).json({ error: 'unknown' });
+        return;
+      }
+      const wantStream = req.query.stream === '1' || (req.headers.accept || '').includes('text/event-stream');
+      if (wantStream) {
+        res.setHeader('Content-Type', 'text/event-stream');
+        res.setHeader('Cache-Control', 'no-cache');
+        res.setHeader('Connection', 'keep-alive');
+        res.flushHeaders && res.flushHeaders();
+        const send = () => {
+          res.write(`data: ${JSON.stringify(inst.getPublicState())}\n\n`);
+        };
+        send();
+        const onUpdate = () => send();
+        inst.clients.add(onUpdate);
+        req.on('close', () => {
+          inst.clients.delete(onUpdate);
+        });
+        return;
+      }
+      res.json(inst.getPublicState());
+    });
+
+    function readJson(req, cb) {
+      if (req.body && typeof req.body === 'object' && !Buffer.isBuffer(req.body)) {
+        cb(null, req.body);
+        return;
+      }
+      let raw = '';
+      req.setEncoding('utf8');
+      req.on('data', (c) => { raw += c; });
+      req.on('end', () => {
+        if (!raw) return cb(null, {});
+        try { cb(null, JSON.parse(raw)); }
+        catch (e) { cb(e); }
+      });
+    }
+
+    express.post('/robot-arm/api/:id/joints', function (req, res) {
+      const id = req.params.id;
+      const inst = instances.get(id);
+      if (!inst) {
+        res.status(404).json({ error: 'unknown' });
+        return;
+      }
+      readJson(req, (err, body) => {
+        if (err || !body || typeof body !== 'object') {
+          res.status(400).json({ error: 'body required' });
+          return;
+        }
+        inst.applyCommand(body, body.source || 'http');
+        res.json({ ok: true });
+      });
+    });
+  }
+
+  function RobotNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+
+    ensureHttpRoutes();
+
+    node.name = config.name || '';
+    node.modelPreset = config.modelPreset || 'ur5e';
+    if (!MODEL_PRESETS[node.modelPreset]) node.modelPreset = 'ur5e';
+    node.urdfPath = (config.urdfPath || '').trim();
+    node.unit = config.unit === 'deg' ? 'deg' : 'rad';
+    node.rosbridgeEnable = !!config.rosbridgeEnable;
+    node.rosbridgeUrl = (config.rosbridgeUrl || 'ws://localhost:9090').trim();
+    node.jointStatesTopic = (config.jointStatesTopic || '/joint_states').trim();
+    node.publishTopic = (config.publishTopic || '').trim();
+    node.robotTag = (config.robotTag || config.name || 'robot').trim() || 'robot';
+
+    const preset = MODEL_PRESETS[node.modelPreset] || MODEL_PRESETS.ur5e;
+    let jointsMeta = { joints: DEFAULT_JOINT_NAMES.map((n) => ({ name: n })) };
+    try {
+      const metaPath = path.join(preset.dir, preset.jointsMeta);
+      if (fs.existsSync(metaPath)) {
+        jointsMeta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+      }
+    } catch (err) {
+      node.warn('Could not load joints meta: ' + err.message);
+    }
+
+    let ros = null;
+    let rosStatus = node.rosbridgeEnable ? 'connecting' : 'disabled';
+
+    const runtime = new RobotRuntime({
+      robotTag: node.robotTag,
+      unit: node.unit,
+      jointsMeta: jointsMeta.joints || [],
+      publishTopic: node.publishTopic,
+      getRosbridgeStatus: () => rosStatus,
+      onPublish: (topic, type, msg) => {
+        if (ros) ros.publish(topic, type, msg);
+      }
+    });
+
+    function getPublicState() {
+      return runtime.getPublicState({
+        id: node.id,
+        name: node.name,
+        modelPreset: node.modelPreset,
+        viewUrl: `/robot-arm/view/${node.id}`,
+        pendantUrl: `/robot-arm/pendant/${node.id}`,
+        urdf: preset.urdf
+      });
+    }
+
+    function setStatus() {
+      const rb = node.rosbridgeEnable ? ` | ros:${rosStatus}` : '';
+      node.status({
+        fill: rosStatus === 'connected' ? 'green' : (node.rosbridgeEnable ? 'yellow' : 'blue'),
+        shape: 'dot',
+        text: `view /robot-arm/view/${node.id}${rb}`
+      });
+    }
+
+    function applyCommand(payload, defaultSource) {
+      const result = runtime.applyCommand(payload, defaultSource);
+      if (result.frozen) {
+        node.send({
+          payload: getPublicState(),
+          topic: 'status',
+          frozen: true
+        });
+        return false;
+      }
+      if (!result.applied) return false;
+      node.send({ payload: result.out, topic: 'joints' });
+      return true;
+    }
+
+    const inst = {
+      id: node.id,
+      name: node.name,
+      robotTag: node.robotTag,
+      modelPreset: node.modelPreset,
+      unit: node.unit,
+      urdf: preset.urdf,
+      clients: runtime.clients,
+      runtime,
+      getPublicState,
+      applyCommand
+    };
+    instances.set(node.id, inst);
+
+    node.on('input', function (msg, send, done) {
+      send = send || node.send.bind(node);
+      try {
+        const payload = msg.payload;
+        if (msg.source && payload && typeof payload === 'object' && !Array.isArray(payload)) {
+          payload.source = payload.source || msg.source;
+        }
+        applyCommand(payload, msg.source || 'input');
+        if (done) done();
+      } catch (err) {
+        if (done) done(err);
+        else node.error(err, msg);
+      }
+    });
+
+    if (node.rosbridgeEnable) {
+      ros = new RosbridgeClient({ url: node.rosbridgeUrl });
+      ros.on('status', (s) => {
+        rosStatus = s;
+        setStatus();
+      });
+      ros.on('error', (err) => {
+        node.warn('rosbridge: ' + (err && err.message ? err.message : String(err)));
+      });
+      if (node.publishTopic) {
+        ros.advertise(node.publishTopic, 'sensor_msgs/JointState');
+      }
+      ros.subscribe(node.jointStatesTopic, 'sensor_msgs/JointState', (rosMsg) => {
+        applyCommand({
+          name: rosMsg.name,
+          position: rosMsg.position,
+          source: 'rosbridge',
+          unit: 'rad'
+        }, 'rosbridge');
+      });
+      ros.connect();
+      rosStatus = 'connecting';
+    } else {
+      rosStatus = 'disabled';
+    }
+
+    setStatus();
+
+    node.on('close', function (removed, done) {
+      instances.delete(node.id);
+      if (ros) {
+        ros.close();
+        ros = null;
+      }
+      runtime.clients.clear();
+      if (done) done();
+    });
+  }
+
+  RED.nodes.registerType('robot-arm', RobotNode);
+};
+
+module.exports.MODEL_PRESETS = MODEL_PRESETS;
+module.exports.listRobotInstances = listRobotInstances;
+module.exports.getInstance = getInstance;