ARDUINO ENERGIEMESSER - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:20

[Video abspielen]

Ich gehöre zu einem Dorf in Odisha, Indien, wo häufige Stromausfälle sehr üblich sind. Es behindert das Leben eines jeden. In meiner Kindheit war das Weiterstudium nach Einbruch der Dunkelheit eine echte Herausforderung. Aufgrund dieses Problems habe ich versuchsweise eine Solaranlage für mein Zuhause entworfen. Ich habe ein Solarpanel von 10 Watt, 6V verwendet, um einige helle LEDs zu beleuchten. Nach vielen Strapazen war das Projekt erfolgreich. Dann beschloss ich, die Spannung, den Strom, die Leistung und die Energie des Systems zu überwachen. Daraus entstand die Idee, ein ENERGIEMESSER zu entwerfen. Ich habe ARDUINO als Herzstück dieses Projekts verwendet, da es sehr einfach ist, Code in seiner IDE zu schreiben und im Internet eine große Anzahl von Open-Source-Bibliotheken verfügbar sind, die gemäß den Anforderung. Ich habe das Projekt für ein Solarsystem mit sehr kleiner Nennleistung (10Watt) ausprobiert, aber dies kann leicht geändert werden, um es für ein System mit höherer Leistung zu verwenden.

Alle meine Projekte finden Sie auf:

Feature: Energieüberwachung durch 1. LCD-Display 2. über Internet (Xively Upload) 3. Datenprotokollierung auf einer SD-Karte

Sie können meinen neuen anweisbaren ARDUINO MPPT SOLAR CHARGE CONTROLLER (Version-3.0) sehen

Sie können auch meine anderen instructables auf sehen

ARDUINO SOLARLADECONTROLLER (Version 2.0)

ARDUINO SOLARLADECONTROLLER (Version-1)

Schritt 1: Erforderliche Teile:

1. ARDUINO UNO (Amazon)2. ARDUINO ETHERNET SHIELD (Amazon)

3. 16x2 ZEICHEN LCD (Amazon)

4. ACS 712 STROMSENSOR (Amazon)4. WIDERSTAND (10k, 330ohm) (Amazon)5. 10K POTENTIOMETER (Amazon)6. ÜBERBRÜCKUNGSDRÄHTE (Amazon)7. ETHERNET-KABEL (Amazon)8. BROTPLATTE (Amazon)

Schritt 2: Leistung und Energie

Leistung: Leistung ist Produkt aus Spannung (Volt) und Strom (Amp) P=VxI Leistungseinheit ist Watt oder KWEEnergie: Energie ist Produkt aus Leistung (Watt) und Zeit (Stunde) E= Pxt Energieeinheit ist Wattstunde oder Kilowatt Stunde (kWh) Aus der obigen Formel ist klar, dass wir zur Messung von Energie drei Parameter benötigen: 1. Spannung 2. Strom 3. Zeit

Schritt 3: Spannungsmessung

Die Spannung wird mit Hilfe einer Spannungsteilerschaltung gemessen. Da die Eingangsspannung des analogen ARDUINO-Pins auf 5 V begrenzt ist, habe ich den Spannungsteiler so konzipiert, dass die Ausgangsspannung weniger als 5 V betragen sollte Die Leistung des Solarpanels beträgt 6 V, 5,5 Ah. Also muss ich diese 6,5 V auf eine Spannung von weniger als 5 V reduzieren. Ich habe R1 = 10k und R2 = 10K verwendet. Der Wert von R1 und R2 kann niedriger sein, aber das Problem besteht darin, dass bei niedrigem Widerstand ein höherer Strom fließt, wodurch eine große Menge an Leistung (P = I^2R) in Form von Wärme abgegeben wird. So können unterschiedliche Widerstandswerte gewählt werden, aber es sollte darauf geachtet werden, den Leistungsverlust über den Widerstand zu minimieren. Vout=R2/(R1+R2)*Vbat Vbat=6.5 bei voller Ladung R1=10k und R2=10k Vout=10/(10+10)*6.5=3.25v was niedriger als 5v ist und für ARDUINO analog pinHINWEIS I Ich habe gezeigt, dass eine 9-Volt-Batterie in freigelegter Platine nur zum Anschließen der Drähte dient. Die tatsächliche Batterie, die ich verwendet habe, ist jedoch eine 6-Volt-, 5,5-Ah-Blei-Säure-Batterie. Spannungskalibrierung: Wenn die Batterie vollständig geladen ist (6,5 V), erhalten wir a Vout = 3,25 V und niedrigerer Wert für andere niedrigere Batteriespannung. AEDUINO ADC wandeln analoges Signal in entsprechende digitale Näherung um. Wenn die Batteriespannung 6,5 V beträgt, habe ich 3,25 V vom Spannungsteiler und Sample1 = 696 im seriellen Monitor erhalten, wobei Sample1 dem ADC-Wert entspricht 3,25 V Zum besseren Verständnis habe ich die Echtzeitsimulation von 123D.circuit für die Spannungsmessung angehängt Kalibrierung: 3,25 V entspricht 696 1 entspricht 3,25/696 = 4,669 mv Vout = (4,669 * Sample1) / 1000 Volt Tatsächliche Batteriespannung = (2 * Vout) VoltARDUINO CODE: // 150 Abtastungen vom Spannungsteiler mit einem Intervall von 2 Sekunden nehmen und dann den Durchschnitt der gesammelten Stichprobendaten für(int i=0;i<150;i++) { sample1=sample1+analogRead(A2); // die Spannung von der Teilerschaltungsverzögerung lesen (2); } Probe1 = Probe1/150; Spannung = 4,669*2*Probe1/1000;

Schritt 4: Strommessung

Für die Strommessung habe ich einen Hall-Effekt-Stromsensor ACS 712 (20 A) verwendet. Es gibt verschiedene ACS712-Sensoren im Strombereich auf dem Markt, wählen Sie also nach Ihren Anforderungen. Im Steckbrettdiagramm habe ich LED als Last gezeigt, aber die tatsächliche Last ist anders. FUNKTIONSPRINZIP: Der Hall-Effekt ist die Erzeugung einer Spannungsdifferenz (der Hall-Spannung) über einem elektrischen Leiter, quer zu einem elektrischen Strom im Leiter und ein Magnetfeld senkrecht zum Strom. Um mehr über Hall-Effekt-Sensoren zu erfahren, klicken Sie hier Das Datenblatt des ACS 712-Sensors finden Sie hier Ab Datenblatt 1. ACS 712 misst positive und negative 20 Ampere, entsprechend dem Analogausgang 100 mV/A 2. VCC / 2 = 5 V / 2 = 2,5 V Kalibrierung: Analoges Lesen erzeugt einen Wert von 0-1023, entspricht 0 V bis 5 V Also Analoges Lesen 1 = (5/1024) V = 4,89 mv Wert = (4,89 * Analoger Lesewert)/ 1000 V Aber laut Datenblatt beträgt der Offset 2,5 V (Wenn der Strom Null ist, erhalten Sie 2,5 V vom Ausgang des Sensors) Istwert = (Wert-2,5) V Strom in Ampere = Istwert * 10ARDUINO CODE: // 150 Abtastungen von Sensoren mit einem Intervall von 2 Sekunden und dann den Durchschnitt der gesammelten Probendaten für (int i=0;i<150;i++) { sample2+=analogRead(A3); // den Strom von der Sensorverzögerung lesen (2); } Probe2 = Probe2/150; val = (5,0 * Probe2)/1024,0; Istwert = Wert – 2,5; // Offsetspannung beträgt 2,5 V Ampere = Istwert * 10;

Schritt 5: Zeitmessung

Für die Zeitmessung ist keine externe Hardware erforderlich, da ARDUINO selbst über einen eingebauten Timer verfügt. Die Funktion millis () gibt die Anzahl der Millisekunden zurück, seit das Arduino-Board mit der Ausführung des aktuellen Programms begonnen hat. ARDUINO CODE: long milisec = millis (); // Zeit in Millisekunden berechnen long time=milisec/1000; // Millisekunden in Sekunden umwandeln

Schritt 6: Wie ARDUINO Leistung und Energie berechnet

totamps = totamps + Ampere; // Gesamtampere berechnen avgamps=totamps/time; // durchschnittliche Ampere Amphr = (avgamps * time)/3600; // Ampere-Stunde Watt = Spannung * Ampere; // Leistung = Spannung * aktuelle Energie = (Watt * Zeit) / 3600; Watt-Sek wird wieder in Watt-Hr umgewandelt, indem 1 Stunde (3600 Sekunden) // Energie = (Watt * Zeit) / (1000 * 3600) geteilt wird; zum Ablesen in kWh

Schritt 7: Visuelle Ausgabe

Alle Ergebnisse können auf dem seriellen Monitor oder mit einem LCD visualisiert werden. Ich habe ein 16x2-Zeichen-LCD verwendet, um alle in den vorherigen Schritten erhaltenen Ergebnisse anzuzeigen. Für Schaltpläne siehe die oben gezeigte Brotplatinenschaltung. Verbinden Sie das LCD mit ARDUINO wie unten angegeben: LCD -> Arduino 1. VSS -> Arduino GND 2. VDD - > Arduino +5v 3. VO -> Arduino GND-Pin + Widerstand oder Potentiometer 4. RS -> Arduino-Pin 8 5. RW -> Arduino-Pin 7 6. E -> Arduino-Pin 6 7. D0 -> Arduino - Nicht verbunden 8 D1 -> Arduino - Nicht verbunden 9. D2 -> Arduino - Nicht verbunden 10. D3 -> Arduino - Nicht verbunden 11. D4 -> Arduino Pin 5 12. D5 -> Arduino Pin 4 13. D6 -> Arduino Pin 3 14. D7 -> Arduino Pin 2 15. A -> Arduino Pin 13 + Widerstand (Hintergrundbeleuchtung) 16. K -> Arduino GND (Hintergrundbeleuchtung Masse)ARDUINO CODE: Für seriellen Monitor:

Serial.print ("SPANNUNG:"); Serial.print (Spannung); Serial.println ("Volt"); Serial.print ("AKTUELL:"); Serial.print (Ampere); Serial.println ("Ampere"); Serial.print ("LEISTUNG:"); Serial.print (Watt); Serial.println("Watt"); Serial.print ("ENERGIEVERBRAUCH:"); Serial.print (Energie); Serial.println ("Wattstunde"); Serial.println(""); // die nächsten Parametersätze nach einer Leerzeilenverzögerung ausgeben (2000); Für LCD: Für LCD-Anzeigen müssen Sie zuerst die Bibliothek "LiquidCrystal" in den Code importieren. Um mehr über die LequidCrystal-Bibliothek zu erfahren, klicken Sie hier Für das LCD-Tutorial klicken Sie hier Der folgende Code ist ein Format, um alle Berechnungen für Leistung und Energie auf dem LCD anzuzeigen #include lcd(8, 7, 6, 5, 4, 3, 2); int backLight = 9; Void setup () { PinMode (backLight, OUTPUT); // Pin 9 als Ausgang setzen AnalogWrite (backLight, 150); // steuert die Intensität der Hintergrundbeleuchtung 0-254 lcd.begin (16, 2); // Spalten Reihen. Displaygröße lcd.clear(); // den Bildschirm löschen aufrechtzuerhalten. Void Schleife () {lcd.setCursor (16, 1); // setze den Cursor außerhalb der Anzeigeanzahl lcd.print (" "); // Leerzeichen ausgeben Verzögerung (600); ///////////////////////////////////////// Leistung und Energie auf einem LCD drucken/ ////////////////////////////////////////////// lcd.setCursor (1, 0); // setze den Cursor auf 1. Spalte und 1. Zeile lcd.print (Watt); lcd.print("W"); lcd.print (Spannung); lcd.print("V"); lcd.setCursor(1, 1); // setze den Cursor auf 1. Spalte und 2. Zeile lcd.print (Energie); lcd.print("WH"); lcd.print (Ampere); lcd.print("A"); }

Schritt 8: Hochladen von Daten auf Xively.com

Beziehen Sie sich zum besseren Verständnis auf die obigen Screenshots. Für das Hochladen von Daten auf xively.com muss zuerst die folgende Bibliothek heruntergeladen werden HttpClient: hier klickenXively: hier klickenSPI: Import von arduino IDE (Skizze -> Import Bibliothek…..)Ethernet: Import von arduino IDE ((Skizze -> Bibliothek importieren…..) Eröffnen Sie ein Konto bei https://xively.com (ehemals pachube.com und cosm.com)Melden Sie sich für ein kostenloses Entwicklerkonto an unter

Wählen Sie einen Benutzernamen, ein Passwort, legen Sie Ihre Adresse und Zeitzone fest usw. Sie erhalten eine Bestätigungs-E-Mail;

Klicken Sie dann auf den Aktivierungslink, um Ihr Konto zu aktivieren. Nach erfolgreicher Eröffnung des Kontos werden Sie zur Seite Entwicklungsgeräte weitergeleitet

• Klicken Sie auf das Feld +Gerät hinzufügen
• Geben Sie Ihrem Gerät einen Namen und eine Beschreibung (z. B. ENERGIEÜBERWACHUNG)·
• Wählen Sie private oder öffentliche Daten (ich wähle privat)·
• Klicken Sie auf Gerät hinzufügen

Nach dem Hinzufügen des Geräts werden Sie auf eine neue Seite umgeleitet, auf der viele wichtige Informationen zu finden sind

• Produkt-ID, Produktgeheimnis, Seriennummer, Aktivierungscode·
• Feed-ID, FeedURL, API-Endpunkt (Feed-ID wird im ARDUINO-Code verwendet)
• Kanäle hinzufügen (IWählen Sie ENERGY und POWER, aber Sie können nach Ihrer Wahl wählen)Geben Sie Einheit und Symbol für den Parameter an·
• Fügen Sie Ihren Standort hinzu ·
• API-Schlüssel (verwendet im ARDUINO-Code, vermeiden Sie es, diese Nummer zu teilen)·
• Trigger (Pingen einer Webseite, wenn ein Ereignis aufgetreten ist, z. B. wenn der Energieverbrauch ein bestimmtes Limit überschreitet)

Schritt 9: Xively und ARDUINO Code

Hier habe ich den vollständigen Code (Beta-Version) für den Energiezähler ohne SD-Karten-Datenprotokollierung angehängt, der im nächsten Schritt separat angehängt wird. /** Energiemonitoring-Daten hochladen zu xively **/ #include #include #include #include #define API_KEY "xxxxxxxx" // Geben Sie Ihren Xively API-Schlüssel ein #define FEED_ID xxxxxxxxx // Geben Sie Ihre Xively Feed-ID ein // MAC-Adresse für Ihre Ethernet-Schildbyte mac = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED}; // Analoger Pin, den wir überwachen (0 und 1 werden vom Ethernet-Shield verwendet) Int sensorPin = 2; unsigned long lastConnectionTime = 0; // letztes Mal, als wir uns mit Cosm verbunden haben const unsigned long connectionInterval = 15000; // Verzögerung zwischen der Verbindung mit Cosm in Millisekunden // Initialisieren der Cosm-Bibliothek // Definieren Sie den String für unsere Datenstrom-ID char sensorId = "POWER"; char sensorId2 = "ENERGIE"; XivelyDatastream datastreams = { XivelyDatastream(sensorId, strlen(sensorId), DATASTREAM_FLOAT), XivelyDatastream(sensorId2, strlen(sensorId2), DATASTREAM_FLOAT), DATASTREAM_FLOAT),}; // Wickeln Sie den Datenstrom in einen Feed ein XivelyFeed feed(FEED_ID, datastreams, 2 /* Anzahl der Datenströme */); EthernetClient-Client; XivelyClient xivelyclient(Client); Void setup () { Serial.begin (9600); Serial.println ("Netzwerk initialisieren"); while (Ethernet.begin(mac) != 1) { Serial.println("Fehler beim Abrufen der IP-Adresse über DHCP, erneuter Versuch…"); Verzögerung (15000); } Serial.println ("Netzwerk initialisiert"); Serial.println(); aufrechtzuerhalten. Void Schleife () { if (millis () - lastConnectionTime> connectionInterval) { sendData (); // Daten an xively senden getData(); // den Datenstrom von xively zurücklesen lastConnectionTime = millis(); // Verbindungszeit aktualisieren, damit wir warten, bevor wir uns erneut verbinden. aufrechtzuerhalten. aufrechtzuerhalten. Void sendData () { Int Sensor1 = Watt; int sensor2 = Energie; datastreams[0].setFloat(sensor1); // Leistungswert Datastreams [1].setFloat (sensor2); // Energiewert Serial.print ("Leistung lesen"); Serial.println (datastreams[0].getFloat()); Serial.print ("Energie lesen"); Serial.println (Datenströme [1].getFloat()); Serial.println ("Auf Xively hochladen"); int ret = xivelyclient.put(feed, API_KEY); Serial.print ("PUT-Rückgabecode: "); Serial.println (ret); Serial.println(); } // den Wert des Datenstroms von Xively abrufen und den erhaltenen Wert ausgeben void getData () { Serial.println ("Daten von Xively lesen"); int ret = xivelyclient.get(feed, API_KEY); Serial.print ("GET-Rückgabecode: "); Serial.println (ret); if (ret > 0) {Serial.print ("Datenstrom ist:"); Serial.println (feed [0]); Serial.print ("Leistungswert ist: "); Serial.println (feed[0].getFloat()); Serial.print ("Datenstrom ist: "); Serial.println (Feed[1]); Serial.print ("Energiewert ist: "); Serial.println (feed[1].getFloat()); } Serial.println();

Schritt 10: Datenprotokollierung auf einer SD-Karte

Um Daten auf einer SD-Karte zu speichern, müssen Sie die SD-Bibliothek importierenFür Tutorial hier klickenUm mehr über die SD-Bibliothek zu erfahren, klicken Sie hierDer Code zum Speichern von Daten auf einer SD-Karte wird separat geschrieben, da ich nachher nicht genügend Speicherplatz in meinem ARDUINO UNO habe Schreiben von Code für LCD-Display und Hochladen von Daten xively.com. Aber ich versuche, den Beta-Versionscode zu verbessern, damit ein einziger Code alle Funktionen enthalten kann (LCD-Anzeige, Xively-Daten-Upload und Datenspeicherung auf einer SD-Karte). Der Code für die Datenprotokollierung ist unten angehängt Besserer Code durch Ändern meines Codes bitte mit mir teilen. Dies ist meine erste technische Anleitung. Wenn jemand einen Fehler darin findet, können Sie gerne Kommentare abgeben oder sende mir eine Nachricht, damit das Projekt mächtiger wird. Ich denke, es wird sowohl für andere als auch für mich hilfreich sein.

Dritter Preis beim 123D Circuits Contest