CONTATORE DI ENERGIA ARDUINO: 10 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:03

[Riproduci video]

Appartengo a un villaggio dell'Odisha, in India, dove sono frequenti interruzioni di corrente. Ostacola la vita di tutti. Durante la mia infanzia continuare gli studi dopo il tramonto era una vera sfida. A causa di questo problema ho progettato in via sperimentale un sistema solare per la mia casa. Ho usato un pannello solare da 10 Watt, 6V per accendere pochi led luminosi. Dopo aver affrontato molte difficoltà, il progetto ha avuto successo. Quindi ho deciso di monitorare la tensione, la corrente, la potenza e l'energia coinvolte nel sistema. Questo ha portato all'idea di progettare un CONTATORE DI ENERGIA. Ho usato ARDUINO come cuore di questo progetto perché è molto facile scrivere codice nel suo IDE e ci sono un numero enorme di librerie open source disponibili in Internet che possono essere utilizzate secondo il requisito. Ho sperimentato il progetto per un sistema solare con rating molto piccolo (10 Watt), ma questo può essere facilmente modificato per utilizzarlo per un sistema di rating più elevato.

Puoi trovare tutti i miei progetti su:

Caratteristica: Monitoraggio energetico tramite 1. Display LCD 2. via Internet (caricamento Xively) 3. Registrazione dati in una scheda SD

Puoi vedere il mio nuovo REGOLATORE DI CARICA SOLARE ARDUINO MPPT istruibile (Versione-3.0)

Puoi anche vedere le mie altre istruzioni su

REGOLATORE DI CARICA SOLARE ARDUINO (Versione 2.0)

REGOLATORE DI CARICA SOLARE ARDUINO (Versione-1)

Passaggio 1: parti necessarie:

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

3. LCD 16x2 CARATTERI (Amazon)

4. SENSORE DI CORRENTE ACS 712 (Amazon)4. RESISTENZE (10k, 330ohm) (Amazon)5. POTENZIOMETRO 10K (Amazon)6. FILI DEL PONTICELLO (Amazon)7. CAVO ETHERNET (Amazon)8. TAGLIERE PER PANE (Amazon)

Passaggio 2: potenza ed energia

Potenza: La potenza è il prodotto della tensione (volt) e della corrente (Amp) P=VxI L'unità di potenza è Watt o KWEnergy: L'energia è il prodotto della potenza (watt) e il tempo (Ora) E= Pxt L'unità di energia è Wattora o Kilowatt Ora (kWh) Dalla formula sopra è chiaro che per misurare l'energia abbiamo bisogno di tre parametri 1. Tensione 2. Corrente 3. Tempo

Passaggio 3: misurazione della tensione

La tensione viene misurata con l'aiuto di un circuito divisore di tensione. Poiché la tensione di ingresso del pin analogico ARDUINO è limitata a 5 V, ho progettato il partitore di tensione in modo tale che la tensione di uscita da esso dovrebbe essere inferiore a 5 V. La mia batteria utilizzata per conservare il la potenza del pannello solare è di 6 V, 5,5 Ah. Quindi devo ridurre questo 6,5 V a una tensione inferiore a 5 V. Ho usato R1=10k e R2 =10K. Il valore di R1 e R2 può essere inferiore a uno, ma il problema è che quando la resistenza è bassa, una corrente maggiore scorre attraverso di essa di conseguenza una grande quantità di potenza (P = I^2R) dissipata sotto forma di calore. Quindi è possibile scegliere un valore di resistenza diverso, ma occorre prestare attenzione per ridurre al minimo la perdita di potenza attraverso la resistenza. Vout=R2/(R1+R2)*Vbat Vbat=6.5 quando completamente carico R1=10k e R2=10k Vout=10/(10+10)*6.5=3.25v che è inferiore a 5v e adatto per il pin analogico ARDUINONOTA I hanno mostrato che la batteria da 9 Volt nel circuito della scheda scoperta è solo per esempio per collegare i fili. Ma la batteria effettiva che ho usato è una batteria al piombo da 6 Volt, 5,5 Ah. Calibrazione della tensione: quando la batteria è completamente carica (6,5 V) otterremo a Vout=3.25v e valore inferiore per un'altra tensione di batteria inferiore. AEDUINO ADC converte il segnale analogico nell'approssimazione digitale corrispondente. Quando la tensione della batteria è 6.5v ho ottenuto 3.25v dal divisore di tensione e sample1 = 696 nel monitor seriale, dove sample1 è il valore ADC corrisponde a 3.25v Per una migliore comprensione ho allegato la simulazione in tempo reale di 123D.circuit per la calibrazione della misurazione della tensione: 3,25v equivalente a 696 1 è equivalente a 3,25/696=4.669mv Vout = (4.669*campione1)/1000 volt Tensione effettiva batteria = (2*Vout) voltARDUINO CODICE: // preleva 150 campioni dal partitore di tensione con un intervallo di 2sec e quindi media i dati dei campioni raccolti per (int i=0;i<150;i++) { sample1=sample1+analogRead(A2); //legge la tensione dal circuito divisore delay (2); } campione1=campione1/150; tensione=4.669*2*campione1/1000;

Passaggio 4: misurazione della corrente

Per la misurazione della corrente ho utilizzato un sensore di corrente ad effetto Hall ACS 712 (20 A). Sul mercato sono disponibili diversi sensori di corrente ACS712, quindi scegli in base alle tue esigenze. Nel diagramma della breadboard ho mostrato il LED come un carico ma il carico effettivo è diverso. PRINCIPIO DI FUNZIONAMENTO: L'effetto Hall è la produzione di una differenza di tensione (la tensione di Hall) attraverso un conduttore elettrico, trasversale a una corrente elettrica nel conduttore e un campo magnetico perpendicolare alla corrente. Per saperne di più sul sensore ad effetto Hall clicca qui La scheda tecnica del sensore ACS 712 si trova qui Dalla scheda tecnica 1. L'ACS 712 misura 20A positivi e negativi, corrispondenti all'uscita analogica 100mV/A 2. Nessuna corrente di prova attraverso la tensione di uscita è VCC / 2 =5v/2=2.5VCalibrazione: La lettura analogica produce un valore di 0-1023, equivalente a 0v a 5v Quindi Lettura analogica 1 = (5/1024) V =4.89mv Valore = (4.89*Valore lettura analogica)/ 1000 V Ma come da schede tecniche l'offset è 2,5 V (quando la corrente zero otterrai 2,5 V dall'uscita del sensore) Valore effettivo = (valore-2,5) V Corrente in amp = valore effettivo*10ARDUINO CODE: // prelevando 150 campioni da sensori con un intervallo di 2sec e quindi mediare i dati dei campioni raccolti per(int i=0;i<150;i++) { sample2+=analogRead(A3); //legge la corrente dal sensore delay(2); } campione2=campione2/150; val =(5.0*campione2)/1024.0; valore effettivo = valore-2,5; // la tensione di offset è 2,5 V ampere = valore effettivo*10;

Passaggio 5: misurazione del tempo

Per la misurazione del tempo non è necessario alcun hardware esterno, poiché lo stesso ARDUINO ha un timer integrato. La funzione millis() restituisce il no di millisecondi da quando la scheda Arduino ha iniziato a eseguire il programma corrente. CODICE ARDUINO: long milisec = millis(); // calcola il tempo in millisecondi long time=milisec/1000; // converte i millisecondi in secondi

Passaggio 6: come ARDUINO calcola potenza ed energia

totamps=totamps+amp; // calcola gli amplificatori totali avgamps=totamps/time; // amplificatori medi amphr=(avgamps*time)/3600; // amp-ora watt = voltaggio*amp; // potenza=tensione*energia corrente=(watt*tempo)/3600; Watt-sec viene nuovamente convertito in Watt-Hr dividendo 1hr(3600sec) // energy=(watt*time)/(1000*3600); per la lettura in kWh

Passaggio 7: output visivo

Tutti i risultati possono essere visualizzati nel monitor seriale o utilizzando un LCD. Ho usato un LCD da 16x2 caratteri per visualizzare tutti i risultati ottenuti nei passaggi precedenti. Per gli schemi vedere il circuito della breadboard mostrato sopra. Collegare l'LCD con ARDUINO come indicato di seguito: LCD -> Arduino 1. VSS -> Arduino GND 2. VDD - > Arduino +5v 3. VO -> Arduino GND pin + Resistenza o Potenziometro 4. RS -> Arduino pin 8 5. RW -> Arduino pin 7 6. E -> Arduino pin 6 7. D0 -> Arduino - Non connesso 8 D1 -> Arduino - Non connesso 9. D2 -> Arduino - Non connesso 10. D3 -> Arduino - Non connesso 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 + Resistor (alimentazione retroilluminazione) 16. K -> Arduino GND (terra retroilluminazione) CODICE ARDUINO: Per monitor seriale:

Serial.print("TENSIONE: "); Serial.print (tensione); Serial.println("Volt"); Serial.print("ATTUALE:"); Serial.print(amp); Serial.println("Ampere"); Serial.print("POTENZA:"); Serial.print(watt); Serial.println("Watt"); Serial.print("ENERGIA CONSUMATA:"); Serial.print(energia); Serial.println("Watt-ora"); Serial.println(""); // stampa i successivi set di parametri dopo un ritardo di riga vuota (2000);Per LCD: Per i display LCD devi prima importare la libreria "LiquidCrystal" nel codice. Per saperne di più sulla libreria LequidCrystal clicca qui Per il tutorial LCD clicca qui Il seguente codice è un formato per visualizzare in LCD tutti i calcoli di potenza ed energia #include lcd(8, 7, 6, 5, 4, 3, 2); int retroilluminazione = 9; void setup() { pinMode(backLight, OUTPUT); //imposta il pin 9 come output analogWrite(backLight, 150); //controlla l'intensità della retroilluminazione 0-254 lcd.begin(16, 2); // colonne, righe. dimensione del display lcd.clear(); // cancella lo schermo } void loop() { lcd.setCursor(16, 1); // imposta il cursore fuori dal display count lcd.print(" "); // stampa il carattere vuoto delay(600); ///////////////////////////////////////// potenza ed energia di stampa su un LCD/ ////////////////////////////////////////////// lcd.setCursor (1, 0); // imposta il cursore alla prima colonna e alla prima riga lcd.print(watt); lcd.print("W"); lcd.print(tensione); lcd.print("V"); lcd.setCursor(1, 1); // imposta il cursore alla 1a colonna e alla 2a riga lcd.print(energy); lcd.print("WH"); lcd.print(amplificatori); lcd.print("A"); }

Passaggio 8: caricamento dei dati su Xively.com

Fare riferimento alle schermate sopra per una migliore comprensione. Per il caricamento dei dati su xively.com, la seguente libreria deve essere scaricata prima HttpClient: fare clic quiXively: fare clic quiSPI: Importa da IDE arduino (schizzo -> Importa libreria…..)Ethernet: Importa da arduino IDE ((schizzo -> Importa libreria…..) Apri un account con https://xively.com (precedentemente pachube.com e cosm.com) Registrati per un account sviluppatore gratuito su

Scegli un nome utente, una password, imposta il tuo indirizzo e fuso orario ecc. Riceverai un'email di conferma;

quindi fai clic sul link di attivazione per attivare il tuo account. Dopo aver aperto con successo l'account verrai reindirizzato alla pagina dei dispositivi di sviluppo

• Fare clic sulla casella +Aggiungi dispositivo
• Dai un nome al tuo dispositivo e una descrizione (es. MONITORAGGIO ENERGETICO)·
• Scegli dati privati o pubblici (scelgo privati)·
• Fare clic su Aggiungi dispositivo

Dopo aver aggiunto il dispositivo vieni reindirizzato a una nuova pagina dove sono presenti molte informazioni importanti

• ID prodotto, codice segreto del prodotto, numero di serie, codice di attivazione·
• Feed ID, FeedURL, API End Point (l'ID feed è utilizzato nel codice ARDUINO)
• Aggiungi canali (Scegli ENERGIA e POTENZA, ma puoi scegliere in base alla tua scelta) Fornisci unità e simbolo per il parametro·
• Aggiungi la tua posizione ·
• Chiavi API (utilizzate nel codice ARDUINO, evitare di condividere questo numero)·
• Trigger (pinga una pagina web quando si verifica un evento, ad esempio quando il consumo di energia supera un certo limite)

Passaggio 9: Xively e codice ARDUINO

Qui ho allegato il codice completo (versione beta) per il contatore di energia esclusa la registrazione dei dati della scheda SD che viene allegato separatamente nel passaggio successivo. /** Caricamento dei dati di monitoraggio energetico su xively **/ #include #include #include #include #define API_KEY "xxxxxxxx" // Inserisci la tua chiave API Xively #define FEED_ID xxxxxxxxx // Inserisci il tuo ID feed Xively // Indirizzo MAC per il tuo byte di schermatura Ethernet mac = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED}; // Pin analogico che stiamo monitorando (0 e 1 sono usati dallo shield Ethernet) int sensorPin = 2; unsigned long lastConnectionTime = 0; // l'ultima volta che ci siamo connessi a Cosm const unsigned long connectionInterval = 15000; // ritardo tra la connessione a Cosm in millisecondi // Inizializza la libreria Cosm // Definisci la stringa per il nostro ID datastream char sensorId = "POWER"; char sensorId2 = "ENERGIA"; XivelyDatastream datastreams = { XivelyDatastream(sensorId, strlen(sensorId), DATASTREAM_FLOAT), XivelyDatastream(sensorId2, strlen(sensorId2), DATASTREAM_FLOAT), DATASTREAM_FLOAT), }; // Avvolge il flusso di dati in un feed XivelyFeed feed(FEED_ID, flussi di dati, 2 /* numero di flussi di dati */); Client client Ethernet; XivelyClient xivelyclient(client); void setup() { Serial.begin(9600); Serial.println("Inizializzazione rete"); while (Ethernet.begin(mac) != 1) { Serial.println("Errore durante l'acquisizione dell'indirizzo IP tramite DHCP, riprovando…"); ritardo (15000); } Serial.println("Rete inizializzata"); Serial.println(); } void loop() { if (millis() - lastConnectionTime > connectionInterval) { sendData(); // invia i dati a xively getData(); // rilegge il flusso di dati da xively lastConnectionTime = millis(); // aggiorna il tempo di connessione così aspettiamo prima di connetterci di nuovo } } void sendData() { int sensor1 = watt; int sensore2 = energia; datastreams[0].setFloat(sensor1); // flussi di dati del valore di potenza[1].setFloat(sensor2); // valore energetico Serial.print("Leggi potenza"); Serial.println(datastreams[0].getFloat()); Serial.print("Leggi energia"); Serial.println(datastreams[1].getFloat()); Serial.println("Caricamento in Xively"); int ret = xivelyclient.put(feed, API_KEY); Serial.print("INSERIRE il codice di ritorno: "); Serial.println(ret); Serial.println(); } // ottiene il valore del datastream da xively, stampando il valore che abbiamo ricevuto void getData() { Serial.println("Lettura dati da Xively"); int ret = xivelyclient.get(feed, API_KEY); Serial.print("OTTIENI codice di ritorno: "); Serial.println(ret); if (ret > 0) { Serial.print("Il flusso di dati è: "); Serial.println(feed[0]); Serial.print("Il valore della potenza è: "); Serial.println(feed[0].getFloat()); Serial.print("Il flusso di dati è: "); Serial.println(feed[1]); Serial.print("Il valore energetico è: "); Serial.println(feed[1].getFloat()); } Serial.println();

Passaggio 10: registrazione dei dati in una scheda SD

Per la memorizzazione dei dati in una scheda SD è necessario importare la libreria SD Per il tutorial clicca quiPer saperne di più sulla libreria SD clicca quiIl codice per la memorizzazione dei dati in una scheda SD viene scritto separatamente poiché non ho memoria sufficiente nel mio ARDUINO UNO dopo codice di scrittura per display LCD e caricamento dati xively.com. Ma sto cercando di migliorare il codice della versione beta in modo che un singolo codice possa contenere tutte le funzionalità (display LCD, caricamento dati Xively e memorizzazione dati in una scheda SD). Il codice per la registrazione dei dati è allegato qui sotto. Se qualcuno scrive un codice migliore modificando il mio codice, per favore condividi con me. Questo è il mio primo istruibile tecnico, se qualcuno trova qualche errore in esso, non esitare a commentare.. in modo che io possa migliorare me stesso. Se trovi aree di miglioramento in questo progetto, per favore commenti o inviami un messaggio, quindi il progetto sarà più potente. Penso che sarà utile per gli altri oltre che per me.

Terzo Premio al Concorso Circuiti 123D