MQTT target_power_consumption

[hhoebel]

Bedingt durch das Über-/Unterschwingen des DPL bzw. Inverters hat man ja bei Regelung auf 0W Netzbezug immer etwas Netzbezug. Ich würde nun gerne, sobald der Akku voll ist, einen anderen Zielwert für den Netzbezug vorgeben (z.B. -100W), um den Netzbezug beim Regeln zu verringern, da ich ohnehin genug solaren Überschuß habe. Full Solar Passthrough kommt aber aus anderen Gründen nicht in Frage.
Mein erste Idee war das per MQTT aus Home-Assistant heraus zu machen und das Topic "target_power_consumption" immer dann auf "-100" zusetzen, wenn der Akku-SOC >= 97% ist.

Was ich aber noch nicht rausgefunden habe: Speichert onBattery die Änderung jedesmal permanent ab, d.h. schreibe ich mir so irgendwann den Flash kaputt?

Falls nicht, würde mir eine alternative, zusätzliche Einstellungen für den Target Power Consumption gefallen, die immer dann angewendet wird, wenn der SOC / Schwellspannung für den Akku "Voll" erreicht bzw. nahe daran ist (so habe ich das derzeit in einem eigenen Branch implementiert).

[AndreasBoehm]

Speichert onBattery die Änderung jedesmal permanent ab, d.h. schreibe ich mir so irgendwann den Flash kaputt?

Korrekt.

[hhoebel]

Hier das Skript, aber Achtung - da muss an allen Ecken und Kanten angepaßt werden. Unter dem MQTT-Pfad "solar/surplus/cmd/mode" wird beispielsweise durch HomeAssistant der zuvor beschriebene Überschussmodus eingetragen und unter "solar/surplus/available_solar_power" die maximal verfügbare Solarleistung (die wird während des Ladens von den Ladereglern geholt) - damit wird die Einspeisung von PWM-Signalen auf den momentanen Überschuß begrenzt, damit kein Akku dafür verwendet wird.
Dann stecken da noch jede Menge Optmierungen auf genau mein Heim-Netz drin - Filter-Länge, sofortige Ausregelung von Änderungen kleiner 500W, PWM-Mindestverhältnis, asymmetrische Filterungen, extra-Support für meine Kaffeemaschine etc.
Also eher als Anregung für eigene Skripte nutzen ....

let filteredPower = 0.0;
let filterValues = [ 0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0 ];
let actIndex = 0;

// query the MQTT prefix on startup
let SHELLY_ID = undefined;
let lastPublishedMQTTFiltered = 0;
let SOC = 0;
let powerDG = 0;
let surplusMode = 0;
let surplusMaxPower = 0;
let countHighPeakReturn = 0;
let minPower = 0.0;
let maxPower = 0.0;
let overallMinPower = 0.0;
let overallMaxPower = 0.0;
let pwm = 0.0;
let pulseCount = 0;
let extraPower = 0;
//variables for handling of rocket-heating
let actRocketStatus = 0;
let lastRocketStatus = 0;
let rocketWR = 0;
let lastOnTimeRocket = 0;
let actOnTimeRocket = 0;
let rocketWRRepeat = 100000;
let rocketWROnTime = 0;
let rocketWROffTime = 0;
let rocketWR = 0;
let rocketPowerEnabled = 0;
let ROCKET_OFFSET_ON_TIME = 15000;	    //Offset in ms an dem der WR eingeschaltet wird *bevor* der Rocket erneut nachheizt
let ROCKET_PULSE_MAX_DURATION = 25000;  //Dauer in ms für die der WR eingschaltet wird
let ROCKET_PULSE_TYP_DURATION = 18000;	//typische Nachheizdauer des Rocket 
let ROCKET_MAX_POWER = 1050;			//in W

Shelly.call("Mqtt.GetConfig", "", function (res, err_code, err_msg, ud) {
  SHELLY_ID = res["topic_prefix"];
});

function getIndex( index )
{
  let length = filterValues.length;
  if (index < 0) { 
    index += length;
  } else if (index >= length) {
    index -= length;
  }  
  return index;
}
function getFilteredValue( offset ) {
  let index = getIndex( actIndex + offset );
  return filterValues[index];
}
function addNewValueToFilter( power ) {
  let index = getIndex( actIndex + 1 );
  filterValues[index] = power;
  actIndex = index;
}
function calcExtrema( power ) {
  let length = filterValues.length;
  minPower = 0;
  maxPower = 0;
  avgPower = 0;
  pwm = 0;

  for (let i=0; i<length; i++) {
	let filtValue = filterValues[i];
	avgPower += filtValue;
  }
  avgPower /= length;
  
  let shortFilterLength = 20;
  let idx = actIndex;
  let maxCount = 0;
  let minCount = 0;
  for (let i=0; i < shortFilterLength; i++) {
	let filtValue = filterValues[idx];
	idx--;
	if (idx < 0) {
		idx += length;
	}
  	if (filtValue > avgPower) {
  		maxPower += filtValue;
		maxCount++;
  	} else {
		minPower += filtValue;
		minCount++;
	}
  }  
  if (minCount > 0) {
	minPower /= minCount;
  } else {
    minPower = avgPower;
  }
  if (maxCount > 0) {
	maxPower /= maxCount;
  } else {
    maxPower = avgPower;
  }  
  pulseCount = 0;
  let prevState = 0;
  overallMaxPower = maxPower;
  overallMinPower = minPower;
  for (let i=0; i<length; i++) {
	let filtValue = filterValues[i];
  	if (filtValue > avgPower) {
  		pwm += 1;
		if (prevState == 0) {
			pulseCount++;
			prevState = 1;
		}
  	} else {
		prevState = 0;
	}
  	if (filtValue > overallMaxPower) {
  		overallMaxPower = filtValue;
  	} 
	if (filtValue < overallMinPower) {
		overallMinPower = filtValue;
	}	
  }
  pwm /= length;
}
function MQTTSocListener(topic, message) {
  let jobj = JSON.parse(message);
  //print("MESSAGE=",jobj);
  SOC = jobj;
}
function MQTTSurplusListener(topic, message) {
  let jobj = JSON.parse(message);
  //print("MESSAGE=",jobj);
  surplusMode = jobj;
}
function MQTTSurplusMaxPowerListener(topic, message) {
  let jobj = JSON.parse(message);
  //print("MESSAGE=",jobj);
  surplusMaxPower = jobj;
}
function MQTTPowerListener(topic, message) {
  let jobj = JSON.parse(message);
 // print("MESSAGE=",jobj.power);
  powerDG = jobj.power;
}
function MQTTRocketListener(topic, message) {
  let jobj = JSON.parse(message);
  let actTime = Shelly.getUptimeMs();
  let power = jobj.power;

  //keine Änderung, wenn gerade eine Flanke vorliegt (Hysterese!)
  if (power > 600) {
	actRocketStatus = 1;
  }
  if (power < 300) {
	actRocketStatus = 0;
  }
  if ((lastRocketStatus == 0) && (actRocketStatus == 1)) {
	lastOnTimeRocket = actOnTimeRocket;
	actOnTimeRocket = actTime;
	//On-/Off-Time korrigieren, für den Fall, das noch nicht eingeschaltet wurde
	rocketWROnTime = actTime - ROCKET_OFFSET_ON_TIME;
	rocketWROffTime = rocketWROnTime + ROCKET_PULSE_TYP_DURATION;
  }
  if ((lastRocketStatus== 1) && (actRocketStatus == 0)) {
	// Anschaltpulse maximal 2min auseinander?
	if ((actOnTimeRocket - lastOnTimeRocket) < 140000) {
		// An-Puls maximal 25s lang? (d.h. wird normalerweise ausgefiltert)
		if ((actTime - actOnTimeRocket) < 24000) {
			if (rocketWR == 1) {
				let calcRepeat = (actOnTimeRocket - lastOnTimeRocket);
				if (calcRepeat < rocketWRRepeat) {
					rocketWRRepeat -= (rocketWRRepeat - calcRepeat) / 4;
				} else {
					rocketWRRepeat += (calcRepeat - rocketWRRepeat) / 8;
				}				
			} 		    
			rocketWROnTime = (actOnTimeRocket + rocketWRRepeat) - ROCKET_OFFSET_ON_TIME;					
			rocketWROffTime = rocketWROnTime + ROCKET_PULSE_MAX_DURATION;
			rocketWR = 1;	
		} else {
			rocketWR = 0;
		}
	} else {
		rocketWR = 0;
	}
	print("Status=" , rocketWR, "StartIn=", (rocketWROnTime-actTime), "Repeat=", rocketWRRepeat);	
  }  
  lastRocketStatus = actRocketStatus;
}
function initMQTT() {
  MQTT.subscribe("solar/battery/stateOfCharge", MQTTSocListener);  
  MQTT.subscribe("solar/surplus/cmd/mode", MQTTSurplusListener); 
  MQTT.subscribe("solar/surplus/available_solar_power", MQTTSurplusMaxPowerListener);   
  MQTT.subscribe("zigbee2mqtt/EM3_WR_DG", MQTTPowerListener);
  MQTT.subscribe("zigbee2mqtt/EM_ROCKET", MQTTRocketListener);
}
initMQTT();
function timerHandler(user_data)
{
    let em = Shelly.getComponentStatus("em", 0);
    let scriptStart = Shelly.getUptimeMs();

    if (typeof em.total_act_power !== 'undefined') {
		let power = em.total_act_power;

		// search for the minimum of the last measurements (to filter out high start-currents of motors etc.)
		calcExtrema( power );
        addNewValueToFilter( power );

		// if actual power isn't a high peak, than don't filter it out
		if (power < (minPower+500))
		{
			if (countHighPeakReturn >= 4) {
				minPower = (getFilteredValue(0) + getFilteredValue(-1) + getFilteredValue(-2))/3; 
			}
			if (countHighPeakReturn < 255) { 
			    countHighPeakReturn++; 
			}
		} else {
			countHighPeakReturn = 0;
		}
		if (surplusMode == 0) {
			// don't follow PWM-signals and spikes to save battery-energy
			filteredPower = minPower;
			extraPower = 0;
			// Nachheizen des Rocket NICHT ausgleichen, um Batterie zu sparen
			rocketPowerEnabled = 0;
		}
		else if (surplusMode == 1) {
			let surplusPower = minPower;

			if ((pwm >= 0.25) && (pulseCount > 2)) {
				// limit the power for PWM-signals to the maximum available solar-power to avoid discharging the battery
				if ((overallMaxPower - overallMinPower) > surplusMaxPower) {
					surplusPower = overallMinPower + surplusMaxPower;
				} else {			
					surplusPower = overallMaxPower;
				}
			}
			if (surplusPower >= filteredPower) {
				// faster filtering at rising power
				filteredPower += (surplusPower - filteredPower) / 6;
			} else {
				// slower filtering at falling power
				filteredPower -= (filteredPower - surplusPower) / 6;
			}		
			extraPower = 50;
			rocketPowerEnabled = 1;			
		}
		else
		{
			let surplusPower = minPower;
			if ((pwm >= 0.25) && (pulseCount > 2)) {
				// limit the power for PWM-signals to the maximum available solar-power to avoid discharging the battery
				if ((overallMaxPower - overallMinPower) > surplusMaxPower) {
					surplusPower = overallMinPower + surplusMaxPower;
				} else {			
					surplusPower = overallMaxPower;
				}
			}
			if (surplusPower >= filteredPower) {
				// faster filtering at rising power
				filteredPower += (surplusPower - filteredPower) / 6;
			} else {
				// slower filtering at falling power
				filteredPower -= (filteredPower - surplusPower) / 12;
			}	
			// add a reserve for short-term-variations
			extraPower = 100;
			rocketPowerEnabled = 1;
		}
	};
 //   console.log("Runtime: ", Shelly.getUptimeMs() - scriptStart, "Surplus-Mode:", surplusMode, " Power:", filteredPower);
}

Timer.set(1000, true, timerHandler, null);

function httpServerHandler(request, response) {
	let actTime = Shelly.getUptimeMs();
	let rocketPower = 0;

	if ((rocketWR == 1) && (rocketPowerEnabled == 1)) {
		if ((actTime < rocketWROffTime) && (actTime >= rocketWROnTime)) {
			rocketPower = ROCKET_MAX_POWER;
		}
	} 

    response.code = 200;
    response.headers = [["Content-Type", "application/json"]]; 
    response.body = "{\"filteredPower\": " + (filteredPower+extraPower+rocketPower) + ",\"filteredPowerMinusSolar\": " + (filteredPower + extraPower + rocketPower + powerDG) + "}";	
    response.send();
    return;
}
HTTPServer.registerEndpoint("filtered_power", httpServerHandler);

[SW-Niko]

Zudem hat der Shelly eine viel höhere Update-Rate bei der Leistungsmessung, so dass die Leistungsinformationen besser gefiltert werden können, inbesondere was PWM und deren Maxima angeht.

Das ist ein Guter Ansatz. Im Endeffekt regeln wir doch wieder mit der Geschwindigkeit die uns die Inverter aufdrücken aber für die Datenvorbereitung hat das Vorteile. Kannst du aussagen mit welcher Messfrequenz die Shellys arbeiten beziehungsweise wie schnell die Daten über das Script zur Verfügung stehen?

[hhoebel]

Ich weis nicht mit welcher internen Messfrequenz die arbeiten, aber beim Pro3EM bekomme ich auch mit Timer-Skript-Start alle 100ms noch verschiedene Werte, die Abtastfrequenz scheint also noch höher zu sein. Dann entscheidet natürlich die weitere Kette - du kannst die Ergebnisse per MQTT verbreiten oder durch OpenDTU per JSON pollen (so wie in meinem Skript dargestellt). Gerade bei der PWM-Erfassung und Auswertung ist eine höhere Abtastrate je nach Gerät vorteilhaft.

[Squint5471]

@hhoebel Danke für das Skript! Mit welcher OpenDTU Firmware kombinierst du das?

[hhoebel]

Ich habe die aktuelle onBattery-Version drauf, ergänzt mit meinem Pull Request zur Ladestrombegrenzung bei Victron.
Im Prinzip ist das aber völlig egal, da die notwendige Logik quasi komplett im Shelly-Skript steckt - nur die verfügbare Solar-Leistung und der Überschuß-Modus kommen aus einem HomeAssistant-Skript. Die zusätzlichen Leistungsmesser "EM3_WG_DG" und "EM_ROCKET" sind nicht notwendig. Der EM3_WG_DG erfaßt bei mir nur den direkt eingespeisten Anteil 2 einzelner Ost/West-Panele die direkt einspeisen und der EM_ROCKET erfaßt die Kaffeemaschine separat, damit ich die regelmässigen Nachheitzpulse auch ausregeln kann.
Die MQTT-Pfade für das HomeAssistant-Skript liegen auch im Pfad "solar", da ich sie dort passen fand, obowohl diese NICHT zur OpenDTU gehören.

[DonJohnLong]

Das hab ich mir auch schon gewünscht, oder alternativ bei aktivem full solar passthrough einen konfigurierbaren zielwert.

Da mein wechselrichter eigentlich zu gross ist, hab ich dann einfach immer abgeregelt.

Lg

[erdna28]

Ich habe wenig Ahnung.Daher vielleicht eine dumme Frage:
Wenn ich den Netzbezug mehrmals Täglich händisch in der Oberfläche
ändere geht dann auch irgendwann der Flash Speicher kaputt?
Lg

[hhoebel]

Ich habe wenig Ahnung.Daher vielleicht eine dumme Frage: Wenn ich den Netzbezug mehrmals Täglich händisch in der Oberfläche ändere geht dann auch irgendwann der Flash Speicher kaputt? Lg

Irgendwann: ja
Das kannst du aber viele Jahre tun bevor der Flash kaputt geht. Das ist eher ein Problem, wenn der Bezug automatisiert gesetzt wird und sich häufig ändert, z.B. wenn der Wert wegen schwankender Solarerleistung durch Bewölkung andauernd geändert wird.

[SW-Niko]

Der Flash im ESP32 schafft so um die 100000 Schreibzyklen. Bei 10 Jahren Betrieb kannst du dann ungefähr 1 mal in der Stunde den Wert ändern. Denke das reicht für händische Änderungen. 🤔

[hhoebel]

Ich weis nicht wie das bei den ESP32 ist, aber bei sehr vielen Mikrocontrollern ist das Flash in Pages organisiert und die Anzahl der Zyklen bezieht sich auf das Löschen und Schreiben einer kompletten Page. In diesen Fällen geht JEDER Löschvorgang in einer Page (der notwendig ist, um einen Wert zu ändern) zu Lasten der Zyklen, d.h. wenn du 100 Werte in einer Page ablegst und jeden davon nacheinander 1000x änderst, hast du auch 100.000 Zyklen (sofern man keine Wear-Leveling-Algorithmen dafür implementiert). Mit einem dedizierten EEPROM hat man dagegen meistens echten Einzel-Byte-Zugriff und nochmals deutlich mehr Schreibzyklen.
In aller Regel bezieht sich aber die Spezifikation der Zyklen auf das obere Limit des Temperaturbereichs und erfahrungsgemäß verkraften die Zellen bei niedrigeren Temperaturen wesentlich mehr Zyklen.

[schlimmchen]

Bei 10 Jahren Betrieb kannst du dann ungefähr 1 mal in der Stunde den Wert ändern.

Unter der Annahme, dass alle Blöcke des Flashs, die zum LittleFS gehören, bei jeder Anpassunge alle neu beschrieben werden.

sofern man keine Wear-Leveling-Algorithmen dafür implementiert

Das im Einsatz befindliche LittleFS beherrscht wear leveling.

Macht euch um die Haltbarkeit eurer Flashs bitte keine Sorgen. Da muss man sich schon anstrengen, um den kaputt zu kriegen.