node-opcua-address-space 2.51.0

package/src/alarms_and_conditions/ua_non_exclusive_deviation_alarm_impl.ts

@@ -0,0 +1,108 @@
+/**
+ * @module node-opcua-address-space.AlarmsAndConditions
+ */
+
+import { assert } from "node-opcua-assert";
+
+import { DataValue } from "node-opcua-data-value";
+import { NodeId } from "node-opcua-nodeid";
+import { DataType } from "node-opcua-variant";
+import { UANonExclusiveDeviationAlarm_Base, UANonExclusiveLimitAlarm_Base } from "node-opcua-nodeset-ua";
+
+import { UAVariable, UAVariableT } from "../../source";
+import { NamespacePrivate } from "../namespace_private";
+import { AddressSpace } from "../address_space";
+import {
+    DeviationAlarmHelper_getSetpointNodeNode,
+    DeviationAlarmHelper_getSetpointValue,
+    DeviationAlarmHelper_install_setpoint,
+    DeviationAlarmHelper_onSetpointDataValueChange,
+    DeviationStuff
+} from "./deviation_alarm_helper";
+import { UALimitAlarmImpl } from "./ua_limit_alarm_impl";
+import { UANonExclusiveLimitAlarmEx, UANonExclusiveLimitAlarmImpl } from "./ua_non_exclusive_limit_alarm_impl";
+
+export interface UANonExclusiveDeviationAlarmEx
+    extends Omit<
+            UANonExclusiveDeviationAlarm_Base,
+            | "ackedState"
+            | "activeState"
+            | "confirmedState"
+            | "enabledState"
+            | "latchedState"
+            | "limitState"
+            | "outOfServiceState"
+            | "shelvingState"
+            | "silenceState"
+            | "suppressedState"
+            //
+            | "highHighState"
+            | "highState"
+            | "lowState"
+            | "lowLowState"
+        >,
+        UANonExclusiveLimitAlarmEx,
+        DeviationStuff {
+    setpointNode: UAVariableT<NodeId, DataType.NodeId>;
+    setpointNodeNode: UAVariable;
+}
+
+export declare interface UANonExclusiveDeviationAlarmImpl extends UANonExclusiveLimitAlarmImpl, UANonExclusiveDeviationAlarmEx {
+    on(eventName: string, eventHandler: any): this;
+    get addressSpace(): AddressSpace;
+}
+
+export class UANonExclusiveDeviationAlarmImpl extends UANonExclusiveLimitAlarmImpl implements UANonExclusiveDeviationAlarmEx {
+    public static instantiate(
+        namespace: NamespacePrivate,
+        type: string | NodeId,
+        options: any,
+        data: any
+    ): UANonExclusiveDeviationAlarmImpl {
+        const addressSpace = namespace.addressSpace;
+
+        const nonExclusiveDeviationAlarmType = addressSpace.findEventType("NonExclusiveDeviationAlarmType");
+        /* istanbul ignore next */
+        if (!nonExclusiveDeviationAlarmType) {
+            throw new Error("cannot find ExclusiveDeviationAlarmType");
+        }
+        assert(type === nonExclusiveDeviationAlarmType.browseName.toString());
+
+        const alarm = UANonExclusiveLimitAlarmImpl.instantiate(namespace, type, options, data) as UANonExclusiveDeviationAlarmImpl;
+        Object.setPrototypeOf(alarm, UANonExclusiveDeviationAlarmImpl.prototype);
+
+        assert(alarm instanceof UANonExclusiveDeviationAlarmImpl);
+        assert(alarm instanceof UANonExclusiveLimitAlarmImpl);
+        assert(alarm instanceof UALimitAlarmImpl);
+
+        alarm._install_setpoint(options);
+
+        return alarm;
+    }
+
+    public _setStateBasedOnInputValue(value: number): void {
+        const setpointValue = this.getSetpointValue();
+        if (setpointValue === null) {
+            throw new Error("Cannot access setpoint Value");
+        }
+        assert(isFinite(setpointValue), "expecting a valid setpoint value");
+        // call base class implementation
+        super._setStateBasedOnInputValue(value - setpointValue);
+    }
+
+    public getSetpointNodeNode(): UAVariable {
+        return DeviationAlarmHelper_getSetpointNodeNode.call(this);
+    }
+
+    public getSetpointValue(): number | null {
+        return DeviationAlarmHelper_getSetpointValue.call(this);
+    }
+
+    public _onSetpointDataValueChange(dataValue: DataValue): void {
+        DeviationAlarmHelper_onSetpointDataValueChange.call(this, dataValue);
+    }
+
+    public _install_setpoint(options: any): any {
+        return DeviationAlarmHelper_install_setpoint.call(this, options);
+    }
+}

package/src/alarms_and_conditions/ua_non_exclusive_limit_alarm_impl.ts

@@ -0,0 +1,224 @@
+/* eslint-disable max-statements */
+/**
+ * @module node-opcua-address-space.AlarmsAndConditions
+ */
+import { assert } from "node-opcua-assert";
+import { LocalizedText } from "node-opcua-data-model";
+import { NodeId } from "node-opcua-nodeid";
+import { UANonExclusiveLimitAlarm_Base, UATwoStateVariable } from "node-opcua-nodeset-ua";
+import { StatusCodes } from "node-opcua-status-code";
+
+import { UAEventType } from "../../source";
+import { UATwoStateVariableEx } from "../../source/ua_two_state_variable_ex";
+import { NamespacePrivate } from "../namespace_private";
+import { _install_TwoStateVariable_machinery } from "../state_machine/ua_two_state_variable";
+import { ConditionInfo } from "./condition_info";
+import { UALimitAlarmEx, UALimitAlarmImpl } from "./ua_limit_alarm_impl";
+
+export interface UANonExclusiveLimitAlarmEx
+    extends UALimitAlarmEx,
+        Omit<
+            UANonExclusiveLimitAlarm_Base,
+            | "ackedState"
+            | "activeState"
+            | "confirmedState"
+            | "enabledState"
+            | "latchedState"
+            | "limitState"
+            | "outOfServiceState"
+            | "shelvingState"
+            | "silenceState"
+            | "suppressedState"
+        > {
+    activeState: UATwoStateVariableEx;
+    highHighState?: UATwoStateVariableEx;
+    highState?: UATwoStateVariableEx;
+    lowState?: UATwoStateVariableEx;
+    lowLowState?: UATwoStateVariableEx;
+}
+
+export declare interface UANonExclusiveLimitAlarmImpl extends UANonExclusiveLimitAlarmEx, UALimitAlarmImpl {
+    on(eventName: string, eventHandler: any): this;
+}
+export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UANonExclusiveLimitAlarmEx {
+    public static instantiate(
+        namespace: NamespacePrivate,
+        type: UAEventType | NodeId | string,
+        options: any,
+        data: any
+    ): UANonExclusiveLimitAlarmImpl {
+        const addressSpace = namespace.addressSpace;
+
+        options.optionals = options.optionals || [];
+
+        if (Object.prototype.hasOwnProperty.call(options,"lowLowLimit")) {
+            options.optionals.push("LowLowLimit");
+            options.optionals.push("LowLowState");
+        }
+        if (Object.prototype.hasOwnProperty.call(options,"lowLimit")) {
+            options.optionals.push("LowLimit");
+            options.optionals.push("LowState");
+        }
+        if (Object.prototype.hasOwnProperty.call(options,"highLimit")) {
+            options.optionals.push("HighLimit");
+            options.optionals.push("HighState");
+        }
+        if (Object.prototype.hasOwnProperty.call(options,"highHighLimit")) {
+            options.optionals.push("HighHighLimit");
+            options.optionals.push("HighHighState");
+        }
+        const nonExclusiveAlarmType = addressSpace.findEventType(type);
+
+        /* istanbul ignore next */
+        if (!nonExclusiveAlarmType) {
+            throw new Error(" cannot find Alarm Condition Type for " + type);
+        }
+
+        const nonExclusiveLimitAlarmType = addressSpace.findEventType("NonExclusiveLimitAlarmType");
+        /* istanbul ignore next */
+        if (!nonExclusiveLimitAlarmType) {
+            throw new Error("cannot find NonExclusiveLimitAlarmType");
+        }
+        // assert(type nonExclusiveLimitAlarmType.browseName.toString());
+
+        const alarm = UALimitAlarmImpl.instantiate(namespace, type, options, data) as UANonExclusiveLimitAlarmImpl;
+        Object.setPrototypeOf(alarm, UANonExclusiveLimitAlarmImpl.prototype);
+        assert(alarm instanceof UALimitAlarmImpl);
+        assert(alarm instanceof UANonExclusiveLimitAlarmImpl);
+
+        // ---------------- install States
+        if (alarm.lowLowState) {
+            _install_TwoStateVariable_machinery(alarm.lowLowState, {
+                falseState: "LowLow inactive",
+                trueState: "LowLow active"
+            });
+            alarm.lowLowState.setValue(false);
+            assert(Object.prototype.hasOwnProperty.call(alarm,"lowLowLimit"));
+        }
+        if (alarm.lowState) {
+            _install_TwoStateVariable_machinery(alarm.lowState, {
+                falseState: "Low inactive",
+                trueState: "Low active"
+            });
+            alarm.lowState.setValue(false);
+            assert(Object.prototype.hasOwnProperty.call(alarm,"lowLimit"));
+        }
+        if (alarm.highState) {
+            _install_TwoStateVariable_machinery(alarm.highState, {
+                falseState: "High inactive",
+                trueState: "High active"
+            });
+            alarm.highState.setValue(false);
+            assert(Object.prototype.hasOwnProperty.call(alarm,"highLimit"));
+        }
+        if (alarm.highHighState) {
+            _install_TwoStateVariable_machinery(alarm.highHighState, {
+                falseState: "HighHigh inactive",
+                trueState: "HighHigh active"
+            });
+            alarm.highHighState.setValue(false);
+            assert(Object.prototype.hasOwnProperty.call(alarm,"highHighLimit"));
+        }
+
+        alarm.activeState.setValue(false);
+
+        alarm.updateState();
+
+        return alarm;
+    }
+
+    public _calculateConditionInfo(
+        states: string | null,
+        isActive: boolean,
+        value: string,
+        oldConditionInfo: ConditionInfo
+    ): ConditionInfo {
+        if (!isActive) {
+            return new ConditionInfo({
+                message: "Back to normal",
+                quality: StatusCodes.Good,
+                retain: true,
+                severity: 0
+            });
+        } else {
+            return new ConditionInfo({
+                message: "Condition value is " + value + " and state is " + states,
+                quality: StatusCodes.Good,
+                retain: true,
+                severity: 150
+            });
+        }
+    }
+
+    public _signalNewCondition2(states: { [key: string]: string }, isActive: boolean, value: string): void {
+        const alarm = this as any;
+
+        if (typeof states === "string") {
+            return;
+        }
+
+        function _install(name: string) {
+            if (states[name] !== "unset") {
+                alarm[name + "State"].setValue(states[name]);
+            }
+        }
+
+        _install("highHigh");
+        _install("high");
+        _install("low");
+        _install("lowLow");
+
+        // build-up state string
+        let state_str = Object.keys(states)
+            .map((s: string) => (states[s] ? s : null))
+            .filter((a) => a !== null)
+            .join(";"); //
+
+        state_str = JSON.stringify(states);
+
+        UALimitAlarmImpl.prototype._signalNewCondition.call(this, state_str, isActive, value);
+    }
+
+    protected _setStateBasedOnInputValue(value: number): void {
+        assert(isFinite(value), "expecting a valid value here");
+
+        let isActive = false;
+
+        const states: any = {
+            highHigh: this.highHighState ? this.highHighState.getValue() : "unset",
+            high: this.highState ? this.highState.getValue() : "unset",
+            low: this.lowState ? this.lowState.getValue() : "unset",
+            lowLow: this.lowLowState ? this.lowLowState.getValue() : "unset"
+        };
+
+        let count = 0;
+
+        function ___p(stateName: string, func_value: () => boolean) {
+            if (states[stateName] !== "unset") {
+                const val = func_value();
+                isActive = isActive || val;
+                if (states[stateName] !== val) {
+                    states[stateName] = val;
+                    count += 1;
+                }
+            }
+        }
+
+        ___p("highHigh", () => {
+            return this.getHighHighLimit() < value;
+        });
+        ___p("high", () => {
+            return this.getHighLimit() < value;
+        });
+        ___p("low", () => {
+            return this.getLowLimit() > value;
+        });
+        ___p("lowLow", () => {
+            return this.getLowLowLimit() > value;
+        });
+
+        if (count > 0) {
+            this._signalNewCondition2(states, isActive, value.toString());
+        }
+    }
+}

package/src/alarms_and_conditions/ua_off_normal_alarm_impl.ts

@@ -0,0 +1,186 @@
+/**
+ * @module node-opcua-address-space.AlarmsAndConditions
+ */
+import { assert } from "node-opcua-assert";
+import { DataValue } from "node-opcua-data-value";
+import { NodeId } from "node-opcua-nodeid";
+import { UAOffNormalAlarm_Base } from "node-opcua-nodeset-ua";
+import { StatusCodes } from "node-opcua-status-code";
+import * as utils from "node-opcua-utils";
+import { DataType } from "node-opcua-variant";
+import { INamespace, UAVariable } from "../../source";
+import { AddressSpacePrivate } from "../address_space_private";
+import { UADiscreteAlarmEx, UADiscreteAlarmImpl } from "./ua_discrete_alarm_impl";
+
+function isEqual(value1: any, value2: any) {
+    return value1 === value2;
+}
+
+export declare interface UAOffNormalAlarmEx
+    extends Omit<
+            UAOffNormalAlarm_Base,
+            | "ackedState"
+            | "activeState"
+            | "confirmedState"
+            | "enabledState"
+            | "latchedState"
+            | "outOfServiceState"
+            | "shelvingState"
+            | "silenceState"
+            | "suppressedState"
+        >,
+        UADiscreteAlarmEx {
+            getNormalStateNode(): UAVariable;
+         
+            getNormalStateValue(): any;
+           
+            setNormalStateValue(value: any): void;
+        }
+
+export declare interface UAOffNormalAlarmImpl extends UAOffNormalAlarmEx, UADiscreteAlarmImpl {
+    on(eventName: string, eventHandler: any): this;
+}
+/**
+ * The OffNormalAlarmType is a specialization of the DiscreteAlarmType intended to represent a
+ * discrete Condition that is considered to be not normal.
+ * This sub type is usually used to indicate that a discrete value is in an Alarm state, it is active as
+ * long as a non-normal value is present.
+ */
+export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNormalAlarmEx {
+    /**
+     * When the value of inputNode doesn't match the normalState node value, then the alarm is raised.
+     *
+     */
+    public static instantiate(
+        namespace: INamespace,
+        limitAlarmTypeId: string | NodeId,
+        options: any,
+        data: any
+    ): UAOffNormalAlarmImpl {
+        const addressSpace = namespace.addressSpace as AddressSpacePrivate;
+
+        const offNormalAlarmType = addressSpace.findEventType("OffNormalAlarmType");
+        /* istanbul ignore next */
+        if (!offNormalAlarmType) {
+            throw new Error("cannot find offNormalAlarmType");
+        }
+
+        assert(Object.prototype.hasOwnProperty.call(options,"inputNode"), "must provide inputNode"); // must provide a inputNode
+        assert(Object.prototype.hasOwnProperty.call(options,"normalState"), "must provide a normalState Node"); // must provide a inputNode
+        options.optionals = options.optionals || [];
+
+        assert(Object.prototype.hasOwnProperty.call(options,"inputNode"), "must provide inputNode"); // must provide a inputNode
+        const alarmNode = UADiscreteAlarmImpl.instantiate(namespace, limitAlarmTypeId, options, data) as UAOffNormalAlarmImpl;
+        Object.setPrototypeOf(alarmNode, UAOffNormalAlarmImpl.prototype);
+
+        const inputNode = addressSpace._coerceNode(options.inputNode);
+        //       assert(inputNode, "Expecting a valid input node");
+
+        const normalState = addressSpace._coerceNode(options.normalState)! as UAVariable;
+        //       assert(normalState, "Expecting a valid normalState node");
+
+        const normalStateNodeId = normalState ? normalState.nodeId : NodeId.nullNodeId;
+        alarmNode.normalState.setValueFromSource({ dataType: DataType.NodeId, value: normalStateNodeId });
+
+        if (inputNode) {
+            // install inputNode Node monitoring for change
+            alarmNode.installInputNodeMonitoring(options.inputNode);
+        }
+
+        alarmNode.normalState.on("value_changed", (newDataValue: DataValue /*, oldDataValue: DataValue*/) => {
+            // The node that contains the normalState value has changed.
+            //   we must remove the listener on current normalState and replace
+            //   normalState with the new one and set listener again
+            //   to do:
+        });
+
+        if (normalState) {
+            // install normalState monitoring for change
+            normalState.on("value_changed", (newDataValue: DataValue /*, oldDataValue: DataValue*/) => {
+                alarmNode._onNormalStateDataValueChange(newDataValue);
+            });
+        }
+        alarmNode._updateAlarmState();
+
+        return alarmNode;
+    }
+
+    // HasProperty Variable NormalState NodeId PropertyType Mandatory
+    // The NormalState Property is a Property that points to a Variable which has a value that
+    // corresponds to one of the possible values of the Variable pointed to by the InputNode
+    // Property where the NormalState Property Variable value is the value that is considered to be
+    // the normal state of the Variable pointed to by the InputNode Property. When the value of the
+    // Variable referenced by the InputNode Property is not equal to the value of the NormalState
+    // Property the Alarm is Active. If this Variable is not in the AddressSpace, a Null NodeId shall
+    // be provided.
+
+    public getNormalStateNode(): UAVariable {
+        const nodeId = this.normalState.readValue().value.value;
+        const node = this.addressSpace.findNode(nodeId) as UAVariable;
+        assert(node, "getNormalStateNode ");
+        return node;
+    }
+
+    /**
+     * @method getNormalStateValue
+     */
+    public getNormalStateValue(): any {
+        const normalStateNode = this.getNormalStateNode();
+        return normalStateNode.readValue().value.value;
+    }
+
+    /**
+     * @method setNormalStateValue
+     * @param value
+     */
+    public setNormalStateValue(value: any): void {
+        const normalStateNode = this.getNormalStateNode();
+        throw new Error("Not Implemented yet");
+    }
+
+    public _updateAlarmState(normalStateValue?: any, inputValue?: any): void {
+
+        if (utils.isNullOrUndefined(normalStateValue) || utils.isNullOrUndefined(inputValue)) {
+            this.activeState.setValue(false);
+            return;
+        }
+        const isActive = !isEqual(normalStateValue, inputValue);
+
+        if (isActive === this.activeState.getValue()) {
+            // no change => ignore !
+            return;
+        }
+
+        const stateName = isActive ? "Active" : "Inactive";
+        // also raise the event
+        this._signalNewCondition(stateName, isActive, "");
+    }
+
+    public _onInputDataValueChange(dataValue: DataValue): void {
+        if (dataValue.statusCode !== StatusCodes.Good) {
+            // what shall we do ?
+            return;
+        }
+        if (dataValue.value.dataType === DataType.Null) {
+            // what shall we do ?
+            return;
+        }
+        const inputValue = dataValue.value.value;
+        const normalStateValue = this.getNormalStateValue();
+        this._updateAlarmState(normalStateValue, inputValue);
+    }
+
+    protected _onNormalStateDataValueChange(dataValue: DataValue): void {
+        if (dataValue.statusCode !== StatusCodes.Good) {
+            // what shall we do ?
+            return;
+        }
+        if (dataValue.value.dataType === DataType.Null) {
+            // what shall we do ?
+            return;
+        }
+        const normalStateValue = dataValue.value.value;
+        const inputValue = this.getInputNodeValue();
+        this._updateAlarmState(normalStateValue, inputValue);
+    }
+}

package/src/alarms_and_conditions/ua_system_off_normal_alarm_impl.ts

@@ -0,0 +1,27 @@
+/**
+ * @module node-opcua-address-space.AlarmsAndConditions
+ */
+import { NodeId } from "node-opcua-nodeid";
+
+import { INamespace } from "../../source";
+import { UAOffNormalAlarmImpl } from "./ua_off_normal_alarm_impl";
+
+/**
+ *
+ * This Condition is used by a Server to indicate that an underlying system that is providing  Alarm information is
+ * having a communication problem and that the Server may have invalid or incomplete Condition state in the
+ * Subscription.
+ *
+ */
+export class UASystemOffNormalAlarmImpl extends  UAOffNormalAlarmImpl {
+
+    public static instantiate(
+        namespace: INamespace,
+        limitAlarmTypeId: string | NodeId,
+        options: any,
+        data: any
+    ): UASystemOffNormalAlarmImpl {
+          return UAOffNormalAlarmImpl.instantiate(
+            namespace, limitAlarmTypeId, options, data) as UASystemOffNormalAlarmImpl;
+    }
+}

package/src/apply_condition_refresh.ts

@@ -0,0 +1,30 @@
+import { BaseNode, UAObject } from "node-opcua-address-space-base";
+import { UAConditionImpl } from "./alarms_and_conditions/ua_condition_impl";
+import { BaseNodeImpl } from "./base_node_impl";
+import { UAObjectImpl } from "./ua_object_impl";
+
+export type ConditionRefreshCache = {[key in string]: UAObject};
+export function apply_condition_refresh(this: BaseNodeImpl, _cache?: ConditionRefreshCache): void {
+    // visit all notifiers recursively
+    _cache = _cache || {};
+    const notifiers = this.getNotifiers();
+    const eventSources = this.getEventSources();
+
+    const conditions = this.findReferencesAsObject("HasCondition", true);
+    for (const condition of conditions) {
+        if (condition instanceof UAConditionImpl) {
+            condition._resend_conditionEvents();
+        }
+    }
+    const arr = ([] as UAObjectImpl[]).concat(notifiers as UAObjectImpl[], eventSources as UAObjectImpl[]);
+
+    for (const notifier of arr) {
+        const key = notifier.nodeId.toString();
+        if (!_cache[key]) {
+            _cache[key] = notifier;
+            if (notifier._conditionRefresh) {
+                notifier._conditionRefresh(_cache);
+            }
+        }
+    }
+}