node-opcua-address-space 2.71.0 → 2.72.0

package/src/alarms_and_conditions/ua_non_exclusive_deviation_alarm_impl.ts

@@ -6,10 +6,9 @@ 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 { DataType, VariantOptions } from "node-opcua-variant";
+import { UANonExclusiveDeviationAlarm_Base } from "node-opcua-nodeset-ua";
+import { UAVariable, UAVariableT } from "node-opcua-address-space-base";
 import { NamespacePrivate } from "../namespace_private";
 import { AddressSpace } from "../address_space";
 import {
@@ -19,7 +18,7 @@ import {
     DeviationAlarmHelper_onSetpointDataValueChange,
     DeviationStuff
 } from "./deviation_alarm_helper";
-import { UALimitAlarmImpl } from "./ua_limit_alarm_impl";
+import { InstantiateLimitAlarmOptions, UALimitAlarmImpl } from "./ua_limit_alarm_impl";
 import { UANonExclusiveLimitAlarmEx, UANonExclusiveLimitAlarmImpl } from "./ua_non_exclusive_limit_alarm_impl";
 
 export interface UANonExclusiveDeviationAlarmEx
@@ -56,8 +55,8 @@ export class UANonExclusiveDeviationAlarmImpl extends UANonExclusiveLimitAlarmIm
     public static instantiate(
         namespace: NamespacePrivate,
         type: string | NodeId,
-        options: any,
-        data: any
+        options: InstantiateLimitAlarmOptions,
+        data?: Record<string, VariantOptions>
     ): UANonExclusiveDeviationAlarmImpl {
         const addressSpace = namespace.addressSpace;
 

package/src/alarms_and_conditions/ua_non_exclusive_limit_alarm_impl.ts

@@ -3,17 +3,16 @@
  * @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 { UANonExclusiveLimitAlarm_Base } from "node-opcua-nodeset-ua";
 import { StatusCodes } from "node-opcua-status-code";
-
-import { UAEventType } from "../../source";
+import { VariantOptions } from "node-opcua-variant";
+import { UAEventType } from "node-opcua-address-space-base";
 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";
+import { InstantiateLimitAlarmOptions, UALimitAlarmEx, UALimitAlarmImpl } from "./ua_limit_alarm_impl";
 
 export interface UANonExclusiveLimitAlarmEx
     extends UALimitAlarmEx,
@@ -44,8 +43,8 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
     public static instantiate(
         namespace: NamespacePrivate,
         type: UAEventType | NodeId | string,
-        options: any,
-        data: any
+        options: InstantiateLimitAlarmOptions,
+        data?: Record<string, VariantOptions>
     ): UANonExclusiveLimitAlarmImpl {
         const addressSpace = namespace.addressSpace;
 

package/src/alarms_and_conditions/ua_off_normal_alarm_impl.ts

@@ -1,15 +1,17 @@
 /**
  * @module node-opcua-address-space.AlarmsAndConditions
  */
+import { INamespace, UAVariable } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 import { DataValue } from "node-opcua-data-value";
-import { NodeId } from "node-opcua-nodeid";
+import { NodeId, NodeIdLike } 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 { DataType, VariantOptions } from "node-opcua-variant";
+
 import { AddressSpacePrivate } from "../address_space_private";
+import { InstantiateAlarmConditionOptions } from "./ua_alarm_condition_impl";
 import { UADiscreteAlarmEx, UADiscreteAlarmImpl } from "./ua_discrete_alarm_impl";
 
 function isEqual(value1: any, value2: any) {
@@ -30,13 +32,16 @@ export declare interface UAOffNormalAlarmEx
             | "suppressedState"
         >,
         UADiscreteAlarmEx {
-    getNormalStateNode(): UAVariable;
+    getNormalStateNode(): UAVariable | null;
 
     getNormalStateValue(): any;
 
     setNormalStateValue(value: any): void;
 }
 
+export interface InstantiateOffNormalAlarmOptions extends InstantiateAlarmConditionOptions {
+    normalState: NodeIdLike;
+}
 export declare interface UAOffNormalAlarmImpl extends UAOffNormalAlarmEx, UADiscreteAlarmImpl {
     on(eventName: string, eventHandler: any): this;
 }
@@ -54,8 +59,8 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
     public static instantiate(
         namespace: INamespace,
         limitAlarmTypeId: string | NodeId,
-        options: any,
-        data: any
+        options: InstantiateOffNormalAlarmOptions,
+        data?: Record<string, VariantOptions>
     ): UAOffNormalAlarmImpl {
         const addressSpace = namespace.addressSpace as AddressSpacePrivate;
 
@@ -73,20 +78,36 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
         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 : new NodeId();
-        alarmNode.normalState.setValueFromSource({ dataType: DataType.NodeId, value: normalStateNodeId });
+        /**
+         * The InputNode Property provides the NodeId of the Variable the Value of which is used as primary input in
+         * the calculation of the Alarm state.
+         *
+         * If this Variable is not in the AddressSpace, a NULL NodeId shall be provided.
+         *
+         * In some systems, an Alarm may be calculated based on multiple Variables Values;
+         * it is up to the system to determine which Variable’s NodeId is used.
+         */
+        const inputNode = addressSpace._coerceNode(options.inputNode) as UAVariable | null;
+        // note: alarmNode.inputNode.readValue() already set by DiscreteAlarmImpl.instantiate
 
         if (inputNode) {
             // install inputNode Node monitoring for change
             alarmNode.installInputNodeMonitoring(options.inputNode);
         }
 
+        /**
+         * 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.
+         *
+         */
+        const normalState = addressSpace._coerceNode(options.normalState) as UAVariable | null;
+        const normalStateNodeId = normalState ? normalState.nodeId : new NodeId();
+        alarmNode.normalState.setValueFromSource({ dataType: DataType.NodeId, value: normalStateNodeId });
         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
@@ -100,7 +121,8 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
                 alarmNode._onNormalStateDataValueChange(newDataValue);
             });
         }
-        alarmNode._updateAlarmState();
+
+        alarmNode._mayBe_updateAlarmState();
 
         return alarmNode;
     }
@@ -114,18 +136,23 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
     // Property the Alarm is Active. If this Variable is not in the AddressSpace, a Null NodeId shall
     // be provided.
 
-    public getNormalStateNode(): UAVariable {
+    public getNormalStateNode(): UAVariable | null {
         const nodeId = this.normalState.readValue().value.value;
         const node = this.addressSpace.findNode(nodeId) as UAVariable;
-        assert(node, "getNormalStateNode ");
+        if (!node) {
+            return null;
+        }
         return node;
     }
 
     /**
      * @method getNormalStateValue
      */
-    public getNormalStateValue(): any {
+    public getNormalStateValue(): any | null {
         const normalStateNode = this.getNormalStateNode();
+        if (!normalStateNode) {
+            return null;
+        }
         return normalStateNode.readValue().value.value;
     }
 
@@ -138,24 +165,29 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
         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);
-
+    public updateAlarmState(isActive: boolean, message: string) {
         if (isActive === this.activeState.getValue()) {
             // no change => ignore !
             return;
         }
-
         const stateName = isActive ? "Active" : "Inactive";
         // also raise the event
-        this._signalNewCondition(stateName, isActive, "");
+        this._signalNewCondition(stateName, isActive, message);
+        if (!isActive) {
+            this.currentBranch().setRetain(false);
+        }
+    }
+
+    private _mayBe_updateAlarmState(normalStateValue?: any, inputValue?: any): void {
+        if (utils.isNullOrUndefined(normalStateValue) || utils.isNullOrUndefined(inputValue)) {
+            this.activeState.setValue(false);
+            return;
+        }
+        const isActive = !isEqual(normalStateValue, inputValue);
+        this.updateAlarmState(isActive, "automatique update");
     }
 
-    public _onInputDataValueChange(dataValue: DataValue): void {
+    protected _onInputDataValueChange(dataValue: DataValue): void {
         if (dataValue.statusCode !== StatusCodes.Good) {
             // what shall we do ?
             return;
@@ -166,7 +198,7 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
         }
         const inputValue = dataValue.value.value;
         const normalStateValue = this.getNormalStateValue();
-        this._updateAlarmState(normalStateValue, inputValue);
+        this._mayBe_updateAlarmState(normalStateValue, inputValue);
     }
 
     protected _onNormalStateDataValueChange(dataValue: DataValue): void {
@@ -180,6 +212,6 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
         }
         const normalStateValue = dataValue.value.value;
         const inputValue = this.getInputNodeValue();
-        this._updateAlarmState(normalStateValue, inputValue);
+        this._mayBe_updateAlarmState(normalStateValue, inputValue);
     }
 }

package/src/alarms_and_conditions/ua_system_off_normal_alarm_impl.ts

@@ -1,10 +1,10 @@
 /**
  * @module node-opcua-address-space.AlarmsAndConditions
  */
+import { INamespace } from "node-opcua-address-space-base";
 import { NodeId } from "node-opcua-nodeid";
-
-import { INamespace } from "../../source";
-import { UAOffNormalAlarmImpl } from "./ua_off_normal_alarm_impl";
+import { VariantOptions } from "node-opcua-variant";
+import { InstantiateOffNormalAlarmOptions, UAOffNormalAlarmImpl } from "./ua_off_normal_alarm_impl";
 
 /**
  *
@@ -17,8 +17,8 @@ export class UASystemOffNormalAlarmImpl extends UAOffNormalAlarmImpl {
     public static instantiate(
         namespace: INamespace,
         limitAlarmTypeId: string | NodeId,
-        options: any,
-        data: any
+        options: InstantiateOffNormalAlarmOptions,
+        data?: Record<string, VariantOptions>
     ): UASystemOffNormalAlarmImpl {
         return UAOffNormalAlarmImpl.instantiate(namespace, limitAlarmTypeId, options, data) as UASystemOffNormalAlarmImpl;
     }

package/src/ua_object_impl.ts

@@ -27,7 +27,8 @@ import {
     UAEventType,
     IEventData,
     defaultCloneFilter,
-    defaultCloneExtraInfo
+    defaultCloneExtraInfo,
+    EventNotifierFlags
 } from "node-opcua-address-space-base";
 
 import { BaseNodeImpl, InternalBaseNodeOptions } from "./base_node_impl";
@@ -35,8 +36,11 @@ import { _clone, ToStringBuilder, UAObject_toString } from "./base_node_private"
 import { apply_condition_refresh, ConditionRefreshCache } from "./apply_condition_refresh";
 
 export class UAObjectImpl extends BaseNodeImpl implements UAObject {
+    private _eventNotifier: EventNotifierFlags;
     public readonly nodeClass = NodeClass.Object;
-    public readonly eventNotifier: number;
+    public get eventNotifier(): EventNotifierFlags {
+        return this._eventNotifier;
+    }
     public readonly symbolicName: string | null;
 
     get typeDefinitionObj(): UAObjectType {
@@ -45,7 +49,7 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
 
     constructor(options: InternalBaseNodeOptions & { eventNotifier?: number; symbolicName?: string | null }) {
         super(options);
-        this.eventNotifier = options.eventNotifier || 0;
+        this._eventNotifier = options.eventNotifier || EventNotifierFlags.None;
         assert(typeof this.eventNotifier === "number" && isValidByte(this.eventNotifier));
         this.symbolicName = options.symbolicName || null;
     }
@@ -111,6 +115,10 @@ export class UAObjectImpl extends BaseNodeImpl implements UAObject {
         return super.getMethods();
     }
 
+    public setEventNotifier(eventNotifierFlags: EventNotifierFlags): void {
+        this._eventNotifier = eventNotifierFlags;
+    }
+
     /**
      * Raise a transient Event
      */

package/src/ua_view_impl.ts

@@ -1,13 +1,12 @@
 /**
  * @module node-opcua-address-space
  */
-import { assert } from "node-opcua-assert";
 import { NodeClass } from "node-opcua-data-model";
 import { AttributeIds } from "node-opcua-data-model";
 import { DataValue, DataValueLike } from "node-opcua-data-value";
 import { StatusCodes } from "node-opcua-status-code";
 import { DataType } from "node-opcua-variant";
-import { ISessionContext, UAView } from "node-opcua-address-space-base";
+import { EventNotifierFlags, ISessionContext, UAView } from "node-opcua-address-space-base";
 
 import { SessionContext } from "../source/session_context";
 import { BaseNodeImpl, InternalBaseNodeOptions } from "./base_node_impl";
@@ -19,12 +18,15 @@ export interface InternalViewOptions extends InternalBaseNodeOptions {
 export class UAViewImpl extends BaseNodeImpl implements UAView {
     public readonly nodeClass = NodeClass.View;
     public readonly containsNoLoops: boolean;
-    public readonly eventNotifier: number;
+    private _eventNotifier: EventNotifierFlags;
+    public get eventNotifier(): EventNotifierFlags {
+        return this._eventNotifier;
+    }
 
     constructor(options: InternalViewOptions) {
         super(options);
         this.containsNoLoops = !!options.containsNoLoops;
-        this.eventNotifier = 0;
+        this._eventNotifier = EventNotifierFlags.None;
     }
 
     public readAttribute(context: ISessionContext | null, attributeId: AttributeIds): DataValue {

package/test_helpers/test_fixtures/dataType_issue.xml

@@ -14,14 +14,14 @@
     <Aliases>
     </Aliases>
 
-    <UADataType NodeId="ns=1;i=3011" BrowseName="1:DatagramConnectionTransport2DataType">
-        <DisplayName>DatagramConnectionTransport2DataType</DisplayName>
+    <UADataType NodeId="ns=1;i=3011" BrowseName="1:MyCustomDataType">
+        <DisplayName>MyCustomDataType</DisplayName>
         <References>
             <Reference ReferenceType="HasSubtype" IsForward="false">i=17467</Reference>
             <Reference ReferenceType="HasEncoding">ns=1;i=5019</Reference>
             <Reference ReferenceType="HasEncoding">ns=1;i=5020</Reference>
         </References>
-        <Definition Name="1:DatagramConnectionTransport2DataType">
+        <Definition Name="1:MyCustomDataType">
             <Field DataType="UInt32" Name="DiscoveryAnnounceRate"/>
             <Field DataType="UInt32" Name="DiscoveryMaxMessageSize"/>
             <Field DataType="Structure" ValueRank="1" ArrayDimensions="0" Name="DatagramQoS"/>
@@ -46,27 +46,27 @@
         </References>
     </UAObject> 
     
-    <UAVariable DataType="String" ParentNodeId="ns=1;i=6001" NodeId="ns=1;i=6023" BrowseName="1:DatagramConnectionTransport2DataType">
-        <DisplayName>DatagramConnectionTransport2DataType</DisplayName>
+    <UAVariable DataType="String" ParentNodeId="ns=1;i=6001" NodeId="ns=1;i=6023" BrowseName="1:MyCustomDataType">
+        <DisplayName>MyCustomDataType</DisplayName>
         <References>
             <Reference ReferenceType="HasDescription" IsForward="false">ns=1;i=5019</Reference>
             <Reference ReferenceType="HasComponent" IsForward="false">ns=1;i=6001</Reference>
             <Reference ReferenceType="HasTypeDefinition">i=69</Reference>
         </References>
         <Value>
-            <uax:String>DatagramConnectionTransport2DataType</uax:String>
+            <uax:String>MyCustomDataType</uax:String>
         </Value>
     </UAVariable>
     
-    <UAVariable DataType="String" ParentNodeId="ns=1;i=6003" NodeId="ns=1;i=6024" BrowseName="1:DatagramConnectionTransport2DataType">
-        <DisplayName>DatagramConnectionTransport2DataType</DisplayName>
+    <UAVariable DataType="String" ParentNodeId="ns=1;i=6003" NodeId="ns=1;i=6024" BrowseName="1:MyCustomDataType">
+        <DisplayName>MyCustomDataType</DisplayName>
         <References>
             <Reference ReferenceType="HasDescription" IsForward="false">ns=1;i=5020</Reference>
             <Reference ReferenceType="HasComponent" IsForward="false">ns=1;i=6003</Reference>
             <Reference ReferenceType="HasTypeDefinition">i=69</Reference>
         </References>
         <Value>
-            <uax:String>//xs:element[@name='DatagramConnectionTransport2DataType']</uax:String>
+            <uax:String>//xs:element[@name='MyCustomDataType']</uax:String>
         </Value>
     </UAVariable>