|
http://sites.schaltungen.at/arduino-uno-r4/impulszaehler/energiezaehler Wels, am 2019-05-10BITTE nützen Sie doch rechts OBEN das Suchfeld [ ] [ Diese Site durchsuchen]DIN A3 oder DIN A4 quer ausdrucken
*******************************************************************************I** DIN A4 ausdrucken (Heftrand 15mm / 5mm) siehe http://sites.schaltungen.at/drucker/sites-prenninger
********************************************************I* ~015_b_PrennIng-a_arduino.uno.r4-impulszaehler-energiezaehler (xx Seiten)_1a.pdf
5.7 Energie-Verbrauchsmesser
In diesem Projekt bestimmen wir mit einem digitalen Energiezähler, wieviel Wirkleistung momentan bezogen wird. Ein digitaler Stromzähler besitzt auf seiner Frontseite eine blinkende LED.
Diese LED hat die Aufgabe der runden Drehscheibe in mechanischen Zählern übernommen:
Sie können sehen, wieviel Energie gerade bezogen wird.
Die Blinkfrequenz ist ein Maß für den Strom:
Je schneller die LED blinkt, desto teurer wird es.
Einmal Ein- und Ausschalten der LED wird imp genannt.
Auf dem Typenschild oder auch auf der Frontseite ist zu lesen, welche Energie einem imp entspricht.
In der Abbildung entspricht 1 imp dem Energieumsatz von 1 Wh.
Wenn die LED also einmal pro Stunde blinkt, so entspricht das einer Leistung von 1Wh.
Bei Ihrem Energiezähler kann das Verhältnis unterschiedlich sein, dann müssen Sie den Sketch anpassen.
Type Nr: ISKRA ME161-D1A52-V12G12-KO
AC - 1 Phase 2 Wire
Type: ME161-D1A52-V12G12-KO 230V 10{85)A 50 Hz Conn. IS10319 Cl. 2
_| |_ 1 Imp = 1Wh
https://www.zelfenergieproduceren.nl/wp-content/uploads/2017/10/2017-8099-Handleiding-ISKRA-ME161-elektriciteitsmeter.pdf
z.B bei diesem Energiezähler entspricht 1 imp 1 Wh.
Um den aktuellen Energiebedarf zu ermitteln, zählen wir über ein Intervall von einer Sekunde, wie oft die LED blinkt.
Dies rechnen wir um nach imp/Stunde und erhalten damit die gelieferte Energie in Watt.
Zunächst detektieren wir mit dem LDR, wann die LED leuchtet und wann nicht.
Wir wollen diese Messung selbstkalibrierend durchführen, damit es nichts ausmacht, ob man im Zähler-Raum das Licht einschaltet oder nicht.
Dazu ziehen wir das Prinzip des Kinderzimmer-Lichtalarms heran, wobei wir diesmal die LED am Arduino nicht nur ein-, sondern auch wieder ausschalten.
if (value>threshold+20){
digitalWrite(led, HIGH); t++;
}
if (value<threshold-20){
digitalWrite(led, LOW);
}
threshold=value;
delay(100);
Der Zähler wird erhöht, wenn die LED eingeschaltet wird.
Dies ist nicht zuverlässig.
Angenommen, wir messen genau dann, wenn die LED des Energiezählers aufleuchtet und es gerade ausreichend ist, um über die Schwelle+20 zu kommen.
Der Zähler wird um 1 erhöht. Bei der folgenden Messung leuchtet die LED des Energiezählers inzwischen vollständig.
Der Wert liegt wieder über der (neuen) Schwelle+20, also zählen wir den gleichen imp fälschlicherweise noch einmal.
Das war auch beim Kinderzimmer-Lichtalarm schon so, doch dort hat es uns nichts ausgemacht.
Die Lösung ist, eine neue Variable mit dem Namen state zu verwenden, die wir auf true setzen, wenn der Sketch ein imp erkannt hat, und auf false, wenn die LED zwischen den imps verlischt.
So zählt der Sketch fehlerlos.
if (value>threshold+20){
digitalWrite(led, HIGH); if (state==false){ t++; state=true; } } if (value<threshold-20){ digitalWrite(led, LOW); state=false;
}
threshold=value;
delay(100);
Wir wollen eine Minute messen.
Dazu setzen wir den Befehl millis() ein, der die Millisekunden seit Start des Arduinos misst. millis() wird in jedem Programmdurchlauf mit der Variablen startT gleichgesetzt.
Dann wird in der Schleife verglichen, ob schon 60.000 Millisekunden (1 Minute) verstrichen sind.
Wenn dem so ist, wird die Energie berechnet und der Wert im HyperTerminal des PC angezeigt.
// pruefen, ob 1 Minute (60000 ms) verstrichen ist
if (millis()>startT+60000){ // Daten zum PC senden Serial.write(27); Serial.print("[7;38H"); Serial.print(t*60); Serial.print(" W "); // Timer neu starten startT = millis(); t = 0;
}
Ein kleines Problem: Nach ungefähr 50 Tagen ist die Variable millis() "voll" und läuft über (overflow) auf null. Die allerletzte Minute kann also niemals beendet werden. Wenn millis() plötzlich kleiner ist als startT, ist die Variable offensichtlich übergelaufen. Der Sketch setzt dann startT zurück und beginnt die Zählung von neuem. Der Sketch arbeitet gut, verpasst aber alle 50 Tage 1 Minute. Es kann übrigens auch passieren, dass wegen der Autokalibrierung der allererste imp verpasst wird.
// auf overflow ueberpruefen
if (millis()<startT){ startT = millis(); t = 0; }
Es dauert eine Minute, bevor sich im HyperTerminal etwas tut, und der Anwender könnte schon misstrauisch werden, ob der Sketch überhaupt läuft. Deshalb bauen wir einen einfachen Indikator (x, o) ein, der bei jedem Programmdurchlauf abwechselnd eingeschaltet wird. Dazu setzen wir eine Variable run ein.
if (run==true){
Serial.print("o"); run=false; } else{ Serial.print("x"); run=true; }
Der Rest des Sketches zeigt keine Besonderheiten. Denken Sie daran, dass millis() mit großen Zahlen arbeitet und genau wie die Variable startT eine unsigned long Variable sein muss!
int ldr = A2;
int led = 2; int threshold=1023, value, t, state=false, run=false; unsigned long startT;
void setup() {
Serial.begin(9600); Serial.write(27); Serial.print("[3;10H"); Serial.print("- ===[ Energy Monitor ]=== "); Serial.write(27); Serial.print("[10;10H"); Serial.print("Running "); Serial.write(27); Serial.print("[7;10H");
Serial.print("Current energy consumption ");
pinMode(led, OUTPUT); startT=millis(); }
void loop() {
// Lichtniveau messen value = analogRead(ldr);
// Blinken notieren
if (value>threshold+20){ digitalWrite(led, HIGH); if (state==false){ t++; state=true; } } if (value<threshold-20){ digitalWrite(led, LOW); state=false; } threshold=value; delay(100);
// Betrieb des Sketches anzeigen
Serial.write(27); Serial.print("[10;18H"); if (run==true){ Serial.print("o"); run=false; } else{ Serial.print("x"); run=true; }
// pruefen, ob 1 Minute (60000 ms) verstrichen ist
if (millis()>startT+60000){ // Daten zum PC senden Serial.write(27); Serial.print("[7;38H"); Serial.print(t*60); Serial.print(" W "); // restart the timer startT = millis();
t = 0;
} // auf overflow ueberpruefen if (millis()<startT){ startT = millis(); t = 0; } }
Wir verwenden die Hardware aus dem letzten Projekt.
Platzieren Sie den LDR direkt an der LED des Energiezählers, wie im Bild zu sehen.
Bild 39. Der Arduino vor der LED des Energiezählers.
Sie werden bestimmt staunen, was alles an ist, wenn doch scheinbar alles aus ist!
Denken Sie nur an die Elektronik der Heizung, an Geräte im Stand-by-Betrieb, an die Klimaanlage oder den Router.
--- ==== [ Energy Monitor ] === ---
Current energy consumption 1920 W Running o_
Quelle:
BUCH: Arduino entdecken Seite 79
Infrarot Lichtschranke mit Arduino zum Auslesen des Stromzählers
Elektromagnetische Ferraris-Stromzähler kommen noch in vielen Haushalten zur Verbrauchsmessung zum Einsatz. Sie besitzen keine direkte Schnittstelle zur elektronischen Datenerfassung. Auf der anderen Seite hilft jedoch eine präzise und minutengenaue Erfassung des Stromverbrauchs beim Energiesparen, da sich so Standbyverbrauch und Lastspitzen besser analysieren lassen. Eine Möglichkeit, dennoch an diese Daten zu kommen, besteht in der optoelektronischen Abtastung der Zählscheibe. Die Signalerfassung erledigt dabei ein Arduino Nano.
Quelle:
https://www.kompf.de/tech/emeir.html
Arduino Energiezähler Für Solaranlage
Benötigte Teile:
Theorie: Arbeit [Ws] = Leistung [W] * Zeit [s] (W=P ∙t) Leistung [W] = Spannung [V] * Stromstärke [A] (P=U ∙I) --> folgende Größen müssen gemesen werden: 1) Zeit [s] 2) Spannung [V] 3) Stromstärke [A]
9) Vollständiger Arduino Code #include #include #include LiquidCrystal lcd(8, 7, 6, 5, 4, 3, 2); // Variablen float fSampleA = 0.0; // Strom Wert float fAmperage = 0.0; // Stromstärke float fAmperageOld = 0.0; // Stromstärke der vorhergehenden Berechnung(en) float fSampleV = 0.0; // Spannungs Wert float fVoltage = 0.0; // Spannung float fVoltageOld = 0.0; // Spannung der vorhergehenden Berchnung(en) float fSampleVBat = 0.0; // Spannungs Wert Batterie float fVoltageBat = 0.0; // Spannung Batterie float fVoltageOldBat = 0.0; // Spannung Batterie der vorhergehenden Berchnung(en) long lTime = 0; // aktuelle Zeit long lTimeOld = 0; // Zeit des vorhergehenden Berechnungszyklus float fPower = 0.0; // Leistung float fEnergy = 0.0; // Arbeit berechnen
void setup()
{ Serial.begin(9600); // initialize SD Card if (!SD.begin(10)) { Serial.println("card initialization failed"); return; }
Serial.println("card initialization successfull");
File logFile = SD.open("logFile.csv", FILE_WRITE); if(logFile) // write table header
{
logFile.println("Zeit [ms]; Stromstaerke [mA]; Spannung [mV]; Spannung Bat [mV]"); Serial.println("Zeit [ms]; Stromstaerke [mA]; Spannung [mV]; Spannung Bat [mV]; Leistung [W]; Arbeit [Wh]; extra Variable [#]"); logFile.close(); } // initialize LCD display pinMode(9, OUTPUT); //pin 9 as output analogWrite(9, 35); // set output of pin 9 (backlight intensity 0-254) lcd.begin(16,2); // display size (columns, rows) }
void loop()
{ // Strom und Spannungs Eingangssignal ermitteln for(int i = 0; i < 250; i++) { fSampleA = fSampleA + analogRead(A3); // Strom fSampleV = fSampleV + analogRead(A2); // Spannung fSampleVBat = fSampleVBat + analogRead(A4); // Spannung Batterie delay(5); }
fSampleA = fSampleA / 250.0;
fSampleV = fSampleV / 250.0; fSampleVBat = fSampleVBat / 250.0; lTime = millis(); // Arduino Laufzeit in ms // Berechnungen fAmperage = (fSampleA - 513.5) / 20.54 * (-1.0); // Stromstärke [A] berechnen fVoltage = 5.5 * 4.82 * fSampleV / 1000.0; // Spannung [V] berechnen fVoltageBat = 5.5 * 4.82 * fSampleVBat / 1000.0; // Spannung Batterie [V] berechnen fPower = fVoltage * fAmperage; // Leistung [W] berechnen fEnergy += fPower * (lTime - lTimeOld) / 1000.0 / 3600.0; // Arbeit [Wh] berechnen lTimeOld = lTime; // alte Zeit speichern // Zeit, Strom und Spannung zu Ausgabestring hinzufuegen String dataString = ""; dataString += String(lTime) + ";"; // Zeit [ms] dataString += String(fAmperage * 1000.0) + ";"; // Stromstaerke [mA] dataString += String(fVoltage * 1000.0) + ";"; // Spannung [mV] dataString += String(fVoltageBat * 1000.0); // Spannung Batterie [mV] // Daten auf SD Karte speichern wenn Grenzwert im Vergleich zur vorhergehenden Messung ueber- / unterschritten wird if(fAmperage > fAmperageOld + 0.025 || fAmperage < fAmperageOld - 0.025 || fVoltage > fVoltageOld + 0.015 || fVoltage < fVoltageOld - 0.015 || fVoltageBat > fVoltageOldBat + 0.015 || fVoltageBat < fVoltageOldBat - 0.015) { fAmperageOld = fAmperage; fVoltageOld = fVoltage; fVoltageOldBat = fVoltageBat; File logFile = SD.open("logFile.csv", FILE_WRITE); if(logFile) { logFile.println(dataString); logFile.close(); } else { Serial.println("could not save data to file"); } } // Energie, Arbeit und extra Variable zu Ausgabestring ergaenzen dataString += ";" + String(fPower) + ";"; // Leistung [W] dataString += String(fEnergy) + ";"; // Arbeit [Wh] dataString += String(fSampleVBat); // extra Variable [#] // serielle Ausgabe Serial.println(dataString); //LCD Ausgabe lcd.clear(); lcd.setCursor(0,0); lcd.print("B" + String(fVoltageBat) + "V P" + String(fPower) + "W"); lcd.setCursor(0,1); lcd.print("Ges " + String(fEnergy) + "Wh"); // naechste Messung um 5s verzögern delay(5000); } Quelle:
https://github.com/GermanEngineering/ArduinoEnergiezaehler
https://trustmeimanengineer.de/arduino-energiezaehler/
https://www.instructables.com/id/Arduino-Energiez%C3%A4hler-F%C3%BCr-Solaranlage/
DIN A4 ausdrucken
********************************************************I*
Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:[email protected]ENDE |
Impulszähler >
