node-red-contrib-power-saver 2.1.0 → 3.0.0

package/docs/nodes/ps-receive-price.md

@@ -0,0 +1,153 @@
+---
+prev: ./ps-strategy-lowest-price.md
+---
+
+# ps-receive-price
+
+![ps-receive-price](../images/node-ps-receive-price.png)
+
+## Description
+
+The `ps-receive-price` node is used to convert prices from Tibber or Nord Pool to the format used by the strategy nodes. It takes its input directly from the output of the following nodes (see details below):
+
+- `tibber-query` node from Tibber (`node-red-contrib-tibber-api`)
+- `current state` node in Home Assistant
+- `events: state` node in Home Assistant
+
+Output can be sent directly to the strategy nodes (for example `strategy-best-save` or `strategy-lowest-price`), or it can be sent via another node to add grid tariff or other additional costs before the calculation is done.
+
+::: warning Note
+In version 2 of `node-red-contrib-power-saver`, prices were received directly by the Power Saver node.
+This made it hard to add grid tariff before the calculation was done.
+That is why this is now a separate node.
+:::
+
+## Configuration
+
+There is no configuration except from node name.
+
+## Input
+
+### Tibber input
+
+If you are a Tibber customer, you can use the `tibber-query` node from the [`node-red-contrib-tibber-api`](https://flows.nodered.org/node/node-red-contrib-tibber-api). Set it up with the following query:
+
+```gql
+{
+  viewer {
+    homes {
+      currentSubscription {
+        priceInfo {
+          today {
+            total
+            startsAt
+          }
+          tomorrow {
+            total
+            startsAt
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+Send the result from the `tibber-query` node with the query above directly to the `ps-receive-price` node. Make sure it is refreshed when new prices are ready. Prices for the next day are normally ready at 13:00, but refreshing every hour can be a good idea.
+
+[See example with Tibber, a switch and MQTT](doc/example-tibber-mqtt.md)
+
+::: danger Warning
+The query above returns an array with all houses you have in your Tibber account.
+It willl work only if the house you want is the first house in the array, for example if you have only one house.
+If that is not the case, you must use the query below.
+:::
+
+**Tibber query for a specific house**
+
+If the above query does not give you the house you want as the first in the result array, you can use the following method. In this method you need run one query in order to find the id of the house you want the prices for first, and then use the id in the real query.
+
+Go to the [Tibber Deeloper pages](https://developer.tibber.com/), sign in, and go to the [API Explorer](https://developer.tibber.com/explorer). Load your personal token, then run the following query:
+
+```gql
+{
+  viewer {
+    homes {
+      id
+      address {
+        address1
+        address2
+        address3
+        postalCode
+        city
+        country
+      }
+    }
+  }
+}
+```
+
+Then copy the `id` of the house you want to use prices for. It may look like this:
+
+```
+NB! This is just an example:
+142c1670-ab43-2ab3-ba6d-723703a551e2
+```
+
+Then use the id in the following query, replacing the id with the one you found in the previous query:
+
+```gql{3}
+{
+  viewer {
+    home(id: "142c1670-ab43-2ab3-ba6d-723703a551e2") {
+      currentSubscription{
+        priceInfo{
+          today {
+            total
+            startsAt
+          }
+          tomorrow {
+            total
+            startsAt
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+This is the query you shall put in the `tibber-query` node.
+
+### Nord Pool input
+
+This is especially designed to work for Home Assistant (HA), and the [Nord Pool custom component](https://github.com/custom-components/nordpool). The Nord Pool component provides a _sensor_ that gives price per hour for today and tomorrow (after 13:00). Send the output from this sensor directly to the `ps-receive-price` node. Make sure this is done whenever the node is updated, as well as when the system starts up.
+
+Data can be sent from both the `current state` node or the `events: state` node.
+
+[See example with Nord Pool and `current state` node](doc/example-nordpool-current-state.md)
+
+[See example with Nord Pool and `events: state` node](doc/example-nordpool-events-state.md)
+
+### Other input
+
+If you cannot use any of the two above (Tibber or Nord Pool), create the input to the node with the payload containing JSON like this:
+
+```json
+{
+  "today": [
+    { "value": 1, "start": "2021-06-21T00:00:00+02:00" },
+    { "value": 2, "start": "2021-06-21T01:00:00+02:00" }
+    //...
+  ],
+  "tomorrow": [
+    { "value": 3, "start": "2021-06-22T00:00:00+02:00" },
+    { "value": 4, "start": "2021-06-22T01:00:00+02:00" }
+    //...
+  ]
+}
+```
+
+## Output
+
+The output is the [common strategy input format](./strategy-input.md), so it can be sent directly to the strategy nodes, or via any `ps-xxx-add-tariff` node.

package/docs/nodes/ps-strategy-best-save.md

@@ -0,0 +1,142 @@
+# ps-strategy-best-save
+
+![ps-strategy-best-save](../images/node-ps-strategy-best-save.png)
+
+Strategy node to postpone power consumption until the price is lower.
+
+## Description
+
+This strategy turns off the hours where the price difference is largest compared to the next hour that is on. The idea is that the power you are not using when the switch is turned off, will be used immediately when the switch is turned on. This would fit well for turning off a water heater or another thermostat controlled heater.
+
+The picture at the bottom of the page, under [Integration with MagicMirror](#integration-with-magicmirror), illustrates this by the purple strokes, taking the price from the top of the price curve to the level of the first hour after the save-period.
+
+## Configuration
+
+![Best Save Config](/best-save-config.png)
+
+| Value                  | Description                                                                                                                                                          |
+| ---------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Max per sequence       | Maximum number of hours to turn off in a sequence.                                                                                                                   |
+| Min recover            | Minimum hours to turn on immediately after a period when turned off the maximum number of hours that is allowed to be turned off                                     |
+| Min saving             | Minimum amount to save per kWh in order to bother turning it off. It is recommended to have some amount here, e.g. 2 cents / 2 øre. No point in saving 0.001, is it? |
+| Schedule for           | Select to schedule for the whole data set or only from the current hour.                                                                                             |
+| Send when rescheduling | Check this to make sure on or off output is sent immediately after rescheduling                                                                                      |
+| If no schedule, send   | What to do if there is no valid schedule any more (turn on or off).                                                                                                  |
+
+::: warning Min recover
+NB! The `Min recover` only has effect if the previous save-period is of length `Max per sequence`. If the save-period is shorter, the following on-period may be as short as one hour.
+:::
+
+### Dynamic config
+
+It is possible to change config dynamically by sending a config message to the node. The config messages has a payload with a config object like this example:
+
+```json
+"payload": {
+  "config": {
+    "maxHoursToSaveInSequence": 4,
+    "minHoursOnAfterMaxSequenceSaved": 2,
+    "minSaving": 0.02,
+    "sendCurrentValueWhenRescheduling": true,
+    "outputIfNoSchedule": true,
+    "scheduleOnlyFromCurrentTime": false
+  }
+}
+```
+
+All the variables in the config object are optional. You can send only those you want to change.
+
+The config sent like this will be valid until a new config is sent the same way, or until the flow is restarted. On a restart, the original config set up in the node will be used.
+
+When a config is sent like this, the schedule will be replanned based on the last previously received price data. If no price data has been received, no scheduling is done.
+
+## Input
+
+The input is the [common strategy input format](./strategy-input.md)
+
+## Output
+
+There are three outputs. You use only those you need for your purpose.
+
+### Output 1
+
+A payload with the word `true` is sent to output 1 whenever the power / switch shall be turned on.
+
+### Output 2
+
+A payload with the word `false` is sent to output 2 whenever the power / switch shall be turned off.
+
+### Output 3
+
+When a valid input is received, and the schedule is recalculated, the resulting schedule, as well as some other information, is sent to output 3. You can use this to see the plan and verify that it meets your expectations. You can also use it to display the schedule in any way you like.
+
+Example of output:
+
+```json
+{
+  "schedule": [
+    {
+      "time": "2021-09-30T00:00:00.000+02:00",
+      "value": false
+    },
+    {
+      "time": "2021-09-30T01:00:00.000+02:00",
+      "value": true
+    }
+  ],
+  "hours": [
+    {
+      "price": 1.2584,
+      "onOff": false,
+      "start": "2021-09-30T00:00:00.000+02:00",
+      "saving": 0.2034
+    },
+    {
+      "price": 1.055,
+      "onOff": true,
+      "start": "2021-09-30T01:00:00.000+02:00",
+      "saving": null
+    },
+    {
+      "price": 1.2054,
+      "onOff": true,
+      "start": "2021-09-30T02:00:00.000+02:00",
+      "saving": null
+    }
+  ],
+  "source": "Nord Pool",
+  "config": {
+    "maxHoursToSaveInSequence": 3,
+    "minHoursOnAfterMaxSequenceSaved": "1",
+    "minSaving": 0.001,
+    "sendCurrentValueWhenRescheduling": true,
+    "outputIfNoSchedule": false
+  }
+}
+```
+
+The `schedule` array shows every time the switch is turned on or off. The `hours` array shows values per hour containing the price (received as input), whether that hour is on or off, the start time of the hour and the amount per kWh that is saved on hours that are turned off, compared to the next hour that is on.
+
+## Algorithm
+
+The calculation that decides what hours to turn off works as follows:
+
+1. A matrix (x \* y) is created where x is the number of hours we have price information for, and y is the configured maximum number of hours to turn off in a sequence.
+2. The matrix is filled with how much you save by turning off hour x for y hours.
+3. The matrix is processed calculating all possibilities for turning off a number of hours in a sequence and by that saving money. In this process all non-saving sequences are discarded. Also, if the average saving per hour is less than what you have configured as minimum amount to save per kWh, the sequence is discarded.
+4. The remaining sequences are sorted by how much that is saved, in descending order.
+5. Next, a table with one value per hour is created, with all hours in state "on".
+6. Then the saving sequences is applied one by one, turning off the hours in each sequence, discarding sequences that lead to any violation of the rules set by the config.
+7. When all sequences are processed, the resulting table shows a pretty good savings plan, that in most cases would be the optimal plan.
+
+I say "in most cases", because there is a chance that a group of two or more sequences combined can give a better plan than a single sequence preceeding those two, but where the selection of the one sequence causes the group to be discarded. If anyone encounters this situation, I would be happy to receive the price data set, and try to improve the algorithm even further.
+
+## Integration with MagicMirror
+
+Are you using [MagicMirror](https://magicmirror.builders/)? Are you also using [Tibber](https://tibber.com/)? If so, there is a module for MM called [MMM-Tibber](https://github.com/ottopaulsen/MMM-Tibber), that easily can be used to show savings from this node.
+
+![Show savings in MMM-Tibber](https://github.com/ottopaulsen/MMM-Tibber/blob/master/doc/MMM-Tibber-screenshot-savings-graph.png?raw=true)
+
+The purple lines show savings per kWh.
+
+Read more about this in the [MMM-Tibber documentation](https://github.com/ottopaulsen/MMM-Tibber#show-savings).

package/docs/nodes/ps-strategy-lowest-price.md

@@ -0,0 +1,165 @@
+---
+next: ./ps-receive-price.md
+---
+
+# ps-strategy-lowest-price
+
+![ps-strategy-lowest-price](../images/node-ps-strategy-lowest-price.png)
+
+Strategy node to turn on power the hours when the price is lowest during a given period, and turn off the other hours.
+
+## Description
+
+The node can work on a specific period from 1 to 24 hours during a 24 hour period. Inside this period, you can decide how many hours that shall be on. The rest of the period will be off. Outside the peiod, you can select that the output shall be either on or off. You can also decide that the hours on shall be consequtive (one continuous period) or spread around in multiple on-periods.
+
+## Configuration
+
+![Node Configuration](/lowest-price-config.png)
+
+| Value                  | Description                                                                      |
+| ---------------------- | -------------------------------------------------------------------------------- |
+| From Time              | The start time of the selected period.                                           |
+| To Time                | The end time of the selected period.                                             |
+| Hours On               | The number of hours that shall be turned on.                                     |
+| Consecutive On-Period  | Check this if you need the on-period to be consecutive.                          |
+| Send When Rescheduling | Check this to make sure on or off output is sent immediately after rescheduling. |
+| If No Schedule, Send   | What to do if there is no valid schedule any more (turn on or off).              |
+| Outside Period, Send   | Select the value to send outside the selected period.                            |
+
+If you want to use a period of 24 hours, set the From Time and To Time to the same value. The time you select is signficant in the way that it decides which 24 hours that are considered when finding the hours with lowest price.
+
+::: tip Example with Consecutive On-Period
+One example to need a consecutive on-period can be if you want to control the washing machine. Let's say it needs 3 hours, and you want it to run between 22:00 and 06:00. Set `From Time = 22:00`, `To Time = 06:00` and check the `Consecutive On-Period` flag. This will turn on the cheapest 3-hour period from 22:00 to 06:00.
+
+NB! It is not recommended to run the washing machine when you are sleeping or away.
+:::
+
+::: tip Example with non-consecutive on-period
+If you have heating cables in the driveway, you may need them to be on only for a few hours every day, for example 4 hours, but it may not be important when this is. Then set `From Time = 00:00`, `To Time = 00:00` and **un-check** the `Consecutive On-Period` flag. This will turn on the 4 cheapest hours during the whole day, and off the rest.
+
+You can use any time for start and end, but it is a good idea to use `00:00`, since the prices normally comes for this period.
+:::
+
+::: warning Outside Period, Send
+Unless the period you select is 24 hours (`From Time` and `To Time` are the same), it is important what value you choose for `Outside Period, Send`. This decides whether the output is on or off during the period that is outside the selected period.
+:::
+
+::: danger Schedule not calculated
+If you select a period for example from 10:00 to 02:00, it may not be possible to calculate before the period starts. This is because electricity prices for the next day (in the Nord Pool area) normally are received around 13:00. The node cannot calculate the period until it has price data for the whole period.
+:::
+
+### Dynamic config
+
+It is possible to change config dynamically by sending a config message to the node. The config messages has a payload with a config object like this example:
+
+```json
+"payload": {
+  "config": {
+    "fromTime" : 10,
+    "toTime" : 16,
+    "hoursOn" : 3,
+    "doNotSplit" : false,
+    "sendCurrentValueWhenRescheduling" : true,
+    "outputIfNoSchedule" : false,
+    "outputOutsidePeriod": false
+  }
+}
+```
+
+All the variables in the config object are optional. You can send only those you want to change.
+
+The config sent like this will be valid until a new config is sent the same way, or until the flow is restarted. On a restart, the original config set up in the node will be used.
+
+When a config is sent like this, the schedule will be replanned based on the last previously received price data. If no price data has been received, no scheduling is done.
+
+## Input
+
+The input is the [common strategy input format](./strategy-input.md)
+
+## Output
+
+When a valid input is received, and the schedule is recalculated, the resulting schedule, as well as some other information, is sent to output 3. You can use this to see the plan and verify that it meets your expectations. You can also use it to display the schedule in any way you like.
+
+Example of output:
+
+```json
+{
+  "schedule": [
+    {
+      "time": "2021-12-10T00:00:00.000+01:00",
+      "value": "true"
+    },
+    {
+      "time": "2021-12-10T04:00:00.000+01:00",
+      "value": true
+    },
+    {
+      "time": "2021-12-10T10:00:00.000+01:00",
+      "value": false
+    },
+    {
+      "time": "2021-12-10T18:00:00.000+01:00",
+      "value": "true"
+    },
+    {
+      "time": "2021-12-11T04:00:00.000+01:00",
+      "value": true
+    },
+    {
+      "time": "2021-12-11T10:00:00.000+01:00",
+      "value": false
+    },
+    {
+      "time": "2021-12-11T18:00:00.000+01:00",
+      "value": "true"
+    }
+  ],
+  "hours": [
+    {
+      "price": 0.4778,
+      "onOff": "true",
+      "start": "2021-12-10T00:00:00.000+01:00",
+      "saving": null
+    },
+    {
+      "price": 0.4828,
+      "onOff": "true",
+      "start": "2021-12-10T01:00:00.000+01:00",
+      "saving": null
+    },
+    //...
+    {
+      "price": 0.6514,
+      "onOff": "true",
+      "start": "2021-12-11T23:00:00.000+01:00",
+      "saving": null
+    }
+  ],
+  "source": "Tibber",
+  "config": {
+    "fromTime": "04",
+    "toTime": "18",
+    "hoursOn": "06",
+    "doNotSplit": false,
+    "sendCurrentValueWhenRescheduling": true,
+    "outputIfNoSchedule": "true",
+    "outputOutsidePeriod": "true"
+  }
+}
+```
+
+The `schedule` array shows every time the switch is turned on or off. The `hours` array shows values per hour containing the price (received as input), whether that hour is on or off, the start time of the hour and the amount per kWh that is saved on hours that are turned off, compared to the next hour that is on.
+
+## Tips & tricks
+
+### Multiple nodes works together
+
+You can use multiple nodes simultanously, for different periods, if you want more hours on one part of the day than another part, or to make sure there are at least some hours on during each period.
+
+### Highest price
+
+If you want to find the `x` hours with the highest prices, do as follows:
+
+1. Calculate `y` as the total number of hours in the period. For example, if the period is from `08:00` to `20:00`, then `y = 12`.
+2. Configure `Hours On = y - x`, so if `x = 4`, then `Hours On = 12 - 4 = 8`.
+3. Use **Output 2** to get a signal when you have the hours with the highest prices. Just remember that the value sent to output 2 is `false`, not `true` as it is on output 1.

package/docs/nodes/strategy-input.md

@@ -0,0 +1,39 @@
+# Strategy input format
+
+The common input for strategy nodes is a payload with a `priceData` array containing an object for each hour. Each object has a `value` wich is the price, and a `start` wich is the start time for the hour.
+
+Example:
+
+```json
+{
+  "priceData": [
+    {
+      "value": 0.9544,
+      "start": "2021-12-07T00:00:00.000+01:00"
+    },
+    {
+      "value": 0.8973,
+      "start": "2021-12-07T01:00:00.000+01:00"
+    },
+    {
+      "value": 0.8668,
+      "start": "2021-12-07T02:00:00.000+01:00"
+    },
+    {
+      "value": 0.8683,
+      "start": "2021-12-07T03:00:00.000+01:00"
+    },
+    {
+      "value": 0.8942,
+      "start": "2021-12-07T04:00:00.000+01:00"
+    }
+    // ... normally 24 or 48 hours
+  ]
+}
+```
+
+This format is used for:
+
+- Output of the `ps-receive-price` node
+- Input and output of the `ps-xxx-add-tariff` nodes
+- Input for the strategy nodes (`ps-strategy-xxx-xxx`)

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "node-red-contrib-power-saver",
-  "version": "2.1.0",
+  "version": "3.0.0",
   "description": "A module for Node-RED that you can use to turn on and off a switch based on power prices",
   "main": "index.js",
   "scripts": {
-    "test": "mocha"
+    "test": "mocha",
+    "docs:dev": "vuepress dev docs",
+    "docs:build": "vuepress build docs"
   },
   "author": "Otto Paulsen <ottpau@gmail.com>",
   "license": "MIT",
@@ -14,11 +16,19 @@
     "energy",
     "smarthome",
     "home-automation",
+    "home-assistant",
     "power"
   ],
   "node-red": {
     "nodes": {
-      "power-saver": "power-saver.js"
+      "power-saver": "src/power-saver.js",
+      "ps-receive-price": "src/receive-price.js",
+      "ps-strategy-best-save": "src/strategy-best-save.js",
+      "ps-strategy-lowest-price": "src/strategy-lowest-price.js",
+      "ps-elvia-config": "src/elvia/elvia-config.js",
+      "ps-elvia-tariff-types": "src/elvia/elvia-tariff-types.js",
+      "ps-elvia-tariff": "src/elvia/elvia-tariff.js",
+      "ps-elvia-add-tariff": "src/elvia/elvia-add-tariff.js"
     }
   },
   "prettier": {
@@ -32,8 +42,10 @@
     "expect": "^27.0.2",
     "lodash.clonedeep": "^4.5.0",
     "mocha": "^6.2.1",
+    "node-fetch": "^2.6.6",
     "node-red": "^1.3.5",
-    "node-red-node-test-helper": "^0.2.7"
+    "node-red-node-test-helper": "^0.2.7",
+    "vuepress": "^2.0.0-beta.27"
   },
   "dependencies": {
     "luxon": "^1.27.0"

package/src/elvia/elvia-add-tariff.html

@@ -0,0 +1,70 @@
+<script type="text/javascript">
+  RED.nodes.registerType("ps-elvia-add-tariff", {
+    category: "Power Saver",
+    color: "#a6bbcf",
+    defaults: {
+      name: { value: "Add Elvia Grid Tariff" },
+      elviaConfig: { value: "", type: "ps-elvia-config" },
+      tariffKey: { value: "", required: true },
+      range: { value: "today", required: true },
+    },
+    inputs: 1,
+    outputs: 1,
+    icon: "elvia_hvite.svg",
+    color: "#FFCC66",
+    label: function () {
+      return this.name || "Add Elvia Grid Tariff";
+    },
+    oneditprepare: function () {
+      const readTariffTypes = function () {
+        const configId = $("#node-input-elviaConfig").val();
+        if (!configId) {
+          return;
+        }
+        $.getJSON("elvia-tariff-types?configId=" + configId, function (data) {
+          if (!data.tariffTypes) {
+            return;
+          }
+          $("#node-input-tariffKey").typedInput({
+            types: [
+              {
+                value: "tariffkeys",
+                options: data.tariffTypes.map((k) => {
+                  return { value: k.tariffKey, label: k.title };
+                }),
+              },
+            ],
+          });
+        });
+      };
+      $("#node-input-elviaConfig").on("change", function () {
+        readTariffTypes();
+      });
+      readTariffTypes();
+    },
+  });
+</script>
+
+<script type="text/html" data-template-name="ps-elvia-add-tariff">
+  <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: 300px" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-elviaConfig"><i class="fa fa-tag"></i> Elvia config</label>
+    <input type="text" id="node-input-elviaConfig" placeholder="Elvia config" style="width: 300px" />
+  </div>
+  <div class="form-row">
+    <label for="node-input-tariffKey"><i class="fa fa-tag"></i> Tariff key</label>
+    <input type="text" id="node-input-tariffKey" placeholder="Tariff" style="width: 300px" />
+  </div>
+</script>
+
+<script type="text/markdown" data-help-name="ps-elvia-add-tariff">
+  # Elvia Add Tariff
+
+  A node to get the tariff from Elvia and add it to the price before it is sent to the power saver strategy nodes.
+  Use this node between the receive-price node and any of the strategy nodes.
+
+  Please read more in the [node documentation](https://ottopaulsen.github.io/node-red-contrib-power-saver/nodes/ps-elvia-add-tariff)
+</script>

package/src/elvia/elvia-add-tariff.js

@@ -0,0 +1,47 @@
+const { DateTime } = require("luxon");
+const { getTariffForPeriod, ping } = require("./elvia-api");
+const { roundPrice } = require("../utils");
+
+module.exports = function (RED) {
+  function PsElviaAddTariffNode(config) {
+    RED.nodes.createNode(this, config);
+    this.elviaConfig = RED.nodes.getNode(config.elviaConfig);
+    this.tariffKey = config.tariffKey;
+    this.range = config.range;
+    const node = this;
+
+    const configList = node.context().global.get("elviaConfigList") || [];
+    const key = configList.find((c) => c.id == node.elviaConfig.id)?.elviaSubscriptionKey;
+    ping(node, key);
+
+    node.on("input", function (msg) {
+      const prices = msg.payload.priceData;
+      const fromTime = prices[0].start.substr(0, 19);
+      const toTime = DateTime.fromISO(prices[prices.length - 1].start)
+        .plus({ hours: 1 })
+        .toISO()
+        .substr(0, 19);
+
+      const configList = node.context().global.get("elviaConfigList") || [];
+      const key = configList.find((c) => c.id == node.elviaConfig.id)?.elviaSubscriptionKey;
+
+      getTariffForPeriod(node, key, node.tariffKey, fromTime, toTime).then((json) => {
+        const tariff = json;
+        const priceInfo = tariff.gridTariff.tariffPrice.priceInfo;
+        if (priceInfo.length !== prices.length) {
+          node.warn(`Elvia tariff count mismatch. Expected ${prices.length} items, but got ${priceInfo.length}`);
+          node.status({ fill: "red", shape: "dot", text: "Tariff error" });
+        } else {
+          prices.forEach((p, i) => {
+            p.powerPrice = p.value;
+            p.gridTariffVariable = priceInfo[i].variablePrice.total;
+            p.value = roundPrice(p.powerPrice + p.gridTariffVariable);
+          });
+        }
+        node.send([{ payload: { priceData: prices } }]);
+      });
+    });
+  }
+
+  RED.nodes.registerType("ps-elvia-add-tariff", PsElviaAddTariffNode);
+};