node-opcua-aggregates 2.77.0 → 2.79.0

package/source/interval.ts

@@ -13,10 +13,20 @@ export function isGoodish(statusCode: StatusCode): boolean {
     return statusCode.value < 0x40000000;
 }
 
+export function isGoodish2(statusCode: StatusCode, { treatUncertainAsBad }: { treatUncertainAsBad?: boolean }): boolean {
+    if (isGoodish(statusCode)) return true;
+    if (isUncertain(statusCode)) return !treatUncertainAsBad;
+    return false;
+}
+
 export function isBad(statusCode: StatusCode): boolean {
     return statusCode.value >= 0x80000000;
 }
 
+export function isUncertain(statusCode: StatusCode): boolean {
+    return (statusCode.value & 0x40000000) === 0x40000000 && statusCode.value !== StatusCodes.BadNoData.value;
+}
+
 export function isGood(statusCode: StatusCode): boolean {
     return statusCode.value === 0x0;
 }
@@ -27,6 +37,7 @@ export interface IntervalOptions {
     index: number;
     count: number;
     isPartial: boolean;
+    processingInterval: number;
 }
 
 interface DataValueWithIndex {
@@ -97,6 +108,7 @@ export class Interval {
     public index: number;
     public count: number;
     public isPartial: boolean;
+    public processingInterval: number;
 
     // startTime
     // dataValues
@@ -108,6 +120,7 @@ export class Interval {
         this.index = options.index;
         this.count = options.count;
         this.isPartial = options.isPartial;
+        this.processingInterval = options.processingInterval;
     }
 
     public getPercentBad(): number {
@@ -155,9 +168,44 @@ export class Interval {
         }
         return str;
     }
+    public getEffectiveEndTime(): number {
+        const e = this.startTime.getTime() + this.processingInterval;
+        if (!this.dataValues || this.dataValues.length === 0) {
+            return e;
+        }
+        let i = this.dataValues.length - 1;
+        while (i >= 0 && this.dataValues[i].statusCode === StatusCodes.BadNoData) {
+            i--;
+        }
+        if (i < 0) {
+            return e;
+        }
+        const lastTimestamp = this.dataValues[i].sourceTimestamp!;
+        return Math.min(e, lastTimestamp.getTime() + 1);
+    }
+
+    /**
+     * 
+     * @returns the interval duration
+     */
+    duration() {
+        const t1 = this.dataValues[this.index].sourceTimestamp!.getTime();
+        const e = this.getEffectiveEndTime();
+        return e - t1;
+    }
+
+    /**
+     * returns the region duration starting at index and finishing at index+1 or end limit of the interval
+     */
+    regionDuration(index: number): number {
+        const t1 = this.dataValues[index].sourceTimestamp!.getTime();
+        const e = this.getEffectiveEndTime();
+        const t2 = index < this.dataValues.length - 1 ? Math.min(this.dataValues[index + 1].sourceTimestamp!.getTime(), e) : e;
+        return t2 - t1;
+    }
 }
 
-export function getInterval(startTime: Date, duration: number, indexHint: number, dataValues: DataValue[]): Interval {
+export function getInterval(startTime: Date, processingInterval: number, indexHint: number, dataValues: DataValue[]): Interval {
     let count = 0;
     let index = -1;
     for (let i = indexHint; i < dataValues.length; i++) {
@@ -170,7 +218,7 @@ export function getInterval(startTime: Date, duration: number, indexHint: number
 
     if (index >= 0) {
         for (let i = index; i < dataValues.length; i++) {
-            if (dataValues[i].sourceTimestamp!.getTime() >= startTime.getTime() + duration) {
+            if (dataValues[i].sourceTimestamp!.getTime() >= startTime.getTime() + processingInterval) {
                 break;
             }
             count++;
@@ -181,7 +229,7 @@ export function getInterval(startTime: Date, duration: number, indexHint: number
     let isPartial = false;
     if (
         index + count >= dataValues.length &&
-        dataValues[dataValues.length - 1].sourceTimestamp!.getTime() < startTime.getTime() + duration
+        dataValues[dataValues.length - 1].sourceTimestamp!.getTime() < startTime.getTime() + processingInterval
     ) {
         isPartial = true;
     }
@@ -194,6 +242,7 @@ export function getInterval(startTime: Date, duration: number, indexHint: number
         dataValues,
         index,
         isPartial,
-        startTime
+        startTime,
+        processingInterval
     });
 }

package/source/percent_bad.ts

@@ -0,0 +1,30 @@
+import { UAVariable } from "node-opcua-address-space";
+import { DataValue } from "node-opcua-data-value";
+import { DataType } from "node-opcua-variant";
+
+import { getAggregateData } from "./common";
+import { Interval, AggregateConfigurationOptions, isGoodish } from "./interval";
+import { calculateBadAndGood } from "./calculate_bad_good";
+
+function calculatePercentBad(interval: Interval, options: AggregateConfigurationOptions): DataValue {
+    const { percentBad, statusCode } = calculateBadAndGood(interval, options);
+    const value = percentBad;
+    if (isGoodish(statusCode)) {
+        return new DataValue({
+            sourceTimestamp: interval.startTime,
+            statusCode,
+            value: { dataType: DataType.Double, value }
+        });
+    }
+    return new DataValue({ sourceTimestamp: interval.startTime, statusCode, value: { dataType: DataType.Null } });
+}
+/**Retrieve the percentage of data (0 to 100) in the interval which has Bad StatusCode. */
+export function getPercentBadData(
+    node: UAVariable,
+    processingInterval: number,
+    startDate: Date,
+    endDate: Date,
+    callback: (err: Error | null, dataValues?: DataValue[]) => void
+): void {
+    getAggregateData(node, processingInterval, startDate, endDate, calculatePercentBad, callback);
+}

package/source/percent_good.ts

@@ -0,0 +1,55 @@
+import { UAVariable } from "node-opcua-address-space";
+import { DataValue } from "node-opcua-data-value";
+import { Variant, DataType } from "node-opcua-variant";
+import { extraStatusCodeBits, StatusCode, StatusCodes } from "node-opcua-status-code";
+
+import { getAggregateData } from "./common";
+import { Interval, AggregateConfigurationOptions, isGood, isGoodish, isUncertain, isBad } from "./interval";
+import { calculateBadAndGood } from "./calculate_bad_good";
+
+function calculatePercentGood(interval: Interval, options: AggregateConfigurationOptions): DataValue {
+    //
+    // The PercentGood Aggregate defined in Table 44 performs the following calculation:
+    //
+    //     PercentGood = DurationGood / ProcessingInterval x 100
+    // where:
+    //
+    // DurationGood is the result from the DurationGood *Aggregate*, calculated using the *ProcessingInterval* supplied to *PercentGood* call.
+    // ProcessingInterval is the duration of interval.
+    // If the last interval is a partial interval then the duration of the partial interval is used in the
+    // calculation.
+    // Each Aggregate is returned with timestamp of the start of the interval. StatusCodes are Good, Calculated.
+    //
+    const { percentGood, statusCode } = calculateBadAndGood(interval, options);
+    if (percentGood < 0) {
+        // special case ! to indicate that no good pointhas been found in the interval
+        return new DataValue({
+            sourceTimestamp: interval.startTime,
+            statusCode: StatusCodes.Bad,
+            value: { dataType: DataType.Null }
+        });
+    }
+    const value = percentGood;
+    if (isGoodish(statusCode)) {
+        return new DataValue({
+            sourceTimestamp: interval.startTime,
+            statusCode,
+            value: { dataType: DataType.Double, value }
+        });
+    }
+    return new DataValue({ sourceTimestamp: interval.startTime, statusCode, value: { dataType: DataType.Null } });
+}
+
+/**
+ *
+ * @param node 	Retrieve the percentage of data (0 to 100) in the interval which has Good StatusCode.
+ */
+export function getPercentGoodData(
+    node: UAVariable,
+    processingInterval: number,
+    startDate: Date,
+    endDate: Date,
+    callback: (err: Error | null, dataValues?: DataValue[]) => void
+): void {
+    getAggregateData(node, processingInterval, startDate, endDate, calculatePercentGood, callback);
+}

package/source/read_processed_details.ts

@@ -5,16 +5,17 @@ import { QualifiedNameLike } from "node-opcua-data-model";
 import { CallbackT, StatusCodes } from "node-opcua-status-code";
 import { DataValue } from "node-opcua-data-value";
 import { NodeId } from "node-opcua-nodeid";
-import {
-    HistoryData,
-    HistoryReadResult,
-    ReadProcessedDetails
-} from "node-opcua-service-history";
+import { HistoryData, HistoryReadResult, ReadProcessedDetails } from "node-opcua-service-history";
 
 import { getMinData, getMaxData } from "./minmax";
 
 import { getInterpolatedData } from "./interpolate";
 import { getAverageData } from "./average";
+import { getCountData } from "./count";
+import { getPercentBadData } from "./percent_bad";
+import { getPercentGoodData } from "./percent_good";
+import { getDurationGoodData } from "./duration_good";
+import { getDurationBadData } from "./duration_bad";
 
 function _buildResult(err: Error | null, dataValues: DataValue[] | undefined, callback2: CallbackT<HistoryReadResult>) {
     if (err) {
@@ -43,23 +44,43 @@ function applyAggregate(
     const buildResult = (err: Error | null, dataValues: DataValue[] | undefined) => {
         _buildResult(err, dataValues, callback2);
     };
-    switch (aggregateType.value) {
-        case AggregateFunction.Minimum:
-            getMinData(variable, processingInterval, startTime, endTime, buildResult);
-            break;
-        case AggregateFunction.Maximum:
-            getMaxData(variable, processingInterval, startTime, endTime, buildResult);
-            break;
-        case AggregateFunction.Interpolative:
-            getInterpolatedData(variable, processingInterval, startTime, endTime, buildResult);
-            break;
-        case AggregateFunction.Average:
-            getAverageData(variable, processingInterval, startTime, endTime, buildResult);
-            break;
-        case AggregateFunction.Count:
-        default:
-            // todo provide correct implementation
-            return callback2(null, new HistoryReadResult({ statusCode: StatusCodes.BadAggregateNotSupported }));
+    if (aggregateType.namespace === 0) {
+        switch (aggregateType.value) {
+            case AggregateFunction.Minimum:
+                getMinData(variable, processingInterval, startTime, endTime, buildResult);
+                break;
+            case AggregateFunction.Maximum:
+                getMaxData(variable, processingInterval, startTime, endTime, buildResult);
+                break;
+            case AggregateFunction.Interpolative:
+                getInterpolatedData(variable, processingInterval, startTime, endTime, buildResult);
+                break;
+            case AggregateFunction.Average:
+                getAverageData(variable, processingInterval, startTime, endTime, buildResult);
+                break;
+            case AggregateFunction.DurationGood:
+                getDurationGoodData(variable, processingInterval, startTime, endTime, buildResult);
+                break;
+            case AggregateFunction.DurationBad:
+                getDurationBadData(variable, processingInterval, startTime, endTime, buildResult);
+                break;
+            case AggregateFunction.PercentBad:
+                getPercentBadData(variable, processingInterval, startTime, endTime, buildResult);
+                break;
+            case AggregateFunction.PercentGood:
+                getPercentGoodData(variable, processingInterval, startTime, endTime, buildResult);
+                break;
+            case AggregateFunction.Count:
+                getCountData(variable, processingInterval, startTime, endTime, buildResult);
+                break;
+            default:
+                // todo provide correct implementation
+                return callback2(null, new HistoryReadResult({ statusCode: StatusCodes.BadAggregateNotSupported }));
+        }
+    } else {
+        // custom aggregate added by some companion specification
+        // to do
+        return callback2(null, new HistoryReadResult({ statusCode: StatusCodes.BadAggregateNotSupported }));
     }
 }
 export function readProcessedDetails(
@@ -137,7 +158,7 @@ export function readProcessedDetails(
     const processingInterval = historyReadDetails.processingInterval || endTime.getTime() - startTime.getTime();
 
     // tslint:disable-next-line: prefer-for-of
-    if (historyReadDetails.aggregateType?.length !== 1) {
+    if (!historyReadDetails.aggregateType || historyReadDetails.aggregateType.length !== 1) {
         return callback(null, new HistoryReadResult({ statusCode: StatusCodes.BadInternalError }));
     }
     return applyAggregate(variable, processingInterval, startTime, endTime, aggregateTypes[0], callback);