node-opcua-address-space 2.51.0

package/src/alarms_and_conditions/ua_discrete_alarm_impl.ts

@@ -0,0 +1,81 @@
+/**
+ * @module node-opcua-address-space.AlarmsAndConditions
+ */
+import { assert } from "node-opcua-assert";
+import { NodeId } from "node-opcua-nodeid";
+import { UADiscreteAlarm, UADiscreteAlarm_Base } from "node-opcua-nodeset-ua";
+import { INamespace, UAEventType } from "../../source";
+import { UAAlarmConditionEx, UAAlarmConditionHelper, UAAlarmConditionImpl } from "./ua_alarm_condition_impl";
+
+export interface UADiscreteAlarmHelper extends UAAlarmConditionHelper {
+  on(eventName:string, eventHandle: any): this;
+}
+export interface UADiscreteAlarmEx extends 
+    UAAlarmConditionEx,  
+    Omit<UADiscreteAlarm_Base, "suppressedState"| "silenceState" |  "shelvingState" | "outOfServiceState" | "latchedState" | "confirmedState" | "ackedState" | "comfirmedState" | "activeState" | "enabledState" >, 
+     UADiscreteAlarmHelper {
+  
+}
+/*=
+ *      +----------------------+
+ *      | UAAlarmCondition     |
+ *      +----------------------+
+ *               ^
+ *               |
+ *      +--------+---------+
+ *      | UADiscreteAlarm  |
+ *      +------------------+
+ *               ^
+ *               |
+ *      +--------+---------+
+ *      | UAOffNormalAlarm |
+ *      +------------------+
+ *               ^
+ *               |
+ *      +--------+---------+
+ *      |   UATripAlarm    |
+ *      +------------------+
+ *
+ *
+ *
+ */
+
+/**
+ * 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).
+ */
+export class UADiscreteAlarmImpl extends UAAlarmConditionImpl implements UADiscreteAlarmEx {
+
+  public static instantiate(
+    namespace: INamespace,
+    discreteAlarmTypeId: UAEventType | NodeId | string,
+    options: any,
+    data: any
+  ): UADiscreteAlarmImpl {
+
+    const addressSpace = namespace.addressSpace;
+
+    const discreteAlarmType = addressSpace.findEventType(discreteAlarmTypeId);
+    /* istanbul 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!");
+
+    /* eventTypeNode should be subtypeOf("DiscreteAlarmType"); */
+    /* istanbul ignore next */
+    if (!discreteAlarmType.isSupertypeOf(discreteAlarmTypeBase as any)) {
+      throw new Error("UADiscreteAlarm.instantiate : event found is not subType of DiscreteAlarmType");
+    }
+
+    const alarmNode = UAAlarmConditionImpl.instantiate(
+      namespace,
+      discreteAlarmType.nodeId, options, data) as UADiscreteAlarm;
+    Object.setPrototypeOf(alarmNode, UADiscreteAlarmImpl.prototype);
+
+    return alarmNode as UADiscreteAlarmImpl;
+  }
+}

package/src/alarms_and_conditions/ua_exclusive_deviation_alarm_impl.ts

@@ -0,0 +1,110 @@
+/**
+ * @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 { UAExclusiveDeviationAlarm_Base } from "node-opcua-nodeset-ua";
+
+import { UAVariable, UAVariableT } from "../../source";
+import { AddressSpace } from "../address_space";
+import { NamespacePrivate } from "../namespace_private";
+import {
+    DeviationAlarmHelper_getSetpointNodeNode,
+    DeviationAlarmHelper_getSetpointValue,
+    DeviationAlarmHelper_install_setpoint,
+    DeviationAlarmHelper_onSetpointDataValueChange,
+    DeviationStuff,
+    InstallSetPointOptions
+} from "./deviation_alarm_helper";
+
+import { UAExclusiveLimitAlarmEx, UAExclusiveLimitAlarmImpl } from "./ua_exclusive_limit_alarm_impl";
+import { UALimitAlarmImpl } from "./ua_limit_alarm_impl";
+
+export interface UAExclusiveDeviationAlarmEx
+    extends Omit<
+            UAExclusiveDeviationAlarm_Base,
+            | "ackedState"
+            | "activeState"
+            | "confirmedState"
+            | "enabledState"
+            | "latchedState"
+            | "limitState"
+            | "outOfServiceState"
+            | "shelvingState"
+            | "silenceState"
+            | "suppressedState"
+        >,
+        UAExclusiveLimitAlarmEx,
+        DeviationStuff {}
+
+export declare interface UAExclusiveDeviationAlarmImpl extends UAExclusiveDeviationAlarmEx, UAExclusiveLimitAlarmImpl {
+    on(eventName: string, eventHandler: any): this;
+    get addressSpace(): AddressSpace;
+}
+export class UAExclusiveDeviationAlarmImpl extends UAExclusiveLimitAlarmImpl implements UAExclusiveDeviationAlarmEx {
+    public static instantiate(
+        namespace: NamespacePrivate,
+        type: string | NodeId,
+        options: any,
+        data: any
+    ): UAExclusiveDeviationAlarmImpl {
+        const addressSpace = namespace.addressSpace;
+
+        const exclusiveDeviationAlarmType = addressSpace.findEventType("ExclusiveDeviationAlarmType");
+        /* istanbul ignore next */
+        if (!exclusiveDeviationAlarmType) {
+            throw new Error("cannot find ExclusiveDeviationAlarmType");
+        }
+
+        assert(type === exclusiveDeviationAlarmType.browseName.toString());
+
+        const alarm = UAExclusiveLimitAlarmImpl.instantiate(namespace, type, options, data) as UAExclusiveDeviationAlarmImpl;
+        Object.setPrototypeOf(alarm, UAExclusiveDeviationAlarmImpl.prototype);
+        assert(alarm instanceof UAExclusiveDeviationAlarmImpl);
+        assert(alarm instanceof UAExclusiveLimitAlarmImpl);
+        assert(alarm instanceof UALimitAlarmImpl);
+
+        alarm._install_setpoint(options);
+
+        return alarm;
+    }
+    
+    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: InstallSetPointOptions): any {
+        return DeviationAlarmHelper_install_setpoint.call(this, options);
+    }
+
+    public _setStateBasedOnInputValue(value: number):void  {
+        const setpointValue = this.getSetpointValue();
+        if (setpointValue === null) {
+            return;
+        }
+        assert(isFinite(setpointValue));
+        // call base class implementation
+        UAExclusiveLimitAlarmImpl.prototype._setStateBasedOnInputValue.call(this, value - setpointValue);
+    }
+}
+export interface UAExclusiveDeviationAlarmHelper {
+    setpointNode: UAVariableT<NodeId, DataType.NodeId>;
+    setpointNodeNode: UAVariable;
+}
+
+/*
+UAExclusiveDeviationAlarm.prototype.getSetpointNodeNode = DeviationAlarmHelper.getSetpointNodeNode;
+UAExclusiveDeviationAlarm.prototype.getSetpointValue = DeviationAlarmHelper.getSetpointValue;
+UAExclusiveDeviationAlarm.prototype._onSetpointDataValueChange = DeviationAlarmHelper._onSetpointDataValueChange;
+UAExclusiveDeviationAlarm.prototype._install_setpoint = DeviationAlarmHelper._install_setpoint;
+ */

package/src/alarms_and_conditions/ua_exclusive_level_alarm_impl.ts

@@ -0,0 +1,19 @@
+/**
+ * @module node-opcua-address-space.AlarmsAndConditions
+ */
+import { NodeId } from "node-opcua-nodeid";
+import { NamespacePrivate } from "../namespace_private";
+import { UAExclusiveLimitAlarmImpl } from "./ua_exclusive_limit_alarm_impl";
+
+export class UAExclusiveLevelAlarmImpl extends UAExclusiveLimitAlarmImpl {
+
+    public static instantiate(
+      namespace: NamespacePrivate,
+      type: NodeId | string,
+      option: any,
+      data: any
+    ): UAExclusiveLevelAlarmImpl {
+        const addressSpace = namespace.addressSpace;
+        return UAExclusiveLimitAlarmImpl.instantiate(namespace, type, option, data) as UAExclusiveLevelAlarmImpl;
+    }
+}

package/src/alarms_and_conditions/ua_exclusive_limit_alarm_impl.ts

@@ -0,0 +1,130 @@
+/**
+ * @module node-opcua-address-space.AlarmsAndConditions
+ */
+import { assert } from "node-opcua-assert";
+import { NodeId } from "node-opcua-nodeid";
+import { UAObject } from "node-opcua-address-space-base";
+import { UAExclusiveLimitAlarm, UAExclusiveLimitAlarm_Base } from "node-opcua-nodeset-ua";
+
+import { UAEventType, UAExclusiveLimitStateMachineEx } from "../../source";
+import { UATwoStateVariableEx } from "../../source/ua_two_state_variable_ex";
+import { NamespacePrivate } from "../namespace_private";
+import { promoteToStateMachine } from "../state_machine/finite_state_machine";
+import { UAShelvedStateMachineEx } from "../state_machine/ua_shelving_state_machine_ex";
+import { UALimitAlarmEx, UALimitAlarmHelper, UALimitAlarmImpl } from "./ua_limit_alarm_impl";
+
+const validState = ["HighHigh", "High", "Low", "LowLow", null];
+
+export interface UAExclusiveLimitAlarmHelper extends UALimitAlarmHelper {}
+export interface UAExclusiveLimitAlarmEx
+    extends Omit<UAExclusiveLimitAlarm_Base, "limitState">,
+        UALimitAlarmEx,
+        UAExclusiveLimitAlarmHelper {
+    on(eventName: string, eventHandler: any): this;
+
+    ackedState: UATwoStateVariableEx;
+    activeState: UATwoStateVariableEx;
+    confirmedState?: UATwoStateVariableEx;
+    enabledState: UATwoStateVariableEx;
+    latchedState?: UATwoStateVariableEx;
+    outOfServiceState?: UATwoStateVariableEx;
+    silenceState?: UATwoStateVariableEx;
+    suppressedState?: UATwoStateVariableEx;
+    //
+    limitState: UAExclusiveLimitStateMachineEx;
+    shelvingState?: UAShelvedStateMachineEx;
+}
+export declare interface UAExclusiveLimitAlarmImpl extends UAExclusiveLimitAlarmEx {}
+
+export class UAExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UAExclusiveLimitAlarmEx {
+    /***
+     *
+     * @method (static)instantiate
+     * @param namespace {INamespace}
+     * @param type
+     * @param options
+     * @param data
+     * @return {UAExclusiveLimitAlarm}
+     */
+    public static instantiate(
+        namespace: NamespacePrivate,
+        type: UAEventType | string | NodeId,
+        options: any,
+        data: any
+    ): UAExclusiveLimitAlarmImpl {
+        const addressSpace = namespace.addressSpace;
+
+        const exclusiveAlarmType = addressSpace.findEventType(type);
+
+        /* istanbul ignore next */
+        if (!exclusiveAlarmType) {
+            throw new Error(" cannot find Alarm Condition Type for " + type);
+        }
+
+        const exclusiveLimitAlarmType = addressSpace.findEventType("ExclusiveLimitAlarmType");
+        /* istanbul ignore next */
+        if (!exclusiveLimitAlarmType) {
+            throw new Error("cannot find ExclusiveLimitAlarmType");
+        }
+
+        const node = UALimitAlarmImpl.instantiate(namespace, type, options, data);
+        Object.setPrototypeOf(node, UAExclusiveLimitAlarmImpl.prototype);
+        const alarm = node as any as UAExclusiveLimitAlarmImpl;
+        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;
+    }
+
+    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(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.toString());
+        }
+    }
+}

package/src/alarms_and_conditions/ua_exclusive_rate_of_change_alarm_impl.ts

@@ -0,0 +1,24 @@
+/**
+ * @module node-opcua-address-space.AlarmsAndConditions
+ */
+import { UAExclusiveRateOfChangeAlarm, UAExclusiveRateOfChangeAlarm_Base } from "node-opcua-nodeset-ua";
+import { UAExclusiveLimitAlarmEx, UAExclusiveLimitAlarmImpl } from "./ua_exclusive_limit_alarm_impl";
+
+export interface UAExclusiveRateOfChangeAlarmEx
+    extends Omit<
+            UAExclusiveRateOfChangeAlarm_Base,
+            | "ackedState"
+            | "activeState"
+            | "confirmedState"
+            | "enabledState"
+            | "latchedState"
+            | "limitState"
+            | "outOfServiceState"
+            | "shelvingState"
+            | "silenceState"
+            | "suppressedState"
+        >,
+        UAExclusiveLimitAlarmEx {
+    on(eventName: string, eventHandler: any): this;
+}
+export class UAExclusiveRateOfChangeAlarmImpl extends UAExclusiveLimitAlarmImpl implements UAExclusiveRateOfChangeAlarmEx {}

package/src/alarms_and_conditions/ua_limit_alarm_impl.ts

@@ -0,0 +1,305 @@
+/* eslint-disable max-statements */
+/**
+ * @module node-opcua-address-space.AlarmsAndConditions
+ */
+import { UAEventType } from "node-opcua-address-space-base";
+import { assert } from "node-opcua-assert";
+import { NodeClass } from "node-opcua-data-model";
+import { DataValue } from "node-opcua-data-value";
+import { NodeId } from "node-opcua-nodeid";
+import { UALimitAlarm_Base , UALimitAlarm} from "node-opcua-nodeset-ua";
+import { StatusCodes } from "node-opcua-status-code";
+import { DataType } from "node-opcua-variant";
+import { UATwoStateVariableEx } from "../../source/ua_two_state_variable_ex";
+
+import { NamespacePrivate } from "../namespace_private";
+import { UAShelvedStateMachineEx } from "../state_machine/ua_shelving_state_machine_ex";
+import { UAAlarmConditionEx, UAAlarmConditionHelper, UAAlarmConditionImpl } from "./ua_alarm_condition_impl";
+
+
+export interface UALimitAlarmHelper extends UAAlarmConditionHelper {
+    setLowLowLimit(value: number): void;
+    setLowLimit(value: number): void;
+    setHighLimit(value: number): void;
+    setHighHighLimit(value: number): void ;
+    getHighHighLimit(): number;
+    getHighLimit(): number;
+    getLowLimit(): number;
+    getLowLowLimit(): number;
+}
+export interface UALimitAlarmEx extends UALimitAlarm_Base, UAAlarmConditionEx, UALimitAlarmHelper {
+    
+    on(eventName: string, eventHandler: any): this;
+
+    enabledState: UATwoStateVariableEx;
+    ackedState: UATwoStateVariableEx;
+    confirmedState?: UATwoStateVariableEx;
+    activeState: UATwoStateVariableEx;
+    latchedState?: UATwoStateVariableEx;
+    outOfServiceState?: UATwoStateVariableEx;
+    silenceState?: UATwoStateVariableEx;
+    shelvingState?: UAShelvedStateMachineEx;
+    suppressedState?: UATwoStateVariableEx;
+}
+
+export declare interface UALimitAlarmImpl extends UALimitAlarmEx, UAAlarmConditionImpl {
+    on(eventName: string, eventHandler: any): this;
+}
+export class UALimitAlarmImpl extends UAAlarmConditionImpl implements UALimitAlarmEx {
+    /**
+     * @method (static)UALimitAlarm.instantiate
+     * @param namespace {INamespace}
+     * @param limitAlarmTypeId
+     * @param options
+     * @param options.inputNode
+     * @param options.optionals
+     * @param options.highHighLimit {Double}
+     * @param options.highLimit     {Double}
+     * @param options.lowLimit      {Double}
+     * @param options.lowLowLimit   {Double}
+     * @param data
+     * @return {UALimitAlarm}
+     */
+    public static instantiate(
+        namespace: NamespacePrivate,
+        limitAlarmTypeId: UAEventType | NodeId | string,
+        options: any,
+        data: any
+    ): UALimitAlarmImpl {
+        const addressSpace = namespace.addressSpace;
+
+        // must provide a inputNode
+        // xx assert(Object.prototype.hasOwnProperty.call(options,"conditionOf")); // must provide a conditionOf
+        assert(Object.prototype.hasOwnProperty.call(options,"inputNode"), "UALimitAlarm.instantiate: options must provide the inputNode");
+
+        options.optionals = options.optionals || [];
+        let count = 0;
+        if (Object.prototype.hasOwnProperty.call(options,"highHighLimit")) {
+            options.optionals.push("HighHighLimit");
+            options.optionals.push("HighHighState");
+            count++;
+        }
+        if (Object.prototype.hasOwnProperty.call(options,"highLimit")) {
+            options.optionals.push("HighLimit");
+            options.optionals.push("HighState");
+            count++;
+        }
+        if (Object.prototype.hasOwnProperty.call(options,"lowLimit")) {
+            options.optionals.push("LowLimit");
+            options.optionals.push("LowState");
+            count++;
+        }
+        if (Object.prototype.hasOwnProperty.call(options,"lowLowLimit")) {
+            options.optionals.push("LowLowLimit");
+            options.optionals.push("LowLowState");
+            count++;
+        }
+
+        // xx assert(options.optionals,"must provide an optionals");
+        const alarmNode = UAAlarmConditionImpl.instantiate(namespace, limitAlarmTypeId, options, data) as UALimitAlarmImpl;
+        Object.setPrototypeOf(alarmNode, UALimitAlarmImpl.prototype);
+
+        assert(alarmNode.conditionOfNode() !== null);
+
+        const inputNode = addressSpace._coerceNode(options.inputNode);
+        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(options.inputNode.dataType);
+
+        alarmNode._dataType = dataType;
+
+        if (Object.prototype.hasOwnProperty.call(options,"highHighLimit")) {
+            alarmNode.setHighHighLimit(options.highHighLimit);
+        }
+        if (Object.prototype.hasOwnProperty.call(options,"highLimit")) {
+            alarmNode.setHighLimit(options.highLimit);
+        }
+        if (Object.prototype.hasOwnProperty.call(options,"lowLimit")) {
+            alarmNode.setLowLimit(options.lowLimit);
+        }
+        if (Object.prototype.hasOwnProperty.call(options,"lowLowLimit")) {
+            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 _dataType: any;
+    
+    /**
+     * @method getHighHighLimit
+     * @return {Number}
+     */
+    public getHighHighLimit(): number {
+        if (!this.highHighLimit) {
+            throw new Error("Alarm do not expose highHighLimit");
+        }
+        return this.highHighLimit.readValue().value.value;
+    }
+
+    /**
+     * @method getHighLimit
+     * @return {Number}
+     */
+    public getHighLimit(): number {
+        if (!this.highLimit) {
+            throw new Error("Alarm do not expose highLimit");
+        }
+        return this.highLimit.readValue().value.value;
+    }
+
+    /**
+     * @method getLowLimit
+     * @return {Float}
+     */
+    public getLowLimit(): number {
+        if (!this.lowLimit) {
+            throw new Error("Alarm do not expose lowLimit");
+        }
+        return this.lowLimit.readValue().value.value;
+    }
+
+    /**
+     * @method getLowLowLimit
+     * @return {Float}
+     */
+    public getLowLowLimit(): number {
+        if (!this.lowLowLimit) {
+            throw new Error("Alarm do not expose lowLowLimit");
+        }
+        return this.lowLowLimit.readValue().value.value;
+    }
+
+    /**
+     * @method setHighHighLimit
+     * @param value {Float}
+     */
+    public setHighHighLimit(value: number): void {
+        if (!this.highHighLimit) {
+            throw new Error("LimitAlarm instance must expose the optional HighHighLimit property");
+        }
+        this.highHighLimit.setValueFromSource({ dataType: this._dataType, value });
+    }
+
+    /**
+     * @method setHighLimit
+     * @param value {Float}
+     */
+    public setHighLimit(value: number): void {
+        if (!this.highLimit) {
+            throw new Error("LimitAlarm instance must expose the optional HighLimit property");
+        }
+        this.highLimit.setValueFromSource({ dataType: this._dataType, value });
+    }
+
+    /**
+     * @method setLowLimit
+     * @param value {Float}
+     */
+    public setLowLimit(value: number): void {
+        if (!this.lowLimit) {
+            throw new Error("LimitAlarm instance must expose the optional LowLimit property");
+        }
+        this.lowLimit.setValueFromSource({ dataType: this._dataType, value });
+    }
+
+
+    /**
+     * @method setLowLowLimit
+     * @param value {Float}
+     */
+    public setLowLowLimit(value: number): void {
+        if (!this.lowLowLimit) {
+            throw new Error("LimitAlarm instance must expose the optional LowLowLimit property");
+        }
+        this.lowLowLimit.setValueFromSource({ dataType: this._dataType, value });
+    }
+
+    public _onInputDataValueChange(dataValue: DataValue): void {
+        assert(dataValue instanceof DataValue);
+
+        if (
+            dataValue.statusCode === StatusCodes.BadWaitingForInitialData &&
+            dataValue.statusCode === StatusCodes.UncertainInitialValue
+        ) {
+            // we are not ready yet to use the input node value
+            return;
+        }
+        if (dataValue.statusCode !== StatusCodes.Good) {
+            // what shall we do ?
+            this._signalNewCondition(null);
+            return;
+        }
+        if (dataValue.value.dataType === DataType.Null) {
+            // what shall we do ?
+            this._signalNewCondition(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);
+    }
+}