Introduction: Arduino Energiezähler Für Solaranlage
Herzlich Willkommen =)
In diesem Projekt möchte ich euch zeigen wie Ihr einen Arduino Energiezähler für eine Solaranlage bauen könnt.
Die Excel Datei mit der Übersicht und Beschreibung des Projektes, den Arduino Quellcode sowie die Excel Datei zur Auswertung der LogFiles könnt Ihr euch auf der folgenden Seite downloaden:
Step 1: Einleitung
In diesem Video erhaltet Ihr eine Übersicht über den Umfang des Projektes.Ihr erhaltet einen kurzen Einblick in den Aufbau und die Funktion des fertigen Energiezählers und der Daten-Auswertung.
Step 2: Teile Und Theorie
In diesem Video wird gezeigt welche Bauteile wir benötigen.Des weiteren wird kurz auf die zugrunde liegenden theoretischen Formeln für die Berechnungen eingegangen, aus denen sich die zu messenden Größen ableiten lassen.
------------------------------------------------------------
Benötigte Teile:
- Arduino Uno Rev.3
- Mikrocontroller Board
- SD Karten-Leser Modul SPI SD TF
- Stromsensor ACS712 20A Range Modul Current Sensor f. Arduino Bascom Projekte
- BreadBoard
- LCD Display
- Jumper Wires
- Widerstände (2x45kOhm, 2x10kOhm)
- Potentiometer
- SD Karte
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]
Step 3: Teile Und Theorie
Step 4: Spannung Messen
In diesem Video wird erklärt wie wir die Spannung des Solar-Moduls und der Batterie mit Hilfe eines Voltage-Divider mit Arduino messen können.
------------------------------------------------------------------
Arduino kann nur bis max 5V messen. (Vout) Da Solaranlage bis zu 21,5V (Vin - Leerlaufspannung) liefern kann muss die Spannung vor dem Messen mithilfe eines Voltage Divider verringert werden.
Vin 21,5 V (entspricht Voc des Solarpanels)
Z1 45000 Ohm
Z2 10000 Ohm
Vout 3,909091 V
Vin/Vout 5,5
--> Z1 = 45 kOhm und Z2 = 10 kOhm gewählt
(je näher Vout an 5 V liegt, desto höher wird die Auflösung der Messung)
(je höher die Widerstände gewählt werden, desto geringer werden die Verluste durch Abwärme)
Arduino Kalibrierung: Um den von der Arduino gemessenen Wert in die ursprüngliche Spannung umzurechnen muss zuerst das Arduino Signal bei einer bekannten Spannung gemessen werden:
Vbatterie 4 bekannte Eingangsspannung der Batterie [V]
Vin/Vout 5,500 Verhätniss zwischen Eingangs- und gemessener Spannung
Vin 0,727273 berechnete Spannung an der Arduino (Vin = Vbatterie * Vout / Vin)
150,9 gemessenes Arduino Signal [#]
Faktor 0,00482 V/#
4,820 mV/# Umrechnungfaktor von Arduino Signal auf gemessene Spannung
Arduino loop() Code:
um das Eingangssignal zu glätten wird die Messung von sampleV 250 mal im Abstand von 5ms durchgeführt, und anschließend mit dem Mittelwert weiter gerechnet. Der gesamte Quellcode ist in Abschnitt 9 zu finden. Die Spannung wird an zwei Stellen gemessen. 1: Spannung des Solar Panels zur Berechnung der momentanen Leistung und gesamt Arbeit und 2: Spannung der Batterie als Anzeige des Ladungszustandes.
Step 5: Spannung Messen
Step 6: Spannung Messen
Step 7: Strom Messen
In diesem Video wird erklärt wie wir den Strom des Solar Moduls mit Hilfe eines ASC 712 Sensors mit Arduino messen können.
---------------------------------------------------------
Arduino Kalibrierung:
Spannung zu Stromstärke aus Datenblatt
A / V / Arduino Signal [#]
25 / 5 / 1027
0 / 2,5 / 513,5 <--Arduino Signal bei 0 A und 2,5 V aus Arduino gemessen
-25 / 0 / 0
0,1 V/A
20,54 #/A Umrechnungfaktor von Arduino Signal auf gemessene Stromstärke
Arduino loop() Code:
um das Eingangssignal zu glätten wird die Messung von sampleA 250 mal im Abstand von 5ms durchgeführt, und anschließend mit dem Mittelwert weiter gerechnet. Der gesamte Quellcode ist in Abschnitt 9 zu finden.
Step 8: Strom Messen
Step 9: Strom Messen
Step 10: Zeit, Berechnung, SD, LCD
In diesem Video wird erklärt wie wir die Zeit bestimmen und die Berechnungen durchgeführt werden. Des weiteren wird erklärt wie die Daten auf der SD Karte gespeichert werden um sie Später mit Excel auswerten zu können und wie wir die wichtigsten Kennzahlen unserer Solaranlage auf einem LCD Display anzeigen können.
----------------------------------------------------------------------
5) Zeit messen
die vergangene Zeit wird aus der aktuellen Laufzeit der Arduino minus der gespeicherten Laufzeit der Arduino des vorhergehenden Berechnungszyklus berechnet. Der gesamte Quellcode ist in Abschnitt 9 zu finden.
6) Berechnung
Leistung in Watt als aktuelle Spannung mal dem aktuellen Strom Arbeit in Kilowattstunden als vorhergehender Wert plus der Leistung mal der Zeitdifferenz geteilt durch 3600 Sekunden pro Stunde und durch 1000 als umrechnung von Wh in kWh Der gesamte Quellcode ist in Abschnitt 9 zu finden.
7) SD Output
SD Karte als FAT32 formatieren
Im setup() Teil des Arduino Code muss die SD Karte
zunächst initialisiert werden. Anschließend wird der Tabellen Header im Logfile eingetragen. Im loop() Teil des Code wird geprüft ob sich der Strom oder Spannungswert der aktuellen Messung außerhalb der Grenzwerte liegt. Wenn ja, dann werden die aktuellen Daten auf der SD Karte gespeichert. Die gespeicherten Werte können in Excel ausgewertet werden. Der gesamte Quellcode ist in Abschnitt 9 zu finden.
8) LCD Output
im setup Teil des Arduino Code wird zuerst Pin 10 als
ChipSelect Pin gesetzt und Pin 9 als Output Pin um die Backlight intensität zu steuern und die Display Größe definiert im loop Teil werden nach jeder Berechnung die aktuellen Messwerte ausgegeben. der gesamte Quellcode befindet sich in Abschnitt 9)
Step 11: Zeit, Berechnung, SD, LCD
Step 12: Zeit, Berechnung, SD, LCD
Step 13: Zeit, Berechnung, SD, LCD
Step 14: Zeit, Berechnung, SD, LCD
Step 15: Arduino Quellcode
In diesem Video gehen wir Schritt für Schritt durch den gesamten Arduino Quellcode.Dabei sehen wir welche Bibliotheken und Variablen verwendet werden und wie wir die Eingangswerte der Analog Pins einlesen und in die Werte für Spannung und Strom umrechnen. Des weiteren sehen wir wie die Berechnung der Leitung und Arbeit durchgeführt wird und wie die Ergebnisse auf der SD Karte gespeichert und im seriellen Output sowie dem LCD Display ausgegeben werden.
------------------------------------------------------------------------
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);
}
Step 16: Anschluss an Solaranlage
In diesem Video wird erklärt wie der Energiezähler an die Solaranlage angeschlossen wird.
------------------------------------------------------------
10) Anschluss an Solaranlage
Nach dem vollständigen zusammenbau muss der Zähler nurnoch an die Solaranlage angeschlossen werden. In diesem Beispiel Fall wird die Spannung des Solar Moduls sowie der Strom des angeschlossenen Moduls gemessen. Dafür werden die mit "Spannung +" und "Spannung -" gekennzeichneten Kabel an die jeweiligen Kontaktpunkte am Charge Controller angeschlossen. Das mit "Solar zu ACS" gekennzeichnete Kabel wird an das negative, von der Solaranlage kommende Kabel angeschlossen und anschließend das mit "ACS zu Charge Controller" gekennzeichnete Kabel an den Minus Pol für das Solar Panel an dem Charge Controller angeschlossen.
Step 17: Anschluss an Solaranlage
Step 18: Anschluss an Solaranlage
Step 19: Anschluss an Solaranlage
Step 20: Energie Daten Auswertung
In diesem Video sehen wir wie die auf der SD Karte gespeicherten Energie Daten der Solaranlage mit Hilfe eines Makros in Excel ausgewertet werden können.
----------------------------------------------------------------------------------
11) Auswertung
1) CSV Datei von SD Karte mit dem Namen "LOGFILE.csv" in gleichem Ordner wie "Auswertung.xlsm" Excel Datei ablegen
2) "Auswertung.xlsm" öffnen und auf "Aktualisierung" klicken
Das Makro welches die Auswertung durchführt besteht hauptsächlich aus 3 Teilen:
1/3) importData
importiert die Zeit- Spannungs- und Stromdaten aus der "LOGFILE.csv" Datei in das "Daten" Tabellenblatt der "Auswertungs.xlsm" Datei
2/3) processData
in diesem Abschnitt werden die Berechnungen durchgeführt
zuerst werden dabei die Spaltenüberschrifter der berchneten Spalten eingefügt
anschließend werden in der ersten Schleife alle aus der csv Datei importierten Überschriftszeilen gelöscht die zwischen den Daten stehen
in der zweiten Schleife werden dann die folgenden Werte berechnet:
Zeitdifferenz in Sekunden als aktuelle cvs Zeit minus der vorhergehenden cvs Zeit
Zeitstempel in Sekunden als alter Zeitstempel plus der aktuellen Zeitdifferenz (fortlaufende, eindeutige ID als Wert für die X-Achse des Diagramms)
Leistung in Watt als aktuelle Spannung mal dem aktuellen Strom
Arbeit in Kilowattstunden als Leistung mal der Zeitdifferenz geteilt durch 3600 Sekunden pro Stunde und durch 1000 als umrechnung von Wh in kWh
Spannung der Batterie [V] als gemesse Spannung [mV] / 1000
3/3) updateCharts
aktualisiert die Datenbereiche der beiden Datenreihen im Diagramm im "Auswertung" Tabellenblatt
Step 21: Energie Daten Auswertung
Participated in the
Solar Contest 2017
