Dem kleinen Mann wird die Schuld am Klimawandel in die Schuhe geschoben, während Unternehmen machen können was sie wollen. Ist die Waschmaschine wirklich so ein Energiefresser? Muss man halt glauben, wenn man keine Daten dazu hat. Die Lösung: Daten dafür haben.

Ich bau mir also ein gerät, dass Live den aktuellen Stromverbrauch ausliest und mir in eine Datenbank schreibt. Anhand dieser Daten kann ich dann diverse Rechnungen aufstellen oder auch nur die Daten visualisieren. Außerdem lässt sich dann auf der Lan Party aufzeigen, wer den fettesten PC mit der größten Leistungsaufnahme mit bringt. Und ich habe Geräte die 24/7 laufen, bei denen ich gerne wissen würde, wie sich deren Stromverbrauch verhält.

Die Theorie

Wenn ich mir meinen Verteilerkasten so anschaue, sind da ziemlich viele Kabel drinnen. Aber meine Ganze Wohnung bekommt ihren gesamten Strom eigentlich von nur 4 Kabeln. 3 Phasen und ein Nullleiter. Von da aus gehts über den FI Schalter zu den einzelnen Sicherungen für die einzelnen Stromkreise (Wohnzimmer, Bad+WC, Kühlschrank, etc.). Wenn ich also den Strom messe, der in den FI Schalter fließt, dann kann ich Aussage darüber treffen wie viel meine komplette Wohnung verbraucht. No na, mocht jo de Wien Energie genau so.

Elektrotechnik Basics:

Wenn ich die Ströme an L1, L2 und L3 messen kann, dann addiere ich diese und weiß wie viel Strom meine Wohnung als ganzes verbraucht.

Diesen Strom (in Ampere) kann ich dann mit der Spannung (in Volt) zu einer Leistungsaufnahme P umrechnen (in Watt)

Aber auf der Stromrechnung werden Kilowatt-Stunden abgerechnet. Also muss ich mir meinen Stromverbrauch (jo eigentlich Leistung) über die Zeit anschauen. (Daten Speichern, Fläche unter der Kurve Berechnen)

Wenn alles funktioniert kann ich meine Daten mit denen auf der Wien Energie Rechnung vergleich und sie sollten sich decken.

Vielleicht mache ich das auch nur, damit mich niemand mehr über den Tisch ziehen kann, wer weiß.

Problem ist nur, das sind richtig dicke, solide Kupferkabel die direkt in den Gebäudeverteiler gehen und die ich nicht wirklich abschalten kann. Mit denen möchte ich nicht blöd rum spielen. Keine Lust der Hausverwaltung zu erklären warum sie jetzt ihre Sicherung wieder einschalten sollen, ist ja nichts passiert. Also am besten gar nicht angreifen. Strom kann man ja auch berührunglos messen. Weil wo Strom fließt, gibts auch ein Magnetfeld.

Stromzangen

Stromzangen Messen den Strom der in einem Leiter fließt, ohne diesen aufzutrennen oder zu berühren. Die dicken, soliden Kupferkabel in meinem Verteiler können also da bleiben wo sie sind.

Sie messen das Magnetfeld, das den Leiter umgibt. Mit der Klemme umschließt die Zange den Leiter und sofern Strom fließt, wird durch das Magnetfeld auch Strom in der Sekundärwicklung im Messgerät induziert. Dieser ist dann proportional zu dem Strom der in der Primärwicklung (dem zu messenden Leiter).

Der Strom wird anschließend durch einen bekannten Widerstand geleitet und es wird eine Spannung erzeugt. Die kann mit einem Microcontroller (ADC) gemessen werden. Die Spannung ist dann ebenfalls proportional zu dem Strom der durch den Leiter fließt. Mit der richtigen Formel kann sie dann in einen Dezimalwert des Stroms umgewandelt werden. Diesen wert multipliziert man dann mit 230V und man erhält die aktuelle Leistung.

Die Hardware

Theorie steht. Was gibt Aliexpress her, damit ich das Projekt realisieren kann?

Stromfühler

SCT-013s

Einer der bekanntesten Stromwandler auf dem Markt. Kostenpunkt je nachdem wo man ihn kauft. Aliexpress: 1-4€, Amazon: 10€.

Gibt es in verschiedenen Ausführungen, je nachdem welcher Widerstand eingebaut ist, können sie verschiedene Strombereiche messen. Ich hab mich für die 20A Version entschieden. Bei ca 5kW (20A*230V) pro Phase wird’s eh schwierig für eine Privatwohnung.

Microcontroller

ESP8266

Der gute, alte ESP8266.

Heutzutage wahrscheinlich in die Jahre gekommen und vom ESP32 überholt, aber damals State of the Art!

• Hat WiFi Support, um sich zum MQTT Broker zu verbinden
• Hat I2C Support um sich zum externen ADC zu verbinden
• Kann easy über USB programmiert werden, da der Serial Chip bereits drauf ist. (CH340 Version)

Analog – Digital Wandler

ADS1115 Breakout Board

Weil der ESP8266 nur einen ADC besitzt, brauchen wir hierfür einen externen ADC. Der ADS1115 wird über I2C angesprochen und hat sogar 16 Bit, was für gute Messwerte sorgen soll.

Display

16×1 Character Display

16 Character in einer Zeile. Ausreichend und gut leserlich. Viel soll ja hier nicht stehen. nur die Watt pro Phase und der Gesamtverbrauch.

Klassischer HD44780 Display controller, der über das Driver board mit einem PCF8574T über I2C angesprochen wird. Somit erspart man sich eine menge paralleler Datenleitungen.

Gehäuse & Zusammenbau

Wer hätte das gedacht: Fusion360 Design.

Wichtig hierbei war es, das ganze möglichst kompakt zu halten, alle Komponenten zu fixieren und noch platz für die Verkabelung und das selbst gelötete extension Board zu lassen. Eigenes PCB wars damals noch nicht.

Das Gehäuse ist diesmal recht komplex und besteht aus drei Teilen. In dem mitteren Teil werden die Komponenten montiert. Dadurch ist noch genug Platz um die Kabel zu verlegen und zu verlöten. Alle Teile werden Mit M2 schrauben direkt an das gedruckte Plastik geschraubt.

Sind die Komponenten erstmal montiert, kann mit dem Verkabeln losgelegt werden. Viel Glück dabei! :>

I2C Signale, GND, VCC vom ESP8266 zum selbst gelöteten PCB, wo der ADC drauf sitzt. Von da aus weiter zum Display Controller.

Common Ground für die Stromwandler, Signal zu den ADC Inputs.

Deckel und Boden drauf schrauben und versteckt is das Chaos!

Hübsche Beschriftungen mit weißem Edding für den DIY flair!

Am Ende werden noch die DIN-Rail Mounts angeschraubt, um das Gerät auch an die Schienen im Verteilerkasten klemmen zu können. Ordnung halten ist wichtig! 

Blöd nur wenn die Kabel dafür zu kurz sind 🙁

Installation

Rein in den Verteiler, die Stromklemmen an die Phasen klippen, die Signalkabel durch die Zuleitung in den LV Bereich und einfach an die Audio Buchsen am Gehäuse anstecken. Ganz Wichtig, die Stromversorgung nicht vergessen. Hier reicht ein 5V Verteiler Netzteil, das ebenfalls in die LV Abteilung geführt wird.

Die Software

Wechselstrommessung

Jetzt habe ich also ein Bauteil, dass mir zu jeder zeit den aktuellen Stromfluss im Leiter messen kann. Easy, oder? Wäre da nicht da nicht das Problem, dass der aktuelle Stromfluss sich 50 mal in der Sekunde ändert. Wie wir alle wissen, verwendet unser Stromnetz Wechselstrom.

Der Stromverlauf schaut dann nämlich so aus. Wechselstrom, weil er die Polarität wechselt. Macht Sinn oder?

Oder eigentlich so, weil unser Stromnetz mit 50Hz läuft.

Wenn ich jetzt versuche einen Punkt zu einem willkürlichem Zeitpunkt zu messen, kann es sein, dass ich genau auf der Nulllinie messe, oder direkt am höchsten Punkt der Schwingung oder irgendwo dazwischen. Nicht sehr aussagekräftig.

Effektivwert

Um jetzt den Stromverbrauch messen zu können, interessiert mich die Fläche unter der Kurve. Sowohl positiv, als auch negativ. Daher kann ich die Kurve mathematisch einfach nach oben klappen indem ich den Betrag davon nehme.

Für einen Sinus gibt es da eine handliche Formel, die uns das ganze einfacher macht. Der Effektivwert der Spannung ist nämlich 0.707 * Peak.

In der Software messe ich dann also einfach einfach öfters, nehme den maximalen Wert, gehe davon aus, dass das mein Peak ist und multiplizieren diesen Wert mit 0.707. Easy as that. Nur, dass da vollkommen falsche Werte heraus kommen.

Also ran ans Debuggen. Oszilloskop ausgepackt und mal das Signal gecheckt.

Bei einer 10W LED Lampe. Das Signal ist weit davon entfernt ein schöner Sinus zu sein.

Signal bei dem 2200W Föhn. So hab ich mir das vorgestellt.

Ich gehe also davon aus, dass bei kleinen Lasten, die nicht direkt mit Wechselstrom betrieben werden, die Messung des Effektivwerts über die maximale Amplitude so gut wie sinnlos zur Strommessung ist.

Stommessung über Abtastung

Back to the roots. Neue Idee: einfach extrem schnell abtasten über eine definierte Zeitspanne und dann den Mittelwert bilden. Lässt sich auch leichter programmieren.

Ich messe einfach so schnell es mit dem ADC im Single Shot Mode geht. Meine Dauer pro Kanal ist 0.5 Sekunden. Das sind dann 158 Messpunkte pro halber Sekunde, oder bisschen mehr als 6 Punkte pro Periode. Das sollte ausreichen um eine halbwegs genaue Abschätzung geben zu können wie der Stromverlauf aussieht.

• Alles in ein Array speichern, dann den Durchschnitt bilden.
• Mit dem conversion Factor von dem SCT013 den mV Wert in Ampere umrechnen
• Mit der Spannung des Netzes (236V) die Leistung in Watt berechnen
• Ausgeben und per MQTT schicken.
• Profit!

----- MEASURING CHANNEL 0 -----
True Watt. Average over all read Values
samples: 158, time: 0.50s, 6.32 samples/period
vpp: 1.063mv, min: -0.781mV, max: 0.281mV
average: 0.494mV sum: 78.06
amps: 0.010A
watt: 2.332W
----- MEASURING CHANNEL 1 -----
True Watt. Average over all read Values
samples: 158, time: 0.50s, 6.32 samples/period
vpp: 74.000mv, min: -38.344mV, max: 35.656mV
average: 22.665mV sum: 3581.06
amps: 0.453A
watt: 106.979W
----- MEASURING CHANNEL 2 -----
True Watt. Average over all read Values
samples: 158, time: 0.50s, 6.32 samples/period
vpp: 181.250mv, min: -89.781mV, max: 91.469mV
average: 51.482mV sum: 8134.13
amps: 1.030A
watt: 242.994W

Defines & Imports

Verwendete Libraries sind:

• PubSubClient von knolleary
• LiquidCrystal_I2C von johnrickman
• ADS1115_lite von terryjmyers

Display wird initialisiert, hat die I2C Adresse 0x27.

ADS1115 wird initialisiert, mit den Default werten.

Dann wird noch der PubSubClient initialisiert, aber nicht gestartet. Das passiert in der reconnect Funktion weiter unten.

Wifi Credentials definieren und ein paar globale Variablen initialisieren.

#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <LiquidCrystal_I2C.h>
#include <Wire.h>
#include <ADS1115_lite.h>

#define BTN_L D6
#define BTN_R D7

LiquidCrystal_I2C lcd(0x27, 8, 2); // I2C address 0x27, 16 column and 2 rows
ADS1115_lite adc(ADS1115_DEFAULT_ADDRESS);
WiFiClient espClient;
PubSubClient client(espClient);

const char* SSID = "";
const char* PSK = "";
const char* MQTT_BROKER = "";
const int PORT = 1883;
const int DELAY = 2000;
char msg[50];

float final_watt[3];
float final_amps[3];
float final_mv[3];

Functions

Ein kurzer Absatz über die helper Funktionen, die den Code leserlicher machen.

printlcd()

Weil mein einzeiliges Display eine special snowflake ist und wie ein zweizeiliges Display funktioniert, wobei die zwei Zeilen hintereinander dargestellt sind, hab ich mir eine Funktion geschrieben, mit der man einen String am ganzen Display verteilen kann ohne sich darüber Gedanken machen zu müssen.

void printlcd(String s){
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print(s.substring(0,8));
    lcd.setCursor(0,1);
    lcd.print(s.substring(8,16));
}

setup_wifi() & reconnect() & publish()

Wifi Verbindung aufbauen. Keine Hexerei.

Reconnect ist eine MQTT Funktion die in der Main loop aufgerufen wird. Wird die MQTT Verbindung warum auch immer einmal unterbrochen, muss der Microcontroller nicht neu gestartet werden, sondern er versucht eine neue Verbindung jedes mal wenn der Loop durch läuft.

Publish ist eine einfache Funktion die eine Nachricht als String einfach an ein Topic als String publisht.

void setup_wifi() {
	delay(10);
	Serial.println();
	Serial.print("Connecting to ");
	Serial.println(SSID);

	WiFi.begin(SSID, PSK);

	while (WiFi.status() != WL_CONNECTED) {
		delay(500);
		Serial.print(".");
	}

	Serial.println("");
	Serial.println("WiFi connected");
	Serial.println("IP address: ");
	Serial.println(WiFi.localIP());
}

void reconnect() {
	while (!client.connected()) {
		Serial.print("Reconnecting...");
		if (!client.connect("ESP8266Client")) {
			Serial.print("failed, rc=");
			Serial.print(client.state());
			Serial.println(" retrying in 5 seconds");
			delay(5000);
		}
	}
}

void publish(String topic, String message){
  char t[50];
  char m[50];
  message.toCharArray(m,50);
  topic.toCharArray(t,50);
  client.publish(t,m);
}

sendAlive()

SendAlive publisht zusätzliche Topics sowie custom Nachricht, die IP des Geräts und die Mac Adresse. Hilft beim debuggen, falls etwas nicht ganz hinhaut. Außerdem blinkt die LED während diese Heartbeat message geschickt wird, damit man auch ohne Serial Monitor sieht, dass das Gerät etwas macht.

void sendAlive(){
  digitalWrite(LED_BUILTIN, LOW);

  // SEND REAL STUFF
  snprintf (msg, 50, "Alive since %ld milliseconds", millis());
  //Serial.print("Publish message: ");
  Serial.println(msg);
  client.publish("homesens/power/message", msg);

  // SEND IP ADDRESS
  char bufIp [20];
  IPAddress ipaddr = WiFi.localIP();
  sprintf(bufIp, "%d.%d.%d.%d", ipaddr[0], ipaddr[1], ipaddr[2], ipaddr[3]);
  client.publish("homesens/power/ip", bufIp);

  // SEND MAC ADDRESS
  String mac = String(WiFi.macAddress());
  char bufMac [20];
  mac.toCharArray(bufMac, 20);
  client.publish("homesens/power/mac", bufMac);

  digitalWrite(LED_BUILTIN, HIGH);
}

readTrueWatt()

Das Herz des ganzen Theaters. Hier wird genau das gemacht, was in den Kapiteln oben beschrieben wird.

Mit dem Parameter kann der ADC Kanal ausgewählt werden. Kurzer Breakdown was diese Funktion macht:

• Setze den ADC Kanal auf den Wert vom Funktionsparameter.
• Konfiguriere die ADC Lesegeschwindigkeit und die Voltage Range.
• Definiere die Zeitdauer, wie lange der Lesevorgang dauern soll. Hier 500ms.
  • Lies den ADC Wert und schreib ihn in ein Array.
• Für jeden Wert im Array:
  • Berechne aus dem Rohwert des ADC en echten Wert in Millivolt.
  • Ist der Wert MAX oder MIN? Wenn ja, dann speichere diesen.
  • Ist der Wert negativ, mach ihn positiv (hochklappen der Kurve, Betrag nehmen)
• Berechne Durchschnitt aus dem Array
• Berechne Stomstärke mit dem Faktor vom Widerstand des SCT013 Sensors.
• Berechne Leistung über die Multiplikation mit 236V.
• Speichere die Werte in einer globalen Variable mit der Kanalnummer.

void readTrueWatt(int channel){
  int millis = 500;
  Serial.println("----- MEASURING CHANNEL " + String(channel) + " -----");
  Serial.println("True Watt. Average over all read Values");
  // SETUP
  switch (channel){
    case 0:
      adc.setMux(ADS1115_REG_CONFIG_MUX_SINGLE_0);
      break;
    case 1:
      adc.setMux(ADS1115_REG_CONFIG_MUX_SINGLE_1);
      break;
    case 2:
      adc.setMux(ADS1115_REG_CONFIG_MUX_SINGLE_2);
      break;

  }
  //adc.setMux(ADS1115_REG_CONFIG_MUX_SINGLE_0);          // welcher messmodus?
  adc.setSampleRate(ADS1115_REG_CONFIG_DR_860SPS);      // wie schnell?
  //adc.setSampleRate(ADS1115_REG_CONFIG_DR_475SPS);
  //adc.setSampleRate(ADS1115_REG_CONFIG_DR_128SPS);
  adc.setGain(ADS1115_REG_CONFIG_PGA_1_024V);           // welche range? +-1,024V
  int16_t ADS1115raw[500];

  // AQUIRE
  unsigned long startloop = micros();
  unsigned long endloop = micros() + millis * 1000;
  int samples = 0;
  while(micros() < endloop){
    adc.triggerConversion(); //Start a conversion.  This immediatly returns
    ADS1115raw[samples] = adc.getConversion(); //This polls the ADS1115 and wait for conversion to finish, THEN returns the value
    samples++;
  }

  double sum = 0;
  // TRUE RMS BERECHNUNG
  Serial.println("samples: " + String(samples) + ", time: " + String(millis/1000.0) + "s, " + String(samples/((millis/1000.0)*50)) + " samples/period");
  //Serial.println("first 10:");
  float max=0;
  float min=0;
  for (int j = 0; j < samples; j++){
    // 1. in mv umrechnen
    float mv = float(ADS1115raw[j])/32; // for 16 bit conversion. 
    if (mv > max){
      max = mv;
    }
    if (mv < min){
      min = mv;
    } 
    
    // 2. hochklappen
    if (mv < 0){
      mv = -mv; // leichter als mit sqrt
    }
    sum += mv;
  }

  if (min == 0 && max>100){
    final_amps[channel] = 0;
    final_watt[channel] = 0;
    final_mv[channel] = 0;
    return;
  }
  
  Serial.println("vpp: " + String(max-min,3) + "mv, min: " + String(min,3) + "mV, max: " + String(max, 3) + "mV");
  // 3. AVERAGE RECHNEN
  float average = sum/float(samples);
  Serial.println("average: " + String(average, 3) + "mV " + "sum: " + String(sum));

  // 4. AMPS BERECHNEN
  float amps = average * 0.020;
  Serial.println("amps: " + String(amps, 3) + "A");

  // 5. WATT RMS BERECHNEN
  float watt = amps * 236;
  Serial.println("watt: " + String(watt, 3) + "W");

  // PRINT & STORE VALUES
  final_amps[channel] = amps;
  final_watt[channel] = watt;
  final_mv[channel] = average;

Setup

• Initialisiere die Serielle Schnittstelle mit 115200 Baud.
• Initialisiere den LCD Bildschirm.
• Teste die I2C Verbindung zum ADC.
• Konfiguriere die LED.
• Verbinde WiFi.
• Definiere den MQTT Broker.

void setup(){
  Serial.begin(115200);
  lcd.init(); // initialize the lcd
  lcd.backlight();
  if (!adc.testConnection()) {
    Serial.println("ADS1115 Connection failed"); //oh man...something is wrong
    printlcd("ADS1115 failed.");
    return;
  }

  pinMode(BTN_L, INPUT_PULLUP);
  pinMode(BTN_R, INPUT_PULLUP);

  pinMode(LED_BUILTIN, OUTPUT);     // Initialize the LED_BUILTIN pin as an output
  digitalWrite(LED_BUILTIN, LOW);
  printlcd("WiFi setup ...");
  setup_wifi();
  client.setServer(MQTT_BROKER, PORT);
  printlcd("ready ...");
}

Loop

Das erste was im Loop passiert, ist die Verbindung zu MQTT checken. Ist diese nicht da, stelle sie her. Somit wird sichergestellt, dass zu jeder Zeit MQTT verbunden ist. Dann wird der Heartbeat geschickt.

Für jeden Kanal funktioniert die Datenaquise und Aufbereitung gleich. Die Funktion readTrueWatt(Kanalnummer) wird aufgerufen. Diese ist oben genauer beschrieben. Danach befinden sich die Messwerte in einer globalen Variable. Jetzt wird aus allen 3 Kanälen die Summe gebildet, was dem Stromverbrauch zu genau dem Zeitpunkt entspricht. Dann werden diverse MQTT Nachrichten zusammengebaut und verschickt. Zuletzt wird die selbe Info noch auf dem Display angezeigt. Während eines jeden Mess- und Sendevorganges wird die LED kurz eingeschaltet, damit man auch von außen erkennt, dass das Gerät etwas tut.

void loop()
{
  if (!client.connected()) {
    digitalWrite(LED_BUILTIN, LOW);
    printlcd("reconnecting ...");
		reconnect();
	}

  // MQTT STUFF
  client.loop(); 
  sendAlive();

  readTrueWatt(0);
  digitalWrite(LED_BUILTIN, LOW);
  publish("homesens/power/sum_watt", String(final_watt[0] + final_watt[1] + final_watt[2],0));
  publish("homesens/power/L1_watt", String(final_watt[0],0));
  publish("homesens/power/L1_amp", String(final_amps[0],2));
  publish("homesens/power/L1_sensor_mV", String(final_mv[0],3));
  printlcd("[" + String(final_watt[0] + final_watt[1] + final_watt[2],0) + "] " + String(final_watt[2],0) + " " + String(final_watt[1],0) + " " + String(final_watt[0],0));
  digitalWrite(LED_BUILTIN, HIGH);

  readTrueWatt(1);
  digitalWrite(LED_BUILTIN, LOW);
  publish("homesens/power/sum_watt", String(final_watt[0] + final_watt[1] + final_watt[2],0));
  publish("homesens/power/L2_watt", String(final_watt[1],0));
  publish("homesens/power/L2_amp", String(final_amps[1],2));
  publish("homesens/power/L2_sensor_mV", String(final_mv[1],3));
  printlcd("[" + String(final_watt[0] + final_watt[1] + final_watt[2],0) + "] " + String(final_watt[2],0) + " " + String(final_watt[1],0) + " " + String(final_watt[0],0));
  digitalWrite(LED_BUILTIN, HIGH);
  
  readTrueWatt(2);
  digitalWrite(LED_BUILTIN, LOW);
  publish("homesens/power/sum_watt", String(final_watt[0] + final_watt[1] + final_watt[2],0));
  publish("homesens/power/L3_watt", String(final_watt[2],0));
  publish("homesens/power/L3_amp", String(final_amps[2],2));
  publish("homesens/power/L3_sensor_mV", String(final_mv[2],3));
  printlcd("[" + String(final_watt[0] + final_watt[1] + final_watt[2],0) + "] " + String(final_watt[2],0) + " " + String(final_watt[1],0) + " " + String(final_watt[0],0));
  digitalWrite(LED_BUILTIN, HIGH);

  // FINISH
}

Download Source Code

Angegeben ist nur die .ino Datei. Die Arduino IDE ist eine Zicke und will diese in einem Ordner haben, der genau dem Dateinamen entspricht.

Datenspeicherung und Darstellung

Das Gerät startet automatisch sobald es Strom bekommt. Wenn am Display etwas angezeigt wird, heißt es dass alle Verbindungen stehen und es sendet. An der User-LED kann man erkennen dass es misst und die Daten an den lokale MQTT Broker verschickt.

MQTT

Mit dem MQTT Explorer hat man einen Live Überblick über alles was von diesem Gerät daher kommt. Man kann sich sogar hübsche Graphen zeichnen lassen um auf dem ersten Blick zu sehen, ob alles passt.

Datenbank

Wenn man die Daten in einer Datenbank mitschreibt, kann man sich mit Grafana hübsche Graphen zeichnen lassen. In der Vergangenheit hat das ein Python Script gemacht, das 24/7 gelaufen ist und über MQTT auf bestimmte Topics gelauscht hat. Mittlerweile macht das Node-RED.

Liefert alle 1.5 Sekunden Daten seit April 2021. Mittlerweile fasse ich sie zusammen und speichere alle 5 Sekunden.

1.6 Millionen Datensätze kommen auf 104 Megabyte. Speicherplatz kostet ja nichts mehr, richtig? (Stand März 2024)

Grafana

Ein normaler Tag. In der Früh wird Kaffee gemacht, zu Mittag kurz was aufgewärmt. Am frühen Abend wird der 3D Drucker für eine Stunde gestartet, dann wird gekocht. Und zur Prime Time wird ein wenig gezockt. Währenddessen läuft der Laptop samt Bildschirm. Die Baseline ist der Kühlschrank, Server und alles was man sonst zum Leben braucht.

Ach wenns keine TÜV kalibrierten Werte sind, für ein kleines Projekt definitiv ein Win!

Und wenn ma lustig ist, dann macht man während einer kleinen LAN Party ein Timelapse Video und vergleicht den Stromverbrauch Graph mit dem was sich so abspielt.

Fazit

• Die Spannung zur Leistungsmessung ist Hardcoded, könnte man direkt messen und aktuelle Werte zur Berechnung miteinbeziehen.
• Ab und zu sollte man die SCT013 auf Null kalibrieren. Das könnte in die Software eingebaut werden. TARA zum Beispiel.
• Wenn die Spannung klein ist, dann rauschen die Messwerte und verfälschen das Ergebnis.
• Bei großen Lasten recht genau.
• Würde ich das Projekt heute neu angehen, wäre der Code viel aufgeräumter! Wiiiiirklich!!!