@haydendonald/node-red-contrib-hass-stuff 0.0.1 → 1.0.1

package/README.md

@@ -541,4 +541,15 @@ A node that provides control of a cover
 * Have curtain be closed at certain hours
 * Have curtain be half at certain hours
 
+## EV Charging Price
+
+A node that keeps track of how much i spend on charging my EV (polestar 2) while at home.
+
+It works by checking if the car started charging while i'm at home. When the car stops charging it will add the price of the session to a sensor.
+This just estimates the value, useful for if you don't have the ability to monitor the charge rate etc.
+
+### Features
+* Calculates how much money per month i spend on charging my EV
+* Detects if the car was charged at home, ignoring fast charging sessions
+
 // MIMO //

package/dist/Connections/connectionsConfigNode.js

@@ -86,11 +86,19 @@ module.exports = function ConnectionsConfigNode(RED) {
             self.sendHASSAPI("http", "post", "/api/states/" + entityId, callback, undefined, data);
         };
         self.addHASSInputBoolean = function (options) {
-            let currentState = options.state || "unknown";
+            let currentState = options.state || options.state || options.defaultState || "unknown";
             const entityId = options.id ? options.id : (0, utility_1.getEntityId)("input_boolean", options.friendlyName);
             const data = (state) => {
+                //If the state is not set, set it to the default state, otherwise "unknown"
+                let setState = state;
+                if (setState === undefined || setState == "unknown") {
+                    setState = options.defaultState;
+                }
+                if (setState === undefined) {
+                    setState = "unknown";
+                }
                 return {
-                    state: state || "unknown",
+                    state: setState,
                     attributes: {
                         friendly_name: options.friendlyName
                     }
@@ -102,7 +110,7 @@ module.exports = function ConnectionsConfigNode(RED) {
                     self.error(`Found more than 1 entity for ${entityId}`);
                     return;
                 }
-                const previousState = entities.length == 1 ? entities[0].state : "unknown";
+                const previousState = entities.length == 1 ? entities[0].state : undefined;
                 self.addHASSEntity(entityId, data(options.state || previousState), options.creationCallback ? (response) => {
                     options.creationCallback(response.payload.state, response);
                 } : undefined);
@@ -133,8 +141,16 @@ module.exports = function ConnectionsConfigNode(RED) {
             var _a;
             const entityId = (_a = options.id) !== null && _a !== void 0 ? _a : (0, utility_1.getEntityId)("button", options.friendlyName);
             const data = (state) => {
+                //If the state is not set, set it to the default state, otherwise "unknown"
+                let setState = state;
+                if (setState === undefined || setState == "unknown") {
+                    setState = options.defaultState;
+                }
+                if (setState === undefined) {
+                    setState = "unknown";
+                }
                 return {
-                    state: state || "unknown",
+                    state: setState,
                     attributes: {
                         friendly_name: options.friendlyName
                     }
@@ -146,7 +162,7 @@ module.exports = function ConnectionsConfigNode(RED) {
                     self.error(`Found more than 1 entity for ${entityId}`);
                     return;
                 }
-                const previousState = entities.length == 1 ? entities[0].state : "unknown";
+                const previousState = entities.length == 1 ? entities[0].state : undefined;
                 self.addHASSEntity(entityId, data(options.state || previousState), options.creationCallback ? (response) => {
                     options.creationCallback(response.payload.state, response);
                 } : undefined);
@@ -166,8 +182,16 @@ module.exports = function ConnectionsConfigNode(RED) {
         self.addHASSScene = function (options) {
             const entityId = options.id || (0, utility_1.getEntityId)("scene", options.friendlyName);
             const data = (state) => {
+                //If the state is not set, set it to the default state, otherwise "unknown"
+                let setState = state;
+                if (setState === undefined || setState == "unknown") {
+                    setState = options.defaultState;
+                }
+                if (setState === undefined) {
+                    setState = "unknown";
+                }
                 return {
-                    state: state || "unknown",
+                    state: setState,
                     attributes: {
                         friendly_name: options.friendlyName
                     }
@@ -179,7 +203,7 @@ module.exports = function ConnectionsConfigNode(RED) {
                     self.error(`Found more than 1 entity for ${entityId}`);
                     return;
                 }
-                const previousState = entities.length == 1 ? entities[0].state : "unknown";
+                const previousState = entities.length == 1 ? entities[0].state : undefined;
                 self.addHASSEntity(entityId, data(options.state || previousState), options.creationCallback ? (response) => {
                     options.creationCallback(response.payload.state, response);
                 } : undefined);
@@ -203,8 +227,16 @@ module.exports = function ConnectionsConfigNode(RED) {
         self.addHASSSelect = function (options) {
             const entityId = options.id || (0, utility_1.getEntityId)("select", options.friendlyName);
             const data = (state) => {
+                //If the state is not set, set it to the default state, otherwise "unknown"
+                let setState = state;
+                if (setState === undefined || setState == "unknown") {
+                    setState = options.defaultState;
+                }
+                if (setState === undefined) {
+                    setState = "unknown";
+                }
                 return {
-                    state: state || "unknown",
+                    state: setState,
                     attributes: {
                         friendly_name: options.friendlyName,
                         options: options.options
@@ -217,7 +249,7 @@ module.exports = function ConnectionsConfigNode(RED) {
                     self.error(`Found more than 1 entity for ${entityId}`);
                     return;
                 }
-                const previousState = entities.length == 1 ? entities[0].state : "unknown";
+                const previousState = entities.length == 1 ? entities[0].state : undefined;
                 self.addHASSEntity(entityId, data(options.state || previousState), options.creationCallback ? (response) => {
                     options.creationCallback(response.payload.state, response);
                 } : undefined);
@@ -271,6 +303,53 @@ module.exports = function ConnectionsConfigNode(RED) {
                 };
             }
         };
+        self.addHASSSensor = function (options) {
+            var _a;
+            const entityId = (_a = options.id) !== null && _a !== void 0 ? _a : (0, utility_1.getEntityId)("number", options.friendlyName);
+            const data = (state) => {
+                //If the state is not set, set it to the default state, otherwise "unknown"
+                let setState = state;
+                if (setState === undefined || setState == "unknown") {
+                    setState = options.defaultState;
+                }
+                if (setState === undefined) {
+                    setState = "unknown";
+                }
+                return {
+                    state: setState,
+                    attributes: {
+                        friendly_name: options.friendlyName
+                    }
+                };
+            };
+            //Add the button to HASS
+            self.getHASSEntities([{ property: "entity_id", logic: "is", value: entityId }], (entities) => {
+                if (entities.length > 1) {
+                    self.error(`Found more than 1 entity for ${entityId}`);
+                    return;
+                }
+                const previousState = entities.length == 1 ? entities[0].state : undefined;
+                self.addHASSEntity(entityId, data(options.state || previousState), options.creationCallback ? (response) => {
+                    options.creationCallback(response.payload.state, response);
+                } : undefined);
+            });
+            return (state) => {
+                self.sendHASSAPI("http", "post", "/api/states/" + entityId, undefined, undefined, data(state));
+                if (options.changedCallback) {
+                    options.changedCallback(state);
+                }
+            };
+        };
+        self.sendCompanionNotification = function (options) {
+            for (const entityId of options.entityIds) {
+                self.sendHASSAction(entityId, undefined, {
+                    message: options.message,
+                    title: options.title,
+                    target: options.target,
+                    data: options.data
+                });
+            }
+        };
         self.handleCallback = function (callbacks, callbackId, ...args) {
             var _a;
             //This is a specific callback id

package/dist/EVChargingPrice/EVChargingPriceNode.html

@@ -0,0 +1,79 @@
+<script type="text/javascript" id="node-ev-charging-price-node">
+    RED.nodes.registerType("ev-charging-price-node", {
+        category: "HASS Stuff",
+        color: "#ffcc00",
+        inputs: 0,
+        outputs: 0,
+        icon: "debug.svg",
+        paletteLabel: "EV Charging Price",
+        defaults: {
+            name: { value: "" },
+            connectionsConfigNode: { value: '', type: "connections-config-node", required: true },
+            chargeRate: { value: 0.0, required: true, validate: RED.validators.number() },
+            peakRate: { value: 0.0, required: true, validate: RED.validators.number() },
+            offPeakRate: { value: 0.0, required: true, validate: RED.validators.number() },
+            peakRateHours: { value: "7,8,9,10,11,12,13,14,15,16,17,18,19", required: true },
+            peakRateDays: { value: "0,1,2,3,4", required: true },
+            chargingEntityId: { value: "", required: true },
+            homeEntityId: { value: "", required: true },
+            notificationId: { value: "", required: false }
+        },
+        label: function () {
+            return this.name || "EV Charging Price"
+        }
+    });
+</script>
+
+
+<script type="text/html" data-template-name="ev-charging-price-node">
+    <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">
+    </div>
+    <div class="form-row">
+        <label for="node-input-connectionsConfigNode">Config</label>
+        <input type="text" id="node-input-connectionsConfigNode" />
+    </div>
+    <div class="form-row">
+        <p>The charge rate in KW</p>
+        <label for="node-input-chargeRate">Charge Rate</label>
+        <input type="number" step="0.01" id="node-input-chargeRate" />
+    </div>
+    <div class="form-row">
+        <p>The cost of charging during the peak hours in $/kWh</p>
+        <label for="node-input-peakRate">Peak Rate</label>
+        <input type="number" step="0.01" id="node-input-peakRate" />
+    </div>
+    <div class="form-row">
+        <p>The cost of charging during the off-peak hours in $/kWh</p>
+        <label for="node-input-offPeakRate">Off-Peak Rate</label>
+        <input type="number" step="0.01" id="node-input-offPeakRate" />
+    </div>
+    <div class="form-row">
+        <p>The hours during which the peak rate applies. For example 7,8,9,10,11,12,13,14,15,16,17,18,19</p>
+        <label for="node-input-peakRateHours">Peak Rate Hours</label>
+        <input type="text" id="node-input-peakRateHours" />
+    </div>
+    <div class="form-row">
+        <p>The days during which the peak rate applies. For example 0,1,2,3,4 for Monday to Friday</p>
+        <label for="node-input-peakRateDays">Peak Rate Days</label>
+        <input type="text" id="node-input-peakRateDays" />
+    </div>
+    <div class="form-row">
+        <p>The entity ID for the charging sensor for example sensor.polestar2_charging_state</p>
+        <label for="node-input-chargingEntityId">Charging Entity ID</label>
+        <input type="text" id="node-input-chargingEntityId" />
+    </div>
+    <div class="form-row">
+        <p>The entity ID for the home presence sensor for example person.hayden</p>
+        <label for="node-input-homeEntityId">Home Entity ID</label>
+        <input type="text" id="node-input-homeEntityId" />
+    </div>
+    <div class="form-row">
+        <p>The entity IDs for the notification target for example notify.mobile_app_haydens_iphone</p>
+        <label for="node-input-notificationId">Notification ID</label>
+        <input type="text" id="node-input-notificationId" />
+    </div>
+</script>
+<script type="text/html" data-help-name="ev-charging-price-node">
+</script>

package/dist/EVChargingPrice/EVChargingPriceNode.js

@@ -0,0 +1,192 @@
+"use strict";
+const baseNode_1 = require("../baseNode");
+const utility_1 = require("../utility");
+module.exports = function EVChargingPriceNode(RED) {
+    function register(config) {
+        const self = this;
+        //Validate the config
+        let hasValidationError = false;
+        if (!config.connectionsConfigNode) {
+            self.error("Connections config node is required");
+            hasValidationError = true;
+        }
+        if (!config.chargingEntityId) {
+            self.error("Charging entity ID is required");
+            hasValidationError = true;
+        }
+        if (!config.homeEntityId) {
+            self.error("Home entity ID is required");
+            hasValidationError = true;
+        }
+        if (!config.chargeRate || parseFloat(config.chargeRate) <= 0) {
+            self.error("Charge rate must be a positive number");
+            hasValidationError = true;
+        }
+        if (!config.peakRate || parseFloat(config.peakRate) <= 0) {
+            self.error("Peak rate must be a positive number");
+            hasValidationError = true;
+        }
+        if (!config.offPeakRate || parseFloat(config.offPeakRate) <= 0) {
+            self.error("Off-peak rate must be a positive number");
+            hasValidationError = true;
+        }
+        if (!config.peakRateHours) {
+            self.error("Peak rate hours are required");
+            hasValidationError = true;
+        }
+        if (!config.peakRateDays) {
+            self.error("Peak rate days are required");
+            hasValidationError = true;
+        }
+        if (hasValidationError) {
+            return;
+        }
+        let chargingState;
+        let homeState;
+        let priceState;
+        let startedChargingAtHomeState;
+        let startedChargingAt;
+        let finishedChargingAt;
+        //Set the price sensor
+        let setPrice;
+        RED.nodes.createNode(this, config);
+        (0, baseNode_1.assignBaseNode)(this);
+        const connectionsConfigNode = RED.nodes.getNode(config.connectionsConfigNode);
+        //When HASS is ready
+        connectionsConfigNode.hassEventReadyCallbacks[this.id] = function (msg) {
+            // Get the current state of the charger
+            connectionsConfigNode.getHASSEntityState(config.chargingEntityId, (payload, data) => {
+                chargingState = data.data.state;
+                if (chargingState == "Charging") {
+                    startedChargingAt = data.data.last_changed;
+                }
+                else {
+                    finishedChargingAt = data.data.last_changed;
+                }
+            });
+            // Get the current state of the home
+            connectionsConfigNode.getHASSEntityState(config.homeEntityId, (payload, data) => { homeState = data.data.state; });
+            //Add a boolean to keep track if the charger started while at home
+            connectionsConfigNode.addHASSInputBoolean({
+                friendlyName: `${self.name} - Started Charging at Home`,
+                id: (0, utility_1.getEntityId)("input_boolean", `${self.name}_started_charging_at_home`),
+                defaultState: "off",
+                creationCallback: (state) => {
+                    startedChargingAtHomeState = state;
+                },
+                changedCallback: (state) => {
+                    startedChargingAtHomeState = state;
+                }
+            });
+            //Add our sensor to track the cost
+            setPrice = connectionsConfigNode.addHASSSensor({
+                friendlyName: `${self.name} - Price`,
+                id: (0, utility_1.getEntityId)("sensor", `${self.name}_price`),
+                defaultState: 0.0,
+                creationCallback: (state) => {
+                    priceState = state;
+                },
+                changedCallback: (state) => {
+                    priceState = state;
+                }
+            });
+            //Add a button to reset the price
+            connectionsConfigNode.addHASSButton({
+                friendlyName: `${self.name} - Reset Price`,
+                id: (0, utility_1.getEntityId)("button", `${self.name}_reset_price`),
+                pressedCallback: () => {
+                    setPrice(0.0);
+                }
+            });
+        };
+        //When a state change happens in home assistant
+        connectionsConfigNode.hassEventStateChangeCallbacks[this.id] = function (entityId, oldState, newState) {
+            switch (entityId) {
+                case config.homeEntityId: {
+                    homeState = newState.state;
+                    handle();
+                    break;
+                }
+                case config.chargingEntityId: {
+                    chargingState = newState.state;
+                    if (chargingState == "Charging") {
+                        startedChargingAt = newState.last_changed;
+                        finishedChargingAt = undefined;
+                    }
+                    else {
+                        startedChargingAt = oldState.last_changed;
+                        finishedChargingAt = newState.last_changed;
+                    }
+                    handle();
+                    break;
+                }
+            }
+        };
+        function sendNotification(title, message) {
+            if (config.notificationId) {
+                connectionsConfigNode.sendCompanionNotification({
+                    entityIds: [config.notificationId],
+                    message,
+                    title
+                });
+            }
+        }
+        function handle() {
+            //Set started charging at home if user is home and car is charging
+            if (startedChargingAtHomeState == "off" && (chargingState == "Charging" && homeState == "home")) {
+                connectionsConfigNode.sendHASSAction("input_boolean.turn_on", { entity_id: [(0, utility_1.getEntityId)("input_boolean", `${self.name}_started_charging_at_home`)] });
+                sendNotification(`Charging has started for ${self.name}`, `Charging has started for ${self.name}`);
+            }
+            //Car has stopped charging and had started while at home
+            if (chargingState != "Charging" && startedChargingAtHomeState == "on") {
+                connectionsConfigNode.sendHASSAction("input_boolean.turn_off", { entity_id: [(0, utility_1.getEntityId)("input_boolean", `${self.name}_started_charging_at_home`)] });
+                const powerKW = parseFloat(config.chargeRate);
+                const peakHours = config.peakRateHours.split(",").map((h) => parseInt(h.trim()));
+                const peakDays = config.peakRateDays.split(",").map((d) => parseInt(d.trim()));
+                const pricePeak = parseFloat(config.peakRate);
+                const priceOffPeak = parseFloat(config.offPeakRate);
+                const startDate = new Date(startedChargingAt);
+                const endDate = new Date(finishedChargingAt);
+                if (endDate < startDate) {
+                    self.error("Finished charging time is before started charging time. Cannot calculate");
+                    return;
+                }
+                // Calculate time spent in peak and off-peak periods
+                // Split charging period at hour boundaries for accurate rate calculation
+                let timeInPeakMs = 0;
+                let timeInOffPeakMs = 0;
+                let currentTime = new Date();
+                while (currentTime < endDate) {
+                    // Find the next hour boundary or end of charging period
+                    const nextHourBoundary = new Date(currentTime);
+                    nextHourBoundary.setHours(currentTime.getHours() + 1, 0, 0, 0);
+                    const segmentEnd = nextHourBoundary > endDate ? endDate : nextHourBoundary;
+                    const duration = segmentEnd.getTime() - currentTime.getTime();
+                    const currentHour = currentTime.getHours();
+                    const currentDay = currentTime.getDay();
+                    // Check if current time falls in peak period
+                    const isPeak = peakHours.includes(currentHour) && peakDays.includes(currentDay);
+                    if (isPeak) {
+                        timeInPeakMs += duration;
+                    }
+                    else {
+                        timeInOffPeakMs += duration;
+                    }
+                    currentTime = segmentEnd;
+                }
+                // Calculate the price
+                const timeInPeakHours = timeInPeakMs / 3600000;
+                const timeInOffPeakHours = timeInOffPeakMs / 3600000;
+                const totalHours = timeInPeakHours + timeInOffPeakHours;
+                const peakPrice = powerKW * timeInPeakHours * pricePeak;
+                const offPeakPrice = powerKW * timeInOffPeakHours * priceOffPeak;
+                const totalPrice = peakPrice + offPeakPrice;
+                const rollingPrice = parseFloat((parseFloat(priceState) + totalPrice).toFixed(2));
+                // Update the price
+                setPrice(rollingPrice);
+                sendNotification(`Charging has finished for ${self.name}`, `Charging finished for ${self.name}. Was charging for ${totalHours.toFixed(2)} hours. The charge session was $${totalPrice.toFixed(2)}, the total so far is $${rollingPrice}`);
+            }
+        }
+    }
+    RED.nodes.registerType("ev-charging-price-node", register);
+};

package/dist/EVChargingPrice/EVChargingPriceTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haydendonald/node-red-contrib-hass-stuff",
-  "version": "0.0.1",
+  "version": "1.0.1",
   "description": "A collection of stuff I use on my Node Red + Home Assistant server. This could be of use for others, i don't know..",
   "devDependencies": {
     "@types/node": "^18.14.0",
@@ -27,7 +27,8 @@
       "ConnectionsConfigNode": "dist/Connections/connectionsConfigNode.js",
       "ConnectionsNode": "dist/Connections/connectionsNode.js",
       "LightControlConfigNode": "dist/LightControl/lightControlConfigNode.js",
-      "LightControlNode": "dist/LightControl/lightControlNode.js"
+      "LightControlNode": "dist/LightControl/lightControlNode.js",
+      "EVChargingPriceNode": "dist/EVChargingPrice/EVChargingPriceNode.js"
     }
   },
   "publishConfig": {