node-opcua-aggregates 2.51.0

package/source/aggregates.ts

@@ -0,0 +1,277 @@
+/**
+ * @module node-opcua-aggregates
+ */
+import { AggregateFunction } from "node-opcua-constants";
+import { makeNodeId } from "node-opcua-nodeid";
+import * as utils from "node-opcua-utils";
+import { DataType } from "node-opcua-variant";
+
+import { AddressSpace, BaseNode, UAHistoryServerCapabilities, UAHistoryServerCapabilities_Base, UAObject, UAServerCapabilities, UAVariable } from "node-opcua-address-space";
+import { AggregateConfigurationOptionsEx } from "./interval";
+import { AddressSpacePrivate } from "node-opcua-address-space/src/address_space_private";
+import { readProcessedDetails } from "./read_processed_details";
+
+// import { HistoryServerCapabilities } from "node-opcua-server";
+
+/*
+HasProperty Variable AccessHistoryDataCapability Boolean PropertyType Mandatory
+HasProperty Variable AccessHistoryEventsCapability Boolean PropertyType Mandatory
+HasProperty Variable MaxReturnDataValues UInt32 PropertyType Mandatory
+HasProperty Variable MaxReturnEventValues UInt32 PropertyType Mandatory
+HasProperty Variable InsertDataCapability Boolean PropertyType Mandatory
+HasProperty Variable ReplaceDataCapability Boolean PropertyType Mandatory
+HasProperty Variable UpdateDataCapability Boolean PropertyType Mandatory
+HasProperty Variable DeleteRawCapability Boolean PropertyType Mandatory
+HasProperty Variable DeleteAtTimeCapability Boolean PropertyType Mandatory
+HasProperty Variable InsertEventCapability Boolean PropertyType Mandatory
+HasProperty Variable ReplaceEventCapability Boolean PropertyType Mandatory
+HasProperty Variable UpdateEventCapability Boolean PropertyType Mandatory
+HasProperty Variable DeleteEventCapability Boolean PropertyType Mandatory
+HasProperty Variable InsertAnnotationsCapability Boolean PropertyType Mandatory
+ */
+const historicalCapabilitiesDefaultProperties /*: HistoryServerCapabilities */ = {
+    accessHistoryDataCapability: true, // Boolean PropertyType Mandatory
+    accessHistoryEventsCapability: true, // Boolean PropertyType Mandatory
+    deleteAtTimeCapability: false, // Boolean PropertyType Mandatory
+    deleteEventCapability: false, // Boolean PropertyType Mandatory
+    deleteRawCapability: false, // Boolean PropertyType Mandatory
+    insertAnnotationCapability: false, // Boolean PropertyType Mandatory
+    insertDataCapability: false, // Boolean PropertyType Mandatory
+    insertEventCapability: false, // Boolean PropertyType Mandatory
+    maxReturnDataValues: 0,
+    maxReturnEventValues: 0, // UInt32 PropertyType Mandatory
+    replaceDataCapability: false, // Boolean PropertyType Mandatory
+    replaceEventCapability: false, // Boolean PropertyType Mandatory
+    updateDataCapability: false, // Boolean PropertyType Mandatory
+    updateEventCapability: false // Boolean PropertyType Mandatory
+};
+
+export function createHistoryServerCapabilities(addressSpace: AddressSpace, serverCapabilities: UAServerCapabilities): UAObject {
+    /* istanbul ignore next */
+    if (serverCapabilities.browseName.toString() !== "ServerCapabilities") {
+        throw new Error("Expecting server Capabilities");
+    }
+
+    const historyServerCapabilitiesType = addressSpace.getNamespace(0).findObjectType("HistoryServerCapabilitiesType")!;
+
+    /* istanbul ignore next */
+    if (!historyServerCapabilitiesType) {
+        throw new Error("Cannot find HistoryServerCapabilitiesType");
+    }
+    return historyServerCapabilitiesType.instantiate({
+        browseName: "HistoryServerCapabilities",
+        componentOf: serverCapabilities
+    });
+}
+
+function setHistoricalServerCapabilities(historyServerCapabilities: any, defaultProperties: any) {
+    function setBoolean(propName: string) {
+        const lowerCase = utils.lowerFirstLetter(propName);
+
+        /* istanbul ignore next */
+        if (!defaultProperties.hasOwnProperty(lowerCase)) {
+            throw new Error("cannot find " + lowerCase);
+        }
+        const value = defaultProperties[lowerCase];
+        const prop = historyServerCapabilities.getChildByName(propName);
+
+        /* istanbul ignore next */
+        if (!prop) {
+            throw new Error(" Cannot find property " + propName);
+        }
+        prop.setValueFromSource({ dataType: DataType.Boolean, value });
+    }
+
+    function setUInt32(propName: string) {
+        const lowerCase = utils.lowerFirstLetter(propName);
+        /* istanbul ignore next */
+        if (!historyServerCapabilities.hasOwnProperty(lowerCase)) {
+            throw new Error("cannot find " + lowerCase);
+        }
+        const value = defaultProperties[lowerCase];
+        const prop = historyServerCapabilities.getChildByName(propName);
+        prop.setValueFromSource({ dataType: DataType.UInt32, value });
+    }
+
+    setBoolean("AccessHistoryDataCapability");
+    setBoolean("AccessHistoryEventsCapability");
+
+    setUInt32("MaxReturnDataValues");
+    setUInt32("MaxReturnEventValues");
+
+    setBoolean("InsertDataCapability");
+    setBoolean("ReplaceDataCapability");
+    setBoolean("UpdateDataCapability");
+    setBoolean("DeleteRawCapability");
+    setBoolean("DeleteAtTimeCapability");
+    setBoolean("InsertEventCapability");
+    setBoolean("ReplaceEventCapability");
+    setBoolean("UpdateEventCapability");
+    setBoolean("DeleteEventCapability");
+
+    /// FOUND A BUG HERE spec says InsertAnnotationsCapability
+    /// Standard nodeset2 says InsertAnnotationCapability ( without s )
+    // xx setBoolean("InsertAnnotationsCapability");
+}
+
+export type AggregateFunctionName =
+    | "AnnotationCount"
+    | "Average"
+    | "Count"
+    | "Delta"
+    | "DeltaBounds"
+    | "DurationBad"
+    | "DurationGood"
+    | "DurationInStateNonZero"
+    | "DurationInStateZero"
+    | "EndBound"
+    | "Interpolative"
+    | "Maximum"
+    | "Maximum2"
+    | "MaximumActualTime"
+    | "MaximumActualTime2"
+    | "Minimum"
+    | "Minimum2"
+    | "MinimumActualTime"
+    | "MinimumActualTime2"
+    | "NumberOfTransitions"
+    | "PercentBad"
+    | "PercentGood"
+    | "Range"
+    | "Range2"
+    | "StandardDeviationPopulation"
+    | "StandardDeviationSample"
+    | "Start"
+    | "StartBound"
+    | "TimeAverage"
+    | "TimeAverage2"
+    | "Total"
+    | "Total2"
+    | "VariancePopulation"
+    | "VarianceSample"
+    | "WorstQuality"
+    | "WorstQuality2";
+
+interface UAHistoryServerCapabilitiesWithH extends UAServerCapabilities {
+    historyServerCapabilities: UAHistoryServerCapabilities;
+}
+function addAggregateFunctionSupport(addressSpace: AddressSpace, functionName: number): void {
+    /* istanbul ignore next */
+    if (!functionName) {
+        throw new Error("Invalid function name");
+    }
+
+    const serverCapabilities = addressSpace.rootFolder.objects.server.serverCapabilities as UAHistoryServerCapabilitiesWithH;
+
+    /* istanbul ignore next */
+    if (!serverCapabilities.historyServerCapabilities) {
+        throw new Error("missing serverCapabilities.historyServerCapabilities");
+    }
+
+    const aggregateFunctions = serverCapabilities.aggregateFunctions;
+
+    const aggregateFunctionsInHist = serverCapabilities.historyServerCapabilities.aggregateFunctions;
+
+    const functionNodeId = makeNodeId(functionName);
+    const functionNode = addressSpace.getNamespace(0).findNode(functionNodeId);
+
+    /* istanbul ignore next */
+    if (!functionNode) {
+        throw new Error("Cannot find node " + functionName + " in addressSpace");
+    }
+
+    aggregateFunctions.addReference({
+        nodeId: functionNode.nodeId,
+        referenceType: "Organizes"
+    });
+    aggregateFunctionsInHist.addReference({
+        nodeId: functionNode.nodeId,
+        referenceType: "Organizes"
+    });
+}
+
+export function addAggregateSupport(addressSpace: AddressSpace) {
+    const aggregateConfigurationType = addressSpace.getNamespace(0).findObjectType("AggregateConfigurationType");
+
+    /* istanbul ignore next */
+    if (!aggregateConfigurationType) {
+        throw new Error("addressSpace do not expose AggregateConfigurationType");
+    }
+
+    const aggregateFunctionType = addressSpace.getNamespace(0).findObjectType("AggregateFunctionType");
+
+    /* istanbul ignore next */
+    if (!aggregateFunctionType) {
+        throw new Error("addressSpace do not expose AggregateFunctionType");
+    }
+
+    const serverObject = addressSpace.rootFolder.objects.getFolderElementByName("Server");
+
+    /* istanbul ignore next */
+    if (!serverObject) {
+        throw new Error("addressSpace do not expose a ServerObject");
+    }
+    // xx serverObject.
+
+    const serverCapabilities = serverObject.getChildByName("ServerCapabilities")! as UAServerCapabilities;
+
+    // Let see if HistoryServer Capabilities object exists
+    let historyServerCapabilities = serverCapabilities.getChildByName("HistoryServerCapabilities");
+
+    /* istanbul ignore next */
+    if (!historyServerCapabilities) {
+        historyServerCapabilities = createHistoryServerCapabilities(addressSpace, serverCapabilities);
+    }
+
+    setHistoricalServerCapabilities(historyServerCapabilities, historicalCapabilitiesDefaultProperties);
+
+    addAggregateFunctionSupport(addressSpace, AggregateFunction.Interpolative);
+    addAggregateFunctionSupport(addressSpace, AggregateFunction.Minimum);
+    addAggregateFunctionSupport(addressSpace, AggregateFunction.Maximum);
+    addAggregateFunctionSupport(addressSpace, AggregateFunction.Average);
+
+    const addressSpaceInternal = (addressSpace as unknown) as AddressSpacePrivate;
+    addressSpaceInternal._readProcessedDetails = readProcessedDetails;
+}
+
+export function installAggregateConfigurationOptions(node: UAVariable, options: AggregateConfigurationOptionsEx) {
+    const nodePriv = node as any;
+    const aggregateConfiguration = nodePriv.$historicalDataConfiguration.aggregateConfiguration;
+    aggregateConfiguration.percentDataBad.setValueFromSource({ dataType: "Byte", value: options.percentDataBad });
+    aggregateConfiguration.percentDataGood.setValueFromSource({ dataType: "Byte", value: options.percentDataGood });
+    aggregateConfiguration.treatUncertainAsBad.setValueFromSource({
+        dataType: "Boolean",
+        value: options.treatUncertainAsBad
+    });
+    aggregateConfiguration.useSlopedExtrapolation.setValueFromSource({
+        dataType: "Boolean",
+        value: options.useSlopedExtrapolation
+    });
+
+    nodePriv.$historicalDataConfiguration.stepped.setValueFromSource({
+        dataType: "Boolean",
+        value: options.stepped
+    });
+}
+
+export function getAggregateConfiguration(node: BaseNode): AggregateConfigurationOptionsEx {
+    const nodePriv = node as any;
+
+    /* istanbul ignore next */
+    if (!nodePriv.$historicalDataConfiguration) {
+        throw new Error("internal error");
+    }
+    const aggregateConfiguration = nodePriv.$historicalDataConfiguration.aggregateConfiguration;
+
+    // Beware ! Stepped value comes from Historical Configuration !
+    const stepped = nodePriv.$historicalDataConfiguration.stepped.readValue().value.value;
+
+    return {
+        percentDataBad: aggregateConfiguration.percentDataBad.readValue().value.value,
+        percentDataGood: aggregateConfiguration.percentDataGood.readValue().value.value,
+        stepped,
+        treatUncertainAsBad: aggregateConfiguration.treatUncertainAsBad.readValue().value.value,
+        // xx stepped:                aggregateConfiguration.stepped.readValue().value,
+        useSlopedExtrapolation: aggregateConfiguration.useSlopedExtrapolation.readValue().value.value
+    };
+}

package/source/average.ts

@@ -0,0 +1,74 @@
+import { UAVariable } from "node-opcua-address-space";
+import { DataValue } from "node-opcua-data-value";
+import { Variant, DataType } from "node-opcua-variant";
+import { getAggregateData } from "./common";
+import { Interval, AggregateConfigurationOptions, isGood } from "./interval";
+import { StatusCode, StatusCodes } from "node-opcua-status-code";
+
+function calculateIntervalAverageValue(
+    interval: Interval,
+    options: AggregateConfigurationOptions
+): DataValue {
+
+    const indexStart = interval.index;
+    let statusCode: StatusCode;
+    let isPartial = interval.isPartial;
+
+    let isRaw = false;
+    let hasBad = false;
+
+    const values: number[] = [];
+
+    for (let i = indexStart; i < indexStart + interval.count; i++) {
+
+        const dataValue = interval.dataValues[i];
+
+        if (dataValue.statusCode === StatusCodes.BadNoData) {
+            isPartial = true;
+            continue;
+        }
+
+        if (!isGood(dataValue.statusCode)) {
+            hasBad = true;
+            continue;
+        }
+        values.push(dataValue.value.value);
+    }
+
+    if (isRaw) {
+        if (hasBad) {
+            statusCode = StatusCodes.UncertainDataSubNormal;
+        } else {
+            statusCode = StatusCodes.Good;
+        }
+    } else if (hasBad) {
+        statusCode = StatusCode.makeStatusCode(StatusCodes.UncertainDataSubNormal, "HistorianCalculated");
+    } else {
+        statusCode = StatusCode.makeStatusCode(StatusCodes.Good, "HistorianCalculated");
+    }
+    if (values.length === 0) {
+        return new DataValue({
+            sourceTimestamp: interval.startTime,
+            statusCode: StatusCodes.BadNoData,
+        });
+    }
+    const mean = values.reduce((p, c) => p + c, 0) / values.length;
+
+    return new DataValue({
+        sourceTimestamp: interval.startTime,
+        statusCode: statusCode as StatusCode,
+        value: {
+            dataType: DataType.Double, value: mean
+        }
+    });
+}
+
+export function getAverageData(
+    node: UAVariable,
+    processingInterval: number,
+    startDate: Date,
+    endDate: Date,
+    callback: (err: Error | null, dataValues?: DataValue[]) => void
+) {
+    return getAggregateData(node, processingInterval, startDate, endDate, calculateIntervalAverageValue, callback);
+}

package/source/common.ts

@@ -0,0 +1,118 @@
+/**
+ * @module node-opca-aggregates
+ */
+import { SessionContext, UAVariable } from "node-opcua-address-space";
+import { NodeClass } from "node-opcua-data-model";
+import { DataValue } from "node-opcua-data-value";
+import { HistoryData, HistoryReadResult, ReadRawModifiedDetails } from "node-opcua-service-history";
+import { StatusCode } from "node-opcua-status-code";
+
+import { getAggregateConfiguration } from "./aggregates";
+import { getInterval, Interval, AggregateConfigurationOptionsEx } from "./interval";
+
+/**
+ * @internal
+ * @param node
+ * @param processingInterval
+ * @param startDate
+ * @param endDate
+ * @param dataValues
+ * @param lambda
+ * @param callback
+ */
+function processAggregateData(
+    node: UAVariable,
+    processingInterval: number,
+    startDate: Date,
+    endDate: Date,
+    dataValues: DataValue[],
+    lambda: (interval: Interval, aggregateConfiguration: AggregateConfigurationOptionsEx) => DataValue,
+    callback: (err: Error | null, dataValues?: DataValue[]) => void
+) {
+    const aggregateConfiguration = getAggregateConfiguration(node);
+
+    const results: DataValue[] = [];
+
+    const tstart = startDate.getTime();
+    const tend = endDate.getTime();
+
+    const indexHint = 0;
+    for (let t = tstart; t < tend; t += processingInterval) {
+        const sourceTimestamp = new Date();
+        sourceTimestamp.setTime(t);
+
+        const interval = getInterval(sourceTimestamp, processingInterval, indexHint, dataValues);
+
+        const dataValue = lambda(interval, aggregateConfiguration);
+
+        /* istanbul ignore next */
+        if (!dataValue || !dataValue.sourceTimestamp) {
+            // const dataValue = interval.interpolatedValue(aggregateConfiguration);
+            throw Error("invalid DataValue");
+        }
+        results.push(dataValue);
+    }
+
+    setImmediate(() => {
+        callback(null, results);
+    });
+
+}
+
+export function getAggregateData(
+    node: UAVariable,
+    processingInterval: number,
+    startDate: Date,
+    endDate: Date,
+    lambda: (interval: Interval, aggregateConfiguration: AggregateConfigurationOptionsEx) => DataValue,
+    callback: (err: Error | null, dataValues?: DataValue[]) => void
+) {
+
+    /* istanbul ignore next */
+    if (node.nodeClass !== NodeClass.Variable) {
+        throw new Error("node must be UAVariable");
+    }
+
+    /* istanbul ignore next */
+    if (processingInterval <= 0) {
+        throw new Error("Invalid processing interval, shall be greater than 0");
+    }
+
+    const context = new SessionContext();
+    const historyReadDetails = new ReadRawModifiedDetails({
+        endTime: endDate,
+        startTime: startDate,
+    });
+    const indexRange = null;
+    const dataEncoding = null;
+    const continuationPoint = null;
+    node.historyRead(context, historyReadDetails, indexRange, dataEncoding, continuationPoint,
+        (err: Error | null, result?: HistoryReadResult) => {
+
+            /* istanbul ignore next */
+            if (err) {
+                return callback(err);
+            }
+            const historyData = result!.historyData as HistoryData;
+
+            const dataValues = historyData.dataValues || [];
+
+            processAggregateData(node, processingInterval, startDate, endDate, dataValues, lambda, callback);
+        });
+}
+
+export function interpolateValue(dataValue1: DataValue, dataValue2: DataValue, date: Date) {
+    const t0 = dataValue1.sourceTimestamp!.getTime();
+    const t = date.getTime();
+    const t1 = dataValue2.sourceTimestamp!.getTime();
+    const coef1 = (t - t0) / (t1 - t0);
+    const coef2 = (t1 - t) / (t1 - t0);
+    const value = dataValue1.value.clone();
+    value.value = coef2 * dataValue1.value.value + coef1 * dataValue2.value.value;
+    const statusCode = StatusCode.makeStatusCode(dataValue1.statusCode, "HistorianInterpolated");
+    return new DataValue({
+        sourceTimestamp: date,
+        statusCode,
+        value
+    });
+}

package/source/index.ts

@@ -0,0 +1,17 @@
+/**
+ * @module node-opca-aggregates
+ */
+export {
+    addAggregateSupport,
+    installAggregateConfigurationOptions,
+    getAggregateConfiguration,
+} from "./aggregates";
+export * from "./interpolate";
+export * from "./minmax";
+export * from "./interval";
+export * from "./common";
+export * from "./average";
+export * from "./read_processed_details";
+export {
+    AggregateFunction
+} from "node-opcua-constants";

package/source/interpolate.ts

@@ -0,0 +1,201 @@
+/**
+ * @module node-opca-aggregates
+ */
+//  excerpt from OPC Unified Architecture, Part 13 21 Release 1.04
+//
+// 5.4.3.4 Interpolative
+// The Interpolative Aggregate defined in Table 15 returns the Interpolated Bounding Value for the startTime
+// of each interval.
+// When searching for Good values before or after the bounding value, the time period searched is Server specific,
+// but the Server should search a time range which is at least the size of the ProcessingInterval.
+//
+//                                 Interpolated Aggregate Characteristics
+//
+// Type                        Interpolated
+// Data Type                   Same as Source
+// Use Bounds                  Interpolated
+// Timestamp                   StartTime
+// Status Code                 Calculations
+// Calculation                 Method Custom
+//                             Good if no  Bad values skipped and Good values are used,
+//                             Uncertain if Bad values skipped or if Uncertain values are used. If
+//                             no starting value then BadNoData.
+// Partial bit                 Not Set
+// Calculated bit              Not Set
+// Interpolated bit            Set Sometimes
+//                             Always set except for when the Raw bit is set
+// Raw bit                     Set Sometimes
+//                             If a value exists with the exact time of interval Start
+// Multi Value bit             Not Set
+//
+// Status Code Common Special Cases
+// Before Start of Data        Return BadNoData
+// After End of Data           Return extrapolated value (see 3.1.8) (sloped or stepped according to settings)
+//                             Status code is Uncertain_DataSubNormal.
+// Start Bound Not Found       BadNoData.
+// End Bound Not Found         See “After End of Data”
+// Bound Bad                   Does not return a Bad bound except as noted above
+// Bound Uncertain             Returned Uncertain_DataSubNormal if any Bad value(s) was/were skipped to
+//                             calculate the bounding value.
+import { UAVariable } from "node-opcua-address-space";
+import { assert } from "node-opcua-assert";
+import { DataValue } from "node-opcua-data-value";
+import { StatusCode, StatusCodes } from "node-opcua-status-code";
+
+import { getAggregateData, interpolateValue } from "./common";
+import {
+    _findGoodDataValueBefore,
+    adjustProcessingOptions,
+    AggregateConfigurationOptionsEx,
+    Interval, isBad,
+    isGood
+} from "./interval";
+
+/*
+ For any intervals containing regions where the StatusCodes are Bad,
+ the total duration of all Bad regions is calculated and divided by the width of the interval.
+ The resulting ratio is multiplied by 100 and compared to the PercentDataBad parameter.
+ The StatusCode for the interval is Bad if the ratio is greater than or equal to the PercentDataBad parameter.
+ For any interval which is not Bad, the total duration of all Good regions is then calculated and divided by
+ the width of the interval. The resulting ratio is multiplied by 100 and compared to the PercentDataGood parameter.
+ The StatusCode for the interval is Good if the ratio is greater than or equal to the PercentDataGood parameter.
+ If for an interval neither ratio applies then that interval is Uncertain_DataSubNormal.
+  */
+export function interpolatedValue(interval: Interval, options: AggregateConfigurationOptionsEx): DataValue {
+
+    options = adjustProcessingOptions(options);
+
+    assert(Object.prototype.hasOwnProperty.call(options,"useSlopedExtrapolation"));
+    assert(Object.prototype.hasOwnProperty.call(options,"treatUncertainAsBad"));
+
+    const bTreatUncertainAsBad = options.treatUncertainAsBad!;
+
+    const steppedValue = (previousDataValue: DataValue): DataValue => {
+        if (!previousDataValue.statusCode) {
+            throw new Error("Expecting statusCode");
+        }
+        const interpValue = new DataValue({
+            sourceTimestamp: interval.startTime,
+            statusCode: StatusCodes.Bad,
+            value: previousDataValue.value,
+        });
+        interpValue.statusCode =
+            StatusCode.makeStatusCode(StatusCodes.UncertainDataSubNormal, "HistorianInterpolated");
+        return interpValue;
+    };
+
+    if (interval.index === -1) {
+        // the interval is beyond end Data
+        // we need to find previous good value
+        // and second previous  good value to extrapolate
+        const prev1 = _findGoodDataValueBefore(interval.dataValues, interval.dataValues.length, bTreatUncertainAsBad);
+        if (prev1.index <= 0) {
+            return new DataValue({
+                sourceTimestamp: interval.startTime,
+                statusCode: StatusCodes.BadNoData,
+                value: undefined,
+            });
+        }
+        if (!options.useSlopedExtrapolation) {
+            return steppedValue(prev1.dataValue);
+        }
+        const prev2 = _findGoodDataValueBefore(interval.dataValues, prev1.index, bTreatUncertainAsBad);
+
+        if (prev2.index <= 0) {
+            // use step value
+            return steppedValue(prev1.dataValue);
+        }
+        // else interpolate
+        const interpVal = interpolateValue(prev2.dataValue, prev1.dataValue, interval.startTime);
+
+        // tslint:disable:no-bitwise
+        if (prev2.index + 1 < prev1.index || prev1.index < interval.dataValues.length - 1) {
+            // some bad data exist in between = change status code
+            const mask = 0x0000FFFFFF;
+            const extraBits = interpVal.statusCode.value & mask;
+            interpVal.statusCode = StatusCode.makeStatusCode(StatusCodes.UncertainDataSubNormal, extraBits);
+        }
+
+        return interpVal;
+
+    }
+
+    /* istanbul ignore next */
+    if (interval.index < 0 && interval.count === 0) {
+        return new DataValue({
+            sourceTimestamp: interval.startTime,
+            statusCode: StatusCodes.BadNoData
+        });
+    }
+
+    const dataValue1 = interval.dataValues[interval.index];
+
+    // if a non-Bad Raw value exists at the timestamp then it is the bounding value;
+    if (!isBad(dataValue1.statusCode) && interval.hasRawDataAsStart()) {
+        return dataValue1;
+    }
+    // find the first non-Bad Raw value before the timestamp;
+
+    // find previous good value
+    const before = interval.beforeStartDataValue(bTreatUncertainAsBad);
+    if (isBad(before.dataValue.statusCode)) {
+        return new DataValue({
+            sourceTimestamp: interval.startTime,
+            statusCode: StatusCodes.BadNoData
+        });
+    }
+
+    if (options.stepped) {
+        if (before.index + 1 === interval.index) {
+            return new DataValue({
+                sourceTimestamp: interval.startTime,
+                statusCode: StatusCode.makeStatusCode(before.dataValue.statusCode, "HistorianInterpolated"),
+                value: before.dataValue.value
+            });
+        }
+        return steppedValue(before.dataValue);
+    }
+    // find the first non-Bad Raw value after the timestamp;
+    const next = interval.nextStartDataValue(bTreatUncertainAsBad);
+
+    //  draw a line between before value and after value;
+    // use point where the line crosses the timestamp as an estimate of the bounding value.
+    //   The calculation can be expressed with the following formula:
+    //    V bound = (T bound – T before)x( V after – V before)/( T after – T before) + V before
+    //    where V
+    //   x is a value at ‘x’ and Tx is the timestamp associated with Vx.
+    const interpolatedDataValue = interpolateValue(before.dataValue, next.dataValue, interval.startTime);
+
+    if (before.index + 1 < next.index
+        || !isGood(next.dataValue.statusCode)
+        || !isGood(before.dataValue.statusCode)
+    ) {
+        // tslint:disable:no-bitwise
+        // some bad data exist in between = change status code
+        const mask = 0x0000FFFFFF;
+        const extraBits = interpolatedDataValue.statusCode.value & mask;
+        interpolatedDataValue.statusCode =
+            StatusCode.makeStatusCode(StatusCodes.UncertainDataSubNormal, extraBits);
+    }
+    // check if uncertain or bad value exist between before/next
+    // todo
+    return interpolatedDataValue;
+}
+
+/**
+ *
+ * @param node
+ * @param processingInterval
+ * @param startDate
+ * @param endDate
+ * @param callback
+ */
+export function getInterpolatedData(
+    node: UAVariable,
+    processingInterval: number,
+    startDate: Date,
+    endDate: Date,
+    callback: (err: Error | null, dataValues?: DataValue[]) => void
+) {
+    return getAggregateData(node, processingInterval, startDate, endDate, interpolatedValue, callback);
+}