@teamcymbeline/node-red-contrib-mcprotocol 0.0.0-stage → 1.4.1

package/nodes/read.js

@@ -0,0 +1,307 @@
+/*
+MIT License
+
+Copyright (c) 2019, 2020 Steve-Mcl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 
+*/
+
+module.exports = function(RED) {
+  var connection_pool = require("../connection_pool.js");
+  function isNumeric(n) {
+    return !isNaN(parseFloat(n)) && isFinite(n);
+  }
+  function mcRead(config) {
+    RED.nodes.createNode(this, config);
+    this.name = config.name;
+    this.topic = config.topic;
+    this.connection = config.connection;
+    this.address = config.address || ""; //address
+    this.addressType = config.addressType || "str";
+    this.outputFormat = config.outputFormat || 0;
+    this.errorHandling = config.errorHandling;
+    this.outputs = config.errorHandling === "output2" ? 2 : 1;//1 output pins if throw or msg.error, 2 outputs if errors to go to seperate output pin
+    this.logLevel = RED.settings.logging.console.level;
+    this.connectionConfig = RED.nodes.getNode(this.connection);
+    var context = this.context();
+    var node = this;
+    node.busy = false;
+    //node.busyMonitor;
+    node.busyTimeMax = 1000; //Initial value, will be updated bt selected connection
+    //var mcprotocol = require('../mcprotocol.js');
+    if (this.connectionConfig) {
+      var options = Object.assign({}, node.connectionConfig.options);
+      options.logLevel = this.logLevel;
+      node.connection = connection_pool.get(
+        this.connectionConfig.port,
+        this.connectionConfig.host,
+        options
+      );
+      if(options.timeout && isNumeric(options.timeout)) node.busyTimeMax = parseInt(options.timeout);
+      
+      node.status({ fill: "yellow", shape: "ring", text: "initialising" });
+
+      this.connection.on("error", function(error) {
+        console.error(error);
+        node.status({ fill: "red", shape: "ring", text: "error" });
+        node.busy = false;
+      });
+      this.connection.on("open", function(error) {
+        node.status({ fill: "green", shape: "dot", text: "connected" });
+      });
+      this.connection.on("close", function(error) {
+        node.status({ fill: "red", shape: "dot", text: "not connected" });
+        node.busy = false;
+      });
+      function handleError(err, msg, node, config, dont_send_msg){
+        if(typeof err === "string"){
+          err = new Error(err);
+        }
+        if(!config) config = {};
+        if(typeof config === "string"){
+          config = {
+            errorHandling: config
+          }
+        }
+        switch (config.errorHandling) {
+          case "throw":
+            node.error(err,msg);
+            break;
+          case "msg":
+            msg.error = err;
+            if(!dont_send_msg) node.send(msg);//send error on 1st pin
+            break;
+          case "output2":
+            node.send([null,{payload: err}]);//send error on 2nd pin
+            break;
+                
+          default:
+            node.error(err,msg);
+            break;
+        }
+      }
+      function myReply(problem, msg) {
+        clearTimeout(node.busyMonitor);
+        if (!node.busy) {
+          return; //not busy - dont process the reply (node may have timed out)
+        }
+        node.busy = false; //reset busy - allow node to be triggered
+        node.msgMem.mcReadDetails = {};
+        node.msgMem.mcReadDetails.request = node.request;
+        node.msgMem.mcReadDetails.response = msg;
+        node.msgMem.mcReadDetails.timeout = msg.timeout; //TODO
+        node.msgMem.mcReadDetails.error = problem;
+        node.msgMem.payload = null;
+        if(problem){
+          msg.problem = true;
+        }
+        if (msg.timeout) {
+          node.status({ fill: "red", shape: "ring", text: "timeout" });
+          handleError("timeout", msg, config);
+          //node.error("timeout", msg);
+          var dbgmsg = {
+            f: "myReply(msg)",
+            msg: msg,
+            error: "timeout"
+          };
+         // console.error(dbgmsg);
+          node.msgMem.mcReadDetails.errorMsg = "timeout";
+          // node.send(node.msgMem);
+          return;
+        }
+
+        if (problem) {
+          node.status({ fill: "grey", shape: "ring", text: "Quality Issue" });
+        } else {
+          node.status({ fill: "green", shape: "dot", text: "Good" });
+        }
+
+        // msg.deviceCode
+        // msg.digitSpec
+        // msg.dataType
+        // msg.deviceNo
+        // msg.isGood
+        // msg.quality
+        // msg.TAG
+        // msg.addr
+        // msg.timeTaken
+        // msg.timeStamp
+        // msg.value
+        // msg.valueType
+
+        var data = msg.value;
+        if (data != null && !problem) {
+          let iWD = msg.deviceNo;
+          let loopBit = 0,
+            bitNo = msg.bitOffset;
+          let JSONData = {};
+          if (node.outputFormat == 0 /*JSON*/) {
+            if (msg.valueType == "CHAR") {
+              if (msg.deviceCodeNotation == "Hexadecimal") {
+                buff_address = `${msg.deviceCode}${Number(iWD)
+                  .toString(16)
+                  .toUpperCase()}`;
+              } else {
+                buff_address = `${msg.deviceCode}${iWD}`;
+              }
+              JSONData[buff_address] = data;
+            } else {
+              if(!Array.isArray(data)) data = [data];
+              for (var x in data) {
+                let buff_address = "";
+                if (msg.dataType == "BIT" && msg.deviceCodeType != "BIT") {
+                  bitNo = msg.bitOffset + loopBit;
+                  if (bitNo == 16) iWD++;
+                  if (bitNo >= 16) {
+                    bitNo = bitNo - 16;
+                  }
+                  if (msg.deviceCodeNotation == "Hexadecimal") {
+                    buff_address = `${msg.deviceCode}${Number(iWD)
+                      .toString(16)
+                      .toUpperCase()}.${Number(bitNo)
+                      .toString(16)
+                      .toUpperCase()}`;
+                  } else {
+                    buff_address = `${msg.deviceCode}${iWD}.${Number(bitNo)
+                      .toString(16)
+                      .toUpperCase()}`;
+                  }
+                  JSONData[buff_address] = data[x];
+                  loopBit++;
+                  if (loopBit >= 16) loopBit = 0;
+                } else {
+                  if (msg.deviceCodeNotation == "Hexadecimal") {
+                    buff_address = `${msg.deviceCode}${Number(iWD)
+                      .toString(16)
+                      .toUpperCase()}`;
+                  } else {
+                    buff_address = `${msg.deviceCode}${iWD}`;
+                  }
+                  JSONData[buff_address] = data[x];
+                  iWD += msg.dataTypeByteLength / 2;
+                }
+              }
+            }
+            node.msgMem.payload = JSONData;
+          } else {
+            node.msgMem.payload = data;
+          }
+        }
+        if(problem) {
+          handleError(msg.error || "", node.msgMem, node, node.errorHandling);
+        } else {
+          node.send(node.msgMem);
+        }
+      }
+
+      this.on("input", function(msg) {
+        if (msg.disconnect === true || msg.topic === "disconnect") {
+          this.connection.closeConnection();
+          return;
+        } else if (msg.connect === true || msg.topic === "connect") {
+          this.connection.connect();
+          return;
+        } else if (msg.reinitialize === true || msg.topic === "reinitialize") {
+          this.connection.reinitialize();
+          return; 
+        }
+
+        if (node.busy) return; //TODO: Consider queueing inputs?
+
+        node.request = undefined;
+        node.msgMem = msg;
+
+        var addr;
+        RED.util.evaluateNodeProperty(
+          node.address,
+          node.addressType,
+          node,
+          msg,
+          (err, value) => {
+            if (err) {
+              handleError("Unable to evaluate address", msg, node, node.errorHandling);
+              //node.error("Unable to evaluate address", msg);
+              node.status({
+                fill: "red",
+                shape: "ring",
+                text: "Unable to evaluate address"
+              });
+              return;
+            } else {
+              addr = value;
+            }
+          }
+        );
+
+        if (addr == "") {
+          handleError("address is empty", msg, node, node.errorHandling);
+          //node.error("address is empty", msg);
+          node.status({ fill: "red", shape: "ring", text: "error" });
+          return;
+        }
+
+        try {
+          node.status({ fill: "yellow", shape: "ring", text: "read" });
+          node.busy = true;
+
+          node.request = {
+            outputFormat: node.outputFormat ? "Array" : "JSON",
+            address: addr,
+            timeStamp: Date.now()
+          };
+
+          if (node.busyTimeMax) {
+            node.busyMonitor = setTimeout(function() {
+              if (node.busy) {
+                node.status({ fill: "red", shape: "ring", text: "timeout" });
+                handleError("timeout", msg, node, node.errorHandling);
+                //node.error("timeout", msg || node.msgMem || {});
+                node.busy = false;
+                return;
+              }
+            }, node.busyTimeMax);
+          }
+          this.connection.read(addr, myReply);
+        } catch (error) {
+          node.busy = false;
+          handleError(error, msg, node, node.errorHandling);
+          //node.error(error, msg || node.msgMem || {});
+          node.status({ fill: "red", shape: "ring", text: "error" });
+          var dbgmsg = {
+            info: "read.js-->on 'input'",
+            connection: `host: ${node.connectionConfig.host}, port: ${node.connectionConfig.port}`,
+            address: addr
+          };
+          node.warn(dbgmsg);
+          return;
+        }
+      });
+      node.status({ fill: "green", shape: "ring", text: "ready" });
+    } else {
+      node.error("configuration not setup");
+      node.status({ fill: "red", shape: "ring", text: "error" });
+    }
+  }
+  RED.nodes.registerType("MC Read", mcRead);
+  mcRead.prototype.close = function() {
+    if (this.connection) {
+      this.connection.disconnect();
+    }
+  };
+};

package/nodes/write.html

@@ -0,0 +1,185 @@
+<!-- 
+MIT License
+
+Copyright (c) 2019, 2020 Steve-Mcl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 
+-->
+
+<script type="text/javascript">
+  function setupTypedInput(varName, types, def) {
+    let varSel = '#node-input-' + varName;
+    let typeSel = varSel + 'Type';
+    let varVal = this[varName];
+    let typeVal = this[varName + 'Type'];
+
+    if (typeVal == null || typeVal === 'none') {
+      typeVal = def;
+    } else if (typeVal === 'string') {
+      typeVal = "str";
+    } else if (typeVal === 'number') {
+      typeVal = "num";
+    }
+    $(typeSel).val(typeVal);
+    $(varSel).typedInput({
+      default: def,
+      typeField: $(typeSel),
+      types: types
+    });
+    $(varSel).typedInput('type', typeVal);
+  }
+  RED.nodes.registerType('MC Write', {
+    category: 'MITSUBISHI',
+    color: '#0090d4',
+    defaults: {
+      name: { value: "" },
+      topic: { value: "" },
+      connection: { type: "MC Protocol Connection", required: true },
+      data: { value: "" },
+      address: { value: "", validate: RED.validators.typedInput("addressType") },
+      addressType: { value: "str" },
+      data: { value: "", validate: RED.validators.typedInput("dataType") },
+      dataType: { value: "str" },
+      errorHandling: { value: "throw" },
+      outputs: { value: 1 }
+    },
+    inputs: 1,
+    outputs: 1,
+    inputLabels: "Trigger request",
+    outputLabels: "Write result",
+    align: "right",
+    icon: "write.png",
+    label: function () {
+      return this.name || "MC Write";
+    },
+    oneditprepare: function () {
+      var sti = setupTypedInput.bind(this);
+      sti('address', ['msg', 'flow', 'global', 'str', 'env'], 'str');//addr
+      sti('data', ['msg', 'flow', 'global','num','str', {
+        value: 'csv',
+        label: 'csv',
+        icon: "red/images/typedInput/09.png"
+      },], 'num');
+    }, 
+    oneditsave: function () {
+      var errH = $("#node-input-errorHandling").val();
+      this.outputs = errH === "output2" ? 2 : 1;//1 output pins if throw or msg.error, 2 outputs if errors to go to seperate output pin
+    }
+  });
+</script>
+
+<style>
+  .mc-protocol-form > .form-row > label {
+    width: 120px !important;
+  }
+</style>
+
+<script type="text/html" data-template-name="MC Write">
+  <div class="mc-protocol-form">
+    <div class="form-row">
+      <label for="node-input-name"><i class="icon-tag"></i> <span data-i18n="write.label.name"> Name</span></label>
+      <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+    <div class="form-row">
+      <label for="node-input-connection"><i class="icon-globe"></i><span data-i18n="write.label.connection"> Connection</span></label>
+      <input type="text" id="node-input-connection">
+    </div>
+    <div class="form-row">
+      <label for="node-input-address"><i class="fa fa-envelope"></i><span data-i18n="ab-df1-read.label.address"> Address</span></label>
+      <input type="hidden" id="node-input-addressType">
+      <input style="width: 70%" type="text" id="node-input-address" placeholder="D0">
+    </div>
+    <div class="form-row">
+      <label for="node-input-data"><i class="fa fa-table"></i> <span data-i18n="write.label.data"> Data</span></label>
+      <input type="hidden" id="node-input-dataType">
+      <input style="width: 70%" type="text" id="node-input-data" >
+    </div>
+    <div class="form-row">
+      <label for="node-input-errorHandling"><i class="fa fa-exclamation"></i><span data-i18n="ab-df1-read.label.errors"> Errors</span></label>
+      <select style="width: 70%" id="node-input-errorHandling">
+        <option value="throw">Throw (default)</option>
+        <option value="msg">Output to msg.error</option>
+        <option value="output2">Send to seperate output</option>
+      </select>
+    </div> 
+  </div>
+</script>
+
+<script type="text/html" data-help-name="MC Write">
+  <p>Write data to an MITSUBISHI PLC using mcprotocol protocol</p>
+  <h3>Inputs</h3>
+  <dl class="message-properties">
+    <dt class="required">Connection<span class="property-type">DF1 Connection</span></dt>
+    <dd>The PLC connection</dd>
+    <dt class="required">Address<span class="property-type">number | string | payload</span></dt>
+    <dd>PLC Memory Address</dd>
+    <dt class="required">Data<span class="property-type">Array&lt;number&gt; | number | string | payload </span></dt>
+    <dd>Data to be written to PLC starting at specified address.</dd>
+    <p><i>INFO: To open / close the MC Protocol connection, send boolean <code>true</code> in <code>msg.connect</code> , <code>msg.disconnect</code> or <code>msg.reinitialize</code>.  Alternatively, send string <code>connect</code>, <code>disconnect</code> or <code>reinitialize</code> in <code>msg.topic</code> to the any mc read / mc write node.</i></p>
+  </dl>
+  <h3>Outputs</h3>
+  <dl class="message-properties">
+    <dt>payload <span class="property-type">boolean</span></dt>
+    <dd>Payload will be <code>true</code> if successful</dd>
+    <dt>mcWriteDetails <span class="property-type">object</span></dt>
+    <dd><code>msg.mcWriteDetails</code> will contain properties like <code>isGood</code>, <code>quality</code>, <code>TAG</code> etc.  The user should inspect these to determine if the PLC write command was unsuccessful.</dd>
+    <dd>Use a debug node to inspect the object</dd>
+  </dl>
+  <h3>Details</h3>
+  <p>
+    If an error occurs the output of this node may still be triggered. 
+    In this case, the payload maybe invalid but the <code>mcWriteDetails</code> will contain additional information about the problem.
+  </p>
+  <p>Address format [DS] DEV [DT] DN [.BIT] [,CNT] [:OPTS]...  
+    <ol>
+      <li>[1] DS	 - {string} Digit specifier (e.g. K4) [optional]</li>
+      <li>[2] DEV  - {string} Device (Y|X|D|F|W|B|R|etc)</li>
+      <li>[3] DT 	 - {string} Data type (REAL|FLOAT|STR|WORD|DWORD|DINT|UINT) [optional]</li>
+      <li>[4] DN 	 - {int} Device number</li>
+      <li>[5] BIT  - {int} Bit number [optional]</li>
+      <li>[6] CNT  - {int} Count of items [optional]</li>
+      <li>[7] OPTS - {JSON} Options for specifying network and station e.g. {N:2,S:3} would attempt to route the message to station 3 on network 2 [optional]</li>
+    </ol>
+    <i>Notes...<br>DS and DT should not be used together. <br>if CNT is omitted, then <code>1</code> is assumed. <br>DN may be DEC or HEX depending on the notation of the Device e.g. YA, X1E, WBA4, B3D   </i> 
+  </p>
+  <p>data must match the address style e.g...
+    <table>
+      <tr>
+        <td>Address Example</td>
+        <td>Expected Type</td>
+        <td>Notes</td>
+        </tr>
+      <tr>
+        <td>K4Y0</td>
+        <td>int</td>
+        <td>−32,768 to 32,767</td>
+        </tr>
+      <tr>
+        <td>DSTR0,10</td>
+        <td>string</td>
+        <td>Upto 10 chars long</td>
+        </tr>
+      <tr>
+        <td>DUINT0,10</td>
+        <td>UINT[10]</td>
+        <td>10 WD array containing values 0 to 65535</td>
+        </tr>
+    </table>
+  </p>
+</script>