ARDUINO ENERGY METER: 10 Steps (med bilder)

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:24

[Spill av video]

Jeg tilhører en landsby Odisha, India, hvor hyppig strømbrudd er veldig vanlig. Det hemmer hverandres liv. I barndommen var det en skikkelig utfordring å fortsette studier etter skumring. På grunn av dette problemet designet jeg et solsystem for hjemmet mitt på eksperimentell basis. Jeg brukte et solcellepanel på 10 Watt, 6V for å belyse noen få lyse lysdioder. Etter å ha møtt mange vanskeligheter, var prosjektet vellykket. Da bestemte jeg meg for å overvåke spenningen, strømmen, effekten og energien som er involvert i systemet. Dette brakte ideen om å designe en ENERGY METER. Jeg brukte ARDUINO som hjertet i dette prosjektet fordi det er veldig enkelt å skrive kode i IDE og det er et stort antall åpen kildekode bibliotek tilgjengelig på internett som kan brukes i henhold til Jeg har eksperimentert med prosjektet for svært små (10Watt) solsystemer, men dette kan enkelt endres for å brukes for et system med høyere karakter.

Du finner alle prosjektene mine på:

Funksjon: Energiovervåkning av 1. LCD -skjerm 2. via internett (Xively opplasting) 3. Datalogging på et SD -kort

Du kan se min nye instruerbare ARDUINO MPPT SOLAR CHARGE CONTROLLER (Versjon-3.0)

Du kan også se mine andre instrukser på

ARDUINO SOLAR CHARGE CONTROLLER (Versjon 2.0)

ARDUINO SOLAR CHARGE CONTROLLER (Versjon-1)

Trinn 1: Nødvendige deler:

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

3. 16x2 KARAKTER LCD (Amazon)

4. ACS 712 AKTUELL SENSOR (Amazon) 4. MOTSTANDER (10k, 330ohm) (Amazon) 5. 10K POTENTIOMETER (Amazon) 6. HØPLEKABLER (Amazon) 7. ETHERNET -KABEL (Amazon) 8. BREAD BOARD (Amazon)

Trinn 2: Kraft og energi

Strøm: Strøm er et produkt av spenning (volt) og strøm (Amp) P = VxI Effektenhet er Watt eller KW Energi: Energi er produkt av effekt (watt) og tid (time) E = Pxt Enhet for energi er watt time eller kilowatt Time (kWh) Fra formelen ovenfor er det klart at for å måle energi trenger vi tre parametere 1. Spenning 2. Strøm 3. Tid

Trinn 3: Spenningsmåling

Spenning måles ved hjelp av en spenningsdelerkrets. Ettersom ARDUINO analoge inngangsspenning er begrenset til 5V designet jeg spenningsdeleren på en slik måte at utgangsspenningen fra den skulle være mindre enn 5V. Batteriet mitt brukt til lagring av Strømmen fra solcellepanelet er vurdert til 6v, 5.5Ah. Så jeg må trappe ned denne 6.5v til en spenning lavere enn 5V. Jeg brukte R1 = 10k og R2 = 10K. Verdien av R1 og R2 kan være lavere, men problemet er at når motstanden er lav, strømmer høyere strøm gjennom den som et resultat at stor mengde kraft (P = I^2R) forsvinner i form av varme. Så forskjellige motstandsverdier kan velges, men det bør tas forsiktighet for å minimere effekttapet over motstanden. Vout = R2/(R1+R2)*Vbat Vbat = 6,5 når den er fulladet R1 = 10k og R2 = 10k Vout = 10/(10+10)*6,5 = 3,25v som er lavere enn 5v og egnet for ARDUINO analog pin MERK I har vist 9 Volt batteri i kretskort er bare for eksempel for å koble ledningene. Men det faktiske batteriet jeg brukte er et 6 Volt, 5,5Ah blybatteri. Spenningskalibrering: Når batteriet er fulladet (6,5v) får vi a Vout = 3,25v og lavere verdi for annen lavere batterispenning. AEDUINO ADC konverterer analogt signal til tilsvarende digital tilnærming. Når batterispenningen er 6,5v, fikk jeg 3,25v fra spenningsdeleren og sample1 = 696 i seriell monitor, hvor sample1 er ADC -verdi tilsvarer 3,25v For bedre forståelse har jeg vedlagt sanntidsimulering ved 123D. -krets for spenningsmåling Kalibrering: 3,25v tilsvarer 696 1 tilsvarer 3,25/696 = 4,669mv Vout = (4,669*sample1)/1000 volt Faktisk batterispenning = (2*Vout) voltARDUINO KODE: // tar 150 prøver fra spenningsdeleren med et intervall på 2sek og deretter gjennomsnittlig prøvedata samlet inn for (int i = 0; i <150; i ++) {sample1 = sample1+analogRead (A2); // les spenningen fra delerkretsforsinkelsen (2); } sample1 = sample1/150; spenning = 4,669*2*sample1/1000;

Trinn 4: Gjeldende måling

For nåværende måling brukte jeg en Hall Effect strømføler ACS 712 (20 A). Det er forskjellige strømområder ACS712 sensor tilgjengelig på markedet, så velg i henhold til dine krav. I brødbrettdiagrammet har jeg vist LED som en belastning, men den faktiske belastningen er annerledes. ARBEIDSPRINSIPP: Hall -effekten er produksjonen av en spenningsforskjell (Hall -spenningen) over en elektrisk leder, på tvers av en elektrisk strøm i lederen og et magnetfelt vinkelrett på strømmen. For å vite mer om Hall Effect -sensor klikk her Databladet til ACS 712 -sensoren finnes her Fra datablad 1. ACS 712 måler positive og negative 20Amps, tilsvarende den analoge utgangen 100mV/A 2. Ingen teststrøm gjennom utgangsspenningen er VCC/2 = 5v/2 = 2.5VCalibrering: Analog avlesning gir en verdi på 0-1023, som tilsvarer 0v til 5v Så Analog lesning 1 = (5/1024) V = 4.89mv Verdi = (4.89*Analog leseverdi)/ 1000 V Men i henhold til datablad er forskyvningen 2,5V (Når nåværende null får du 2,5V fra sensorens utgang) Faktisk verdi = (verdi-2,5) V Strøm i forsterker = faktisk verdi*10ARDUINO KODE: // tar 150 prøver fra sensorer med et intervall på 2sek og deretter gjennomsnittlig prøvedata samlet inn for (int i = 0; i <150; i ++) {sample2+= analogRead (A3); // lese strømmen fra sensorforsinkelse (2); } sample2 = sample2/150; val = (5,0*sample2) /1024,0; actualval = val-2.5; // forskyvningsspenning er 2,5v ampere = actualval*10;

Trinn 5: Tidsmåling

For tidsmåling er det ikke behov for ekstern maskinvare, ettersom ARDUINO selv har innebygd timer. Millis () -funksjonen returnerer antall millisekunder siden Arduino -kortet begynte å kjøre det nåværende programmet. ARDUINO KODE: long milisec = millis (); // beregne tid i millisekunder lang tid = milisek/1000; // konvertere millisekunder til sekunder

Trinn 6: Hvordan ARDUINO beregner kraft og energi

totamps = totamps+ampere; // beregne totalt ampere avgamps = totamps/time; // gjennomsnittlig ampere amphr = (avgamps*tid)/3600; // amp-time watt = spenning*ampere; // effekt = spenning*nåværende energi = (watt*tid)/3600; Watt-sek konverteres igjen til Watt-Hr ved å dele 1 time (3600 sek) // energi = (watt*tid)/(1000*3600); for avlesning i kWh

Trinn 7: Visuell utgang

Alle resultatene kan visualiseres i den serielle skjermen eller ved hjelp av en LCD. Jeg brukte en 16 x 2 tegn LCD for å vise alle resultatene som ble oppnådd i de foregående trinnene. For skjemaer se brødbrettskretsen vist ovenfor. Koble LCD med ARDUINO som vist nedenfor: 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 -Ikke tilkoblet 8. D1 -> Arduino -Ikke tilkoblet 9. D2 -> Arduino -Ikke tilkoblet 10. D3 -> Arduino -Ikke tilkoblet 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 + motstand (bakgrunnsbelysning) 16. K -> Arduino GND (bakgrunnsbelysning) ARDUINO KODE: For seriell monitor:

Serial.print ("VOLTAGE:"); Serial.print (spenning); Serial.println ("Volt"); Serial.print ("CURRENT:"); Serial.print (ampere); Serial.println ("Ampere"); Serial.print ("POWER:"); Serial.print (watt); Serial.println ("Watt"); Serial.print ("FORBRUKT ENERGI:"); Serial.print (energi); Serial.println ("Watt-time"); Serial.println (""); // skriv ut de neste settene med parametere etter en forsinkelse på en tom linje (2000); For LCD: For LCD -skjerm må du først importere "LiquidCrystal" -biblioteket i koden. For å vite mer om LequidCrystal -biblioteket klikk her For LCD -opplæring klikk her Følgende kode er et format for å vise all beregning for effekt og energi på LCD #include lcd (8, 7, 6, 5, 4, 3, 2); int backLight = 9; void setup () {pinMode (backLight, OUTPUT); // sett pin 9 som output analogWrite (backLight, 150); // styrer bakgrunnsbelysningsintensiteten 0-254 lcd.begin (16, 2); // kolonner, rader. visningsstørrelse lcd.clear (); // tøm skjermen} void loop () {lcd.setCursor (16, 1); // sett markøren utenfor visningstallet lcd.print (""); // skriv ut forsinkelse med tomme tegn (600); ////////////////////////////////////////// ////////////////////////////////////// (1, 0); // sett markøren på 1. kol og 1. rad lcd.print (watt); lcd.print ("W"); lcd.print (spenning); lcd.print ("V"); lcd.setCursor (1, 1); // sett markøren på 1. kol og 2. rad lcd.print (energi); lcd.print ("WH"); lcd.print (ampere); lcd.print ("A"); }

Trinn 8: Last opp data til Xively.com

Se skjermbildene ovenfor for bedre forståelse. For dataopplasting til xively.com kan følgende bibliotek lastes ned først HttpClient: klikk herXively: klikk herSPI: Import fra arduino IDE (skisse -> Importer bibliotek …..) Ethernet: Import fra arduino IDE ((skisse -> Importer bibliotek …..) Åpne en konto med https://xively.com (tidligere pachube.com og cosm.com) Registrer deg for en gratis utviklerkonto på

Velg et brukernavn, passord, angi adresse og tidssone etc. Du vil motta en bekreftelse på e -post;

klikk deretter på aktiveringslenken for å aktivere kontoen din. Etter at du har åpnet kontoen, blir du viderekoblet til siden for utviklingsenheter

• Klikk på boksen Legg til enhet
• Gi enheten din et navn og en beskrivelse (f.eks. ENERGY MONITORING)
• Velg private eller offentlige data (jeg velger privat) ·
• Klikk på Legg til enhet

Etter at du har lagt til enheten, blir du viderekoblet til en ny side der det er mye viktig informasjon

• Produkt -ID, produkthemmelighet, serienummer, aktiveringskode ·
• Feed -ID, FeedURL, API -sluttpunkt (Feed -ID brukes i ARDUINO -kode)
• Legg til kanaler (IVelg ENERGI og POWER, men du kan velge etter eget valg) Gi enhet og symbol for parameteren ·
• Legg til din posisjon ·
• API -nøkler (brukt i ARDUINO -kode, unngå å dele dette nummeret) ·
• Utløser (ping aweb -side når en hendelse skjedde, for eksempel når energiforbruket overstiger en viss grense)

Trinn 9: Xively og ARDUINO Code

Her har jeg lagt ved den komplette koden (betaversjon) for energimåler eksklusive SD -kortdatalogging som er vedlagt separat i neste trinn. / ** Energiovervåkingsdata lastes opp til xively **/ #include #include #include #include #define API_KEY "xxxxxxxx" // Skriv inn din Xively API -nøkkel #definer FEED_ID xxxxxxxxx // Skriv inn Xively feed -ID // MAC -adressen din Ethernet -skjoldbyte mac = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED}; // Analog pin som vi overvåker (0 og 1 brukes av Ethernet -skjoldet) int sensorPin = 2; unsigned long lastConnectionTime = 0; // forrige gang vi koblet til Cosm const unsigned long connectionInterval = 15000; // forsinkelse mellom å koble til Cosm i millisekunder // Initialiser Cosm -biblioteket // Definer strengen for datastrøm -ID -en vår sensorId = "POWER"; char sensorId2 = "ENERGI"; XivelyDatastream datastreams = {XivelyDatastream (sensorId, strlen (sensorId), DATASTREAM_FLOAT), XivelyDatastream (sensorId2, strlen (sensorId2), DATASTREAM_FLOAT), DATASTREAM_FLOAT),}; // Pakk datastrømmen inn i en XivelyFeed -feed -feed (FEED_ID, datastrømmer, 2/ * antall datastrømmer */); EthernetClient -klient; XivelyClient xivelyclient (klient); ugyldig oppsett () {Serial.begin (9600); Serial.println ("Initialiserer nettverk"); mens (Ethernet.begin (mac)! = 1) {Serial.println ("Feil ved henting av IP -adresse via DHCP, prøver igjen …"); forsinkelse (15000); } Serial.println ("Nettverk initialisert"); Serial.println (); } void loop () {if (millis () - lastConnectionTime> connectionInterval) {sendData (); // sende data til xively getData (); // les datastrømmen tilbake fra xively lastConnectionTime = millis (); // oppdater tilkoblingstid, så vi venter før vi kobler til igjen}} void sendData () {int sensor1 = watt; int sensor2 = energi; datastrømmer [0].setFloat (sensor1); // strømverdi datastrømmer [1].setFloat (sensor2); // energiverdi Serial.print ("Lesekraft"); Serial.println (datastreams [0].getFloat ()); Serial.print ("Les energi"); Serial.println (datastreams [1].getFloat ()); Serial.println ("Laster opp til Xively"); int ret = xivelyclient.put (feed, API_KEY); Serial.print ("PUT returkode:"); Serial.println (ret); Serial.println (); } // hent verdien av datastrømmen fra xively, og skriv ut verdien vi mottok void getData () {Serial.println ("Lese data fra Xively"); int ret = xivelyclient.get (feed, API_KEY); Serial.print ("GET returkode:"); Serial.println (ret); if (ret> 0) {Serial.print ("Datastream er:"); Serial.println (feed [0]); Serial.print ("Strømverdien er:"); Serial.println (feed [0].getFloat ()); Serial.print ("Datastream er:"); Serial.println (feed [1]); Serial.print ("Energiverdi er:"); Serial.println (feed [1].getFloat ()); } Serial.println ();

Trinn 10: Datalogging på et SD -kort

For lagring av data på et SD -kort må du importere SD -biblioteket For opplæring klikk her For å vite mer om SD -biblioteket klikk her Koden for lagring av data på et SD -kort skrives separat da jeg ikke har nok minne i min ARDUINO UNO etter skrive kode for LCD -skjerm og dataopplasting xively.com. Men jeg prøver å forbedre betaversjonskoden slik at en enkelt kode kan inneholde alle funksjonene (LCD -skjerm, opplasting av data og lagring av data på et SD -kort). Koden for datalogging er vedlagt nedenfor. Hvis noen skriver en bedre kode ved å endre koden, vennligst del med meg. Dette er min første tekniske instruks, hvis noen finner feil i den, kan du gjerne kommentere.. slik at jeg kan forbedre meg selv. Hvis du finner forbedringsområder i dette prosjektet, vennligst kommenter eller send meg en melding, så prosjektet blir mer kraftfullt. Jeg tror det vil være nyttig for andre så vel som for meg.

Tredje premie i 123D Circuits Contest