@energiok/node-red-contrib-pricecontrol-thermal 1.0.0

package/.eslintrc.js

@@ -0,0 +1,15 @@
+module.exports = {
+    "env": {
+        "browser": true,
+        "commonjs": true,
+        "es2021": true
+    },
+    "extends": "eslint:recommended",
+    "overrides": [
+    ],
+    "parserOptions": {
+        "ecmaVersion": "latest"
+    },
+    "rules": {
+    }
+}

package/CHANGELOG.md

@@ -0,0 +1 @@
+[The changelog has moved here](https://powersaver.no/changelog/#change-log)

package/COMPARISON-BEST-SAVE-VS-SMART-THERMAL.md

@@ -0,0 +1,264 @@
+# Comparison: Best Save vs Smart Thermal Strategy
+
+## Overview
+
+Both nodes solve the same fundamental problem: **minimize electricity cost while maintaining system requirements**. However, they use different approaches.
+
+---
+
+## Best Save Strategy (Deleted/Old)
+
+### Core Algorithm
+Uses a **greedy optimization** approach that:
+1. Calculates "saving per minute" for every possible off-sequence
+2. Sorts sequences by total savings (highest first)
+3. Iteratively picks the best sequences that satisfy constraints
+
+### Key Features
+
+#### 1. Recovery Mechanism
+```javascript
+// After being off, system must recover
+recoveryPercentage: 100  // % of off-time that must be on afterward
+recoveryMaxMinutes: 60   // Cap on recovery time
+```
+**Example**: If system is off for 4 hours (240 min), it must be on for 2-4 hours after (depending on recoveryPercentage).
+
+#### 2. Constraint Validation
+```javascript
+function isOnOffSequencesOk(onOff, maxMinutesOff, minMinutesOff, recoveryPercentage, recoveryMaxMinutes)
+```
+- **maxMinutesOff**: Maximum continuous off time (prevents damage)
+- **minMinutesOff**: Minimum off duration (prevents short-cycling)
+- **recoveryPercentage**: Ensures sufficient recovery after long off periods
+- **recoveryMaxMinutes**: Caps recovery time (prevents excessive on-time)
+
+#### 3. Minimum Savings Threshold
+```javascript
+minSaving: 0.05  // Only turn off if saving > 5 øre/kWh
+```
+Prevents turning off for trivial savings.
+
+#### 4. Day-Before Context
+```javascript
+lastValueDayBefore = undefined
+lastCountDayBefore = 0
+```
+Considers previous day's state to ensure constraints span across days.
+
+### Pros
+- **Optimal** for the given constraints (maximizes savings)
+- **Flexible** - works for any device (water heater, heat pump, etc.)
+- **Recovery logic** ensures system doesn't stay off too long
+- **Cross-day awareness** prevents constraint violations at midnight
+
+### Cons
+- **Complex algorithm** (nested loops, sorting, filtering)
+- **No temperature awareness** (doesn't consider thermal dynamics)
+- **Binary on/off** (no intermediate states)
+- **Assumes constant load** when on
+
+---
+
+## Smart Thermal Strategy (Current)
+
+### Core Algorithm
+Uses a **physics-based** approach that:
+1. Calculates how long building can coast based on outdoor temperature
+2. Identifies price peaks (top 20%)
+3. Schedules coast during peaks, boost before peaks
+
+### Key Features
+
+#### 1. Thermal Modeling
+```javascript
+function calculateCoastTime(outdoorTemp, heatLossCoefficient = 0.05) {
+  const indoorTemp = 22;
+  const comfortMin = 20;
+  const tempDelta = indoorTemp - outdoorTemp;
+  const tempBuffer = indoorTemp - comfortMin;
+  const heatLossRate = tempDelta * heatLossCoefficient;
+  return (tempBuffer / heatLossRate) * 60; // minutes
+}
+```
+**Adapts to weather**: Colder outdoor = shorter coast time allowed.
+
+#### 2. Peak Detection
+```javascript
+function findPeaks(prices, topPercentage = 20)
+```
+- Identifies top 20% of prices as "expensive"
+- Coasts during these periods only
+
+#### 3. Anti-Short-Cycling
+```javascript
+minCoastMinutes: 60
+minBoostMinutes: 60
+function enforceMinimumDurations(modes, intervalMinutes, minCoastMinutes, minBoostMinutes)
+```
+Prevents rapid mode switching (similar to minMinutesOff in best-save).
+
+#### 4. Simple Output
+```javascript
+output: "boost" or "coast"  // Just mode strings
+```
+User decides actual temperatures/settings.
+
+### Pros
+- **Temperature-aware** - considers outdoor temp and thermal mass
+- **Simple to understand** - coast during expensive periods
+- **User-friendly config** - only 5 parameters
+- **Weather adaptive** - automatically adjusts to conditions
+
+### Cons
+- **Not optimal** - doesn't maximize savings, just avoids peaks
+- **Assumes thermal model** - may not fit all buildings
+- **No recovery logic** - doesn't ensure minimum on-time after long coast
+- **No minimum savings** - will coast even for small price differences
+
+---
+
+## What Smart Thermal Could Learn from Best Save
+
+### 1. **Recovery Logic** ⭐ MOST VALUABLE
+The best-save recovery mechanism ensures the system doesn't stay off too long and has adequate recovery time.
+
+**How to add to Smart Thermal**:
+```javascript
+// After coasting, ensure minimum boost time for recovery
+const coastDuration = calculateCoastDuration(schedule);
+const minBoostAfterCoast = Math.max(
+  coastDuration * (recoveryPercentage / 100),
+  minBoostMinutes
+);
+```
+
+**Example**: If system coasts for 4 hours during a price peak, require at least 2-4 hours of boost afterward to ensure building is properly heated.
+
+### 2. **Minimum Savings Threshold** ⭐ VALUABLE
+Prevents turning off for trivial price differences.
+
+**How to add to Smart Thermal**:
+```javascript
+// Only coast if price difference justifies it
+const avgPrice = calculateAverage(prices);
+const peakPrice = item.price;
+if (peakPrice - avgPrice < minSaving) {
+  mode = 'boost'; // Not worth coasting
+}
+```
+
+### 3. **Cross-Day State Tracking**
+Best-save considers yesterday's final state to ensure constraints don't break at midnight.
+
+**How to add to Smart Thermal**:
+```javascript
+// Store last mode and duration in context
+const lastMode = node.context().get('lastMode') || 'boost';
+const lastModeDuration = node.context().get('lastModeDuration') || 0;
+
+// Use when enforcing minimum durations
+const effectiveModes = [
+  ...fillArray(lastMode, lastModeDuration),
+  ...todaysModes
+];
+```
+
+### 4. **Greedy Optimization** (Optional)
+Best-save's algorithm finds the truly optimal solution, not just "avoid peaks".
+
+**Trade-off**: Much more complex, probably not worth it for the thermal use case since weather/temperature dynamics dominate over pure price optimization.
+
+---
+
+## Recommended Improvements to Smart Thermal
+
+### Priority 1: Add Recovery Logic ⭐⭐⭐
+```javascript
+// Add to config
+recoveryPercentage: 100  // Default: equal recovery time
+recoveryMaxMinutes: 120  // Default: cap at 2 hours
+
+// In createSchedule function
+function enforceRecovery(schedule) {
+  let coastMinutes = 0;
+  for (let i = 0; i < schedule.length; i++) {
+    if (schedule[i].mode === 'coast') {
+      coastMinutes++;
+    } else if (coastMinutes > 0) {
+      // Just finished a coast period, ensure recovery
+      const minRecovery = Math.min(
+        coastMinutes * (recoveryPercentage / 100),
+        recoveryMaxMinutes / intervalMinutes
+      );
+
+      // Force next minRecovery intervals to be boost
+      for (let j = 0; j < minRecovery && i + j < schedule.length; j++) {
+        schedule[i + j].mode = 'boost';
+      }
+      coastMinutes = 0;
+    }
+  }
+  return schedule;
+}
+```
+
+### Priority 2: Add Minimum Savings Threshold ⭐⭐
+```javascript
+// Add to config
+minSaving: 5  // Only coast if saving > 5 øre/kWh
+
+// In createSchedule function
+const avgPrice = prices.reduce((sum, p) => sum + p.value, 0) / prices.length;
+
+schedule.forEach(item => {
+  if (item.mode === 'coast' && item.price - avgPrice < minSaving) {
+    item.mode = 'boost';  // Not worth the savings
+  }
+});
+```
+
+### Priority 3: Cross-Day Context ⭐
+```javascript
+// Store state at end of each schedule creation
+node.context().set('lastScheduleEnd', {
+  mode: schedule[schedule.length - 1].mode,
+  duration: calculateDurationInSameMode(schedule)
+}, contextStore);
+
+// Use when enforcing minimum durations
+const lastState = node.context().get('lastScheduleEnd', contextStore);
+if (lastState) {
+  const combinedModes = [
+    ...fillArray(lastState.mode, lastState.duration),
+    ...currentModes
+  ];
+  enforceMinimumDurations(combinedModes, ...);
+}
+```
+
+---
+
+## Conclusion
+
+**Best Save** is an optimal general-purpose scheduler that maximizes savings for any binary on/off device.
+
+**Smart Thermal** is a simpler, temperature-aware scheduler specifically designed for heating systems.
+
+**Best additions from Best Save to Smart Thermal**:
+1. ✅ **Recovery logic** - Ensure adequate heating after coast periods
+2. ✅ **Minimum savings threshold** - Don't coast for trivial savings
+3. ✅ **Cross-day context** - Better constraint enforcement at day boundaries
+
+The greedy optimization algorithm from Best Save is **not recommended** because thermal dynamics (heat loss, outdoor temp) are more important than pure price optimization for heating systems.
+
+---
+
+## Implementation Status
+
+- [ ] Recovery logic
+- [ ] Minimum savings threshold
+- [ ] Cross-day context
+- [x] Basic thermal modeling
+- [x] Anti-short-cycling
+- [x] Simple user interface

package/DASHBOARD-TEMPLATE-3-MODES.md

@@ -0,0 +1,288 @@
+# Dashboard Template for 3-Mode Smart Thermal
+
+This template visualizes the three-state thermal optimizer: **normal**, **boost**, and **coast**.
+
+## Colors
+- **Blue** - Normal operation (default state)
+- **Green** - Boost (pre-heat before peaks)
+- **Red** - Coast (turn off during expensive periods)
+
+## Template Code for ui-template node
+
+```html
+<template>
+  <div class="thermal-chart">
+    <div class="chart-header">
+      <h3>Price & Mode Schedule</h3>
+      <div class="legend">
+        <span class="legend-item normal"><span class="legend-color"></span> Normal</span>
+        <span class="legend-item boost"><span class="legend-color"></span> Boost (Pre-heat)</span>
+        <span class="legend-item coast"><span class="legend-color"></span> Coast (Turn Off)</span>
+      </div>
+    </div>
+
+    <div v-if="msg.payload && msg.payload.schedule" class="schedule-container">
+      <div class="schedule-bar">
+        <div
+          v-for="(item, index) in msg.payload.schedule"
+          :key="index"
+          class="schedule-item"
+          :class="item.mode"
+          :style="{width: (100 / msg.payload.schedule.length) + '%'}"
+          :title="formatTime(item.time) + ': ' + item.price + ' øre/kWh (' + item.mode + ')'"
+        >
+          <div class="time-label" v-if="index % 4 === 0">{{ formatTime(item.time) }}</div>
+        </div>
+      </div>
+
+      <div class="price-chart">
+        <svg viewBox="0 0 1000 200" preserveAspectRatio="none">
+          <!-- Price line -->
+          <polyline
+            :points="getPriceLinePoints()"
+            fill="none"
+            stroke="#2196F3"
+            stroke-width="2"
+          />
+          <!-- Price points with mode colors -->
+          <circle
+            v-for="(item, index) in msg.payload.schedule"
+            :key="'point-' + index"
+            :cx="(index / (msg.payload.schedule.length - 1)) * 1000"
+            :cy="200 - ((item.price - minPrice) / priceRange) * 180"
+            r="3"
+            :fill="getModeColor(item.mode)"
+          />
+        </svg>
+
+        <div class="y-axis">
+          <span class="y-label">{{ Math.round(maxPrice) }} øre</span>
+          <span class="y-label">{{ Math.round((maxPrice + minPrice) / 2) }} øre</span>
+          <span class="y-label">{{ Math.round(minPrice) }} øre</span>
+        </div>
+      </div>
+
+      <div class="info-bar">
+        <span>Outdoor: {{ msg.payload.outdoorTemp }}°C</span>
+        <span>Current: {{ msg.payload.currentMode }}</span>
+      </div>
+    </div>
+
+    <div v-else class="no-data">
+      Waiting for data...
+    </div>
+  </div>
+</template>
+
+<script>
+export default {
+  data() {
+    return {
+      msg: { payload: null }
+    }
+  },
+  computed: {
+    minPrice() {
+      if (!this.msg.payload?.schedule) return 0;
+      return Math.min(...this.msg.payload.schedule.map(s => s.price || 0));
+    },
+    maxPrice() {
+      if (!this.msg.payload?.schedule) return 100;
+      return Math.max(...this.msg.payload.schedule.map(s => s.price || 0));
+    },
+    priceRange() {
+      return this.maxPrice - this.minPrice || 1;
+    }
+  },
+  methods: {
+    formatTime(timestamp) {
+      const date = new Date(timestamp);
+      return date.toLocaleTimeString('no-NO', { hour: '2-digit', minute: '2-digit' });
+    },
+    getPriceLinePoints() {
+      if (!this.msg.payload?.schedule) return '';
+
+      return this.msg.payload.schedule.map((item, index) => {
+        const x = (index / (this.msg.payload.schedule.length - 1)) * 1000;
+        const y = 200 - ((item.price - this.minPrice) / this.priceRange) * 180;
+        return `${x},${y}`;
+      }).join(' ');
+    },
+    getModeColor(mode) {
+      switch(mode) {
+        case 'boost': return '#4CAF50'; // Green
+        case 'coast': return '#FF5722'; // Red
+        case 'normal':
+        default: return '#2196F3'; // Blue
+      }
+    }
+  },
+  watch: {
+    msg: {
+      handler(newMsg) {
+        console.log('Received data:', newMsg);
+      },
+      deep: true
+    }
+  }
+}
+</script>
+
+<style scoped>
+.thermal-chart {
+  padding: 16px;
+  background: #fafafa;
+  border-radius: 8px;
+  font-family: Arial, sans-serif;
+}
+
+.chart-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 20px;
+  flex-wrap: wrap;
+}
+
+.chart-header h3 {
+  margin: 0;
+  color: #333;
+}
+
+.legend {
+  display: flex;
+  gap: 15px;
+  flex-wrap: wrap;
+}
+
+.legend-item {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  font-size: 13px;
+}
+
+.legend-color {
+  width: 18px;
+  height: 18px;
+  border-radius: 3px;
+}
+
+.legend-item.normal .legend-color {
+  background: #2196F3;
+}
+
+.legend-item.boost .legend-color {
+  background: #4CAF50;
+}
+
+.legend-item.coast .legend-color {
+  background: #FF5722;
+}
+
+.schedule-container {
+  background: white;
+  border-radius: 8px;
+  padding: 16px;
+  box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+}
+
+.schedule-bar {
+  display: flex;
+  height: 60px;
+  border-radius: 4px;
+  overflow: hidden;
+  margin-bottom: 20px;
+  border: 1px solid #ddd;
+}
+
+.schedule-item {
+  position: relative;
+  cursor: pointer;
+  transition: opacity 0.2s;
+}
+
+.schedule-item:hover {
+  opacity: 0.8;
+}
+
+.schedule-item.normal {
+  background: linear-gradient(180deg, #42A5F5 0%, #2196F3 100%);
+}
+
+.schedule-item.boost {
+  background: linear-gradient(180deg, #66BB6A 0%, #4CAF50 100%);
+}
+
+.schedule-item.coast {
+  background: linear-gradient(180deg, #FF7043 0%, #FF5722 100%);
+}
+
+.time-label {
+  position: absolute;
+  bottom: -20px;
+  left: 0;
+  font-size: 10px;
+  color: #666;
+  white-space: nowrap;
+}
+
+.price-chart {
+  position: relative;
+  height: 200px;
+  margin: 20px 0;
+  padding-left: 60px;
+}
+
+.price-chart svg {
+  width: 100%;
+  height: 100%;
+  background: #f5f5f5;
+  border-radius: 4px;
+}
+
+.y-axis {
+  position: absolute;
+  left: 0;
+  top: 0;
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+  justify-content: space-between;
+  padding: 10px 0;
+}
+
+.y-label {
+  font-size: 12px;
+  color: #666;
+}
+
+.info-bar {
+  display: flex;
+  justify-content: space-between;
+  padding-top: 16px;
+  border-top: 1px solid #e0e0e0;
+  font-size: 14px;
+  color: #666;
+}
+
+.no-data {
+  text-align: center;
+  padding: 40px;
+  color: #999;
+  font-style: italic;
+}
+</style>
+```
+
+## Summary
+
+**Three modes now supported:**
+1. **Normal** (Blue) - Default operation, most of the time
+2. **Boost** (Green) - Pre-heat when prices are significantly cheap AND there's an upcoming peak
+3. **Coast** (Red) - Turn off when prices are significantly expensive
+
+**Thresholds that control behavior:**
+- `minCoastSaving`: Only coast if price is 10+ øre/kWh above average
+- `minBoostSaving`: Only boost if price is 10+ øre/kWh below average
+- This prevents mode switching for trivial price differences!

package/LICENSE

@@ -0,0 +1 @@
+MIT

package/README.md

@@ -0,0 +1,10 @@
+# node-red-contrib-power-saver
+
+A Node-RED node to save money when power prices are changing by the hour.
+
+![Logo](docs/.vuepress/public/logo.png)
+
+## Please read more in the [documentation](https://powersaver.no/).
+
+
+[![Donation](./donation.png)](https://powersaver.no/contribute/#donate)

package/SIMPLIFIED-CONFIG.md

@@ -0,0 +1,92 @@
+# Simplified Configuration
+
+The smart thermal node can run with three primary parameters. Everything else has sensible defaults.
+
+## Configuration Parameters
+
+### 1. Heat Loss Coefficient (0.03 - 0.08)
+**Default:** 0.05
+
+Controls how quickly your building loses heat. This is the only parameter you need to tune based on your building.
+
+- **0.03** = Very well insulated modern house (slow heat loss)
+- **0.05** = Average insulation (default)
+- **0.08** = Older house, poor insulation (fast heat loss)
+
+**How to tune:** Run it for a few days. If temperature drops too much during coast periods, increase the coefficient. If it does not coast enough, decrease it.
+
+### 2. Minimum Mode Duration (minutes)
+**Default:** 60 minutes
+
+Minimum time the system stays in any mode (coast, boost, or normal) before switching. Prevents short-cycling that damages equipment.
+
+- **30-45 min** = More responsive (switches modes more often)
+- **60 min** = Balanced (default)
+- **90+ min** = More stable (prioritizes comfort over optimization)
+
+### 3. Minimum Savings Percent
+**Default:** 5
+
+Minimum price variation required before coast/boost can activate.
+
+- **2-3%** = Aggressive (more mode changes)
+- **5%** = Balanced (default)
+- **8-12%** = Conservative (fewer mode changes)
+
+## What Was Removed
+
+The following legacy parameters are no longer supported:
+
+- `peakThreshold`
+- `troughThreshold`
+- `minCoastSavingPercent`
+- `minBoostSavingPercent`
+- `minCoastSaving`
+- `minBoostSaving`
+- `minCoastMinutes`
+- `minBoostMinutes`
+- `minNormalMinutes`
+
+## Example Configuration
+
+```javascript
+{
+  heatLossCoefficient: 0.05,  // Average insulation
+  minModeDuration: 60,        // 1 hour minimum per mode
+  minSavingsPercent: 5        // Balanced price sensitivity
+}
+```
+
+## How It Works
+
+1. Prices are clustered into cheap, normal, and expensive groups.
+2. `minSavingsPercent` gates clustering when variation is too small.
+3. Heat loss coefficient limits coast duration based on outdoor temperature.
+4. Minimum mode duration prevents excessive mode switching.
+
+## Migration from Old Config
+
+**Old (many parameters):**
+```javascript
+{
+  heatLossCoefficient: 0.05,
+  peakThreshold: 20,
+  troughThreshold: 20,
+  minCoastSavingPercent: 5,
+  minBoostSavingPercent: 5,
+  minCoastSaving: undefined,
+  minBoostSaving: undefined,
+  minCoastMinutes: 60,
+  minBoostMinutes: 60,
+  minNormalMinutes: 60
+}
+```
+
+**New (3 parameters):**
+```javascript
+{
+  heatLossCoefficient: 0.05,
+  minModeDuration: 60,
+  minSavingsPercent: 5
+}
+```