npm - node-red-contrib-power-saver - Versions diffs - 3.3.2 → 3.4.2 - Mend

node-red-contrib-power-saver 3.3.2 → 3.4.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (137) hide show

package/public/index.html ADDED Viewed

@@ -0,0 +1,89 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>Welcome to Firebase Hosting</title>
+    <!-- update the version number as needed -->
+    <script defer src="/__/firebase/9.6.6/firebase-app-compat.js"></script>
+    <!-- include only the Firebase features as you need -->
+    <script defer src="/__/firebase/9.6.6/firebase-auth-compat.js"></script>
+    <script defer src="/__/firebase/9.6.6/firebase-database-compat.js"></script>
+    <script defer src="/__/firebase/9.6.6/firebase-firestore-compat.js"></script>
+    <script defer src="/__/firebase/9.6.6/firebase-functions-compat.js"></script>
+    <script defer src="/__/firebase/9.6.6/firebase-messaging-compat.js"></script>
+    <script defer src="/__/firebase/9.6.6/firebase-storage-compat.js"></script>
+    <script defer src="/__/firebase/9.6.6/firebase-analytics-compat.js"></script>
+    <script defer src="/__/firebase/9.6.6/firebase-remote-config-compat.js"></script>
+    <script defer src="/__/firebase/9.6.6/firebase-performance-compat.js"></script>
+    <!--
+      initialize the SDK after all desired features are loaded, set useEmulator to false
+      to avoid connecting the SDK to running emulators.
+    -->
+    <script defer src="/__/firebase/init.js?useEmulator=true"></script>
+    <style media="screen">
+      body { background: #ECEFF1; color: rgba(0,0,0,0.87); font-family: Roboto, Helvetica, Arial, sans-serif; margin: 0; padding: 0; }
+      #message { background: white; max-width: 360px; margin: 100px auto 16px; padding: 32px 24px; border-radius: 3px; }
+      #message h2 { color: #ffa100; font-weight: bold; font-size: 16px; margin: 0 0 8px; }
+      #message h1 { font-size: 22px; font-weight: 300; color: rgba(0,0,0,0.6); margin: 0 0 16px;}
+      #message p { line-height: 140%; margin: 16px 0 24px; font-size: 14px; }
+      #message a { display: block; text-align: center; background: #039be5; text-transform: uppercase; text-decoration: none; color: white; padding: 16px; border-radius: 4px; }
+      #message, #message a { box-shadow: 0 1px 3px rgba(0,0,0,0.12), 0 1px 2px rgba(0,0,0,0.24); }
+      #load { color: rgba(0,0,0,0.4); text-align: center; font-size: 13px; }
+      @media (max-width: 600px) {
+        body, #message { margin-top: 0; background: white; box-shadow: none; }
+        body { border-top: 16px solid #ffa100; }
+      }
+    </style>
+  </head>
+  <body>
+    <div id="message">
+      <h2>Welcome</h2>
+      <h1>Firebase Hosting Setup Complete</h1>
+      <p>You're seeing this because you've successfully setup Firebase Hosting. Now it's time to go build something extraordinary!</p>
+      <a target="_blank" href="https://firebase.google.com/docs/hosting/">Open Hosting Documentation</a>
+    </div>
+    <p id="load">Firebase SDK Loading&hellip;</p>
+    <script>
+      document.addEventListener('DOMContentLoaded', function() {
+        const loadEl = document.querySelector('#load');
+        // // 🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥
+        // // The Firebase SDK is initialized and available here!
+        //
+        // firebase.auth().onAuthStateChanged(user => { });
+        // firebase.database().ref('/path/to/ref').on('value', snapshot => { });
+        // firebase.firestore().doc('/foo/bar').get().then(() => { });
+        // firebase.functions().httpsCallable('yourFunction')().then(() => { });
+        // firebase.messaging().requestPermission().then(() => { });
+        // firebase.storage().ref('/path/to/ref').getDownloadURL().then(() => { });
+        // firebase.analytics(); // call to activate
+        // firebase.analytics().logEvent('tutorial_completed');
+        // firebase.performance(); // call to activate
+        //
+        // // 🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥
+        try {
+          let app = firebase.app();
+          let features = [
+            'auth',
+            'database',
+            'firestore',
+            'functions',
+            'messaging',
+            'storage',
+            'analytics',
+            'remoteConfig',
+            'performance',
+          ].filter(feature => typeof app[feature] === 'function');
+          loadEl.textContent = `Firebase SDK loaded with ${features.join(', ')}`;
+        } catch (e) {
+          console.error(e);
+          loadEl.textContent = 'Error loading the Firebase SDK, check the console.';
+        }
+      });
+    </script>
+  </body>
+</html>

package/src/elvia/elvia-tariff.js CHANGED Viewed

@@ -1,5 +1,6 @@
 const fetch = require("node-fetch");
-const { getTariff, ping } = require("./elvia-api");
+const { getTariff, ping } = require("./elvia-api.js");
 module.exports = function (RED) {
   function PsElviaTariffNode(config) {

package/src/handle-input.js CHANGED Viewed

@@ -12,7 +12,7 @@ function handleStrategyInput(node, msg, doPlanning) {
     node.warn("Resetting node context by command");
     // Reset all saved data
     node.context().set(["lastPlan", "lastPriceData", "lastSource"], [undefined, undefined, undefined]);
-    deleteSavedScheduleBefore(node, DateTime.now().plus({ days: 1 }), 100);
+    deleteSavedScheduleBefore(node, DateTime.now().plus({ days: 2 }), 100);
   }
   const { priceData, source } = getPriceData(node, msg);
   if (!priceData) {
@@ -125,12 +125,14 @@ function runSchedule(node, schedule, time, currentSent = false) {
 function deleteSavedScheduleBefore(node, day, checkDays = 0) {
   let date = day;
+  let data = null;
   let count = 0;
   do {
     date = date.plus({ days: -1 });
-    data = node.context().set(date.toISO(), undefined);
+    data = node.context().get(date.toISODate());
+    node.context().set(date.toISODate(), undefined);
     count++;
-  } while (data || count <= checkDays);
+  } while (data !== undefined || count <= checkDays);
 }
 function saveDayData(node, date, plan) {
@@ -181,4 +183,5 @@ function validateInput(node, msg) {
 module.exports = {
   handleStrategyInput,
+  validateInput,
 };

package/src/strategy-heat-capacitor-functions.js ADDED Viewed

@@ -0,0 +1,246 @@
+"use strict";
+const { DateTime } = require("luxon");
+const { roundPrice } = require("./utils");
+function calculateOpportunities(prices, pattern, amount) {
+  //creating a price vector with minute granularity
+  const tempPrice = Array(prices.length * 60).fill(0);
+  for (let i = 0; i < prices.length; i++) {
+    tempPrice.fill(prices[i], i * 60, (i + 1) * 60);
+    //debugger;
+  }
+  //Calculate weighted pattern
+  const weight = amount / pattern.reduce((a, b) => a + b, 0); //last calculates the sum of all numbers in the pattern
+  const weightedPattern = pattern.map((x) => x * weight);
+  //Calculating procurement opportunities. Sliding the pattern over the price vector to find the price for procuring
+  //at time t
+  const dot = (a, b) => a.map((x, i) => a[i] * b[i]).reduce((m, n) => m + n);
+  const procurementOpportunities = Array(prices.length * 60 - pattern.length + 1);
+  for (let i = 0; i < procurementOpportunities.length; i++) {
+    procurementOpportunities[i] = dot(weightedPattern, tempPrice.slice(i, i + pattern.length));
+  }
+  return procurementOpportunities;
+}
+// This function finds the buy sell
+// schedule for maximum profit
+// two vectors containing the buy and sell indexes are returned in an array
+function findBestBuySellPattern(priceBuy, buyLength, priceSell, sellLength) {
+  // Traverse through given price array
+  const buyIndexes = [];
+  const sellIndexes = [];
+  let i = 0;
+  while (i < priceBuy.length - 1) {
+    // Find Local Minima
+    // Note that the limit is (n-2) as we are
+    // comparing present element to the next element
+    while (i < priceBuy.length - 1 && priceBuy[i + 1] < priceBuy[i]) i++;
+    // If we reached the end, break
+    // as no further solution is possible
+    if (i == priceBuy.length - 1) break;
+    // Store the index of minima
+    buyIndexes.push(i);
+    // Move the next allowed maxima away from the minima - required due to the asymmetric buy/sell prices
+    i = i + Math.round(buyLength / 2);
+    // Find Local Maxima
+    // Note that the limit is (n-1) as we are
+    // comparing to previous element
+    while (i < priceSell.length && priceSell[i] >= priceSell[i - 1]) i++;
+    // Store the index of maxima
+    sellIndexes.push(i - 1);
+    i = i + Math.round(sellLength / 2);
+  }
+  return [buyIndexes, sellIndexes];
+}
+function calculateValueDictList(buySell, buyPrices, sellPrices, startDate) {
+  const buySellValueDictList = [];
+  for (let i = 0; i < buySell[0].length; i++) {
+    const buyDateTime = startDate.plus({ minutes: buySell[0][i] });
+    const sellDateTime = startDate.plus({ minutes: buySell[1][i] });
+    if (i != 0) {
+      const prevSellDateTime = startDate.plus({ minutes: buySell[1][i - 1] });
+      buySellValueDictList.push({
+        type: "sell - buy",
+        tradeValue: roundPrice(sellPrices[buySell[1][i - 1]] - buyPrices[buySell[0][i]]),
+        buyIndex: buySell[0][i],
+        buyDate: buyDateTime,
+        buyPrice: roundPrice(buyPrices[buySell[0][i]]),
+        sellIndex: buySell[1][i - 1],
+        sellDate: prevSellDateTime,
+        sellPrice: roundPrice(sellPrices[buySell[1][i - 1]]),
+      });
+    }
+    buySellValueDictList.push({
+      type: "buy - sell",
+      tradeValue: roundPrice(sellPrices[buySell[1][i]] - buyPrices[buySell[0][i]]),
+      buyIndex: buySell[0][i],
+      buyDate: buyDateTime,
+      buyPrice: roundPrice(buyPrices[buySell[0][i]]),
+      sellIndex: buySell[1][i],
+      sellDate: sellDateTime,
+      sellPrice: roundPrice(sellPrices[buySell[1][i]]),
+    });
+  }
+  return buySellValueDictList;
+}
+function removeLowBuySellPairs(buySellPattern, buyPrices, sellPrices, minSavings, startDate) {
+  let lowestSaving = -1;
+  const buySellClone = Array.from(buySellPattern);
+  while (minSavings >= lowestSaving) {
+    const dictList = calculateValueDictList(buySellClone, buyPrices, sellPrices, startDate);
+    if (dictList.length === 0) {
+      return buySellClone;
+    }
+    let sellIndex = 0;
+    let buyIndex = 0;
+    for (let i = 0; i < dictList.length; i++) {
+      if (i == 0 || dictList[i].tradeValue < lowestSaving) {
+        lowestSaving = dictList[i].tradeValue;
+        sellIndex = dictList[i].sellIndex;
+        buyIndex = dictList[i].buyIndex;
+      }
+    }
+    if (lowestSaving <= minSavings) {
+      buySellClone[0] = buySellClone[0].filter((x) => x != buyIndex);
+      buySellClone[1] = buySellClone[1].filter((x) => x != sellIndex);
+    }
+  }
+  return buySellClone;
+}
+function calculateSchedule(
+  startDate,
+  buySellStackedArray,
+  buyPrices,
+  sellPrices,
+  maxTempAdjustment,
+  boostTempHeat,
+  boostTempCool,
+  buyDuration,
+  sellDuration
+) {
+  const arrayLength = buyPrices.length;
+  const schedule = {
+    startAt: startDate,
+    temperatures: Array(arrayLength),
+    maxTempAdjustment: maxTempAdjustment,
+    durationInMinutes: arrayLength,
+    boostTempHeat: boostTempHeat,
+    boostTempCool: boostTempCool,
+    heatingDuration: buyDuration,
+    coolingDuration: sellDuration,
+  };
+  if (buySellStackedArray[0].length === 0) {
+    //No procurements or sales scheduled
+    schedule.temperatures.fill(-maxTempAdjustment, 0, arrayLength);
+  } else {
+    let lastBuyIndex = 0;
+    let boostHeat;
+    let boostCool;
+    for (let i = 0; i < buySellStackedArray[0].length; i++) {
+      const buyIndex = buySellStackedArray[1][i];
+      const sellIndex = buySellStackedArray[0][i];
+      //If this is the start of the time-series, do not boost the temperatures
+      sellIndex == 0 ? (boostHeat = 0) : (boostHeat = boostTempHeat);
+      lastBuyIndex == 0 ? (boostCool = 0) : (boostCool = boostTempCool);
+      //Cooling period. Adding boosted cooling temperature for the period of divestment
+      if (sellIndex - lastBuyIndex <= sellDuration) {
+        schedule.temperatures.fill(-maxTempAdjustment - boostCool, lastBuyIndex, sellIndex);
+      } else {
+        schedule.temperatures.fill(-maxTempAdjustment - boostCool, lastBuyIndex, lastBuyIndex + sellDuration);
+        schedule.temperatures.fill(-maxTempAdjustment, lastBuyIndex + sellDuration, sellIndex);
+      }
+      //Heating period. Adding boosted heating temperature for the period of procurement
+      if (buyIndex - sellIndex <= buyDuration) {
+        schedule.temperatures.fill(maxTempAdjustment + boostHeat, sellIndex, buyIndex);
+      } else {
+        schedule.temperatures.fill(maxTempAdjustment + boostHeat, sellIndex, sellIndex + buyDuration);
+        schedule.temperatures.fill(maxTempAdjustment, sellIndex + buyDuration, buyIndex);
+      }
+      lastBuyIndex = buyIndex;
+    }
+    //final fill
+    if (arrayLength - lastBuyIndex <= sellDuration) {
+      schedule.temperatures.fill(-maxTempAdjustment - boostCool, lastBuyIndex, arrayLength);
+    } else {
+      schedule.temperatures.fill(-maxTempAdjustment - boostCool, lastBuyIndex, lastBuyIndex + sellDuration);
+      schedule.temperatures.fill(-maxTempAdjustment, lastBuyIndex + sellDuration, arrayLength);
+    }
+  }
+  schedule.trades = calculateValueDictList(buySellStackedArray, buyPrices, sellPrices, startDate);
+  return schedule;
+}
+function findTemp(date, schedule) {
+  let diff = Math.round(date.diff(schedule.startAt).as("minutes"));
+  return schedule.temperatures[diff];
+}
+function runBuySellAlgorithm(
+  priceData,
+  timeHeat1C,
+  timeCool1C,
+  boostTempHeat,
+  boostTempCool,
+  maxTempAdjustment,
+  minSavings
+) {
+  const prices = [...priceData.map((pd) => pd.value)];
+  const startDate = DateTime.fromISO(priceData[0].start);
+  //pattern for how much power is procured/sold when.
+  //This has, for now, just a flat acquisition/divestment profile
+  const buyDuration = Math.round(timeHeat1C * maxTempAdjustment * 2);
+  const sellDuration = Math.round(timeCool1C * maxTempAdjustment * 2);
+  const buyPattern = Array(buyDuration).fill(1);
+  const sellPattern = Array(sellDuration).fill(1);
+  //Calculate what it will cost to procure/sell 1 kWh as a function of time
+  const buyPrices = calculateOpportunities(prices, buyPattern, 1);
+  const sellPrices = calculateOpportunities(prices, sellPattern, 1);
+  //Find dates for when to procure/sell
+  const buySell = findBestBuySellPattern(buyPrices, buyPattern.length, sellPrices, sellPattern.length);
+  //Remove small/disputable gains (least profitable buy/sell pairs)
+  const buySellCleaned = removeLowBuySellPairs(buySell, buyPrices, sellPrices, minSavings, startDate);
+  //Calculate temperature adjustment as a function of time
+  const schedule = calculateSchedule(
+    startDate,
+    buySellCleaned,
+    buyPrices,
+    sellPrices,
+    maxTempAdjustment,
+    boostTempHeat,
+    boostTempCool,
+    buyDuration,
+    sellDuration
+  );
+  return schedule;
+}
+module.exports = {
+  runBuySellAlgorithm,
+  findTemp,
+  calculateOpportunities,
+  findBestBuySellPattern,
+  calculateValueDictList,
+  removeLowBuySellPairs,
+  calculateSchedule,
+};

package/src/strategy-heat-capacitor.html ADDED Viewed

@@ -0,0 +1,85 @@
+<script type="text/javascript">
+  RED.nodes.registerType("ps-strategy-heat-capacitor", {
+    category: "Power Saver",
+    color: "#FFCC66",
+    defaults: {
+      name: { value: "Heat capacitor" },
+      timeHeat1C: { value: 50, required: true, align: "left" },
+      timeCool1C: { value: 50, required: true, align: "left" },
+      maxTempAdjustment: { value: 0.5, required: true, align: "left" },
+      boostTempHeat: { value: 0, required: true, align: "left" },
+      boostTempCool: { value: 0, required: true, align: "left" },
+      minSavings: { value: 0.08, required: true, align: "left" },
+      setpoint: { value: 23, required: true, align: "left" },
+    },
+    inputs: 1,
+    outputs: 3,
+    color: "#FFCC66",
+    icon: "font-awesome/fa-bar-chart",
+    label: function () {
+      return this.name || "Heat capacitor";
+    },
+    outputLabels: ["T", "dT", "schedule"],
+  });
+</script>
+<script type="text/html" data-template-name="ps-strategy-heat-capacitor">
+  <div class="form-row">
+    <label for="node-input-name"><i class="icon-tag"></i> Name</label>
+    <input type="text" id="node-input-name" placeholder="Name" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-timeHeat1C"><i class="icon-tag"></i> Time +1C [minutes]</label>
+    <input type="text" id="node-input-timeHeat1C" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-timeCool1C"><i class="icon-tag"></i> Time -1C [minutes]</label>
+    <input type="text" id="node-input-timeCool1C" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-setpoint"><i class="icon-tag"></i> Setpoint</label>
+    <input type="text" id="node-input-setpoint" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-maxTempAdjustment"><i class="icon-tag"></i> Max temp adj.</label>
+    <input type="text" id="node-input-maxTempAdjustment" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-minSavings"><i class="icon-tag"></i> Min Savings</label>
+    <input type="text" id="node-input-minSavings" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-boostTempHeat"><i class="icon-tag"></i> Heating Boost [C]</label>
+    <input type="text" id="node-input-boostTempHeat" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-boostTempCool"><i class="icon-tag"></i> Cooling Boost [C]</label>
+    <input type="text" id="node-input-boostTempCool" />
+  </div>
+</script>
+<script type="text/markdown" data-help-name="ps-strategy-heat-capacitor">
+  # ps-strategy-heat-capacitor
+  A strategy for moving consumption from expensive to cheap periods utilizing climate entities.
+  ## Description
+  The heat capacitor strategy utilizes a large body of mass, like your house or cabin, to procure heat at a time where electricity is cheap, and divest at a time where electricity is expensive. This is achieved by increasing the temperature setpoint of one or several climate entities at times when electricity is cheap, and reducing it when electricity is expensive.
+  It is a good application for cabins/heated storage spaces, as the entity never actually shuts off the climate entities and should therefore be rather safe to apply (still at you own risk :-)). It can also be used for you house, jacuzzi, and/or pool.
+  | Value             | Description                                                                |
+  | ----------------- | -------------------------------------------------------------------------- |
+  | Time + 1C         | The time required to increase the temperature by 1C.                       |
+  | Time - 1C         | The time required to decrease the temperature by 1C.                       |
+  | Setpoint          | Ideal temperature in C                                                     |
+  | Max temp adj.     | The number of degrees the system is allowed to increase/decrease.          |
+  | Heating Boost [C] | An extra increase in temperature to the setpoint for the investment period |
+  | Cooling Boost [C] | An extra decrease in temperature to the setpoint for the divestment period |
+  | Min Savings       | The minimum amount of savings required for a buy/sell cycle.               |
+  Please read more in the [node documentation](https://ottopaulsen.github.io/node-red-contrib-power-saver/nodes/ps-strategy-heat-capacitor)
+</script>

package/src/strategy-heat-capacitor.js ADDED Viewed

@@ -0,0 +1,125 @@
+"use strict";
+const { DateTime } = require("luxon");
+const { validateInput } = require("./handle-input");
+const { runBuySellAlgorithm, findTemp } = require("./strategy-heat-capacitor-functions");
+const { version } = require("../package.json");
+module.exports = function (RED) {
+  function TempMan(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+    node.timeHeat1C = Number(config.timeHeat1C);
+    node.timeCool1C = Number(config.timeCool1C);
+    node.setpoint = Number(config.setpoint);
+    node.maxTempAdjustment = Number(config.maxTempAdjustment);
+    node.boostTempHeat = Number(config.boostTempHeat);
+    node.boostTempCool = Number(config.boostTempCool);
+    node.minSavings = Number(config.minSavings);
+    // sanitise disabled output as this is used when all else fails
+    if (isNaN(node.disabled_op)) {
+      node.disabled_op = 0;
+    }
+    node.on("close", function () {
+      clearTimeout(node.schedulingTimeout);
+    });
+    this.on("input", function (msg) {
+      if (validateInput(node, msg)) {
+        // Using msg.payload.config to change specific properties
+        if (msg.hasOwnProperty("payload")) {
+          if (msg.payload.hasOwnProperty("config")) {
+            if (msg.payload.config.hasOwnProperty("timeHeat1C"))
+              node.timeHeat1C = Number(msg.payload.config.timeHeat1C);
+            if (msg.payload.config.hasOwnProperty("timeCool1C"))
+              node.timeCool1C = Number(msg.payload.config.timeCool1C);
+            if (msg.payload.config.hasOwnProperty("setpoint")) node.setpoint = Number(msg.payload.config.setpoint);
+            if (msg.payload.config.hasOwnProperty("maxTempAdjustment"))
+              node.maxTempAdjustment = Number(msg.payload.config.maxTempAdjustment);
+            if (msg.payload.config.hasOwnProperty("boostTempHeat"))
+              node.boostTempHeat = Number(msg.payload.config.boostTempHeat);
+            if (msg.payload.config.hasOwnProperty("boostTempCool"))
+              node.boostTempCool = Number(msg.payload.config.boostTempCool);
+            if (msg.payload.config.hasOwnProperty("minSavings"))
+              node.minSavings = Number(msg.payload.config.minSavings);
+          }
+          //merge pricedata to escape some midnight issues. Store max 72 hour history
+          if (msg.payload.hasOwnProperty("priceData")) {
+            if (node.hasOwnProperty("priceData")) {
+              node.priceData = mergePriceData(node.priceData, msg.payload.priceData);
+              if (node.priceData.length > 72) node.priceData = node.priceData.slice(-72);
+            } else {
+              node.priceData = msg.payload.priceData;
+            }
+          }
+          if (node.hasOwnProperty("priceData")) {
+            node.schedule = runBuySellAlgorithm(
+              node.priceData,
+              node.timeHeat1C,
+              node.timeCool1C,
+              node.boostTempHeat,
+              node.boostTempCool,
+              node.maxTempAdjustment,
+              node.minSavings
+            );
+            if (msg.payload.hasOwnProperty("time")) {
+              node.dT = findTemp(msg.payload.time, node.schedule);
+            } else {
+              node.dT = findTemp(DateTime.now(), node.schedule);
+            }
+            node.T = node.setpoint + node.dT;
+            //Add config to statistics
+            node.schedule.config = {
+              timeHeat1C: node.timeHeat1C,
+              timeCool1C: node.timeCool1C,
+              setpoint: node.setpoint,
+              maxTempAdjustment: node.maxTempAdjustment,
+              boostTempHeat: node.boostTempHeat,
+              boostTempCool: node.boostTempCool,
+              minSavings: node.minSavings,
+            };
+            node.schedule.priceData = node.priceData;
+            node.schedule.time = DateTime.now().toISO();
+            node.schedule.version = version;
+            // Send output
+            node.send([
+              { payload: node.T, topic: "setpoint", time: node.schedule.time, version: version },
+              { payload: node.dT, topic: "adjustment", time: node.schedule.time, version: version },
+              { payload: node.schedule },
+            ]);
+          }
+        }
+      }
+    });
+  }
+  RED.nodes.registerType("ps-strategy-heat-capacitor", TempMan);
+};
+function mergePriceData(priceDataA, priceDataB) {
+  const tempDict = {};
+  priceDataA.forEach((e) => {
+    tempDict[e.start] = e.value;
+  });
+  priceDataB.forEach((e) => {
+    tempDict[e.start] = e.value;
+  });
+  var keys = Object.keys(tempDict);
+  keys.sort();
+  const res = Array(keys.length);
+  for (let i = 0; i < res.length; i++) {
+    res[i] = { value: tempDict[keys[i]], start: keys[i] };
+  }
+  return res;
+}

package/test/data/converted-prices.json CHANGED Viewed

@@ -194,4 +194,4 @@
       "start": "2021-10-12T23:00:00.000+02:00"
     }
   ]
-}
+}

package/test/data/multiple-trades.json ADDED Viewed

@@ -0,0 +1,53 @@
+{
+  "source": "Tibber",
+  "priceData": [
+    { "value": 1.4157, "start": "2022-02-06T00:00:00.000+01:00" },
+    { "value": 1.3705, "start": "2022-02-06T01:00:00.000+01:00" },
+    { "value": 1.2487, "start": "2022-02-06T02:00:00.000+01:00" },
+    { "value": 1.1812, "start": "2022-02-06T03:00:00.000+01:00" },
+    { "value": 0.9632, "start": "2022-02-06T04:00:00.000+01:00" },
+    { "value": 1.0862, "start": "2022-02-06T05:00:00.000+01:00" },
+    { "value": 1.2638, "start": "2022-02-06T06:00:00.000+01:00" },
+    { "value": 1.3266, "start": "2022-02-06T07:00:00.000+01:00" },
+    { "value": 1.3734, "start": "2022-02-06T08:00:00.000+01:00" },
+    { "value": 1.4653, "start": "2022-02-06T09:00:00.000+01:00" },
+    { "value": 1.513, "start": "2022-02-06T10:00:00.000+01:00" },
+    { "value": 1.518, "start": "2022-02-06T11:00:00.000+01:00" },
+    { "value": 1.505, "start": "2022-02-06T12:00:00.000+01:00" },
+    { "value": 1.5038, "start": "2022-02-06T13:00:00.000+01:00" },
+    { "value": 1.5239, "start": "2022-02-06T14:00:00.000+01:00" },
+    { "value": 1.5269, "start": "2022-02-06T15:00:00.000+01:00" },
+    { "value": 1.5464, "start": "2022-02-06T16:00:00.000+01:00" },
+    { "value": 1.5553, "start": "2022-02-06T17:00:00.000+01:00" },
+    { "value": 1.6066, "start": "2022-02-06T18:00:00.000+01:00" },
+    { "value": 1.5541, "start": "2022-02-06T19:00:00.000+01:00" },
+    { "value": 1.5437, "start": "2022-02-06T20:00:00.000+01:00" },
+    { "value": 1.4912, "start": "2022-02-06T21:00:00.000+01:00" },
+    { "value": 1.473, "start": "2022-02-06T22:00:00.000+01:00" },
+    { "value": 1.4281, "start": "2022-02-06T23:00:00.000+01:00" },
+    { "value": 1.4179, "start": "2022-02-07T00:00:00.000+01:00" },
+    { "value": 1.3966, "start": "2022-02-07T01:00:00.000+01:00" },
+    { "value": 1.3953, "start": "2022-02-07T02:00:00.000+01:00" },
+    { "value": 1.3939, "start": "2022-02-07T03:00:00.000+01:00" },
+    { "value": 1.3962, "start": "2022-02-07T04:00:00.000+01:00" },
+    { "value": 1.4335, "start": "2022-02-07T05:00:00.000+01:00" },
+    { "value": 1.5191, "start": "2022-02-07T06:00:00.000+01:00" },
+    { "value": 1.6244, "start": "2022-02-07T07:00:00.000+01:00" },
+    { "value": 1.6508, "start": "2022-02-07T08:00:00.000+01:00" },
+    { "value": 1.6142, "start": "2022-02-07T09:00:00.000+01:00" },
+    { "value": 1.5632, "start": "2022-02-07T10:00:00.000+01:00" },
+    { "value": 1.5516, "start": "2022-02-07T11:00:00.000+01:00" },
+    { "value": 1.4922, "start": "2022-02-07T12:00:00.000+01:00" },
+    { "value": 1.5288, "start": "2022-02-07T13:00:00.000+01:00" },
+    { "value": 1.5522, "start": "2022-02-07T14:00:00.000+01:00" },
+    { "value": 1.5526, "start": "2022-02-07T15:00:00.000+01:00" },
+    { "value": 1.5799, "start": "2022-02-07T16:00:00.000+01:00" },
+    { "value": 1.6909, "start": "2022-02-07T17:00:00.000+01:00" },
+    { "value": 1.7136, "start": "2022-02-07T18:00:00.000+01:00" },
+    { "value": 1.703, "start": "2022-02-07T19:00:00.000+01:00" },
+    { "value": 1.675, "start": "2022-02-07T20:00:00.000+01:00" },
+    { "value": 1.6173, "start": "2022-02-07T21:00:00.000+01:00" },
+    { "value": 1.5638, "start": "2022-02-07T22:00:00.000+01:00" },
+    { "value": 1.4645, "start": "2022-02-07T23:00:00.000+01:00" }
+  ]
+}