node-red-contrib-power-saver 2.0.4 → 3.0.1

package/{power-saver.js → src/power-saver.js}

@@ -1,12 +1,16 @@
 const { DateTime } = require("luxon");
 const {
-  convertMsg,
   countAtEnd,
-  makeSchedule,
-  getSavings,
   extractPlanForDate,
+  getDiff,
+  getEffectiveConfig,
+  getSavings,
+  getStartAtIndex,
+  loadDayData,
+  makeSchedule,
 } = require("./utils");
-const mostSavedStrategy = require("./mostSavedStrategy");
+const { convertMsg } = require("./receive-price-functions");
+const { calculate } = require("./strategy-best-save-functions");
 
 let schedulingTimeout = null;
 
@@ -15,57 +19,57 @@ module.exports = function (RED) {
     RED.nodes.createNode(this, config);
     const node = this;
 
-    // Save config in node
-    this.maxHoursToSaveInSequence = config.maxHoursToSaveInSequence;
-    this.minHoursOnAfterMaxSequenceSaved =
-      config.minHoursOnAfterMaxSequenceSaved;
-    this.minSaving = parseFloat(config.minSaving);
-    this.sendCurrentValueWhenRescheduling =
-      config.sendCurrentValueWhenRescheduling;
-    this.outputIfNoSchedule = config.outputIfNoSchedule === "true";
+    const originalConfig = {
+      maxHoursToSaveInSequence: config.maxHoursToSaveInSequence,
+      minHoursOnAfterMaxSequenceSaved: config.minHoursOnAfterMaxSequenceSaved,
+      minSaving: parseFloat(config.minSaving),
+      sendCurrentValueWhenRescheduling: config.sendCurrentValueWhenRescheduling,
+      outputIfNoSchedule: config.outputIfNoSchedule === "true",
+      scheduleOnlyFromCurrentTime: config.scheduleOnlyFromCurrentTime === "true",
+    };
+    node.context().set("config", originalConfig);
 
     node.on("close", function () {
       clearTimeout(schedulingTimeout);
     });
 
     node.on("input", function (msg) {
-      if (!validateMsg(node, msg)) {
-        return;
-      }
-
-      const input = convertMsg(msg);
-      if (!validateInput(node, input)) {
+      const effectiveConfig = getEffectiveConfig(node, msg);
+      const priceData = getPriceData(node, msg);
+      if (!priceData) {
         return;
       }
+      const planFromTime = msg.payload.time ? DateTime.fromISO(msg.payload.time) : DateTime.now();
 
-      const priceData = [...input.today, ...input.tomorrow];
+      // Store config variables in node
+      Object.keys(effectiveConfig).forEach((key) => (node[key] = effectiveConfig[key]));
 
       clearTimeout(schedulingTimeout);
 
-      const dates = [
-        ...new Set(priceData.map((v) => DateTime.fromISO(v.start).toISODate())),
-      ];
+      const dates = [...new Set(priceData.map((v) => DateTime.fromISO(v.start).toISODate()))];
 
       // Load data from day before
+      const dateToday = DateTime.fromISO(dates[0]);
       const dateDayBefore = DateTime.fromISO(dates[0]).plus({ days: -1 });
-      const dataDayBefore = loadDayData(node, dateDayBefore);
 
       // Make plan
-      const values = priceData.map((d) => d.value);
-      const startTimes = priceData.map((d) => d.start);
-      const plan = makePlan(node, values, startTimes, dataDayBefore.onOff);
+      const startAtIndex = getStartAtIndex(effectiveConfig, priceData, planFromTime);
+      const dataJustBefore = loadDataJustBefore(node, dateDayBefore, dateToday, startAtIndex);
+      const values = priceData.map((d) => d.value).slice(startAtIndex);
+      const startTimes = priceData.map((d) => d.start).slice(startAtIndex);
+      const onOffBefore = dataJustBefore.hours.map((h) => h.onOff);
+      const lastPlanHours = node.context().get("lastPlan")?.hours ?? [];
+      const plan = makePlan(node, values, startTimes, onOffBefore);
+      const includeFromLastPlanHours = lastPlanHours.filter(
+        (h) => h.start < plan.hours[0].start && h.start >= priceData[0].start
+      );
+      adjustSavingsPassedHours(plan, includeFromLastPlanHours);
+      plan.hours.splice(0, 0, ...includeFromLastPlanHours);
 
       // Save schedule
+      node.context().set("lastPlan", plan);
       dates.forEach((d) => saveDayData(node, d, extractPlanForDate(plan, d)));
 
-      const config = {
-        maxHoursToSaveInSequence: this.maxHoursToSaveInSequence,
-        minHoursOnAfterMaxSequenceSaved: this.minHoursOnAfterMaxSequenceSaved,
-        minSaving: this.minSaving,
-        sendCurrentValueWhenRescheduling: this.sendCurrentValueWhenRescheduling,
-        outputIfNoSchedule: this.outputIfNoSchedule,
-      };
-
       // Prepare output
       let output1 = null;
       let output2 = null;
@@ -73,21 +77,15 @@ module.exports = function (RED) {
         payload: {
           schedule: plan.schedule,
           hours: plan.hours,
-          source: input.source,
-          config,
+          source: priceData.source,
+          config: effectiveConfig,
         },
       };
 
       // Find current output, and set output (if configured to do)
-      const time = msg.payload.time
-        ? DateTime.fromISO(msg.payload.time)
-        : DateTime.now();
-      const pastSchedule = plan.schedule.filter(
-        (entry) => DateTime.fromISO(entry.time) <= time
-      );
-      const outputCurrent = node.sendCurrentValueWhenRescheduling;
+      const pastSchedule = plan.schedule.filter((entry) => DateTime.fromISO(entry.time) <= planFromTime);
 
-      if (outputCurrent && pastSchedule.length > 0) {
+      if (node.sendCurrentValueWhenRescheduling && pastSchedule.length > 0) {
         const currentValue = pastSchedule[pastSchedule.length - 1].value;
         output1 = currentValue ? { payload: true } : null;
         output2 = currentValue ? null : { payload: false };
@@ -100,26 +98,53 @@ module.exports = function (RED) {
       node.send([output1, output2, output3]);
 
       // Run schedule
-      schedulingTimeout = runSchedule(node, plan.schedule, time);
+      schedulingTimeout = runSchedule(node, plan.schedule, planFromTime);
     });
   }
 
   RED.nodes.registerType("power-saver", PowerSaverNode);
 };
 
-function loadDayData(node, date) {
-  // Load saved schedule for the date (YYYY-MM-DD)
-  // Return null if not found
-  const key = date.toISO();
-  return (
-    node.context().get(key) || {
-      values: [],
-      onOff: [],
-      startTimes: [],
-      schedule: [],
-      savings: [],
-    }
-  );
+function adjustSavingsPassedHours(plan, includeFromLastPlanHours) {
+  const firstOnIndex = plan.hours.findIndex((h) => h.onOff);
+  if (firstOnIndex < 0) {
+    return;
+  }
+  const nextOnValue = plan.hours[firstOnIndex].price;
+  let adjustIndex = includeFromLastPlanHours.length - 1;
+  while (adjustIndex >= 0 && !includeFromLastPlanHours[adjustIndex].onOff) {
+    includeFromLastPlanHours[adjustIndex].saving = getDiff(includeFromLastPlanHours[adjustIndex].price, nextOnValue);
+    adjustIndex--;
+  }
+}
+
+function getPriceData(node, msg) {
+  const isConfigMsg = !!msg?.payload?.config;
+  if (isConfigMsg) {
+    return node.context().get("lastPriceData");
+  }
+
+  if (!validateMsg(node, msg)) {
+    return null;
+  }
+  const input = convertMsg(msg);
+  if (!validateInput(node, input)) {
+    return null;
+  }
+
+  priceData = [...input.today, ...input.tomorrow];
+  priceData.source = input.source;
+  node.context().set("lastPriceData", priceData);
+  return priceData;
+}
+
+function loadDataJustBefore(node, dateDayBefore, dateToday, startAtIndex) {
+  const dataDayBefore = loadDayData(node, dateDayBefore);
+  const dataToday = loadDayData(node, dateToday);
+  return {
+    schedule: [...dataDayBefore.schedule, ...dataToday.schedule.slice(0, startAtIndex)],
+    hours: [...dataDayBefore.hours, ...dataToday.hours.slice(0, startAtIndex)],
+  };
 }
 
 function saveDayData(node, date, plan) {
@@ -140,7 +165,7 @@ function makePlan(node, values, startTimes, onOffBefore, firstValueNextDay) {
   const lastCountDayBefore = countAtEnd(onOffBefore, lastValueDayBefore);
   const onOff =
     strategy === "mostSaved"
-      ? mostSavedStrategy.calculate(
+      ? calculate(
           values,
           node.maxHoursToSaveInSequence,
           node.minHoursOnAfterMaxSequenceSaved,
@@ -161,7 +186,6 @@ function makePlan(node, values, startTimes, onOffBefore, firstValueNextDay) {
   return {
     hours,
     schedule,
-    onOff,
   };
 }
 
@@ -175,8 +199,7 @@ function validateMsg(node, msg) {
     validationFailure(node, "Payload missing");
     return false;
   }
-  const payload =
-    msg.data?.new_state?.attributes ?? msg.data?.attributes ?? msg.payload;
+  const payload = msg.data?.new_state?.attributes ?? msg.data?.attributes ?? msg.payload;
   if (typeof payload !== "object") {
     validationFailure(node, "Payload must be an object");
     return false;
@@ -191,10 +214,7 @@ function validateInput(node, input) {
         return day.start === undefined || day.value === undefined;
       })
     ) {
-      validationFailure(
-        node,
-        `Malformed entries in payload.${arr}. All entries must contain start and value.`
-      );
+      validationFailure(node, `Malformed entries in payload.${arr}. All entries must contain start and value.`);
     }
   });
   if (!input.today.length && !input.tomorrow.length) {
@@ -214,18 +234,16 @@ function validateInput(node, input) {
  */
 function runSchedule(node, schedule, time) {
   let currentTime = time;
-  let remainingSchedule = schedule.filter(
-    (entry) => DateTime.fromISO(entry.time) > time
-  );
+  let remainingSchedule = schedule.filter((entry) => DateTime.fromISO(entry.time) > time);
   if (remainingSchedule.length > 0) {
     const entry = remainingSchedule[0];
     const nextTime = DateTime.fromISO(entry.time);
     const wait = nextTime - currentTime;
     const onOff = entry.value ? "on" : "off";
     node.log("Switching " + onOff + " in " + wait + " milliseconds");
-    const statusMessage = `Scheduled ${
-      remainingSchedule.length
-    } changes. Next: ${remainingSchedule[0].value ? "on" : "off"}`;
+    const statusMessage = `Scheduled ${remainingSchedule.length} changes. Next: ${
+      remainingSchedule[0].value ? "on" : "off"
+    }`;
     node.status({ fill: "green", shape: "dot", text: statusMessage });
     return setTimeout(() => {
       sendSwitch(node, entry.value);

package/src/receive-price-functions.js

@@ -0,0 +1,99 @@
+const { validationFailure } = require("./utils");
+
+function getPriceData(node, msg) {
+  const isConfigMsg = !!msg?.payload?.config;
+  if (isConfigMsg) {
+    return node.context().get("lastPriceData");
+  }
+
+  if (!validateMsg(node, msg)) {
+    return null;
+  }
+  const input = convertMsg(msg);
+  if (!validateInput(node, input)) {
+    return null;
+  }
+
+  priceData = [...input.today, ...input.tomorrow];
+  priceData.source = input.source;
+  node.context().set("lastPriceData", priceData);
+  return priceData;
+}
+
+function validateMsg(node, msg) {
+  if (!msg.payload && !msg.data?.new_state?.attributes) {
+    validationFailure(node, "Payload missing");
+    return false;
+  }
+  const payload = msg.data?.new_state?.attributes ?? msg.data?.attributes ?? msg.payload;
+  if (typeof payload !== "object") {
+    validationFailure(node, "Payload must be an object");
+    return false;
+  }
+  return true;
+}
+
+function validateInput(node, input) {
+  ["today", "tomorrow"].forEach((arr) => {
+    if (
+      input[arr].some((day) => {
+        return day.start === undefined || day.value === undefined;
+      })
+    ) {
+      validationFailure(node, `Malformed entries in payload.${arr}. All entries must contain start and value.`);
+    }
+  });
+  if (!input.today.length && !input.tomorrow.length) {
+    validationFailure(node, "Payload has no data");
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Get today and tomorrow data out of the input message.
+ * Can accept 3 types of messages: Tibber, Nordpool or plain payload with data already converted.
+ * @param {*} msg
+ */
+function convertMsg(msg) {
+  const result = { source: "Unknown" };
+
+  ["today", "tomorrow"].forEach((day) => {
+    if (msg.payload?.viewer?.home?.currentSubscription?.priceInfo[day]) {
+      result.source = "Tibber";
+      result[day] = msg.payload.viewer.home.currentSubscription.priceInfo[day].map((v) => ({
+        value: v.total,
+        start: v.startsAt,
+      }));
+    } else if (msg.payload?.viewer?.homes && msg.payload?.viewer?.homes[0]?.currentSubscription?.priceInfo[day]) {
+      result.source = "Tibber";
+      result[day] = msg.payload.viewer.homes[0].currentSubscription.priceInfo[day].map((v) => ({
+        value: v.total,
+        start: v.startsAt,
+      }));
+    } else if (msg.data?.new_state?.attributes["raw_" + day]) {
+      result.source = "Nordpool";
+      result[day] = msg.data.new_state.attributes["raw_" + day].map((v) => ({
+        value: v.value,
+        start: v.start,
+      }));
+    } else if (msg.payload?.attributes && msg.payload?.attributes["raw_" + day]) {
+      result.source = "Nordpool";
+      result[day] = msg.payload.attributes["raw_" + day].map((v) => ({
+        value: v.value,
+        start: v.start,
+      }));
+    } else {
+      result.source = "Other";
+      result[day] = msg.payload[day] || [];
+    }
+  });
+
+  return result;
+}
+
+module.exports = {
+  getPriceData,
+  convertMsg,
+};

package/src/receive-price.html

@@ -0,0 +1,30 @@
+<script type="text/javascript">
+  RED.nodes.registerType("ps-receive-price", {
+    category: "Power Saver",
+    color: "#a6bbcf",
+    defaults: {
+      name: { value: "Price Receiver" },
+    },
+    inputs: 1,
+    outputs: 1,
+    icon: "font-awesome/fa-euro",
+    color: "#FFCC66",
+    label: function () {
+      return this.name || "Price Receiver";
+    },
+  });
+</script>
+
+<script type="text/html" data-template-name="ps-receive-price">
+  <div class="form-row">
+    <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+    <input type="text" id="node-input-name" placeholder="Name" style="width: 240px" />
+  </div>
+</script>
+
+<script type="text/markdown" data-help-name="ps-receive-price">
+  A node to receive price data from one of the supported sources,
+  and adapt it for calculation in the Power Saver strategy nodes.
+
+  Please read more in the [node documentation](https://ottopaulsen.github.io/node-red-contrib-power-saver/nodes/ps-receive-price)
+</script>

package/src/receive-price.js

@@ -0,0 +1,21 @@
+const { getPriceData } = require("./receive-price-functions");
+
+module.exports = function (RED) {
+  function ReceivePriceNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+
+    node.on("input", function (msg) {
+      const priceData = getPriceData(node, msg);
+      if (!priceData) {
+        // Set status failed
+        return;
+      }
+
+      // Send output
+      node.send({ payload: { priceData } });
+    });
+  }
+
+  RED.nodes.registerType("ps-receive-price", ReceivePriceNode);
+};

package/src/strategy-best-save-functions.js

@@ -0,0 +1,110 @@
+"use strict";
+
+const { fillArray } = require("./utils");
+
+/**
+ * Takes an array of true/false values where true means on and false means off.
+ * Evaluates of the on/off sequences are valid according to other arguments.
+ *
+ * @param {*} onOff Array of on/off values
+ * @param {*} maxOff Max number of values that can be off in a sequence
+ * @param {*} minOnAfterOff Min number of values that must be on after maxOff is reached
+ * @returns
+ */
+function isOnOffSequencesOk(onOff, maxOff, minOnAfterOff) {
+  let offCount = 0;
+  let onCount = 0;
+  let reachedMaxOff = false;
+  for (let i = 0; i < onOff.length; i++) {
+    if (!onOff[i]) {
+      if (maxOff === 0 || reachedMaxOff) {
+        return false;
+      }
+      offCount++;
+      onCount = 0;
+      if (offCount >= maxOff) {
+        reachedMaxOff = true;
+      }
+    } else {
+      if (reachedMaxOff) {
+        onCount++;
+        if (onCount >= minOnAfterOff) {
+          reachedMaxOff = false;
+        }
+      }
+      offCount = 0;
+    }
+  }
+  return true;
+}
+
+/**
+ * Turn off the hours where you save most compared to the next hour on.
+ *
+ * @param {*} values Array of prices
+ * @param {*} maxOffInARow Max number of hours that can be saved in a row
+ * @param {*} minOnAfterMaxOffInARow Min number of hours that must be on after maxOffInARow is saved
+ * @param {*} minSaving Minimum amount that must be saved in order to turn off
+ * @param {*} lastValueDayBefore Value of the last hour the day before
+ * @param {*} lastCountDayBefore Number of lastValueDayBefore in a row
+ * @returns Array with same number of values as in values array, where true is on, false is off
+ */
+
+function calculate(
+  values,
+  maxOffInARow,
+  minOnAfterMaxOffInARow,
+  minSaving,
+  lastValueDayBefore = undefined,
+  lastCountDayBefore = 0
+) {
+  const dayBefore = fillArray(lastValueDayBefore, lastCountDayBefore);
+  const last = values.length - 1;
+
+  // Create matrix with saving per hour
+  const savingPerHour = [];
+  for (let hour = 0; hour < last; hour++) {
+    const row = [];
+    for (let count = 1; count <= maxOffInARow; count++) {
+      const on = hour + count;
+      const saving = values[hour] - values[on >= last ? last : on];
+      row.push(saving);
+    }
+    savingPerHour.push(row);
+  }
+
+  // Create list with summary saving per sequence
+  let savingsList = [];
+  for (let hour = 0; hour < last; hour++) {
+    for (let count = 1; count <= maxOffInARow; count++) {
+      let saving = 0;
+      for (let offset = 0; offset < count && hour + offset < last; offset++) {
+        saving += savingPerHour[hour + offset][count - offset - 1];
+      }
+      if (saving > minSaving * count && hour + count <= last && values[hour] > values[hour + count] + minSaving) {
+        savingsList.push({ hour, count, saving });
+      }
+    }
+  }
+
+  savingsList.sort((a, b) => b.saving - a.saving);
+  let onOff = values.map((v) => true); // Start with all on
+
+  // Find the best possible sequences
+  while (savingsList.length > 0) {
+    const { hour, count } = savingsList[0];
+    const onOffCopy = [...onOff];
+    for (let c = 0; c < count; c++) {
+      onOff[hour + c] = false;
+    }
+    if (isOnOffSequencesOk([...dayBefore, ...onOff], maxOffInARow, minOnAfterMaxOffInARow)) {
+      savingsList = savingsList.filter((s) => s.hour < hour || s.hour >= hour + count);
+    } else {
+      onOff = [...onOffCopy];
+      savingsList.splice(0, 1);
+    }
+  }
+  return onOff;
+}
+
+module.exports = { calculate, isOnOffSequencesOk };

package/src/strategy-best-save.html

@@ -0,0 +1,116 @@
+<script type="text/javascript">
+  RED.nodes.registerType("ps-strategy-best-save", {
+    category: "Power Saver",
+    color: "#a6bbcf",
+    defaults: {
+      name: { value: "Best Save" },
+      maxHoursToSaveInSequence: {
+        value: 3,
+        required: true,
+        validate: RED.validators.number(),
+      },
+      minHoursOnAfterMaxSequenceSaved: {
+        value: 2,
+        required: true,
+        validate: RED.validators.number(),
+      },
+      minSaving: {
+        value: 0.01,
+        required: true,
+        validate: RED.validators.number(),
+      },
+      sendCurrentValueWhenRescheduling: {
+        value: true,
+        required: true,
+        // validate: RED.validators.number(),
+        align: "left",
+      },
+      outputIfNoSchedule: { value: "true", required: true, align: "left" },
+      scheduleOnlyFromCurrentTime: {
+        value: "true",
+        required: true,
+        align: "left",
+      },
+    },
+    inputs: 1,
+    outputs: 3,
+    icon: "font-awesome/fa-bar-chart",
+    color: "#FFCC66",
+    label: function () {
+      return this.name || "Best Save";
+    },
+    outputLabels: ["on", "off", "schedule"],
+    oneditprepare: function () {
+      $("#node-input-outputIfNoSchedule").typedInput({
+        types: [
+          {
+            value: "onoff",
+            options: [
+              { value: "true", label: "On" },
+              { value: "false", label: "Off" },
+            ],
+          },
+        ],
+      });
+      $("#node-input-scheduleOnlyFromCurrentTime").typedInput({
+        types: [
+          {
+            value: "nowOrStart",
+            options: [
+              { value: "false", label: "Whole data set" },
+              { value: "true", label: "From current hour" },
+            ],
+          },
+        ],
+      });
+    },
+  });
+</script>
+
+<script type="text/html" data-template-name="ps-strategy-best-save">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name" style="width: 240px">
+    </div>
+    <h3>Rules</h3>
+    <div class="form-row">
+        <label for="node-input-maxHoursToSaveInSequence"><i class="fa fa-arrows-h"></i> Max per sequence</label>
+        <input type="text" id="node-input-maxHoursToSaveInSequence" style="width: 80px" placeholder="Max hours to save in sequence">
+    </div>
+    <div class="form-row">
+        <label for="node-input-minHoursOnAfterMaxSequenceSaved"><i class="fa fa-ellipsis-h"></i> Min recover</label>
+        <input type="text"
+               id="node-input-minHoursOnAfterMaxSequenceSaved"
+               style="width: 80px"
+               placeholder="Min hours on after a max sequence">
+    </div>
+    <div class="form-row">
+        <label for="node-input-minSaving"><i class="fa fa-eur"></i> Min saving</label>
+        <input type="text" id="node-input-minSaving" placeholder="Minimum to save for turning off" style="width: 80px">
+    </div>
+    <div class="form-row">
+      <label for="node-input-scheduleOnlyFromCurrentTime">Schedule for</label>
+      <input type="text" id="node-input-scheduleOnlyFromCurrentTime" style="width: 160px">
+      </label>
+  </div>
+  <h3>Output</h3>
+    <div class="form-row">
+        <label for="node-input-sendCurrentValueWhenRescheduling" style="width:240px">
+        <input type="checkbox"
+               id="node-input-sendCurrentValueWhenRescheduling"
+               style="display:inline-block; width:22px; vertical-align:top;"
+               autocomplete="off"><span>Send when rescheduling</span>
+        </label>
+    </div>
+    <div class="form-row">
+        <label for="node-input-outputIfNoSchedule">If no schedule, send</label>
+        <input type="text" id="node-input-outputIfNoSchedule" style="width: 80px">
+        </label>
+    </div>
+</script>
+
+<script type="text/markdown" data-help-name="ps-strategy-best-save">
+  A node you can use to save money by turning off and on a switch based on power prices.
+
+  Please read more in the [node documentation](https://ottopaulsen.github.io/node-red-contrib-power-saver/nodes/ps-strategy-best-save)
+</script>