@tier0/node-opc-da 1.0.7

package/src/opcBrowser.js

@@ -0,0 +1,285 @@
+//@ts-check
+/*
+  Copyright: (c) 2019, Guilherme Francescon Cittolin <gfcittolin@gmail.com>
+  GNU General Public License v3.0+ (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+*/
+
+const constants = require('./constants.js');
+const {CallBuilder, ComString, ComValue, Types, Pointer, Flags} = require('node-dcom');
+const EnumString = require('./enumString');
+const util = require('util');
+const debug = util.debuglog('node-opc-da');
+
+/**
+ * Represents an OPC Browser
+ */
+class OPCBrowser {
+
+  constructor() {
+    this._comObj = null;
+  }
+
+  /**
+   *
+   * @param {*} unknown
+   * @returns {Promise<?>}
+   */
+  async init(unknown) {
+    debug("Initing OPCBrowser...");
+    if (this._comObj) throw new Error("Already initialized");
+
+    this._comObj = await unknown.queryInterface(constants.iid.IOPCBrowseServerAddressSpace_IID);
+
+    debug("OPCBrowser successfully created.");
+  }
+
+  async end() {
+    debug("Destroying OPCBrowser...");
+    if (!this._comObj) return;
+
+    let obj = this._comObj;
+    this._comObj = null;
+    await obj.release();
+    debug("OPCBrowser successfully destroyed.");
+  }
+
+  /**
+   *
+   * @returns {Promise<number>}
+   * @opNum 0
+   */
+  async queryOrganization() {
+    debug("Querying OPCServer for items organization...");
+    if (!this._comObj) throw new Error("Not initialized");
+
+    let callObject = new CallBuilder(true);
+    callObject.setOpnum(0);
+
+    callObject.addOutParamAsType(Types.SHORT, Flags.FLAG_NULL);
+
+    let resultObj = await this._comObj.call(callObject);
+
+    let hresult = resultObj.hresult;
+    let result = resultObj.getResults();
+    if (hresult != 0) {
+        if (result.lenght == 0)
+            throw new Error(String(hresult));
+        else 
+            debug(String(new Error(String(hresult))));
+    }
+    debug("Item organization obtained.");
+    return result[0];
+  }
+
+  /**
+   * 
+   * @param {string} position 
+   * @param {number} direction
+   * @returns {Promise<void>}
+   * @opNum 1
+   */
+  async changePosition(position, direction) {
+    debug("Changing browsing position to " + direction);
+    if (!this._comObj) throw new Error("Not initialized");
+
+    let callObject = new CallBuilder(true);
+    callObject.setOpnum(1);
+
+    callObject.addInParamAsShort(direction, Flags.FLAG_NULL);
+    callObject.addInParamAsString(position, Flags.FLAG_REPRESENTATION_STRING_LPWSTR);
+
+    let resultObj = await this._comObj.call(callObject);
+
+    let hresult = resultObj.hresult;
+    let result = resultObj.getResults();
+    if (hresult != 0) {
+        if (result.lenght == 0)
+          throw new Error(String(hresult));
+        else { 
+          if (hresult == 1) {
+            if (direction == constants.opc.browse.direction.TO)
+              debug("Already on top directory.");
+            else if (direction == constants.opc.browse.direction.DOWN)
+              debug("There is not directory to go down to.");
+            else if (direction == constants.opc.browse.direction.UP)
+              debug("There is not directory to go up to. Already on top directory");
+          } else if (hresult == 0x80004001) {
+              debug ("Browsing is not implemented by the server");
+          }
+        }
+    }
+    debug("Browsing position successfully changed.");
+  }
+
+  /**
+   * 
+   * @param {number} type 
+   * @param {string} [filter=""]
+   * @param {number} [dataType=0]
+   * @param {number} [accessRights=0]
+   * @returns {Promise<EnumString>}
+   * @opNum 2
+   */
+  async browse(type, filter, accessRights, dataType) {
+    debug("Browsing OPCServer with type: " + type + " filter: " + filter + " accessRights: " + accessRights + " dataType: " + dataType + "...");
+    if (!this._comObj) throw new Error("Not initialized");
+
+    let callObject = new CallBuilder(true);
+    callObject.setOpnum(2);
+
+    callObject.addInParamAsShort(type, Flags.FLAG_NULL);
+    callObject.addInParamAsString(filter, Flags.FLAG_REPRESENTATION_STRING_LPWSTR);
+    callObject.addInParamAsShort(dataType, Flags.FLAG_NULL);
+    callObject.addInParamAsInt(accessRights, Flags.FLAG_NULL);
+    callObject.addOutParamAsType(Types.COMOBJECT, Flags.FLAG_NULL);
+
+    let resultObj = await this._comObj.call(callObject);
+
+    let hresult = resultObj.hresult;
+    let result = resultObj.getResults();
+    if (hresult != 0) {
+        if (result.lenght == 0)
+          throw new Error(String(hresult));
+        else {
+          if (hresult == 1) { 
+            if (type == constants.opc.browse.type.LEAF)
+              debug("No more leafs found for the current level.");
+            else if (type = constants.opc.browse.type.BRANCH)
+              debug("No more branches found for the current level.")
+          } else if (hresult == 0x80004001) {
+              debug("Browsing is not implemented by the server");
+          }
+        }
+    }
+
+    let enumResults = new EnumString();
+    await enumResults.init(result[0].getValue());
+    debug("Browsing request successfully executed.");
+    return enumResults;
+  }
+
+  /**
+   * Gets the complete item id from an item at the local position.
+   *
+   * Browsing a hierarchical namespace the browse method will return items based on the
+   * local level in the namespace. So actually only the last part of the item ID hierarchy
+   * is returned. In order to convert this to the full item ID one can use this method. It
+   * will only work if the browser is still at the position in question.
+   * 
+   * @param {string} item the local item
+   * @returns {Promise<string>} the complete item ID
+   * @opNum 3
+   */
+  async getItemID(item) {
+    debug("Querying OPCServer for itemID: " + item + "...");
+    if (!this._comObj) throw new Error("Not initialized");
+
+    let callObject = new CallBuilder(true);
+    callObject.setOpnum(3);
+
+    let strValue = new ComValue(new ComString(Flags.FLAG_REPRESENTATION_STRING_LPWSTR), Types.COMSTRING);
+    let strPointerValue = new ComValue(new Pointer(strValue), Types.POINTER);
+    callObject.addInParamAsString(item, Flags.FLAG_REPRESENTATION_STRING_LPWSTR );
+    callObject.addOutParamAsObject(strPointerValue, Flags.FLAG_NULL);
+
+    let resultObj = await this._comObj.call(callObject);
+
+    let hresult = resultObj.hresult;
+    let result = resultObj.getResults();
+    if (hresult != 0) {
+        if (result.lenght == 0)
+            throw new Error(String(hresult));
+        else 
+            debug(new Error(String(hresult)));
+    }
+
+    let resultPtr = result[0].getValue();
+    let resultPtrRef = resultPtr.getReferent();
+    debug("Item request successfully executed.");
+    return resultPtrRef.getString();
+  }
+
+  /**
+   * Returns the possible access paths for an item
+   * 
+   * @param {string} itemID the item to query
+   * @returns {Promise<EnumString>} the complete item ID
+   * @opNum 4
+   */
+  async browseAccessPaths(itemID) {
+    debug("Querying OPCServer for browseAcessPaths for the item " + itemID + "...");
+    if (!this._comObj) throw new Error("Not initialized");
+
+    let callObject = new CallBuilder(true);
+    callObject.setOpnum(4);
+
+    callObject.addInParamAsString(itemID, Flags.FLAG_REPRESENTATION_STRING_LPWSTR);
+    callObject.addOutParamAsType (Types.COMOBJECT, Flags.FLAG_NULL );
+
+    let resultObj = await this._comObj.call(callObject);
+
+    let hresult = resultObj.hresult;
+    let result = resultObj.getResults();
+    if (hresult != 0) {
+        if (result.lenght == 0)
+            throw new Error(String(hresult));
+        else 
+            debug(new Error(String(hresult)));
+    }
+
+    let enumResults = new EnumString();
+    await enumResults.init(result[0]);
+    debug("Item browseAccessPaths successfully obtained.");
+    return enumResults;
+  }
+
+  // -------
+
+  /**
+   * @returns {Promise<Array<string>>} an array with all items in a flat address space
+   */
+  async browseAllFlat() {
+    debug("Browsing OPCServer on Flat mode...");
+    await this.changePosition(null, constants.opc.browse.direction.TO);
+    let enumItems = await this.browse(constants.opc.browse.type.FLAT)
+      .catch(function(reject) {
+        throw reject;
+      });
+    
+    let result =  await enumItems.asArray();
+    debug("Successfully browsed OPCServer and obtained " + result.length + " items.");
+    return result;
+  }
+
+  /**
+   * @returns {Promise<object>} an object representing the hierarchy of items
+   */
+  async browseAllTree() {
+    await this.changePosition(null, constants.opc.browse.direction.TO);
+    return await this.browseLevel();
+  }
+
+  /**
+   * change the browsing level
+   */
+  async browseLevel() {
+    let res = {}
+   
+    // get items on this level
+    let enumItems = await this.browse(constants.opc.browse.type.LEAF);
+    let items = await enumItems.asArray();
+    for (const item of items) {
+      res[item] = await this.getItemID(item);
+    }
+    let enumBranches = await this.browse(constants.opc.browse.type.BRANCH);
+    let branches = await enumBranches.asArray();
+    for (const branch of branches) {
+      await this.changePosition(branch, constants.opc.browse.direction.DOWN);
+      res[branch] = await this.browseLevel();
+      await this.changePosition(null, constants.opc.browse.direction.UP);
+    }
+    return res;
+  }
+}
+
+module.exports = OPCBrowser;

package/src/opcCommon.js

@@ -0,0 +1,84 @@
+//@ts-check
+/*
+  Copyright: (c) 2019, Guilherme Francescon Cittolin <gfcittolin@gmail.com>
+  GNU General Public License v3.0+ (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+*/
+
+const constants = require('./constants.js');
+
+/**
+ * Represents an OPC Server
+ */
+class OPCCommon {
+
+  constructor() {
+    this._comObj = null;
+  }
+
+  /**
+   *
+   * @param {*} unknown
+   * @returns {Promise<?>}
+   */
+  async init(unknown) {
+    if (this._comObj) throw new Error("Already initialized");
+
+    this._comObj = await unknown.queryInterface(constants.iid.IOPCCommon_IID);
+  }
+
+  async end() {
+    if (!this._comObj) return;
+
+    let obj = this._comObj;
+    this._comObj = null;
+    await obj.release();
+  }
+
+  /**
+   * 
+   * @param {number} localeId 
+   * @opNum 0
+   */
+  async setLocaleID(localeId) {
+    if (!this._comObj) throw new Error("Not initialized");
+
+  }
+
+  /**
+   * @returns the current localeID
+   * @opNum 1
+   */
+  async getLocaleID() {
+    if (!this._comObj) throw new Error("Not initialized");
+  }
+
+  /**
+   * @returns the available localeIDs
+   * @opNum 2
+   */
+  async queryAvailableLocaleIDs() {
+    if (!this._comObj) throw new Error("Not initialized");
+  }
+
+  /**
+   * 
+   * @param {number} error 
+   * @param {number} [localeID]
+   * @returns a descriptive error string for the error code
+   * @opNum 3
+   */
+  async getErrorString(error, localeID) {
+    if (!this._comObj) throw new Error("Not initialized");
+  }
+
+  /**
+   * 
+   * @param {string} name the client name
+   * @opNum 4
+   */
+  async setClientName(name) {
+    if (!this._comObj) throw new Error("Not initialized");
+  }
+}
+
+module.exports = OPCCommon;

package/src/opcGroupStateManager.js

@@ -0,0 +1,248 @@
+//@ts-check
+/*
+  Copyright: (c) 2019, Guilherme Francescon Cittolin <gfcittolin@gmail.com>
+  GNU General Public License v3.0+ (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+*/
+
+const constants = require('./constants.js');
+const OPCItemManager = require('./opcItemManager.js');
+const OPCSyncIO = require('./opcSyncIO.js');
+const OPCAsyncIO = require('./opcAsyncIO.js');
+const util = require('util');
+const debug = util.debuglog('node-opc-da');
+const { EventEmitter } = require('events');
+
+const { CallBuilder, ComString, ComValue, Flags, Pointer, types} = require('node-dcom');
+
+
+/**
+ * Group properties
+ * @typedef {object} GroupProperties
+ * @property {number} updateRate
+ * @property {boolean} active
+ * @property {number} timeBias
+ * @property {number} deadband
+ * @property {number} localeID
+ * @property {number} [clientHandle]
+ * @property {number} [serverHandle]
+ *
+ */
+
+/**
+ * Represents an OPC Server
+ * @emits data
+ */
+class OPCGroupStateManager extends EventEmitter {
+
+  constructor() {
+    super();
+
+    this._opcItemManager = null;
+    this._syncIO = null;
+    this._asyncIO = null;
+  }
+
+  /**
+   *
+   * @param {*} unknown
+   * @returns {Promise<?>}
+   */
+  async init(unknown) {
+    debug("Initing opcGroupStateManager...");
+    if (this._comObj) throw new Error("Already initialized");
+
+    this._comObj = await unknown.queryInterface(constants.iid.IOPCGroupStateMgt_IID);
+    debug("opcGroupStateManager successfully inited");
+  }
+
+  async end() {
+    debug("Destryoing opcGroupStateManager...")
+    if (!this._comObj) return;
+
+    let obj = this._comObj;
+    let opcItemManager = this._opcItemManager;
+    let syncIO = this._syncIO;
+    let asyncIO = this._asyncIO;
+    this._comObj = null;
+    this._opcItemManager = null;
+    this._syncIO = null;
+    this._asyncIO = null;
+
+    //TODO maybe paralelize this with Promise.all
+    if (opcItemManager) await opcItemManager.end();
+    if (syncIO) await syncIO.end();
+    if (asyncIO) await asyncIO.end();
+    await obj.release();
+
+    debug("opcGroupStateManager successfully desroyed.");
+  }
+
+  /**
+   * @returns {Object<{name: string}, {state: GroupProperties}}>}
+   */
+  async getState() {
+    debug("Querying OPCServer for the current state of the group...");
+    if (!this._comObj) throw new Error("Not initialized");
+
+    let callObject = new CallBuilder(true);
+    callObject.setOpnum(0);
+
+    let namePtr = new Pointer(new ComValue(new ComString(Flags.FLAG_REPRESENTATION_STRING_LPWSTR), types.COMSTRING));
+
+    callObject.addOutParamAsType(types.INTEGER, Flags.FLAG_NULL);
+    callObject.addOutParamAsType(types.BOOLEAN, Flags.FLAG_NULL);
+    callObject.addOutParamAsObject(new ComValue(namePtr, types.POINTER), Flags.FLAG_NULL);
+    callObject.addOutParamAsType(types.INTEGER, Flags.FLAG_NULL);
+    callObject.addOutParamAsType(types.FLOAT, Flags.FLAG_NULL);
+    callObject.addOutParamAsType(types.INTEGER, Flags.FLAG_NULL);
+    callObject.addOutParamAsType(types.INTEGER, Flags.FLAG_NULL);
+    callObject.addOutParamAsType(types.INTEGER, Flags.FLAG_NULL);
+
+    let result = await this._comObj.call(callObject);
+
+    debug("Group State successfully obtained.");
+    return {
+      name: result[2].getReferent().getString(),
+      state: {
+        updateRate: result[0],
+        active: result[1],
+        timeBias: result[3],
+        deadband: result[4],
+        localeID: result[5],
+        clientHandle: result[6],
+        serverHandle: result[7]
+      }
+    }
+  }
+
+  /**
+   * 
+   * @param {GroupProperties} state
+   * @returns {Promise<number>} the granted update rate
+   * @opNum 1
+   */
+  async setState(state) {
+    debug("Querying OPCServer to set the group properties: " + state);
+    if (!this._comObj) throw new Error("Not initialized");
+
+    let callObject = new CallBuilder(true);
+    callObject.setOpnum(1);
+
+    let activeCV = state.active === null ? null : new ComValue(state.active ? 1 : 0, types.INTEGER);
+
+    callObject.addInParamAsPointer(new Pointer(new ComValue(state.updateRate, types.INTEGER)), Flags.FLAG_NULL);
+    callObject.addInParamAsPointer(new Pointer(activeCV), Flags.FLAG_NULL);
+    callObject.addInParamAsPointer(new Pointer(new ComValue(state.timeBias, types.INTEGER)), Flags.FLAG_NULL);
+    callObject.addInParamAsPointer(new Pointer(new ComValue(state.deadband, types.FLOAT)), Flags.FLAG_NULL);
+    callObject.addInParamAsPointer(new Pointer(new ComValue(state.localeID, types.INTEGER)), Flags.FLAG_NULL);
+    callObject.addInParamAsPointer(new Pointer(new ComValue(state.clientHandle, types.INTEGER)), Flags.FLAG_NULL);
+
+    callObject.addOutParamAsType(types.INTEGER, Flags.FLAG_NULL);
+
+    let result = await this._comObj.call(callObject);
+    debug("Group Properties sucessfully set.");
+    return result[0];
+  }
+
+  /**
+   * 
+   * @param {string} name
+   * @returns {Promise<void>}
+   * @opNum 2
+   */
+  async setName(name) {
+    debug("Setting group name to: " + name + "...");
+    if (!this._comObj) throw new Error("Not initialized");
+
+    let callObject = new CallBuilder(true);
+    callObject.setOpnum(2);
+    
+    callObject.addInParamAsString(name, Flags.FLAG_REPRESENTATION_STRING_LPWSTR);
+
+    await this._comObj.call(callObject);
+    debug("Group Name successfully set");
+  }
+
+  /**
+   * 
+   * @param {string} name
+   * @returns {Promise<OPCGroupStateManager>}
+   * @opNum 3
+   */
+  async clone(name) {
+    debug("Cloning group named: " + name + "...");
+    if (!this._comObj) throw new Error("Not initialized");
+
+    let callObject = new CallBuilder(true);
+    callObject.setOpnum(3);
+
+    callObject.addInParamAsString(name, Flags.FLAG_REPRESENTATION_STRING_LPWSTR);
+    callObject.addInParamAsUUID(constants.iid.IOPCGroupStateMgt_IID, Flags.FLAG_NULL);
+    callObject.addOutParamAsType(types.COMOBJECT, Flags.FLAG_NULL);
+
+    let result = await this._comObj.call(callObject);
+
+    let group = new OPCGroupStateManager();
+    await group.init(result[0]);
+
+    return group;
+  }
+
+  /**
+   * enables receiving events to this group
+   * 
+   * @returns {Promise<void>}
+   */
+  async atach() {
+    throw new Error("Not yet supported");
+  }
+
+  /**
+   * @returns {Promise<OPCItemManager>}
+   */
+  async getItemManager() {
+    debug("Querying server for an ItemManager for the current group...");
+    if (!this._comObj) throw new Error("Not initialized");
+
+    if (!this._opcItemManager) {
+      let opcItemManager = new OPCItemManager();
+      await opcItemManager.init(this._comObj);
+      this._opcItemManager = opcItemManager;
+    }
+    debug("ItemManager successfully obtained.");
+    return this._opcItemManager;
+  }
+
+  /**
+   * @returns {Promise<OPCSyncIO>}
+   */
+  async getSyncIO() {
+    debug("Querying OPCServer for a SyncIO object...");
+    if (!this._comObj) throw new Error("Not initialized");
+
+    if (!this._syncIO) {
+      let syncIO = new OPCSyncIO();
+      await syncIO.init(this._comObj);
+      this._syncIO = syncIO;
+    }
+    debug("SyncIO object successfully obtained.");
+    return this._syncIO;
+  }
+
+  /**
+   * @returns {Promise<OPCAsyncIO>}
+   */
+  async getAsyncIO2() {
+    if (!this._comObj) throw new Error("Not initialized");
+
+    if (!this._asyncIO) {
+      let asyncIO = new OPCAsyncIO();
+      await asyncIO.init(this._comObj);
+      this._asyncIO = asyncIO;
+    }
+    return this._asyncIO;
+  }
+
+}
+
+module.exports = OPCGroupStateManager;

package/src/opcItemIO.js

@@ -0,0 +1,60 @@
+//@ts-check
+/*
+  Copyright: (c) 2019, Guilherme Francescon Cittolin <gfcittolin@gmail.com>
+  GNU General Public License v3.0+ (see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt)
+*/
+
+const constants = require('./constants.js');
+
+/**
+ * Represents an OPC Item I/O object
+ */
+class OPCItemIO {
+
+  constructor() {
+    this._comObj = null;
+  }
+
+  /**
+   *
+   * @param {*} unknown
+   * @returns {Promise<?>}
+   */
+  async init(unknown) {
+    if (this._comObj) throw new Error("Already initialized");
+
+    this._comObj = await unknown.queryInterface(constants.iid.IOPCItemIO_IID);
+  }
+
+  async end() {
+    if (!this._comObj) return;
+
+    let obj = this._comObj;
+    this._comObj = null;
+    await obj.release();
+  }
+
+  /**
+   * 
+   * @param {object[]} items
+   * @param {string} items[].itemID
+   * @param {number} items[].maxAge
+   * @returns {Promise<?>}
+   * @opNum 0
+   */
+  async read(items) {
+    if (!this._comObj) throw new Error("Not initialized");
+  }
+
+  /**
+   *
+   * @param {object[]} items ????
+   * @returns {Promise<?>}
+   * @opNum 1
+   */
+  async writeVQT(items) {
+    if (!this._comObj) throw new Error("Not initialized");
+  }
+}
+
+module.exports = OPCItemIO;