..working on! :-D
by Mirco Piccin aka pitusso - CC BY-SA
Sezioni:
E’ un sistema opensource di monitoraggio e controllo per ambienti domestici o industriali:
http://www.openenergymonitor.org
Ovvero un sistema in grado di raccogliere informazioni (temperature, consumi, etc ) e rappresentarle con dei grafici di vario tipo.
Oltre a questa componente sw, il progetto comprende anche dei moduli hw basati su Arduino ma ottimizzati, per esempio, per gestire determinati tipi di sensori.
Rispetto a sistemi analoghi di raccolta e pubblicazione dati, che prevedono un esclusivo utilizzo cloud, OpenEnergyMonitor è disponibile anche in download e quindi è installabile ed utilizzabile in una rete locale.
La qual cosa è sicuramente una nota positiva, considerando che i dati relativi ai nostri consumi - direttamente correlati a quel che facciamo e quando - sono di fatto dati sensibili.
Per realizzare gli esempi che seguiranno, è indifferente il tipo di istanza (locale o cloud).
Per l’installazione è possibile seguire la guida ufficiale
Per utilizzare invece la versione cloud, è possibile creare un account qui:
http://emoncms.org/
Sia nel caso di installazione locale, che di uso su cloud, come primo passo per l’utilizzo della piattaforma, è necessario creare un account.
Ad ogni login, veniamo indirizzati alla pagina del nostro profilo.
Per poter iniziare a popolare il nostro account, dobbiamo come prima cosa recuperare la apikey.
Questa ci permette di accedere a risorse di emoncms o appunto di postare dati da sensori, senza necessità di effettuare un login.
In alto troviamo un menu
selezioniamo Input e ci ritroviamo nella pagina in cui troveremo elencati i nostri input.
Troviamo sulla destra il link Input API help
Nella pagina che si apre, innanzitutto ci vengono fornite le apikey di lettura -utili se vogliamo condividere input, feed, dashboard o altro con utenti esterni, e le apikey di scrittura - quella che ci servirà per inviare dati a emoncms.
La modalità di invio la troviamo nella stessa pagina, nella sezione Post data, ed in particolare nella sottosezione API KEY.
Per inviare dati, utilizzeremo una query get come questa: http://<emoncms_url>/input/post?json={power:200}&apikey=<apikey>
<emoncms_url> rappresenta la url del cms di OpenEnergyMonitor (da sostituire con emoncms.org in caso di uso cloud).
<apikey> rappresenta il codice univoco di 32 caratteri esadecimali, che sarà univoco per ogni utenza / installazione
I dati vengono i questo caso passati a emoncms in formato json.
La coppia variabile (qui power) : valore (qui 200, del tutto arbitrario) è racchiusa tra parentesi graffe.
Possimo quindi provare a copiare quella url sulla barra di navigazione di un web broswer, e premere invio.
La scritta "ok" apparirà sul browser a conferma dell’avvenuta imputazione.
Ora, se ritorniamo nella pagina Input troveremo una sezione titolata No Group, che espanderemo con il +
Troviamo un input configurato: esattamente quello passato con la url (variabile e valore son i medesimi)
Nel caso volessimo gestire più input, è sufficiente modificare la url.Per esempio (ricordarsi di sostituire <emoncms_url> e <apikey> con i valori corretti):
http://<emoncms_url>/input/post?json={temp:21,light:300}&apikey=<apikey>
in questo caso passiamo altre 2 coppie variabile:valore, separati da una virgola (anche qui i valori passati son arbitrari)
Il risultato:
Ho predefinito quindi degli inputs per gestire consumo, luminosità e temperatura.
I dati ricevuti non sono storicizzati, nel senso che ho a disposizione solo l'ultimo valore inserito.
Per poter mantenere uno storico (log) dei dati ricevuti, si utilizza un feed.
Il feed è utile anche per interconnettere input diversi secondo operazioni più o meno elementari.
Per esempio possiamo voler sommare i consumi letti da più sensori.
Oppure convertire i consumi in valore in valuta (secondo costo kwh).
Le operazioni eseguibili sono molte.
Uno schema di esempio:
Il primo feed da creare è di storicizzazione (logging), pertanto creiamo per ogni input, un feed di tipo Log to Feed
La creazione del Feed avviene selezionado l’Input dall’elenco nella pagina stessa degli Input
Nella pagina del Feed, selezionare dalla lista Log to Feed, il nome del Feed per la maggior parte dei casi potrà essere lo stesso dell’Input, oppure avere un nome autoesplicativo.
Quindi Add
Questo passaggio va effettuato per i 3 input.
Un altro feed utile per il monitoraggio dei consumi, è il Power to kWh/d, che permette di calcolare il consumo di kw nella giornata.
Al termine della creazione dei feed, il risultato potrebbe essere questo:
Nella stessa pagina, è possibile effettuare modifiche, eliminare o visualizzare il feed, usando le icone a fine riga
Tutti i passi sopra descritti, si ritrovano anche sul sito del progetto.
Per la gestione di sensori utilizzeremo:
oppure
Per la programmazione di Arduino, utilizzeremo il nuovo IDE 1.0.3
Nel caso si sia propensi ad utilizzare una connessione di rete cablata, è possibile utilizzare anche Arduino Ethernet invece di Arduino UNO + Ethernet Shield.
Come sensori, utilizzeremo :
Nel caso si utilizzi un Tinkerkit Sensor Shield, per termistore e fotoresistore è sufficiente dotarsi di :
altrimenti, per poter usare un fotoresistore e un termistore sono necessari, oltre ai due sensori stessi:
Per utilizzare la pinza amperometrica, oltre alla pinza amperometrica stessa:
Dotiamoci anche di:
Qui di seguito gli schemi di collegamento di ogni componente, con elencati nuovamente i componenti necessari:
Nello schema qui sopra, c’è una resistenza di carico il cui valore è "variabile", nel senso che varia in base al tipo di sensore amperometrico utilizzato. E’ necessaria se il sensore ha un output in corrente (Ampere), non se il sensore ha una uscita in tensione (Volt), in quanto la resistenza è embeddata nella pinza stessa - e quest’ultimo è il nostro caso, utilizzando una pinza SCT-013-030.
Tale informazione è reperibile anche nel datasheet del componente.
Qui una panoramica della serie di sensori di corrente CT-013 (nel riquadro rosso quello utilizzato in questo tutorial):
Traslando i singoli schemi sulla nostra breadboard, il risultato che otteniamo è pressapoco questo:
Per il collegamento della pinza amperometrica, che ha un jack da 3.5mm dello stesso tipo usato per cuffie stereo, ci sono 3 possibilità:
Io ho preferito quest’ultima possibilità, considerato che il connettore da pcb difficilmente si riesce ad utilizzare su breadboar o millefori, e che non mi piaceva l’idea di tagliare il jack lato sensore.
Per utilizzare questo jack Femmina è necessario munirsi di saldatore. A noi servono i segnali che viaggiano su GND e LEFT del jack (RIGHT è inutilizzato)
Predisponiamo quindi il nostro jack Femmina saldandoci un paio di cavi. Volendo poi possiamo saldare all’altro lato dei cavi, un paio di pin per facilitare l’utilizzo su breadboard (qui ho coperto poi la saldatura con della guaina termorestringente)
Prima di procedere, controlliamo tutti i collegamenti.
La pinza amperometrica va chiusa attorno ad uno dei 2 fili della corrente (non ad entrambi, o non si misurerà alcunchè!).
Nella pinza è presente una freccia, che sta ad indicare il "verso" della corrente.
E’ necessaria una taratura, che va effettuata aiutandosi con un misuratore di consumi funzionante.
Io ne avevo acquistato tempo fa uno in una catena di discount per meno di 10 eur.
Per una taratura più facile, per esempio, ho preparato una piccola prolunga con uno dei cavi accessibile.
Per poter quindi convertire la lettura del sensore di corrente, approfittiamo dell’ottimo lavoro svolto da Trystan e dal team del progetto OpenEnergyMonitor.
Scarchiamo la libreria Emonlib da qui:
https://github.com/openenergymonitor/EmonLib
e installiamola in Arduino (per l’installazione della libreria : http://arduino.cc/en/Guide/Libraries)
Per poter invece convertire il dato recuperato dal termistore in formato celsius, utilizziamo la funzione getCelsius() scritta da Federico Vanzati per il modulo termistore del TinkerKit, nell’omonima libreria (che non è necessario installare, nel codice ho riportato la sola funzione necessaria)
Collegare quindi Arduino al pc, avviare l'IDE, e caricare lo sketch di test e calibrazione presente qui
Ci sono delle costanti, ad inizio codice:
const int volt = 220;
const float ct_calibration = 29;
const float temp_offset = 0;
volt indica il voltaggio presente nel nostro impianto (può variare tra i 210 e 220 volt, serve per il calcolo del consumo)
ct_calibration indica il fattore per la calibrazione della pinza amperometrica
temp_offset indica un valore che andrà aggiunto (o sottratto, se negativo) al valore tornato dalla funzione getCelsius
Il valore ct_calibration settato qui di default a 29 viene calcolato dal rapporto:
Turn Ratio / Burden Resistor
L’informazione relativa al Turn Ratio si recupera dal datasheet.
Burder Resistor corrisponde invece alla resistenza di carico che nel nostro caso è embeddata nella pinza amperometrica (si tratta della resistenza di carico dal valore variabile, di cui si è parlato contestualmente allo schema di utilizzo).
Anche in questo caso, tale informazione è recuperabile dal datasheet.
Quindi:
ct_calibration = 1800/62 = 29
Procediamo con la taratura.
Aprendo il monitor seriale, vedremo i valori raccolti dai nostri sensori con la configurazione di default.
Temp : 21.79 ; Light : 777 ; Power : 250.83
Temp : 21.69 ; Light : 780 ; Power : 250.82
Temp : 21.79 ; Light : 782 ; Power : 250.70
Temp : 21.79 ; Light : 776 ; Power : 260.03
Se copriamo con la mano il fotoresistore, vedremo che il valore letto scenderà. Raggiungere lo 0 (zero) è quasi impossibile, così come 1023, ovvero i valori di inizio e fine scala (sono 1024 i valori possibili). Questo perchè si tratta di un sensore analogico, soggetto a interferenze fisiche.
Per calibrare il termistore, abbiamo bisogno di un termometro di riferimento.
Nel caso specifico, il risultato della conversione è 21.79°C, mentre in realtà la temperatura è di 20.5°C.
Quindi il mio offset sarà di -1.2
Per quel che riguarda il sensore di corrente, per la taratura si può utilizzare la seguente formula:
nuova_calibrazione = (lettura_corretta / lettura_arduino) * attuale_calibrazione
Nel caso specifico, leggo un consumo di 260w, mentre in realtà in mio lettore di consumi ne registra 220w.
Quindi:
nuova_calibrazione = (220 / 260) * 29 = 24.5
Vado quindi a modificare i valori di configurazione in testa al codice, ricarico nuovamente il codice su Arduino, e riverifico.
const int volt = 213;
const float ct_calibration = 24.5;
const float temp_offset = -1.2;
Il procedimento potrebbe essere eseguito più e più volte e/o in modo più raffinato, fintanto che si ottengono dei risultati soddisfacenti
Abbiamo visto come caricare dei dati manualmente su emoncms , utilizzando delle url.
Abbiamo anche visto come collegare i sensori ad Arduino, e come leggere i dati.
Ora uniamo le due cose, e facciamo aggiornare i dati su OpenEnergyMonitor in modo automagico da Arduino.
Prima di cominciare dobbiamo aggiornare lo sketch definitivo alle nostre esigenze.
Lo si può scaricare qui
Come prima cosa, modifichiamo le seguente riga: String apikey = "abababcdcdcdefefef001122334567890";
int node = 0;
apikey è la chiave che abbiamo recuperato qui e con cui abbiamo già fatto qualche prova
node rappresenta un indice che è di aiuto nel momento in cui si abbiano più Arduino e si vogliano di conseguenza raggruppare gli input. Lasciato a 0 (zero) non ha alcun effetto.
Passiamo poi a modificare le righe di configurazione dei sensori, con i valori recuperati in fase di calibrazione (di seguito i miei valori):
const int volt = 213;
const float ct_calibration = 24.5;
const float temp_offset = -1.2;
Pr quanto riguarda invece la connettività, questo codice è valido sia nel caso si utilizzi uno shield Ethernet, che uno shield Wifi, con poche modifiche.
La prima riga di codice che troviamo è:
#define WIFI
Nel caso si utilizzi uno shield Ethernet (o Arduino Ethernet), questa riga è da commentare (anteponendole la doppia slash //).
Se si sta utilizzando uno shield Wifi, le righe da modificare sono: char ssid[] = "ssid";
char pass[] = "password";
Andranno inserite qui le corrette credenziali per accedere alla rete wifi.
Questi dati verranno usati più avanti nel codice: status = WiFi.begin(ssid, pass);
Nel caso si utilizzi una rete aperta, tale riga andrà aggiornata eliminando il parametro pass: status = WiFi.begin(ssid);
E' possibile trovare maggiori informazioni o modalità di uso di tale funzione qui.
Debitamente aggiornato lo sketch e caricato su Arduino, all'avvio apriamo il monitor seriale:
Emoncms client starting...
Attempting to connect to SSID: your_ssid
Connected to wifi
SSID: your_ssid
IP Address: xxx.xxx.xxx.xxx
signal strength (RSSI):-74 dBm
Temp : 21.98 ; Light : 423 ; Power : 75.31
Connecting...
HTTP/1.1 200 OK
Date: Tue, 08 Jan 2013 17:27:58 GMT
Server: Apache/2.2.17 (Ubuntu)
X-Powered-By: PHP/5.3.5-1ubuntu7.11
Disconnecting...
Se si sta utilizzando invece lo shield Ethernet (o Arduino Ethernet), ci sono due possibilità.
Se nella rete è attivo un servizio dhcp, la configurazione della parte parte di rete può venire trascurata.
La riga di codice : Ethernet.begin(mac)
fa infatti in modo che lo shield Ethernet ottenga automaticamente un indirizzo valido.
In alternativa, le righe: IPAddress ip(192, 168, 1, 2);
IPAddress subnet(255, 255, 255, 0);
IPAddress dns(8, 8, 8, 8);
IPAddress gw(192, 168, 1, 254);
andranno aggiornate con i dati relativi alla vostra rete.
ip rappresenta l'indirizzo ip che volete assegnare ad Arduino
subnet rappresenta la sottorete, il valore presente dovrebbe andare bene nella maggior parte dei casi
dns rappresenta il dns server, anche in questo caso il valore presente dovrebbe andare bene nella maggior parte dei casi
gw rappresenta il gateway, e nella maggior parte dei casi corrisponde all'indirizzo ip del router (simile all'indirizzo ip di Arduio, ma con otteto finale 1 oppure 254).
Tali dati verranno utilizzati più avanti nel codice: Ethernet.begin(mac, ip, dns, gw, subnet);
E' possibile trovare maggiori informazioni o modalità di uso di tale funzione qui.
Debitamente aggiornato lo sketch e caricato su Arduino, all'avvio apriamo il monitor seriale:
Emoncms client starting...
IP address: xxx.xxx.xxx.xxx.
Temp : 20.94 ; Light : 801 ; Power : 128.96
Connecting...
HTTP/1.1 200 OK
Date: Tue, 08 Jan 2013 17:26:36 GMT
Server: Apache/2.2.17 (Ubuntu)
X-Powered-By: PHP/5.3.5-1ubuntu7.11
Vary: Accept-Encoding
Content-Length: 2
Connection: close
Content-Type: text/html
ok
Disconnecting...
Questo codice ogni 10 secondi effettua una GET per imputare la lettura dei sensori.
Nel caso si voglia variare questo intervallo, modificare il valore della costante postingInterval nella riga (valore in millisecondi): const unsigned long postingInterval = 10*1000;
Per poter visualizzare i dati imputati in modo grafico, si possono utilizzare vari modi.
Quello che permette più libertà è l'utilizzo di dashboard.
In una dashboard è possibile inserire grafici, dial (gauge), testo, html, etc.
Creiamo quindi una dashboard che ci permetta di visualizzare i dati dei nostri sensori.
Dal menu nella parte alta, selezioniamo Dashboard
Con il pulsante + è possibile creare una nuova dashboard, che si potrà modificare selezionando la prima icona nella colonna corrispondente alle Actions
Ci troviamo quindi nell'ambiente di disegno della dashboard.
Ci sono qui una serie di strumenti a disposizione.
Per inserire un oggetto prima lo si seleziona nella barra degli strumenti, ed in seguito si click-a con il mouse nell'area della dashboard in cui lo si vuole inserire.
Ogni oggetto inserito nella dashboard mostra, se selezionato, 5 piccoli quadrati grigi (uno centrale e uno per lato): permettono di spostare l'oggetto stesso o ridimensionarlo.
Ogni oggetto importato è ad un livello superiore dei precedenti, ovvero se sovrapposto a quelli già presenti, li nasconderà.
Come prima cosa inseriamo un Container-White e in seguito un Text heading-center, che sposto sopra al container.
In questo modo posso definire un titolo ben visibile per la dashboard.
Non appena selezioniamo un oggetto, sulla barra degli strumenti appaiono:
Quindi, con l'oggetto testo appena inserito selezionato, utilizzando Options posso definire il testo del titolo.
Creiamo un nuovo Container-White, ed in seguito un Widget dial
Il Widget dial cambia dinamicamente valore in tempo reale, in base al valore del feed di cui visualizza i dati.
Appena inserito, lavoriamo sulle Options per fare in modo di visualizzare il nostro consumo
E' possibile definire:
Ora inseriamo una Visualization rawdata, che permette di visualizzare la serie di valori presenti nel feed, in un grafico a linea zoom-abile e navigabile.
Non appena inserito, ridimensioniamolo e collochiamolo di fianco al Widget dial.
Lavoriamo quindi sulle Options, è possibile definire:
Possiamo quindi aggiungere un Text paragraph per inserire un testo descrittivo del container.
Procediamo quindi inserendo dei container analoghi per Temperatura e Luce.
Per la temperatura, inseriamo quindi un Container-White e un Widget dial, e definiamone le opzioni (max 35 e type 8)
Quindi inseriamo una Visualization rawdata e definiamone le opzioni
Infine aggiungiamo un Text paragraph per la descrizione del container.
Per la luce, con lo stesso criterio, inseriamo un Container-white, un Widget dial (con opzioni max 1023 e type 7), una Visualization rawdata e un Text paragraph.
In questa dashboard, è rimasto parecchio spazio vuoto.
Possiamo riempirlo ridimensionando a piacimento gli oggetti inseriti, oppure possiamo inserire informazioni addizionali.
Questo è possibile perchè lo strumento Text permette di inserire anche codice html.
Nel nostro esempio, inseriamo una piccola mappa con le previsioni meteo per la regione Veneto (in cui vivo), utilizzando un iframe. Di fatto un iframe permette di "inglobare" in un'area di una pagina web, il contenuto di una seconda pagina web.
Nel caso specifico, si tratta di un'immagine dinamica, che ogni giorno varia.
Quindi, inserimento Container-white, inserimento di un Text paragraph e tramite Options definizione del contenuto html.
Come contenuto inseriamo:<iframe src="http:\/\/www.ilmeteo.it/cartine2/0.VEN.png" width="250" height="287" frameborder="0"></iframe>
Il passo successivo è la configurazione della dashboard.
Utilizzano l'icona a forma di chiave inglese presente sopra alla barra degli strumenti
possiamo quindi definire:
Chiusa la finestra di configurazione, utilizzando la action con icona a forma di occhio, è possibile visionare la dashboard, dopo gli ultimi ritocchi (spostamenti e ridimensionamenti).
Ora torniamo all'elenco delle dashboard (Menu in alto voce Dashboard).
Nella colonna Actions ci sono una serie di icone.
La prima icona abbiamo già visto che ci serve per modificare la dashboard.
La seconda icona, a forma di occhio, ci permette di visualizzarla.
La terza icona, a forma di cestino, la elimina.
La quarta icona, con le 2 frecce incrociate, permette di clonarla in una nuova dashboard.
Le colonne Main, Published, Public rappresentano i valori definiti nella precedente configurazione.
Di default una dashboard è privata.
Se però si volesse renderla pubblica, le operazioni da eseguire sono di fatto 2.
Come prima cosa, rendere pubblici i feed utilizzati nella dashboard (altrimenti non si visualizzeranno dati). Per fare ciò, spostarsi sui feed.
E' sufficiente un click sull'icona a forma di lucchetto, per far diventare il feed pubblico (icona a forma di mondo).
Ora torniamo sulle dashboard, anche qui è sufficiente un click sull'icona a forma di lucchetto per renderla pubblica.
Se non lo abbiamo ancora fatto, rendiamola anche pubblicata.
Apparirà un'icona nella colonna Share
con un clink su quell'icona, si accede alla dashboard; la url presente nella barra degli indirizzi è quella necessaria per la condivisione.
Di seguito un altro paio di dashboard, facilmente realizzabili.
Questa rappresenta solo dati relativi a consumi. Nella parte alta si visualizzano i dati in tempo reale (Widget dial e Visualization realtime), nella parte inferiore i dati storicizzati (Visualization rawdata e Visualization bargraph)
Questa rappresenta i dati relativi a temperatura e luminosità esterni.
La visualizzazione dei dati è fatta con Widget dial e Visualization rawdata.
Approfondimenti sugli oggetti a disposizione si trovano nella guida ufficiale di Emoncms
Inoltre qui sono disponibili le dashboard pubbliche degli utenti di emoncms.org
Abbiamo utilizzato in questo tutorial componenti di facile reperibilità.
I sensori di temperatura e di luce sono standard e di costo molto basso.
Ovviamente è possibile utilizzare sensori di temperatura più precisi e affidabili (vedi LM35 o DS18B20), ma che hanno costi superiori.
E’ inoltre possibile collegare più sensori ad una unica Arduino.
Il circuito realizzato sulla breadboard è ovviamente portabile su millefori o proto shield, se non su un semplice pcb, realizzato in modo casalingo con la tecnica del toner transfer.
Per quel che riguarda invece OpenEnergyMonitor, abbiamo costruito una dashboard molto semplice.
Approfondendo sul sito del progetto, è possibile imparare ad utilizzare molti altri strumenti, più o meno avanzati, per realizzare dashboard più complete, riepilogative e accattivanti.