Tesina sul Monitoraggio Fotovoltaico

1.5 La trasmissione dei dati

La trasmissione dei dati raccolti da Arduino verso il database

viene effettuata attraverso l'Ethernet Shield ufficiale di Arduino

connesso ad un router e ad una pennetta 3g. In questo modo è

possibile sfruttare questo dispositivo ovunque ci sia una

sufficiente ricezione telefonica ed un'alimentazione sufficiente.

L'Arduino utilizza il protocollo http, che interrogando pagine php

permette l'elaborazione ed il caricamento dei dati nel database.

1.6 L'elaborazione/archiviazione dei dati

Su un servizio di hosting come quello di altervista, che utilizza

la accoppiata MySQL/PHP, è stato attivato un servizio di database.

I dati raccolti sono immagazzinati in un database MySQL, che viene

poi interrogato per la costruzione delle varie statistiche e per

la creazione dei grafici.

Proprio per i grafici vengono utilizzate le API Google, che

permettono in maniera abbastanza semplice di disegnarne degli

ottimi.

2. La realizzazione

2.1 Progetto circuito elettrico

Considerando che l'arduino accetta in ingresso solamente tensioni

comprese tra 0 e 5V, il circuito di condizionamento è stato

progettato affinché la tensione massima che il pannello è in grado

di generare in uscita corrisponda a 5V.

Per poter verificare quanta corrente scorre su di un carico e

quindi, successivamente, calcolare la potenza assorbita è stato

necessario aggiungere al progetto un blocco composto da una serie

di resistori che, commutati uno alla volta, vengono applicati in

parallelo al pannello.

Il circuito è stato realizzato attraverso opportune reti resistive

ed un integrato contenente amplificatori operazionali.

2.2 Reperimento dei materiali

Sono stati utilizzati comuni materiali facilmente reperibili in

commercio, quali resistori, trimmer, resistori di potenza, diodi

led e l'integrato LM324.

Part list:

n.1 integrato LM324

• n.5 morsetti bipolari

• n.1 trimmer da 10k

• n.1 trimmer da 220k

• n.1 trimmer da 470k

• n.1 diodo led

• n.1 potenziometro a scatti 11 posizioni

• n.1 condensatore elettrolitico da 100uF

• n.1 condensatore da 100nF

• n.4 resistori da 1/4 di watt

• n.9 resistori di potenza

• n.1 arduino uno

• n.1 arduino ethernet shield

• n.1 router

• n.1 pennetta 3G

• n.1 display LCD 48x84

•

2.3 Montaggio e collaudo circuito elettrico

Il circuito di condizionamento è stato prima creato e simulato su

software Multisim della National Instruments e successivamente

riportato e cablato su una basetta breadboard.

Per una corretta amplificazione degli operazionali, abbiamo

utilizzato dei trimmer da calibrare in modo che l'uscita

dall'amplificatore si trovasse nell'intervallo desiderato.

Il circuito è stato montato seguendo lo schema elettrico .

2.4 Rilevazione dei dati

La rilevazione dei dati avviene attraverso le porte analogiche

dell'arduino.

Esse leggono un valore compreso tra 0 e 1023 (intervallo

corrispondente a 0÷5V).

Attraverso una proporzione è stato quindi possibile calcolare il

valore reale della corrente ed inviarlo al database.

Nella lettura dall'arduino avviene la perequazione, ovvero

l'arduino effettua 11 letture al secondo, e attraverso il metodo

statistico arriva ad ottenere un unico valore che invierà al

database. Questa operazione è necessaria affinché eventuali errori

casuali nella lettura vengano limitati.

2.5 Realizzazione Database

Considerando che il progetto prevede la misurazione di Tensione e

Corrente il database creato è così strutturato:

Il database è formato da due tabelle: una contenente il valore

della tensione misurato la data e l'ora della misurazione, ed

un'altra tabella dove vengono memorizzate la corrente e la

tensione misurate.

La seconda tabella ha una foreign key collegata alla chiave

primaria della tabella delle tensioni, cosicché, con le necessarie

accortezze, alla modifica o alla cancellazione di una riga nella

tabella delle tensioni la riga collegata nella tabella della

corrente farà la stessa operazione a cascata.

2.6 Comunicazione dati

Per la comunicazione dei dati è stato scelto il protocollo http,

dato che l'Arduino deve collegarsi con un webserver per l’invio

dei dati ad un database remoto.

La comunicazione avviene attraverso la shied ethernet dell'Arduino

ed il router a cui è collegato.

2.7 Realizzazione sito web

Nella realizzazione del sito web è stato necessario utilizzare più

linguaggi. In HTML sono state create le pagine statiche, ad

esempio tutte quelle contenenti le spiegazioni teoriche o gli

schemi.

In PHP sono invece state create le pagine dinamiche o quelle che

devono interagire con il database.

Una delle pagine dinamiche è ad esempio quella dei download, che

controlla con che browser viene aperto il sito prima di impostare

gli indirizzi dei file di download.

Le pagine che invece devono interagire con il database sono per lo

più collegate alla pagina "Produzione elettrica", tutti i dati

mostrati in quella pagina vengono infatti estratti dal database.

Con questo linguaggio è stata creata anche la pagina contatti,

cioè quella adibita ad inviare mail con le richieste degli utenti

al proprietario del sito.

Per alcune pagine, come quella "Produzione elettrica", che

necessita di aggiornare frequentemente gli indicatori della

tensione e della corrente, è stato utilizzato il javascript che ad

intervalli di tempo regolari, aggiorna la posizione della lancetta

sul misuratore, il grafico a spezzate della tensione, o i vari

valori mostrati.

3. Gli Utilizzi

3.1 Introduzione

Il nostro progetto è un sistema che permette di monitorare un

pannello fotovoltaico rendendo noti i dati relativi alla

produzione elettrica del pannello in tempo reale.

Quest'esperienza, sebbene si tratti di un progetto di contenuta

complessità, nonché in scala, potrebbe simulare un impianto su

scala più ampia che svolge le stesse funzioni.

Un sistema analogo di opportune proporzioni potrebbe monitorare,

infatti, la produzione di piccoli impianti autonomi (stand-alone).

3.2 Utilizzi

Questa figura rappresenta un piccolo impianto fotovoltaico

autonomo in cui è possibile utilizzare una serie di pannelli,

regolati tramite un opportuno regolatore di carica, per alimentare

ad esempio elettrodomestici.

Lo stesso sistema può essere adoperato per alimentare altri tipi

di dispositivi, quali lampade a led, lampade a risparmio

energetico, caricabatterie ed altri utilizzatori che richiedono

una modesta potenza elettrica.

Il nostro progetto è assolutamente applicabile a questo genere di

apparati, permettendo la visualizzazione della produttività del

fotovoltaico.

4. Schemi e codice

4.1 Schema Generale

4.2 Schema elettrico

4.3 Codice Arduino

4.3.1 Lo sketch

#include <SPI.h>

#include <Ethernet.h>

#include <stdio.h>

byte mac[] = { 0x90, 0xA2, 0xDA, 0x0D, 0xD5, 0x37 };

//byte server[] = { 178,63,11,147 }; // Altervista

char server[] = "www.monitoraggiofotovoltaico.altervista.org";

EthernetClient client;

const float VMax = 20.00; // tensione massima prodotta dal pannello

const float IMax = 300.00; // corrente massima prodotta dal pannello

int led_con_1 = 1;

int led_con_2 = 2;

int sensorPinV = A0;

int sensorPinI = A2;

//LCD

#define PIN_SCE 8 // SCE

#define PIN_RESET 7 // RST

#define PIN_DC 6 // D/C

#define PIN_SDIN 5 // DN(MOSI)

#define PIN_SCLK 4 // SCLK

int led = 3; // LED = Retroilluminazione LCD

int lagnd = 9;

int alim = 10;

#define LCD_C LOW

#define LCD_D HIGH

#define LCD_X 84

#define LCD_Y 48.

void setup()

{ Serial.begin(9600);

pinMode(led, OUTPUT); //LED Retroilluminazione

pinMode(lagnd, OUTPUT);

pinMode(alim, OUTPUT);

digitalWrite(lagnd, LOW);

digitalWrite(alim, HIGH);

digitalWrite(led, HIGH);

LcdInitialise();

LcdClear();

LcdString("connessione");

Serial.println("Connessione...");

pinMode(led_con_1, OUTPUT);

pinMode(led_con_2, OUTPUT);

pinMode(sensorPinV, INPUT);

pinMode(sensorPinI, INPUT);

if(Ethernet.begin(mac) == 0)

{ LcdClear();

gotoXY(1,1);

LcdString("Failed to");

gotoXY(1,10);

LcdString("configure");

gotoXY(1,20);

LcdString("Ethernet");

Serial.println("Failed to configure Ethernet using DHCP");

}

delay(1000); // give the Ethernet shield a second to initialize

LcdClear();

gotoXY(1,1);

LcdString("Ethernet");

gotoXY(1,10);

LcdString("initialized");

Serial.print("This IP address: ");

IPAddress myIPAddress = Ethernet.localIP();

Serial.print(myIPAddress);

delay(500);

LcdClear();

gotoXY(0,10);

LcdString("connessione");

LcdString(" in corso...");

delay(1500);

LcdClear();

}

void loop()

{ if (client.available())

{ char c = client.read();

Serial.print(c);

}

if (!client.connected())

{ Serial.println();

digitalWrite(led_con_1, HIGH);

digitalWrite(led_con_2, LOW);

LcdClear();

Serial.println("Connessione in corso...");

client.stop();

delay(1000);

LcdClear();

}

if (!client.connected()){

httpRequest();

}

}

4.3.2 Le funzioni

Sono inoltre presenti alcune funzioni; per vedere quelle

necessarie per il funzionamento del display vai nella pagina

download e scarica il file zip contenete il codice completo

caricato su arduino.

Le altre funzioni presenti sono:

httpRequest(), necessaria in quanto è quella che effettua le

letture ed invia i risultati al database.

void httpRequest() {

// if there's a successful connection:

if (client.connect(server, 80))

{ gotoXY(0,0);

LcdString("Connesso");

Serial.println("Connesso");

digitalWrite(led_con_1, LOW);

digitalWrite(led_con_2, HIGH);

float ValTen[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

float ValCor[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

for (int i=0; i <= 10; i++)

{ int ten_In = analogRead(sensorPinV);

ValTen[i] = ((5/1024)*(float)ten_In);

int cor_In = analogRead(sensorPinI);

ValCor[i] = ((5/1024)*(float)cor_In);

delay(80);

}

float ten = PEREQ(ValTen);

float cor = PEREQ(ValCor);

float tenV = (ten*(VMax/5));

float corV = (cor*(IMax/5));

gotoXY(0,10);

LcdString("V: ");

char laten[7];

dtostrf(tenV,2,2,laten);

LcdString(laten);

gotoXY(0,20);

LcdString("mA: ");

char lacor[7];

dtostrf(corV,2,2,lacor);

LcdString(lacor);

Serial.print("Tensione: ");

Serial.print(ten);

Serial.print(" -> ");

Serial.println(tenV);

Serial.println();

Serial.print("Corrente: ");

Serial.print(cor);

Serial.print(" -> ");

Serial.println(corV);

Serial.println();

Serial.println("Richiesta http in corso");

// HTTP request:

client.println();

client.print("GET /pagina.php?volt=");

client.print(tenV);

client.print("&ampere=");

client.print(corV);

client.println(" HTTP/1.0");

client.println("Host: nomehost.it");

client.println("User-Agent: arduino-ethernet");

client.println("Connection: close");

client.println();

Serial.println("Richiesta http completata");

}

else

{ Serial.println("Connessione fallita");

Serial.println("Disconnesso.");

gotoXY(0,0);

LcdString("Connessione fallita");

gotoXY(0,20);

LcdString("Disconnesso.");

client.stop();

delay(1000);

LcdClear();

}

}

PEREQ(), che è la funzione che ha il compito di effettuare la

perequazione dei valori letti.

float PEREQ(float Vettore[10])

{ float Ret=0;

float N1 = ((Vettore[0]+Vettore[1]+Vettore[2]+Vettore[3]+Vettore[4])/5);

float N2 = ((Vettore[1]+Vettore[2]+Vettore[3]+Vettore[4]+Vettore[5])/5);

float N3 = ((Vettore[2]+Vettore[3]+Vettore[4]+Vettore[5]+Vettore[6])/5);

float N4 = ((Vettore[3]+Vettore[4]+Vettore[5]+Vettore[6]+Vettore[7])/5);

float N5 = ((Vettore[4]+Vettore[5]+Vettore[6]+Vettore[7]+Vettore[8])/5);

float N6 = ((Vettore[5]+Vettore[6]+Vettore[7]+Vettore[8]+Vettore[9])/5);

float N10 = ((N1+N2+N3+N4+N5)/5);

float N11 = ((N2+N3+N4+N5+N6)/5);

Ret = ((N10+N11)/2.);

return Ret;

}

5. Conoscenze

5.1 Elettronica

5.1.1 Circuito di condizionamento

Per poter analizzare le funzionalità del pannello fotovoltaico e

monitorarle tramite Arduino è necessario condizionare la sua

tensione di uscita per adattarla alla dinamica d'ingresso standard

dell'Arduino, ovvero compresa tra 0 e 5V.

Il blocco di condizionamento può offrire funzionalità quali

amplificazione o attenuazione del segnale, adattamento di

impedenze, traslazione della curva caratteristica del segnale di

uscita, inversione della curva caratteristica e filtraggio.

Il nostro circuito di condizionamento deve essere configurato in

modo tale che l'Arduino possa leggere sia la tensione fornita dal

pannello fotovoltaico, sia la corrente che scorre su un eventuale

carico applicato. Per fare ciò abbiamo utilizzato il circuito

integrato LM324 che contiene 4 amplificatori operazionali, di cui

ne abbiamo usati soltanto tre.