node-opcua-address-space 2.179.0 → 2.181.0

package/impl/alarms_and_conditions/ua_discrete_alarm_impl.ts

@@ -0,0 +1,60 @@
+/**
+ * @module node-opcua-address-space.AlarmsAndConditions
+ */
+
+import type { INamespace, UAEventType } from "node-opcua-address-space-base";
+import { assert } from "node-opcua-assert";
+import type { NodeId } from "node-opcua-nodeid";
+import type { UADiscreteAlarm } from "node-opcua-nodeset-ua";
+import type { VariantOptions } from "node-opcua-variant";
+import type { InstantiateAlarmConditionOptions } from "../../api/interfaces/alarms_and_conditions/instantiate_alarm_condition_options.js";
+import type { UADiscreteAlarmEx } from "../../api/interfaces/alarms_and_conditions/ua_discrete_alarm_ex.js";
+import { UAAlarmConditionImplBase } from "./ua_alarm_condition_impl.js";
+/**
+ * The DiscreteAlarmType is used to classify Types into Alarm Conditions where the input for the
+ * Alarm may take on only a certain number of possible values (e.g. true/false,
+ * running/stopped/terminating).
+ * @internal
+ */
+export class UADiscreteAlarmImplBase extends UAAlarmConditionImplBase {
+    public static instantiate(
+        namespace: INamespace,
+        discreteAlarmTypeId: UAEventType | NodeId | string,
+        options: InstantiateAlarmConditionOptions,
+        data?: Record<string, VariantOptions>
+    ): UADiscreteAlarmImpl {
+        const addressSpace = namespace.addressSpace;
+
+        const discreteAlarmType = addressSpace.findEventType(discreteAlarmTypeId);
+        /* c8 ignore next */
+        if (!discreteAlarmType) {
+            throw new Error(` cannot find Condition Type for ${discreteAlarmType}`);
+        }
+
+        const discreteAlarmTypeBase = addressSpace.findObjectType("DiscreteAlarmType");
+        assert(discreteAlarmTypeBase, "expecting DiscreteAlarmType - please check you nodeset xml file!");
+        if (!discreteAlarmTypeBase) {
+            throw new Error("expecting DiscreteAlarmType - please check you nodeset xml file!");
+        }
+
+        /* eventTypeNode should be subtypeOf("DiscreteAlarmType"); */
+        /* c8 ignore next */
+        if (!discreteAlarmType.isSubtypeOf(discreteAlarmTypeBase)) {
+            throw new Error("UADiscreteAlarm.instantiate : event found is not subType of DiscreteAlarmType");
+        }
+
+        const alarmNode = UAAlarmConditionImplBase.instantiate(
+            namespace,
+            discreteAlarmType.nodeId,
+            options,
+            data
+        ) as unknown as UADiscreteAlarm;
+        Object.setPrototypeOf(alarmNode, UADiscreteAlarmImplBase.prototype);
+
+        return alarmNode as unknown as UADiscreteAlarmImpl;
+    }
+}
+/** @internal */
+export type UADiscreteAlarmImpl = UADiscreteAlarmImplBase & UADiscreteAlarmEx;
+/** @internal */
+export const UADiscreteAlarmImpl = UADiscreteAlarmImplBase as unknown as UADiscreteAlarmImpl;

package/impl/alarms_and_conditions/ua_exclusive_deviation_alarm_impl.ts

@@ -0,0 +1,95 @@
+/**
+ * @module node-opcua-address-space.AlarmsAndConditions
+ */
+
+import type { UAVariableT } from "node-opcua-address-space-base";
+import { assert } from "node-opcua-assert";
+import type { DataValue } from "node-opcua-data-value";
+import type { NodeId } from "node-opcua-nodeid";
+import type { DataType, VariantOptions } from "node-opcua-variant";
+import type {
+    InstallSetPointOptions,
+    SetPointSupport
+} from "../../api/interfaces/alarms_and_conditions/install_setpoint_options.js";
+import type { InstantiateExclusiveLimitAlarmOptions } from "../../api/interfaces/alarms_and_conditions/instantiate_exclusive_limit_alarm_options.js";
+import type { UAExclusiveDeviationAlarmEx } from "../../api/interfaces/alarms_and_conditions/ua_exclusive_deviation_alarm_ex.js";
+
+import type { NamespacePrivate } from "../namespace_private.js";
+import {
+    DeviationAlarmHelper_getSetpointNodeNode,
+    DeviationAlarmHelper_getSetpointValue,
+    DeviationAlarmHelper_install_setpoint,
+    DeviationAlarmHelper_onSetpointDataValueChange
+} from "./deviation_alarm_helper.js";
+
+import { UAExclusiveLimitAlarmImpl, UAExclusiveLimitAlarmImplBase } from "./ua_exclusive_limit_alarm_impl.js";
+import { UALimitAlarmImpl } from "./ua_limit_alarm_impl.js";
+
+/** @internal */
+export class UAExclusiveDeviationAlarmImplBase extends UAExclusiveLimitAlarmImplBase implements UAExclusiveDeviationAlarmEx {
+    /** installed as child nodes by the address space, not assigned here - hence `declare` */
+    public declare readonly setpointNode: UAVariableT<NodeId, DataType.NodeId>;
+    public declare readonly setpointNodeNode?: UAVariableT<number, DataType.Double> | UAVariableT<number, DataType.Float>;
+
+    public static instantiate(
+        namespace: NamespacePrivate,
+        type: string | NodeId,
+        options: InstantiateExclusiveLimitAlarmOptions & InstallSetPointOptions,
+        data?: Record<string, VariantOptions>
+    ): UAExclusiveDeviationAlarmImpl {
+        const addressSpace = namespace.addressSpace;
+
+        const exclusiveDeviationAlarmType = addressSpace.findEventType("ExclusiveDeviationAlarmType");
+        /* c8 ignore next */
+        if (!exclusiveDeviationAlarmType) {
+            throw new Error("cannot find ExclusiveDeviationAlarmType");
+        }
+
+        assert(type === exclusiveDeviationAlarmType.browseName.toString());
+
+        const alarm = UAExclusiveLimitAlarmImplBase.instantiate(
+            namespace,
+            type,
+            options,
+            data
+        ) as unknown as UAExclusiveDeviationAlarmImplBase;
+        Object.setPrototypeOf(alarm, UAExclusiveDeviationAlarmImpl.prototype);
+        assert(alarm instanceof UAExclusiveDeviationAlarmImpl);
+        assert(alarm instanceof UAExclusiveLimitAlarmImpl);
+        assert(alarm instanceof UALimitAlarmImpl);
+
+        alarm._install_setpoint(options);
+
+        return alarm as UAExclusiveDeviationAlarmImpl;
+    }
+    public getSetpointNodeNode(): UAVariableT<number, DataType.Double> | UAVariableT<number, DataType.Float> | undefined {
+        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: InstallSetPointOptions): void {
+        DeviationAlarmHelper_install_setpoint.call(this, options);
+    }
+
+    public _setStateBasedOnInputValue(value: number): void {
+        const setpointValue = this.getSetpointValue();
+        if (setpointValue === null) {
+            return;
+        }
+        assert(Number.isFinite(setpointValue));
+        // call base class implementation
+        UAExclusiveLimitAlarmImpl.prototype._setStateBasedOnInputValue.call(this, value - setpointValue);
+    }
+}
+/** @internal */
+export type UAExclusiveDeviationAlarmImpl = UAExclusiveDeviationAlarmImplBase;
+/** @internal */
+export const UAExclusiveDeviationAlarmImpl = UAExclusiveDeviationAlarmImplBase;
+export interface UAExclusiveDeviationAlarmHelper extends SetPointSupport {}

package/impl/alarms_and_conditions/ua_exclusive_level_alarm_impl.ts

@@ -0,0 +1,21 @@
+/**
+ * @module node-opcua-address-space.AlarmsAndConditions
+ */
+import type { NodeId } from "node-opcua-nodeid";
+import type { VariantOptions } from "node-opcua-variant";
+import type { InstantiateLimitAlarmOptions } from "../../api/interfaces/alarms_and_conditions/instantiate_limit_alarm_options.js";
+import type { NamespacePrivate } from "../namespace_private.js";
+import { UAExclusiveLimitAlarmImpl, UAExclusiveLimitAlarmImplBase } from "./ua_exclusive_limit_alarm_impl.js";
+
+/** @internal */
+export class UAExclusiveLevelAlarmImpl extends UAExclusiveLimitAlarmImpl {
+    public static instantiate(
+        namespace: NamespacePrivate,
+        type: NodeId | string,
+        options: InstantiateLimitAlarmOptions,
+        data?: Record<string, VariantOptions>
+    ): UAExclusiveLevelAlarmImpl {
+        const _addressSpace = namespace.addressSpace;
+        return UAExclusiveLimitAlarmImplBase.instantiate(namespace, type, options, data) as UAExclusiveLevelAlarmImpl;
+    }
+}

package/impl/alarms_and_conditions/ua_exclusive_limit_alarm_impl.ts

@@ -0,0 +1,112 @@
+import type { UAEventType, UAObject } from "node-opcua-address-space-base";
+import { assert } from "node-opcua-assert";
+import type { NodeId } from "node-opcua-nodeid";
+import type { VariantOptions } from "node-opcua-variant";
+import type { InstantiateLimitAlarmOptions } from "../../api/interfaces/alarms_and_conditions/instantiate_limit_alarm_options.js";
+import type { UAExclusiveLimitAlarmEx } from "../../api/interfaces/alarms_and_conditions/ua_exclusive_limit_alarm_ex.js";
+import type { UAExclusiveLimitStateMachineEx } from "../../api/interfaces/state_machine/ua_exclusive_limit_state_machine_type_ex.js";
+import type { NamespacePrivate } from "../namespace_private.js";
+import { promoteToStateMachine } from "../state_machine/finite_state_machine.js";
+import { UALimitAlarmImpl, UALimitAlarmImplBase } from "./ua_limit_alarm_impl.js";
+
+const validState = ["HighHigh", "High", "Low", "LowLow", null];
+
+/** @internal */
+export class UAExclusiveLimitAlarmImplBase extends UALimitAlarmImpl implements UAExclusiveLimitAlarmEx {
+    /** installed as a child node by the address space, not assigned here - hence `declare` */
+    public declare readonly limitState: UAExclusiveLimitStateMachineEx;
+
+    /***
+     *
+     * @param namespace {INamespace}
+     * @param type
+     * @param options
+     * @param data
+     * @return {UAExclusiveLimitAlarm}
+     */
+    public static instantiate(
+        namespace: NamespacePrivate,
+        type: UAEventType | string | NodeId,
+        options: InstantiateLimitAlarmOptions,
+        data?: Record<string, VariantOptions>
+    ): UAExclusiveLimitAlarmImpl {
+        const addressSpace = namespace.addressSpace;
+
+        const exclusiveAlarmType = addressSpace.findEventType(type);
+
+        /* c8 ignore next */
+        if (!exclusiveAlarmType) {
+            throw new Error(` cannot find Alarm Condition Type for ${type}`);
+        }
+
+        const exclusiveLimitAlarmType = addressSpace.findEventType("ExclusiveLimitAlarmType");
+        /* c8 ignore next */
+        if (!exclusiveLimitAlarmType) {
+            throw new Error("cannot find ExclusiveLimitAlarmType");
+        }
+
+        const node = UALimitAlarmImplBase.instantiate(namespace, type, options, data);
+        Object.setPrototypeOf(node, UAExclusiveLimitAlarmImplBase.prototype);
+        const alarm = node as unknown as UAExclusiveLimitAlarmImplBase;
+        assert(alarm instanceof UAExclusiveLimitAlarmImpl);
+        assert(alarm instanceof UALimitAlarmImpl);
+
+        // ---------------- install LimitState StateMachine
+        assert(alarm.limitState, "limitState is mandatory");
+        promoteToStateMachine(alarm.limitState as unknown as UAObject);
+
+        // start with a inactive state
+        alarm.activeState.setValue(false);
+
+        alarm.updateState();
+
+        return alarm as UAExclusiveLimitAlarmImpl;
+    }
+    public _signalNewCondition(stateName: string | null, isActive: boolean, value: string): void {
+        assert(stateName === null || typeof isActive === "boolean");
+        assert(validState.indexOf(stateName) >= 0, `must have a valid state : ${stateName}`);
+
+        const _oldState = this.limitState.getCurrentState();
+        const _oldActive = this.activeState.getValue();
+
+        if (stateName) {
+            this.limitState.setState(stateName);
+        } else {
+            assert(stateName === null);
+            this.limitState.setState(stateName);
+        }
+        super._signalNewCondition(stateName, isActive, value);
+    }
+
+    public _setStateBasedOnInputValue(value: number): void {
+        assert(Number.isFinite(value));
+        let isActive = false;
+
+        let state = null;
+
+        const oldState = this.limitState.getCurrentState();
+
+        if (this.highHighLimit && this.getHighHighLimit() < value) {
+            state = "HighHigh";
+            isActive = true;
+        } else if (this.highLimit && this.getHighLimit() < value) {
+            state = "High";
+            isActive = true;
+        } else if (this.lowLowLimit && this.getLowLowLimit() > value) {
+            state = "LowLow";
+            isActive = true;
+        } else if (this.lowLimit && this.getLowLimit() > value) {
+            state = "Low";
+            isActive = true;
+        }
+
+        if (state !== oldState) {
+            this._signalNewCondition(state, isActive, value.toFixed(3));
+        }
+    }
+}
+
+/** @internal */
+export type UAExclusiveLimitAlarmImpl = UAExclusiveLimitAlarmImplBase;
+/** @internal */
+export const UAExclusiveLimitAlarmImpl = UAExclusiveLimitAlarmImplBase;

package/impl/alarms_and_conditions/ua_exclusive_rate_of_change_alarm_impl.ts

@@ -0,0 +1,25 @@
+/**
+ * @module node-opcua-address-space.AlarmsAndConditions
+ */
+import type { UAExclusiveRateOfChangeAlarm_Base } from "node-opcua-nodeset-ua";
+import type { UAExclusiveLimitAlarmEx } from "../../api/interfaces/alarms_and_conditions/ua_exclusive_limit_alarm_ex.js";
+import { UAExclusiveLimitAlarmImpl } from "./ua_exclusive_limit_alarm_impl.js";
+
+export interface UAExclusiveRateOfChangeAlarmEx
+    extends Omit<
+            UAExclusiveRateOfChangeAlarm_Base,
+            | "ackedState"
+            | "activeState"
+            | "confirmedState"
+            | "enabledState"
+            | "latchedState"
+            | "limitState"
+            | "outOfServiceState"
+            | "shelvingState"
+            | "silenceState"
+            | "suppressedState"
+        >,
+        UAExclusiveLimitAlarmEx {}
+export class UAExclusiveRateOfChangeAlarmImpl extends UAExclusiveLimitAlarmImpl implements UAExclusiveRateOfChangeAlarmEx {
+    /** empty interface */
+}

package/impl/alarms_and_conditions/ua_limit_alarm_impl.ts

@@ -0,0 +1,265 @@
+import type { UAEventType, UAProperty, UAVariable } from "node-opcua-address-space-base";
+import { assert } from "node-opcua-assert";
+import type { UInt16 } from "node-opcua-basic-types";
+import { NodeClass } from "node-opcua-data-model";
+import { DataValue } from "node-opcua-data-value";
+import { make_warningLog } from "node-opcua-debug";
+import type { NodeId } from "node-opcua-nodeid";
+import { StatusCodes } from "node-opcua-status-code";
+import { DataType, type VariantOptions } from "node-opcua-variant";
+import type { InstantiateLimitAlarmOptions } from "../../api/interfaces/alarms_and_conditions/instantiate_limit_alarm_options.js";
+import type { UALimitAlarmEx } from "../../api/interfaces/alarms_and_conditions/ua_limit_alarm_ex.js";
+import type { NamespacePrivate } from "../namespace_private.js";
+import { UAAlarmConditionImplBase } from "./ua_alarm_condition_impl.js";
+
+const warningLog = make_warningLog("AlarmsAndConditions");
+
+const uaLimitAlarmInputSupportedDataType: DataType[] = [
+    DataType.Double,
+    DataType.Float,
+    DataType.Byte,
+    DataType.SByte,
+    DataType.Int16,
+    DataType.Int32,
+    DataType.UInt16,
+    DataType.UInt32
+];
+
+/** @internal */
+export class UALimitAlarmImplBase extends UAAlarmConditionImplBase implements UALimitAlarmEx {
+    /**
+     * The limits, all optional: which ones exist depends on the alarm type instantiated.
+     * Installed as child nodes by the address space, not assigned here - hence `declare`.
+     */
+    public declare readonly highHighLimit?: UAProperty<number, DataType.Double>;
+    public declare readonly highLimit?: UAProperty<number, DataType.Double>;
+    public declare readonly lowLimit?: UAProperty<number, DataType.Double>;
+    public declare readonly lowLowLimit?: UAProperty<number, DataType.Double>;
+    public declare readonly baseHighHighLimit?: UAProperty<number, DataType.Double>;
+    public declare readonly baseHighLimit?: UAProperty<number, DataType.Double>;
+    public declare readonly baseLowLimit?: UAProperty<number, DataType.Double>;
+    public declare readonly baseLowLowLimit?: UAProperty<number, DataType.Double>;
+    public declare readonly severityHighHigh?: UAProperty<UInt16, DataType.UInt16>;
+    public declare readonly severityHigh?: UAProperty<UInt16, DataType.UInt16>;
+    public declare readonly severityLow?: UAProperty<UInt16, DataType.UInt16>;
+    public declare readonly severityLowLow?: UAProperty<UInt16, DataType.UInt16>;
+    public declare readonly highHighDeadband?: UAProperty<number, DataType.Double>;
+    public declare readonly highDeadband?: UAProperty<number, DataType.Double>;
+    public declare readonly lowDeadband?: UAProperty<number, DataType.Double>;
+    public declare readonly lowLowDeadband?: UAProperty<number, DataType.Double>;
+
+    public static instantiate(
+        namespace: NamespacePrivate,
+        limitAlarmTypeId: UAEventType | NodeId | string,
+        options: InstantiateLimitAlarmOptions,
+        data?: Record<string, VariantOptions>
+    ): UALimitAlarmImpl {
+        const addressSpace = namespace.addressSpace;
+
+        // must provide a inputNode
+        // xx assert(Object.prototype.hasOwnProperty.call(options,"conditionOf")); // must provide a conditionOf
+        assert(Object.hasOwn(options, "inputNode"), "UALimitAlarm.instantiate: options must provide the inputNode");
+
+        options.optionals = options.optionals || [];
+        let count = 0;
+        if (Object.hasOwn(options, "highHighLimit")) {
+            options.optionals.push("HighHighLimit");
+            options.optionals.push("HighHighState");
+            count++;
+        }
+        if (Object.hasOwn(options, "highLimit")) {
+            options.optionals.push("HighLimit");
+            options.optionals.push("HighState");
+            count++;
+        }
+        if (Object.hasOwn(options, "lowLimit")) {
+            options.optionals.push("LowLimit");
+            options.optionals.push("LowState");
+            count++;
+        }
+        if (Object.hasOwn(options, "lowLowLimit")) {
+            options.optionals.push("LowLowLimit");
+            options.optionals.push("LowLowState");
+            count++;
+        }
+
+        // xx assert(options.optionals,"must provide an optionals");
+        const alarmNode = UAAlarmConditionImplBase.instantiate(namespace, limitAlarmTypeId, options, data) as UALimitAlarmImpl;
+        Object.setPrototypeOf(alarmNode, UALimitAlarmImpl.prototype);
+
+        assert(alarmNode.conditionOfNode() !== null);
+
+        const inputNode = addressSpace._coerceNode(options.inputNode) as UAVariable;
+        if (!inputNode) {
+            throw new Error("Expecting a valid input node");
+        }
+        assert(inputNode.nodeClass === NodeClass.Variable);
+
+        // ----------------------- Install Limit Alarm specifics
+        // from spec 1.03:
+        // Four optional limits are defined that configure the states of the derived limit Alarm Types.
+        // These Properties shall be set for any Alarm limits that are exposed by the derived limit Alarm
+        // Types. These Properties are listed as optional but at least one is required. For cases where
+        // an underlying system cannot provide the actual value of a limit, the limit Property shall still be
+        // provided, but will have its AccessLevel set to not readable. It is assumed that the limits are
+        // described using the same Engineering Unit that is assigned to the variable that is the source
+        // of the alarm. For Rate of change limit alarms, it is assumed this rate is units per second
+        // unless otherwise specified.
+        if (count === 0) {
+            throw new Error("at least one limit is required");
+        }
+
+        const dataType = addressSpace.findCorrespondingBasicDataType(inputNode.dataType);
+
+        if (-1 === uaLimitAlarmInputSupportedDataType.indexOf(dataType)) {
+            const message = `UALimitAlarm.instantiate: inputNode must be of type ${uaLimitAlarmInputSupportedDataType
+                .map((a) => DataType[a])
+                .join("|")}, got ${DataType[dataType]}`;
+            warningLog(message);
+            throw new Error(message);
+        }
+
+        if (Object.hasOwn(options, "highHighLimit") && options.highHighLimit !== undefined) {
+            alarmNode.setHighHighLimit(options.highHighLimit);
+        }
+        if (Object.hasOwn(options, "highLimit")) {
+            alarmNode.setHighLimit(options.highLimit);
+        }
+        if (Object.hasOwn(options, "lowLimit")) {
+            alarmNode.setLowLimit(options.lowLimit);
+        }
+        if (Object.hasOwn(options, "lowLowLimit") && options.lowLowLimit !== undefined) {
+            alarmNode.setLowLowLimit(options.lowLowLimit);
+        }
+
+        /*
+         * 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.
+         */
+        assert(alarmNode.inputNode.nodeClass === NodeClass.Variable);
+        alarmNode.inputNode.setValueFromSource({ dataType: "NodeId", value: inputNode.nodeId });
+
+        // install inputNode monitoring for change
+        alarmNode.installInputNodeMonitoring(options.inputNode);
+        alarmNode._watchLimits();
+
+        return alarmNode;
+    }
+
+    public getHighHighLimit(): number {
+        if (!this.highHighLimit) {
+            throw new Error("Alarm do not expose highHighLimit");
+        }
+        return this.highHighLimit.readValue().value.value;
+    }
+
+    public getHighLimit(): number {
+        if (!this.highLimit) {
+            throw new Error("Alarm do not expose highLimit");
+        }
+        return this.highLimit.readValue().value.value;
+    }
+
+    public getLowLimit(): number {
+        if (!this.lowLimit) {
+            throw new Error("Alarm do not expose lowLimit");
+        }
+        return this.lowLimit.readValue().value.value;
+    }
+
+    public getLowLowLimit(): number {
+        if (!this.lowLowLimit) {
+            throw new Error("Alarm do not expose lowLowLimit");
+        }
+        return this.lowLowLimit.readValue().value.value;
+    }
+
+    public setHighHighLimit(value: number): void {
+        if (!this.highHighLimit) {
+            throw new Error("LimitAlarm instance must expose the optional HighHighLimit property");
+        }
+        this.highHighLimit.setValueFromSource({ dataType: DataType.Double, value });
+    }
+
+    public setHighLimit(value: number): void {
+        if (!this.highLimit) {
+            throw new Error("LimitAlarm instance must expose the optional HighLimit property");
+        }
+        this.highLimit.setValueFromSource({ dataType: DataType.Double, value });
+    }
+
+    public setLowLimit(value: number): void {
+        if (!this.lowLimit) {
+            throw new Error("LimitAlarm instance must expose the optional LowLimit property");
+        }
+        this.lowLimit.setValueFromSource({ dataType: DataType.Double, value });
+    }
+    public setLowLowLimit(value: number): void {
+        if (!this.lowLowLimit) {
+            throw new Error("LimitAlarm instance must expose the optional LowLowLimit property");
+        }
+        this.lowLowLimit.setValueFromSource({ dataType: DataType.Double, value });
+    }
+
+    protected _onInputDataValueChange(dataValue: DataValue): void {
+        assert(dataValue instanceof DataValue);
+
+        if (dataValue.statusCode.equals(StatusCodes.BadWaitingForInitialData)) {
+            // we are not ready yet to use the input node value
+            return;
+        }
+        if (dataValue.statusCode.isNotGood() && !dataValue.statusCode.equals(StatusCodes.UncertainInitialValue)) {
+            // genuinely bad status (not the initial uncertain state) → no specific limit state, alarm inactive
+            this._signalNewCondition(null, false, "Input node value is not good");
+            return;
+        }
+        if (dataValue.value.dataType === DataType.Null) {
+            // input not yet set → no specific limit state, alarm inactive
+            this._signalNewCondition(null, false, "Input node value is null");
+            return;
+        }
+        const value = dataValue.value.value;
+        this._setStateBasedOnInputValue(value);
+    }
+
+    protected _setStateBasedOnInputValue(_value: number): void {
+        throw new Error("_setStateBasedOnInputValue must be overriden");
+    }
+
+    protected _watchLimits(): void {
+        /// ----------------------------------------------------------------------
+        /// Installing Limits monitored
+        const _updateState = () => this.updateState();
+
+        if (this.highHighLimit) {
+            this.highHighLimit.on("value_changed", _updateState);
+        }
+        if (this.highLimit) {
+            this.highLimit.on("value_changed", _updateState);
+        }
+        if (this.lowLimit) {
+            this.lowLimit.on("value_changed", _updateState);
+        }
+        if (this.lowLowLimit) {
+            this.lowLowLimit.on("value_changed", _updateState);
+        }
+    }
+
+    protected evaluateConditionsAfterEnabled(): void {
+        assert(this.getEnabledState() === true);
+        // simulate input value event
+        const input = this.getInputNodeNode();
+        if (!input) {
+            return;
+        }
+        const dataValue = input.readValue();
+        this._onInputDataValueChange(dataValue);
+    }
+}
+
+/** @internal */
+export const UALimitAlarmImpl = UALimitAlarmImplBase;
+/** @internal */
+export type UALimitAlarmImpl = UALimitAlarmImplBase;

package/impl/alarms_and_conditions/ua_non_exclusive_deviation_alarm_impl.ts

@@ -0,0 +1,94 @@
+/**
+ * @module node-opcua-address-space.AlarmsAndConditions
+ */
+
+import type { UAVariableT } from "node-opcua-address-space-base";
+import { assert } from "node-opcua-assert";
+import type { DataValue } from "node-opcua-data-value";
+import type { NodeId } from "node-opcua-nodeid";
+import type { DataType, VariantOptions } from "node-opcua-variant";
+import type { InstallSetPointOptions } from "../../api/interfaces/alarms_and_conditions/install_setpoint_options.js";
+import type { InstantiateLimitAlarmOptions } from "../../api/interfaces/alarms_and_conditions/instantiate_limit_alarm_options.js";
+import type { UANonExclusiveDeviationAlarmEx } from "../../api/interfaces/alarms_and_conditions/ua_non_exclusive_deviation_alarm_ex.js";
+import type { NamespacePrivate } from "../namespace_private.js";
+import {
+    DeviationAlarmHelper_getSetpointNodeNode,
+    DeviationAlarmHelper_getSetpointValue,
+    DeviationAlarmHelper_install_setpoint,
+    DeviationAlarmHelper_onSetpointDataValueChange
+} from "./deviation_alarm_helper.js";
+import { UALimitAlarmImpl } from "./ua_limit_alarm_impl.js";
+import { UANonExclusiveLimitAlarmImpl, UANonExclusiveLimitAlarmImplBase } from "./ua_non_exclusive_limit_alarm_impl.js";
+
+/** @internal */
+export class UANonExclusiveDeviationAlarmImplBase
+    extends UANonExclusiveLimitAlarmImplBase
+    implements UANonExclusiveDeviationAlarmEx
+{
+    /** installed as child nodes by the address space, not assigned here - hence `declare` */
+    public declare readonly setpointNode: UAVariableT<NodeId, DataType.NodeId>;
+    // required here, though SetPointSupport declares it optional
+    public declare readonly setpointNodeNode: UAVariableT<number, DataType.Double> | UAVariableT<number, DataType.Float>;
+
+    public static instantiate(
+        namespace: NamespacePrivate,
+        type: string | NodeId,
+        options: InstantiateLimitAlarmOptions & InstallSetPointOptions,
+        data?: Record<string, VariantOptions>
+    ): UANonExclusiveDeviationAlarmImpl {
+        const addressSpace = namespace.addressSpace;
+
+        const nonExclusiveDeviationAlarmType = addressSpace.findEventType("NonExclusiveDeviationAlarmType");
+        /* c8 ignore next */
+        if (!nonExclusiveDeviationAlarmType) {
+            throw new Error("cannot find ExclusiveDeviationAlarmType");
+        }
+        assert(type === nonExclusiveDeviationAlarmType.browseName.toString());
+
+        const alarm = UANonExclusiveLimitAlarmImplBase.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(Number.isFinite(setpointValue), "expecting a valid setpoint value");
+        // call base class implementation
+        super._setStateBasedOnInputValue(value - setpointValue);
+    }
+
+    public getSetpointNodeNode(): UAVariableT<number, DataType.Double> | UAVariableT<number, DataType.Float> | undefined {
+        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: InstallSetPointOptions): void {
+        DeviationAlarmHelper_install_setpoint.call(this, options);
+    }
+}
+
+/** @internal */
+export type UANonExclusiveDeviationAlarmImpl = UANonExclusiveDeviationAlarmImplBase;
+/** @internal */
+export const UANonExclusiveDeviationAlarmImpl = UANonExclusiveDeviationAlarmImplBase;