ARDUINO ENERGI METER: 10 steg (med bilder)

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:45

[Spela filmen]

Jag tillhör en by Odisha, Indien där frekvent strömavbrott är mycket vanligt. Det hämmar varandras liv. Under mina barndomsdagar var det en riktig utmaning att fortsätta studera efter skymningen. På grund av detta problem konstruerade jag ett solsystem för mitt hem på experimentell basis. Jag använde en solpanel på 10 Watt, 6V för att tända några ljusa lysdioder. Efter många svårigheter blev projektet framgångsrikt. Sedan bestämde jag mig för att övervaka spänningen, strömmen, effekten och energin i systemet. Detta förde tanken på att designa ett ENERGI METER. Jag använde ARDUINO som hjärtat i detta projekt eftersom det är mycket lätt att skriva kod i dess IDE och det finns ett stort antal öppna källbibliotek tillgängliga på internet som kan användas enligt Jag har experimenterat med projektet för mycket små (10 Watt) solsystem, men det kan enkelt ändras för att användas för högre klassningssystem.

Du hittar alla mina projekt på:

Funktion: Energiövervakning med 1. LCD -display 2. via internet (Xively uppladdning) 3. Dataloggning på ett SD -kort

Du kan se min nya instruerbara ARDUINO MPPT SOLAR CHARGE CONTROLLER (Version-3.0)

Du kan också se mina andra instruktioner på

ARDUINO SOLAR CHARGE CONTROLLER (Version 2.0)

ARDUINO SOLAR CHARGE CONTROLLER (Version-1)

Steg 1: Delar som krävs:

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

3. 16x2 KARAKTER LCD (Amazon)

4. ACS 712 AKTUELL SENSOR (Amazon) 4. RESISTORS (10k, 330ohm) (Amazon) 5. 10K POTENTIOMETER (Amazon) 6. JUMPER WIRES (Amazon) 7. ETHERNET -KABEL (Amazon) 8. BREAD BOARD (Amazon)

Steg 2: Kraft och energi

Effekt: Effekt är en produkt av spänning (volt) och ström (Amp) P = VxI Effektenhet är Watt eller KW Energi: Energi är produkt av effekt (watt) och tid (timme) E = Pxt Enhet för energi är wattimme eller kilowatt Timme (kWh) Av formeln ovan är det klart att för att mäta energi behöver vi tre parametrar 1. Spänning 2. Ström 3. Tid

Steg 3: Spänningsmätning

Spänningen mäts med hjälp av en spänningsdelarkrets. Eftersom ARDUINO analoga stiftinspänning är begränsad till 5V konstruerade jag spänningsdelaren på ett sådant sätt att utspänningen från den ska vara mindre än 5V. Mitt batteri som används för lagring av Strömmen från solpanelen är 6v, 5.5Ah. Så jag måste trappa ner denna 6.5v till en spänning lägre än 5V. Jag använde R1 = 10k och R2 = 10K. Värdet på R1 och R2 kan vara lägre ett men problemet är att när motståndet är lågt högre strömflöde genom det som en följd av att stor mängd kraft (P = I^2R) försvinner i form av värme. Så olika motståndsvärden kan väljas men försiktighet bör iakttas för att minimera effektförlusten över motståndet. Vout = R2/(R1+R2)*Vbat Vbat = 6,5 vid fulladdning R1 = 10k och R2 = 10k Vout = 10/(10+10)*6,5 = 3,25v vilket är lägre än 5v och lämpligt för ARDUINO analog pin ANMÄRKNING I har visat 9 volt batteri i kretskortskretsen är bara till exempel för att ansluta kablarna. Men det faktiska batteriet jag använde är ett 6 Volt, 5,5 Ah blybatteri. Spänningskalibrering: När batteriet är fulladdat (6,5 v) får vi a Vout = 3,25v och lägre värde för annan lägre batterispänning. AEDUINO ADC konverterar analog signal till motsvarande digital approximation. När batterispänningen är 6,5v fick jag 3,25v från spänningsdelaren och sample1 = 696 i seriell bildskärm, där sample1 är ADC -värde motsvarar 3,25vFör bättre förståelse har jag bifogat realtidsimuleringen med 123D. -krets för spänningsmätning Kalibrering: 3,25v motsvarar 696 1 motsvarar 3,25/696 = 4,669mv Vout = (4,669*sample1)/1000 volt Faktisk batterispänning = (2*Vout) voltARDUINO -KOD: // tar 150 prover från spänningsdelaren med ett intervall på 2sek och sedan genomsnittet av samplingsdata som samlats in för (int i = 0; i <150; i ++) {sample1 = sample1+analogRead (A2); // läs spänningen från avdelningskretsfördröjningen (2); } sample1 = sample1/150; spänning = 4,669*2*sample1/1000;

Steg 4: Strömmätning

För strömmätning använde jag en Hall Effect -strömsensor ACS 712 (20 A). Det finns olika ACS712 -givare för nuvarande räckvidd på marknaden, så välj enligt dina krav. I brödskivor har jag visat LED som en belastning men den faktiska belastningen är annorlunda. ARBETSPRINCIP: Hall -effekten är produktionen av en spänningsskillnad (Hall -spänningen) över en elektrisk ledare, tvärs mot en elektrisk ström i ledaren och ett magnetfält vinkelrätt mot strömmen. För att veta mer om Hall Effect -sensor klicka här Databladet för ACS 712 -sensorn finns här Från datablad 1. ACS 712 mäter positiva och negativa 20Amps, motsvarande den analoga utgången 100mV/A 2. Ingen testström genom utspänningen är VCC/2 = 5v/2 = 2.5VCalibrering: Analog läsning ger ett värde på 0-1023, vilket motsvarar 0v till 5v Så Analog läsning 1 = (5/1024) V = 4.89mv Värde = (4.89*Analog läsvärde)/ 1000 V Men enligt datablad är förskjutningen 2,5 V (När nuvarande noll får du 2,5 V från sensorns utgång) Faktiskt värde = (värde-2,5) V Ström i amp = verkligt värde*10ARDUINO KOD: // tar 150 prover från sensorer med ett intervall på 2sek och sedan genomsnittet av samplade data som samlats in för (int i = 0; i <150; i ++) {sample2+= analogRead (A3); // läs strömmen från sensorfördröjning (2); } sample2 = sample2/150; val = (5,0*sample2)/1024,0; actualval = val-2.5; // offset spänning är 2,5v ampere = actualval*10;

Steg 5: Tidsmätning

För tidsmätning behövs ingen extern hårdvara, eftersom ARDUINO själv har inbyggd timer. Funktionen millis () returnerar antalet millisekunder sedan Arduino -kortet började köra det aktuella programmet. ARDUINO KOD: lång milisek = millis (); // beräkna tiden i millisekunder lång tid = milisek/1000; // konvertera millisekunder till sekunder

Steg 6: Hur ARDUINO beräknar kraft och energi

totamps = totamps+ampere; // beräkna totala ampere avgamps = totamps/time; // genomsnittliga ampere amphr = (avgamps*tid)/3600; // amp-timme watt = spänning*ampere; // effekt = spänning*ström energi = (watt*tid)/3600; Watt-sek konverteras igen till Watt-Hr genom att dividera 1 timme (3600sek) // energi = (watt*tid)/(1000*3600); för avläsning i kWh

Steg 7: Visuell utmatning

Alla resultat kan visualiseras i den seriella bildskärmen eller med hjälp av en LCD -skärm. Jag använde en 16x2 tecken LCD för att visa alla resultat som erhållits i de föregående stegen. För scheman se brödbrädkretsen som visas ovan. Anslut LCD med ARDUINO enligt nedan: LCD -> Arduino 1. VSS -> Arduino GND 2. VDD - > Arduino + 5v 3. VO -> Arduino GND pin + Resistor eller Potentiometer 4. RS -> Arduino pin 8 5. RW -> Arduino pin 7 6. E -> Arduino pin 6 7. D0 -> Arduino -Ej ansluten 8. D1 -> Arduino -Ej ansluten 9. D2 -> Arduino -Ej ansluten 10. D3 -> Arduino -Ej ansluten 11. D4 -> Arduino stift 5 12. D5 -> Arduino stift 4 13. D6 -> Arduino stift 3 14. D7 -> Arduino -stift 2 15. A -> Arduino -stift 13 + motstånd (motljuseffekt) 16. K -> Arduino GND (bakgrundsbelysning) ARDUINO -KOD: För seriell bildskärm:

Serial.print ("VOLTAGE:"); Serial.print (spänning); Serial.println ("Volt"); Serial.print ("CURRENT:"); Serial.print (ampere); Serial.println ("Ampere"); Serial.print ("POWER:"); Serial.print (watt); Serial.println ("Watt"); Serial.print ("ENERGI CONSUMED:"); Serial.print (energi); Serial.println ("Watt-timme"); Serial.println (""); // skriv ut nästa uppsättning parametrar efter en tom radfördröjning (2000); För LCD: För LCD -display måste du först importera "LiquidCrystal" -biblioteket i koden. För att veta mer om LequidCrystal -biblioteket klicka här För LCD -handledning klicka här Följande kod är ett format för att visa alla beräkningar för effekt och energi i LCD #include lcd (8, 7, 6, 5, 4, 3, 2); int backLight = 9; void setup () {pinMode (backLight, OUTPUT); // ställ in stift 9 som utgång analogWrite (backLight, 150); // styr bakgrundsbelysningsintensiteten 0-254 lcd.begin (16, 2); // kolumner, rader. skärmens storlek lcd.clear (); // rensa skärmen} void loop () {lcd.setCursor (16, 1); // ställ markören utanför displayräkningen lcd.print (""); // skriv ut teckenfördröjning (600); /////////////////////////////////////////////////////////////// ///////////////////////////////////// (1, 0); // ställ markören på 1: a kol och 1: a raden lcd.print (watt); lcd.print ("W"); lcd.print (spänning); lcd.print ("V"); lcd.setCursor (1, 1); // ställ markören på 1: a kol och 2: a raden lcd.print (energi); lcd.print ("WH"); lcd.print (ampere); lcd.print ("A"); }

Steg 8: Uppladdning av data till Xively.com

Se ovanstående skärmdumpar för bättre förståelse. För dataöverföring till xively.com kan följande bibliotek laddas ned först HttpClient: klicka härXively: klicka härSPI: Importera från arduino IDE (skiss -> Importera bibliotek …..) Ethernet: Importera från arduino IDE ((skiss -> Importera bibliotek …..) Öppna ett konto med https://xively.com (tidigare pachube.com och cosm.com) Registrera dig för ett kostnadsfritt utvecklarkonto på

Välj ett användarnamn, lösenord, ange din adress och tidszon etc. Du får ett bekräftelsemail

klicka sedan på aktiveringslänken för att aktivera ditt konto. Efter att du har öppnat kontot kommer du att vidarebefordras till sidan för utvecklingsenheter

• Klicka på rutan +Lägg till enhet
• Ge ett namn till din enhet och beskrivning (t.ex. energiövervakning) ·
• Välj privat eller offentlig data (jag väljer privat) ·
• Klicka på Lägg till enhet

Efter att du har lagt till enheten omdirigeras du till en ny sida där det finns mycket viktig information

• Produkt -ID, produkthemlighet, serienummer, aktiveringskod ·
• Feed ID, FeedURL, API End Point (Feed ID används i ARDUINO -kod)
• Lägg till kanaler (IVälj ENERGI och POWER, men du kan välja enligt ditt val) Ge enhet och symbol för parametern ·
• Lägg till din plats ·
• API -nycklar (används i ARDUINO -kod, undvik att dela detta nummer) ·
• Utlösare (ping aweb -sida när en händelse inträffade, som när energiförbrukningen överstiger en viss gräns)

Steg 9: Xively och ARDUINO -kod

Här bifogade jag hela koden (betaversion) för energimätare exklusive SD -kortdataloggning som bifogas separat i nästa steg. / ** Energiövervakningsdata laddas upp till xively **/ #include #include #include #include #define API_KEY "xxxxxxxx" // Ange din Xively API -nyckel #define FEED_ID xxxxxxxxx // Ange ditt Xively -flödes -ID // MAC -adress för din Ethernet -sköldbyte mac = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED}; // Analog stift som vi övervakar (0 och 1 används av Ethernet -skölden) int sensorPin = 2; unsigned long lastConnectionTime = 0; // förra gången vi anslöt till Cosm const unsigned long connectionInterval = 15000; // fördröjning mellan anslutning till Cosm i millisekunder // Initiera Cosm -biblioteket // Definiera strängen för vårt dataström -ID char sensorId = "POWER"; char sensorId2 = "ENERGI"; XivelyDatastream dataströmmar = {XivelyDatastream (sensorId, strlen (sensorId), DATASTREAM_FLOAT), XivelyDatastream (sensorId2, strlen (sensorId2), DATASTREAM_FLOAT), DATASTREAM_FLOAT),}; // Slå in dataströmmen i ett XivelyFeed -flöde (FEED_ID, datastreams, 2/ * antal dataströmmar */); EthernetClient -klient; XivelyClient xivelyclient (klient); void setup () {Serial.begin (9600); Serial.println ("Initierar nätverk"); medan (Ethernet.begin (mac)! = 1) {Serial.println ("Fel vid hämtning av IP -adress via DHCP, försök igen …"); fördröjning (15000); } Serial.println ("Nätverk initierat"); Serial.println (); } void loop () {if (millis () - lastConnectionTime> connectionInterval) {sendData (); // skicka data till xively getData (); // läs dataströmmen tillbaka från xively lastConnectionTime = millis (); // uppdatera anslutningstiden så vi väntar innan vi ansluter igen}} void sendData () {int sensor1 = watt; int sensor2 = energi; dataströmmar [0].setFloat (sensor1); // effektvärdesdataströmmar [1].setFloat (sensor2); // energivärde Serial.print ("Läseffekt"); Serial.println (datastreams [0].getFloat ()); Serial.print ("Läs energi"); Serial.println (datastreams [1].getFloat ()); Serial.println ("Uppladdning till Xively"); int ret = xivelyclient.put (feed, API_KEY); Serial.print ("PUT returkod:"); Serial.println (ret); Serial.println (); } // få värdet på dataströmmen från xively, skriva ut värdet vi fick void getData () {Serial.println ("Läsa data från Xively"); int ret = xivelyclient.get (feed, API_KEY); Serial.print ("Hämta returkod:"); Serial.println (ret); if (ret> 0) {Serial.print ("Datastream är:"); Serial.println (feed [0]); Serial.print ("Effektvärdet är:"); Serial.println (feed [0].getFloat ()); Serial.print ("Datastream är:"); Serial.println (feed [1]); Serial.print ("Energivärdet är:"); Serial.println (feed [1].getFloat ()); } Serial.println ();

Steg 10: Dataloggning på ett SD -kort

För datalagring på ett SD -kort måste du importera SD -biblioteket För handledning klicka här För mer information om SD -biblioteket klicka här Koden för lagring av data på ett SD -kort skrivs separat eftersom jag inte har tillräckligt med minne i min ARDUINO UNO efter skriva kod för LCD -display och dataöverföring xively.com. Men jag försöker förbättra betaversionskoden så att en enda kod kan innehålla alla funktioner (LCD -skärm, Xively dataöverföring och datalagring på ett SD -kort). Koden för dataloggning bifogas nedan. Om någon skriver en bättre kod genom att ändra min kod, vänligen dela med mig. Det här är min första tekniska instruktion, om någon hittar något fel i den, kommentera gärna.. så att jag kan förbättra mig själv. Om du hittar förbättringsområden i detta projekt vänligen kommentera eller meddela mig, så projektet kommer att bli mer kraftfullt. Jag tror att det kommer att vara till hjälp för såväl andra som för mig.

Tredje priset i 123D Circuits Contest