Search the Arduino Playground 

Manuals and Curriculum

(http://playground.arduino.cc/Main/ManualsAndCurriculum)
Arduino StackExchange
(http://arduino.stackexchange.com)
Board Setup and Configuration
(http://playground.arduino.cc/Main/ArduinoCoreHardware)
Development Tools
(http://playground.arduino.cc/Main/DevelopmentTools)
Arduino on other Atmel Chips
(http://playground.arduino.cc/Main/ArduinoOnOtherAtmelChips)
Interfacing With Hardware
(http://playground.arduino.cc/Main/InterfacingWithHardware)
- Output
(http://playground.arduino.cc/Main/InterfacingWithHardware#Output)
- Input
(http://playground.arduino.cc/Main/InterfacingWithHardware#InputTOC)
- User Interface
(http://playground.arduino.cc/Main/InterfacingWithHardware#ui)
- Storage
(http://playground.arduino.cc/Main/InterfacingWithHardware#Storage)
- Communication
(http://playground.arduino.cc/Main/InterfacingWithHardware#Communication)
- Power supplies
(http://playground.arduino.cc/Main/IntWithHW-
PwrSup)
- General
(http://playground.arduino.cc/Main/InterfacingWithHardware#General)
Interfacing with Software
(http://playground.arduino.cc/Main/InterfacingWithSoftware)
User Code Library
(http://playground.arduino.cc/Main/GeneralCodeLibrary)
- Snippets and Sketches
(http://playground.arduino.cc/Main/SketchList)
- Libraries
(http://playground.arduino.cc/Main/LibraryList)
- Tutorials
 (http://playground.arduino.cc/Main/TutorialList)
Suggestions & Bugs
(http://code.google.com/p/arduino/issues/list)
Electronics Technique
(http://playground.arduino.cc/Main/ElectroInfoResources)
Sources for Electronic Parts
(http://playground.arduino.cc/Main/Resources)
Related Hardware and Initiatives
(http://playground.arduino.cc/Main/SimilarBoards)
Arduino People/Groups & Sites
(http://playground.arduino.cc/Main/People)
Exhibition
(http://playground.arduino.cc/Projects/ArduinoUsers)
Project Ideas
(http://playground.arduino.cc/Projects/Ideas)
Languages
(http://playground.arduino.cc/Main/Languages)

Partecipate
(http://playground.arduino.cc/Main/Participate)
- Formatting guidelines
(http://playground.arduino.cc/Main/Participate#contribrules)
- All recent changes
(http://playground.arduino.cc/Site/AllRecentChanges)
- PmWiki
(http://playground.arduino.cc/PmWiki/PmWiki)
- WikiSandBox training
(http://playground.arduino.cc/Main/WikiSandbox)
- Basic Editing
(http://playground.arduino.cc/PmWiki/BasicEditing)
- Documentation index
(http://www.pmwiki.org/wiki/PmWiki/DocumentationIndex)

..working on! :-D

Arduino e OpenEnergyMonitor
by Mirco Piccin aka pitusso (http://arduino.cc/forum/index.php?action=profile;u=21644) - CC BY-SA

Sezioni:

- Introduzione a OpenEnergyMonitor
- Primi passi con Emoncms
- Arduino e sensori
- Sketch di test e calibrazione
- Sketch definitivo
- Visualizzazione dati
- Conclusioni
Introduzione a OpenEnergyMonitor

Cos’è OpenEnergyMonitor
E’ un sistema opensource di monitoraggio e controllo per ambienti domestici o industriali:
http://www.openenergymonitor.org (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
(http://openenergymonitor.org/emon/Modules) basati su Arduino ma ottimizzati, per esempio, per
gestire determinati tipi di sensori.

Cosa ha di differente rispetto a Cosm, Thingspeak & co

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
(http://openenergymonitor.org/emon/emoncms/installation)
Per utilizzare invece la versione cloud, è possibile creare un account qui: http://emoncms.org/
(http://emoncms.org/)

Primi passi con Emoncms

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

(http://en.wikipedia.org/wiki/GET_HTTP#Request_methods) come questa:

http://<emoncms_url>/input/post?json= (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= (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 (http://openenergymonitor.org/emon/node/297) sono molte.

Uno schema (http://goo.gl/XD0s6) 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
(http://openenergymonitor.org/emon/emoncms/using-emoncms) del progetto.

Arduino e sensori
Per la gestione di sensori utilizzeremo:
- Arduino UNO (http://arduino.cc/en/Main/ArduinoBoardUno)
- shield Arduino Wifi (http://arduino.cc/en/Main/ArduinoWiFiShield)
oppure

- shield Arduino Ethernet (http://arduino.cc/en/Main/ArduinoEthernetShield)

Per la programmazione di Arduino, utilizzeremo il nuovo IDE 1.0.3
(http://arduino.cc/en/Main/Software)

Nel caso si sia propensi ad utilizzare una connessione di rete cablata, è possibile utilizzare anche
Arduino Ethernet (http://arduino.cc/en/Main/ArduinoBoardEthernet) invece di Arduino UNO +
Ethernet Shield.

Come sensori, utilizzeremo :

- un sensore temperatura (o termistore) da 4,7 kOhm

- una fotoresistenza (o LDR o fotoresistore) da 40< kOhm
- una pinza Amperometrica da 30A / 100A max - nello specifico SCT-013-030
Nel caso si utilizzi un Tinkerkit (http://www.tinkerkit.com/) Sensor Shield, per termistore e
fotoresistore è sufficiente dotarsi di :

- Tinkerkit LDR Sensor (http://www.tinkerkit.com/ldr/)

- Tinkerkit Thermistor Module (http://www.tinkerkit.com/thermistor/)
altrimenti, per poter usare un fotoresistore e un termistore sono necessari, oltre ai due sensori stessi:

- 2x resistenza da 10kOhm
Per utilizzare la pinza amperometrica, oltre alla pinza amperometrica stessa:

- 2x resistenza da 10kOhm
- 1x condensatore elettrolitico da 10uF
- 1x jack 3.5mm (d’obbligo se non si vuole "cannibalizzare" il connettore!)
Dotiamoci anche di:

- 1x breadboard,
- qb fili per breadboard
Qui di seguito gli schemi di collegamento di ogni componente, con elencati nuovamente i componenti
necessari:

Termistore
- 1x sensore temperatura (o termistore) da 4,7 kOhm
- 1x resistenza da 10kOhm

Fotoresistore

- 1x fotoresistenza (o LDR o fotoresistore) da 40< kOhm

- 1x resistenza da 10kOhm

Pinza amperometrica
- 1x pinza Amperometrica da 30A / 100A max - nello specifico SCT-013-030
- 2x resistenza da 10kOhm
- 1x condensatore elettrolitico da 10uF
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à:

- cannibalizzare il connettore, eliminandolo e collegando direttamente i cavi del sensore alla

breadboard
- utilizzare un connettore da pcb

- utilizzare un jack Femmina

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)

Sketch di test e calibrazione

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
(https://github.com/openenergymonitor/EmonLib)
e installiamola in Arduino (per l’installazione della libreria : http://arduino.cc/en/Guide/Libraries
(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 (http://www.tinkerkit.com/tinkerkit-
library/#tkthermistor) 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
(https://github.com/OfficineArduino/Tutorial-
Wired/blob/master/OpenEnergyMonitor/emon_test/emon_test.ino)

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
(http://arduino.cc/en/Reference/analogRead) 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
(http://openenergymonitor.org/emon/modules/emontx/firmware/calibration):
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

Sketch definitivo
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 (https://github.com/OfficineArduino/Tutorial-
Wired/blob/master/OpenEnergyMonitor/emon_simple_client/emon_simple_client.ino)

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 //).

Utilizzo di Shield Wifi

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
(http://arduino.cc/en/Reference/WiFiBegin).
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...

Utilizzo di Shield Ethernet (o Arduino Ethernet)

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
(http://arduino.cc/en/Reference/EthernetBegin).
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;

Visualizzazione dati
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.

- Text per lavorare con testi e html

- Containers per disegnare dei contenitori utili a raggruppare logicamente grafici, testo, altro - di
fatto è uno sfondo
- Widgets per utilizzare componenti grafici particolari (useremo soprattutto il dial -o gauge)
- Visualization per visualizzare classici grafici di vario tipo
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:

- Options per specificare i parametri dell'oggetto

- Delete per elilminare l'oggetto
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:

- il feed che viene visualizzato - selezioniamo qui quello relativo a power

- il valore max (fondoscala) del dial - qui ho messo 3000, ovvero il limite del mio contratto
- l'indice scale per cui viene moltiplicato il valore del feed (comodo per alcune conversioni) - qui
impostato a 1 (uno)
- l'unità di misura units - qui impostato W (Watt)
- la combinazione di colori e offset del dial, il type - qui impostato 2 (due)
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:

- il feedid che viene visualizzato

- il fill (ovvero il riempimento): 1 (uno) per colorare il grafico, 0 (zero) per disegnare solo la riga
- l'unità di misura units
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
(http://www.w3schools.com/html/default.asp).

Nel nostro esempio, inseriamo una piccola mappa con le previsioni meteo per la regione Veneto (in cui
vivo), utilizzando un iframe (http://www.w3schools.com/html/html_iframe.asp). 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="https:\/\/fanyv88.com:443\/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:

- Dashboard name
- Menu name che può essere uguale alla voce precedente, o un alias
- Description
- Main che indica se vogliamo che sia la dashboard principale (la prima ad esserci mostrata)
- Published che indica se la dashboard è terminata (e quindi sarà presente a menù)
- Public che indica se la dashboard è pubblica e quindi visionabile da chiunque ne abbia link

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.

Pubblicazione della dashboard

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

(http://openenergymonitor.org/emon/emoncms/using-emoncms) di Emoncms
Inoltre qui (http://emoncms.org/dashboard/public) sono disponibili le dashboard pubbliche degli
utenti di emoncms.org

Conclusioni
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
(http://it.wikipedia.org/wiki/Basetta_millefori) o proto shield (http://store.arduino.cc/ww/index.php?
main_page=product_info&cPath=11_5&products_id=207), se non su un semplice pcb, realizzato in
modo casalingo con la tecnica del toner transfer (http://www.dr-lex.be/hardware/tonertransfer.html).

Per quel che riguarda invece OpenEnergyMonitor, abbiamo costruito una dashboard molto semplice.
Approfondendo sul sito del progetto (http://openenergymonitor.org/emon/emoncms/using-
emoncms), è possibile imparare ad utilizzare molti altri strumenti, più o meno avanzati, per realizzare
dashboard più complete, riepilogative e accattivanti.

Share

NEWSLETTER
Enter your email to sign up 

©2015 Arduino Copyright Notice (http://arduino.cc/en/Main/CopyrightNotice)

Contact us (http://arduino.cc/en/Main/ContactUs)

(https://twitter.com/arduino) (http://www.facebook.com/official.arduino)
 (https://plus.google.com/+Arduino) (http://www.flickr.com/photos/arduino_cc)

(http://youtube.com/arduinoteam)

Texto original

Sugiere una traducción mejor