Monitoraggio della potenza del pannello solare basato su IOT utilizzando esp32 e thingspeak

Nell'area delle energie rinnovabili, l'energia solare è in prima linea, perché produrre energia utilizzando la potenza del sole è il modo più semplice e commercialmente praticabile di energia rinnovabile. Parlando di pannelli solari, la potenza di uscita di un pannello solare deve essere monitorata al fine di ottenere una potenza ottimale dai pannelli. Ecco perché diventa necessario un sistema di monitoraggio in tempo reale. In un grande impianto di energia solare, può anche essere utilizzato per monitorare la potenza in uscita da ciascun pannello che aiuta a identificare l'accumulo di polvere. Inoltre impedisce qualsiasi condizione di guasto durante il tempo di funzionamento. In alcuni dei nostri articoli precedenti, abbiamo realizzato alcuni progetti relativi all'energia solare come un caricatore per cellulare alimentato a energia solare e un circuito inverter solare, ecc. Puoi verificarli se stai cercando altri progetti sull'energia solare.

In questo progetto, realizzeremo un sistema di monitoraggio dell'energia solare basato su IoT incorporando la tecnica di ricarica della batteria basata su MPPT (Maximum Power Point Tracker), che contribuirà a ridurre il tempo di ricarica e migliorare l'efficienza. Inoltre, misureremo la temperatura del pannello, la tensione di uscita e la corrente per migliorare l'aspetto della sicurezza del circuito. Infine, per completare il tutto, utilizzeremo i servizi cloud ThingSpeak per monitorare i dati di output da qualsiasi parte del mondo. Si noti che questo progetto è una continuazione del progetto del regolatore di carica solare MPPT che abbiamo costruito in precedenza. Qui, monitoreremo la tensione di uscita, la corrente e la potenza del pannello utilizzando la scheda di sviluppo IoT ESP32.

Scelta dei componenti giusti per il monitoraggio dell'energia solare abilitato per IoT

Con un monitor solare, diventa molto facile monitorare e rilevare i guasti in qualsiasi sistema solare. Questo è il motivo per cui la selezione dei componenti diventa una parte molto importante quando si progetta un tale sistema. Di seguito è riportato l'elenco delle parti che abbiamo utilizzato.

1. Scheda di sviluppo ESP32
2. Circuito MPPT (può essere qualsiasi circuito solare)
3. Un resistore di shunt (ad esempio 1 Ohm 1 watt - adatto per un massimo di 1A di corrente)
4. Una batteria al litio (preferibilmente 7,4 V).
5. Connessione Wi-Fi attiva
6. Sensore di temperatura per il pannello solare
7. Circuito divisore di tensione (vedi descrizione)

Scheda di sviluppo Esp32:

Per un'applicazione abilitata per IoT, è essenziale scegliere il giusto tipo di scheda di sviluppo che sarà in grado di elaborare i dati dai suoi pin analogici e inviare i dati tramite qualsiasi tipo di protocollo di connessione come Wi-Fi o al cloud server. Abbiamo selezionato specificamente ESP32 in quanto è un microcontrollore a basso costo con tonnellate di funzionalità. Inoltre, ha una radio Wi-Fi integrata attraverso la quale possiamo connetterci a Internet molto facilmente.

Circuito solare:

Un circuito di ricarica solare è un circuito che riceve una tensione più elevata dal pannello solare e la converte in una tensione di carica in modo che possa caricare in modo efficiente la batteria. Per questo progetto, utilizzeremo il circuito del controller di carica MPPT basato su LT3562 che abbiamo già realizzato in uno dei nostri progetti precedenti. Ma se vuoi incorporare questo monitoraggio dell'abilitazione IoT, puoi utilizzare qualsiasi tipo di circuito solare. Abbiamo scelto questa scheda perché il circuito è dotato di Maximum Power Point Tracking (MPPT), utile per i progetti di pannelli solari a bassa potenza. È un modo efficiente per caricare una piccola batteria al litio da un pannello solare.

Resistenza shunt:

Qualsiasi resistenza segue la legge di ohm, il che significa che se una certa quantità di corrente scorre attraverso la resistenza, apparirà una certa quantità di caduta di tensione. Le resistenze shunt non fanno eccezione e sono utilizzate specificamente per misurare il flusso di corrente. Tuttavia, a seconda del flusso di corrente nominale attraverso il pannello solare, scegliere un resistore shunt che produrrà una quantità adeguata di tensione che può essere misurata dall'unità microcontrollore. Ma, allo stesso tempo, anche la potenza del resistore è una cosa importante. Anche la selezione della potenza del resistore di shunt è importante.

La caduta di tensione può essere calcolata utilizzando la formula riportata di seguito. Questa è conosciuta come la legge di Ohm-

V = I x R

V è la tensione che verrà prodotta durante "I", ovvero la quantità di corrente che scorre attraverso la quantità di resistenza "R". Ad esempio, un resistore da 1 ohm produrrà 1 V di caduta di tensione quando scorre 1 A di corrente.

Per la potenza del resistore, è possibile utilizzare la formula riportata di seguito:

P = I ² R

Dove I è il flusso di corrente massimo e R è il valore del resistore. Per 1A di corrente con resistenza da 1 Ohm, 1 watt è sufficiente per la dissipazione di potenza. Tuttavia, questo è utile per piccoli progetti di pannelli solari ma non è affatto adatto per applicazioni relative alla rete solare. In tal caso, la tecnica di misurazione della corrente non invasiva è effettivamente ciò che deve essere utilizzato. In tal caso, il flusso di corrente può essere misurato con precisione dove è possibile misurare una quantità di corrente molto bassa, nonché una quantità di corrente molto elevata.

Batteria al litio:

La scelta della batteria al litio è una parte essenziale di qualsiasi progetto che coinvolga i pannelli solari. Perché l'unità microcontrollore che rimane sempre accesa e controlla e invia costantemente i dati richiede almeno cento milliampere di corrente per un funzionamento stabile.

La capacità della batteria dovrebbe essere qualcosa che possa alimentare il microcontrollore per almeno 4-5 giorni quando il sole non splende a causa del monsone. È anche importante che la corrente di carica sia maggiore della corrente di carico dal punto di vista della batteria. È abbastanza insolito se qualcuno collega 100 mA di carico con una batteria e fornisce una corrente di carica, che è inferiore a quella. Per essere più sicuri, dovremmo avere almeno 5 volte più corrente di carica rispetto alla corrente di carico.

D'altra parte, la tensione della batteria deve essere superiore a qualsiasi normale tensione di ingresso del regolatore di tensione richiesta per il microcontrollore. Ad esempio, una batteria al litio da 7,4 V potrebbe essere collegata a entrambi i regolatori di tensione lineare da 3,3 V e 5,0 V (poiché il regolatore lineare richiede una tensione di caduta più elevata rispetto a LDO e commutazione).

Nel nostro progetto, abbiamo utilizzato una batteria da 4000 mAH con una potenza nominale di 7,4 V. Abbiamo utilizzato un regolatore da 5,0 V che fornisce corrente e tensione di uscita sufficienti per l'ESP32.

Divisore di tensione:

Un partitore di tensione è una parte essenziale della misurazione della tensione del pannello solare. Si dovrebbe scegliere un partitore di tensione che dividerà la tensione in base all'ingresso di tensione I / O del microcontrollore.

Scegliere i resistori di cui sopra in modo tale che la tensione di uscita del partitore di tensione non superi la tensione I / O massima del microcontrollore (3,3 V per ESP32). Tuttavia, si consiglia di utilizzare un potenziometro perché fornirà flessibilità per scegliere qualsiasi tensione nominale del pannello solare superiore o inferiore e può facilmente impostare la tensione utilizzando un multimetro.

Nel nostro caso, abbiamo un potenziometro nel circuito della scheda MPPT che funge da partitore di tensione. Impostiamo il partitore di tensione con un fattore di divisione di 6V. Abbiamo collegato due multimetri, uno in ingresso e un altro in uscita della pentola, e abbiamo impostato il valore che quando la tensione di ingresso è 18V l'uscita sarà 3V poiché la tensione di uscita nominale del pannello solare è 18V.

Sensore di temperatura per il pannello solare:

La potenza erogata dal pannello solare ha una connessione diretta con la temperatura del pannello solare. Perché? Perché quando la temperatura di un pannello solare inizia ad aumentare, la corrente di uscita dal pannello solare aumenta in modo esponenziale mentre la tensione di uscita inizia a ridursi linearmente.

Secondo la formula della potenza, il wattaggio è uguale alla tensione moltiplicata per la corrente (W = V x A), diminuendo la tensione di uscita diminuisce anche la potenza di uscita del pannello solare anche dopo l'aumento del flusso di corrente. Ora, la prossima domanda che ci viene in mente è: come misurare la temperatura solare? Ebbene, è piuttosto interessante in quanto i pannelli solari sono generalmente esposti al calore ambientale in quanto esposto alla luce solare diretta e per ovvi motivi. Il modo migliore per misurare la temperatura del pannello solare è utilizzare un sensore di temperatura a superficie piana. Si suggerisce inoltre di utilizzare una termocoppia di tipo K posta direttamente nel pannello solare.

Per la nostra applicazione, abbiamo utilizzato un modulo sensore di temperatura basato su termistore, mostrato di seguito.

Schema del circuito per il monitoraggio dell'energia solare basato su IoT

Di seguito è mostrato lo schema del circuito completo per il Solar Power Monitor abilitato per IoT. Lo schema è semplice. La scheda con i punti rossi è la scheda MPPT che abbiamo utilizzato per questo progetto.

Configurazione di ThingSpeak

Crea un account con ThingSpeak e vai all'opzione "il mio canale", quindi fai clic su Nuovo canale.

Crea un nuovo canale con i nomi dei campi.

Ora dopo aver impostato il campo, vai al campo Chiavi API in cui è disponibile la chiave API di scrittura. Questa chiave deve essere fornita nel codice e nell'ID del canale.

L'indirizzo di ThingSpeak può essere trovato sulla stessa pagina.

Con i passaggi precedenti, puoi configurare ThingSpeak molto facilmente. Se vuoi saperne di più su ThingSpeak e sul suo processo di configurazione, puoi consultare i nostri articoli precedenti sull'argomento.

Codice Arduino per il monitoraggio dell'energia solare utilizzando ESP32

Il codice completo per il monitoraggio dell'energia solare ESP32 è disponibile in fondo a questa pagina. Il codice inizia con la definizione del SSID, della password e di alcuni altri parametri costanti come mostrato di seguito.

// definisce l'SSID WiFi e il PWD per l'uplink. #define WLAN_SSID "xxxx" #define WLAN_PASS "xxxxxxxxxx"

// resistenza a 25 gradi C #define TERMISTORNOMINALE 10000 // temp. per la resistenza nominale (quasi sempre 25 C) #define TEMPERATURENOMINAL 25 // Il coefficiente beta del termistore (solitamente 3000-4000) #define BCOEFFICIENT 3950 // il valore dell '' altra 'resistenza #define SERIESRESISTOR 10000

Gli ohm nominali del termistore sono forniti alla temperatura nominale. Impostare questo valore in base alla scheda tecnica del termistore. Metti il ​​coefficiente Beta e il valore della resistenza in serie del termistore.

// definisce analogico per corrente e tensione const int curr_an_pin = 35; const int volt_an_pin = 34; const int ntc_temp_an_pin = 33;

I PIN sono definiti qui.

#define thingSpeakAddress "xxxxxxxxx" #define channelID xxxxx #define writeFeedAPIKey "xxxxxxx" #define readFeedAPIKey "xxxxxxx" #define readFieldAPIKey "xxxxxxxx" #define readStatusAPIKey "xxxxxxx"

Inserisci cosaSpeakAddress, channelID, Write Feed API Key. Il resto delle cose non sono richieste ma sono comunque utili se i dati devono essere ricevuti dal web.

void setup () { // inserisci qui il tuo codice di configurazione, da eseguire una volta: // imposta la porta seriale su 115200 Serial.begin (115200); // Inizializza il ritardo seriale (1000); WiFi.mode (WIFI_STA); ThingSpeak.begin (client); // Inizializza ThingSpeak // todo: crea un'attività per leggere un pin per ottenere corrente e tensione e calcolare watt e temperatura del pannello solare xTaskCreate ( wifi_task, / * Task function. * / "Wifi_task", / * Stringa con il nome di attività. * / 1024 * 2, / * Dimensione dello stack in byte. * / NULL, / * Parametro passato come input dell'attività * / 5, / * Priorità dell'attività. * / NULL); / * Maniglia attività. * / Serial.print ("Lettura dati."); }

Nel codice sopra, il server ThingSpeak viene inizializzato e viene creata un'attività che otterrà i dati relativi al pannello solare.

Nel circuito principale, la corrente e la tensione solare vengono rilevate tramite un pin analogico e viene eseguita la media.

float solar_curr_adc_val = 0; float solar_volt_adc_val = 0; for (i = 0; i <NUMSAMPLES; i ++) { curr_samples = analogRead (curr_an_pin); volt_samples = analogRead (volt_an_pin); temp_samples = analogRead (ntc_temp_an_pin); ritardo (10); } // media tutti i campioni fuori float curr_avg = 0; float volt_avg = 0; float temp_avg = 0; for (i = 0; i <NUMSAMPLES; i ++) { curr_avg + = curr_samples; volt_avg + = volt_samples; temp_avg + = temp_samples; } curr_avg / = NUMSAMPLES; volt_avg / = NUMSAMPLES; temp_avg / = NUMSAMPLES; //Serial.print("ADC VALUE = "); //Serial.println(ADC_VALUE); // converte il valore adc in tensioni per ottenere corrente e tensione effettive. float solar_curr = (curr_avg * 3.3) / (4095); float solar_volt = (volt_avg * 3.3) / (4095); // utilizzando un partitore di tensione diminuiamo la tensione effettiva. // per questo motivo moltiplichiamo il 6 con la tensione media per ottenere la tensione effettiva del pannello solare. solar_volt * = 6;

La tensione solare viene inviata moltiplicando per 6 poiché abbiamo creato il partitore di tensione che dividerà la tensione di ingresso per 6 volte.

La temperatura viene generata dal termistore utilizzando una formazione logaritmica.

// converte il valore in resistenza temp_avg = 4095 / temp_avg - 1; temp_avg = SERIESRESISTOR / temp_avg; //Serial.print("Thermistor resistance "); //Serial.println(temp_avg); float steinhart; steinhart = temp_avg / THERMISTORNOMINAL; // (R / Ro) steinhart = log (steinhart); // ln (R / Ro) steinhart / = BCOEFFICIENT; // 1 / B * ln (R / Ro) steinhart + = 1.0 / (TEMPERATURENOMINAL + 273.15); // + (1 / To) steinhart = 1.0 / steinhart; // Inverti steinhart - = 273,15; // converte la temperatura assoluta in C

I dati vengono letti ogni 15 secondi.

ritardo (1000); count ++; Serial.print ("."); if (count> = 15) { count = 0; Serial.println ("============================================= ============================ "); Serial.print ("Solar Voltage ="); Serial.println (solar_volt); Serial.print ("Solar Current ="); Serial.println (solar_curr); float solar_watt = solar_volt * solar_curr; Serial.print ("Solar Watt ="); Serial.println (solar_watt); Serial.print ("Solar Temperature ="); Serial.println (steinhart); Serial.println ("============================================= ============================ ");

I dati per i rispettivi campi vengono trasmessi utilizzando la funzione Thing.Speak.setField (); quando il WiFi è connesso.

if (WiFi.status () == WL_CONNECTED) { ThingSpeak.setField (1, solar_volt); ThingSpeak.setField (2, solar_curr); ThingSpeak.setField (3, solar_watt); ThingSpeak.setField (4, steinhart); // scrive nel canale ThingSpeak int x = ThingSpeak.writeFields (channelID, writeFeedAPIKey); if (x == 200) { Serial.println ("Aggiornamento canali riuscito."); } else { Serial.println ("Problema di aggiornamento del canale. Codice di errore HTTP" + String (x)); } } altrimenti { Serial.println ("\ r \ n ################################### ####################### "); Serial.println ("Impossibile aggiornare i dati su thingSpeak Server."); Serial.println ("WiFi non connesso…"); Serial.println ("########################################### ############### \ r \ n "); } Serial.print ("Lettura dati."); } }

L'attività Wi-Fi creata nello snippet di codice seguente-

void wifi_task (void * parameter) { while (1) { if (WiFi.status ()! = WL_CONNECTED) { Serial.print ("Attempting to connect to SSID:"); Serial.println (WLAN_SSID); while (WiFi.status ()! = WL_CONNECTED) { WiFi.begin (WLAN_SSID, WLAN_PASS); // Connettiti alla rete WPA / WPA2. Modificare questa riga se si utilizza una rete aperta o WEP Serial.print ("."); ritardo (5000); } Serial.println ("\ nConnected."); Serial.println (); Serial.println ("WiFi connesso"); Serial.println ("indirizzo IP:"); Serial.println (WiFi.localIP ()); } vTaskDelay (1000 / portTICK_PERIOD_MS); } vTaskDelete (NULL); }

Dati di test e monitoraggio

Il pannello solare è collegato al circuito e posto alla luce del sole per il test come mostrato di seguito.

Il funzionamento completo è mostrato nel video sottostante. Il nostro circuito è stato in grado di leggere la tensione di uscita, la corrente e la potenza dal pannello e aggiornarlo in tempo reale sul canale thingspeak come mostrato di seguito.

Come possiamo vedere, i dati di 15 minuti sono mostrati nel grafico sopra. Poiché si tratta di un progetto operativo all'aperto, è necessario utilizzare un PCB appropriato insieme a una scatola chiusa. L'involucro deve essere realizzato in modo tale che il circuito rimanga impermeabile in caso di pioggia. Per modificare questo circuito o per discutere ulteriori aspetti di questo progetto, utilizzate gentilmente il forum attivo di Circuit Digest. Spero ti sia piaciuto il tutorial e hai imparato qualcosa di utile.