In quei progetti dove diverse schede interagiscono tra loro, scambiandosi e memorizzando dati, potrebbe risultare utile avere un mini server (LAMP) per la memorizzazione e l’elaborazione dei dati. In questo caso niente di più flessibile di un computer embedded come una Raspberry PI.

Nel mio caso mi sono trovato a realizzare un sistema composto da diverse schede Arduino MKRZero + MKR ETH che acquisiscono dati da dei sensori analogici. Questi dati invece di essere memorizzati su scheda SD ho deciso di inviarli ad un database locale, dato che le schede sono collegate alla stessa lan. Per limitare i costi ho inserito un Raspberry PI configurato come server LAMP (Linux + Apache + Mysql + Php).

In questo articolo vediamo come installare tutto il necessario per creare un server LAMP con Raspberry PI seguendo questi 5 passi:

1. Installare server web apache
2. Installare motore PHP
3. Installare database relazionale Mysql (MAriaDB)
4. Installare software di gestione PhpMyAdmin
5. Configurare utenti e privilegi

1. Installare Apache

Il server Apache permette di avere un server HTTP locale capace di elaborare le richieste dei client collegati alla stessa rete. Per l’installazione si utilizza il commando seguente :

sudo apt-get install apache2

Premiamo invio e alla richiesta di continuare digitiamo S e nuovamente invio

Terminata l’installazione digitiamo il seguente comando per leggere l’indirizzo ip della scheda Raspberry PI

hostname -I

premendo invio verrà visualizzato l’ip assegnato alla scheda.

apriamo il browser su un pc della stessa rete e digitiamo nella barra degli indirizzi l’ip della scheda. Se il server apache è stato installato correttamente dovreste visualizzare una schermata come la seguente:

2. Installare PHP

Il passo successivo è quello di installare il motore PHP che permetterà di eseguire tutti gli script php contenuti nelle pagine web. Digitiamo il seguente comando:

sudo apt-get install php

premiamo invio, confermiamo l’installazione digitando S e nuovamente invio.

Terminata l’installazione procediamo a verificare che il motore php sia stato installato correttamente. Portiamoci sulla directory seguente:

cd /var/www/html/

elenchiamo ora i file presenti nella cartella con il comando:

ls -l

dovrebbe esserci un solo file, index.html. rimuoviamolo con il seguente comando

sudo rm index.html

Ora utilizzando un editor di testo creiamo una nuova pagina , index.php, eseguendo questo comando

sudo nano index.php

Premiamo invio e digitiamo nel’editor di testo nano la seguente istruzione

<?php echo(phpinfo()) ?>

Per salvare il file index.php premiamo sulla tastiera i tasti CTRL+O e per uscire i tasti CRTL+X

nuovamente eseguiamo un elenco dei files contenuti nella cartella html con il comando:

ls -l

dovremmo avere un solo file, index.php:

dal browser precedentemente aperto ricarichiamo la pagina (oppure digitiamo nuovamente l’ip della scheda Raspberry) e se tutto sta girando correttamente dovremmo visualizzare le informazioni relative al motore php, come di seguito:

Se il server web non risponde potremmo provare a riavviarlo digitando questo comando:

sudo service apache2 restart

3. Installare MySQL

Mysql è un RDBMS molto diffuso in ambiente web. Sviluppato come progetto open source è poi stato acquisito da Oracle. Attualmente è disponibile sotto licenza GNU e anche commerciale. Nel nostro Raspberry installeremo mariaDB un progetto totalmente open che si basa sul codice sorgente di MySql. Per eseguire l’installazione digitiamo il seguente comadndo:

sudo apt-get install mariadb-server

confermiamo digitando S e premendo invio

4. Installate PhpMyAdmin (opzionale)

Se siete arrivati fin qui la parte server è stata installata correttamente. Ora possiamo installare un software scritto in php che permette di interagire con il server MySql, tramite una comoda interfaccia web. Eseguiamo quindi il seguente comando per avviare l’installazione e la configurazione di PhpMyAdmin:

sudo apt-get install phpmyadmin

Confermiamo digitando S e premendo invio per avviare il download del software e la sua installazione.

Dopo qualche istante ci viene richiesto di selezionare il server web installato sul Raspberry in modo tale che phpmyadmin esegua le sue configurazioni. Selezioniamo con la barra spaziatrice la voce apache2, con il tasto tab ci spostiamo sul pulsante <ok>. Premiamo invio per continuare:

Successivamente viene mostrata una nuova finestra per poter configurare il database mysql. Selezioniamo il pulsante <Sì> e premiamo invio:

Ora digitiamo una password per l’utente phpmyadmin e premiamo invio:

ripetiamo digitando e confermando la password, continuiamo premendo invio:

dopo qualche istante l’installazione terminerà.

Proviamo ora a verificare se l’installazione del software phpmyadmin è avvenuta con successo. Portiamoci nuovamente sul browser e digitiamo nella barra degli indirizzi il seguente link

[ip raspberry]/phpmyadmin

dovremmo visualizzare la schermata di login come segue:

digitiamo come nome utente phpmyadmin e come password quella inserita nella procedura guidata per eseguire l’accesso all’interfaccia web.

l’utente phpmyadmin non ha privilegi che permettano la gestione dei databases. Nel prossimo passo provvederemo a creare un utente che possieda tutti i privilegi.

5. Creare un utente per gestire il database

I comandi seguenti servono a creare un utente con tutti i privilegi di amministrazione del database. In questo modo protremmo accedere tramite phpmyadmin per creare e gestire i nostri databases.

Il comando seguente permette di avviare la console mysql in modo tale da poter inviare comandi sql all’ RDBMS:

sudo mariadb

e premiamo invio:

ora creiamo un utente, nel mio caso con nome marco, tra apici inseriamo anche una password:

CREATE USER marco@localhost IDENTIFIED BY 'inserisci la tua password';

ricordati di terminate la stringa sql con il simbolo di punto e virgola. Premiamo invio per per eseguire la query:

ora l’utente marco è stato creato ma come l’utente phpmyadmin non ha nessun privilegio e non puo effettuare nessuna operazione. Assegniamo quindi a questo utente tutti i privilegi eseguendo questa query:

GRANT ALL PRIVILEGES ON *.* TO marco@localhost;

premiamo invio per eseguire la query:

usciamo dal dal database eseguendo il seguente comando:

exit;

riavviamo il servizio mysql eseguendo il seguente comando

sudo service mysql restart

Conclusioni

Utilizzando un Raspberry PI dal costo contenuto è possibile creare un hub di rete capace di eseguire un server LAMP con adeguate prestazioni. In questo modo è possibile integrare un sistema di schede che piuttosto che memorizzare i dati in una propria memoria può invece inviare i dati su un database relazionale con tutti i vantaggi che ne derivano.

The post 5 passi per installare un webserver LAMP sul Raspberry PI appeared first on Esperimenti con logiche programmabili.

Il termine ‘internet delle cose‘ sta diventando sempre più popolare per due motivi fondamentali, il primo riguarda la grande diffusione dei dispositivi programmabili come Arduino e Netduino (senza tralasciare  il sistema OpenPicus e il RaspberryPI) con la loro relativa semplicità di utilizzo, mentre il secondo motivo è dovuto alla necessità di conoscere in tempo reale cosa questo dispositivo sta facendo e come sia possibile controllarne le funzionalità, anche a distanza.
Tutto questo è strettamente legato alla diffusione della rete 3G e degli smartphone che permettono di avere una connessione ad internet pressoché ovunque.

Questo scenario rende interessante lo sviluppo di nuove tipologie di applicazioni legate appunto al controllo e allo scambio dati tra dispositivi hardware collegati ad internet.

Esistono numerosi prototipi ma anche esempi reali che dimostrano come l’utilizzo di sistemi embedded+internet creino infrastrutture, anche complesse, controllabili. Il classico esempio riguarda la gestione del traffico che nelle nostre città viene gestito da semplici semafori che regolano il traffico in modo statico. Utilizzando dispositivi smart è possibile ottimizzare questo sistema migliorando la viabilità, evitando ingorghi e facendo risparmiare energia e carburante. Ma le applicazioni sono davvero notevoli e sono tutte orientate al risparmio energetico e al migliorare il nostro modo di vivere.

Di seguito sono elencate le categorie dove maggiormente verranno sviluppati dispositivi riconducibili all’internet delle cose

• Domotica
• Controllo inquinamento ambientale cittadino
• Monitoraggio Ambientale
• Energie rinnovabili, Smart Grid
• Illuminazione pubblica intelligente
• Sistemi per il rilevamento tempestivo degli incendi
• Controllo delle acque, tra cui livello degli argini.
• Controllo e gestione degli accessi con tecnologia RFID
• Agricoltura, irrigazione intelligente.
• Sorveglianza di pazienti e anziani in abitazioni isolate.
• Miglioramento processi industriali, gestione magazzino.

Gartner ha identificato l’IOT come una delle 10 tecnologiche trainanti per il 2013.

Per quello che ci riguarda dobbiamo dotarci di un dispositivo capace di connettersi ad internet, nel mio caso utilizzerò l’Arduino Ethernet, di una connessione internet e di un server web capace di elaborare le richieste inviate dall’Arduino.

Il progetto di questo tutorial permette di acquisire un segnale analogico, di inviarne il valore al server remoto che lo memorizzerà in una tabella del database MySql.
L’invio dei dati avviene tramite architettura REST. Praticamente i valori acquisiti da Arduino verranno inviati utilizzando l’URL.
Lato server, uno script PHP recupererà i valori dall’url e li memorizzerà sul database.

se non disponete di un server web remoto potete installarne uno nella vostra macchina locale utilizzando XAMPP. Il pacchetto installa automaticamente il server web Apache, l’interprete PHP ed il server MySql.

Iniziamo subito con il codice che ho caricato sull’Arduino:

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
//indirizzo server web (locale)
IPAddress server(192, 168, 0, 140);

//indirizzo ip dell'Arduino
IPAddress ip(192, 168, 0, 200);

EthernetClient client;

String strURL = "";
float temp = 0;

void setup()
{
Serial.begin(9600);

if (Ethernet.begin(mac) == 0)
{
Serial.println("Configurazione DHCP fallita!");
Ethernet.begin(mac, ip);
}

delay(1000);

}

void loop()
{
UpdateTemp();

while(client.available())
{
char c = client.read();
Serial.print(c);
}

if (!client.connected())
{
Serial.println();
Serial.println("Disconnesso.");
client.stop();
}

//esegui la richiesta ogni 10 secondi
delay(10000);
}

void UpdateTemp()
{
Serial.println("Connessione...");

if (client.connect(server, 80))
{
Serial.println("Connesso");
//acquisisco il valore analogico dal sensore MCP9700
//vedi questo articolo
//logicaprogrammabile.it/mcp9700a-netduino-sensore-temperatura-analogico
temp = analogRead(0);

//creo l'url utilizzanso una stringa
strURL = "GET /arduino/index.php?valore=";
strURL += (int)temp;
strURL += "&localita=Sardegna HTTP/1.1";

//invio la richiesta al server
client.println(strURL);
client.println("Host: localhost");
client.println("Connection: close");
client.println();
//chiudo la connessione
client.stop();
}
else
{
Serial.println("Errore Connessione");
}
}

Il codice esegue una connessione al server locale e, dopo aver acquisito il segnale proveniente dal sensore analogico, costruisce l’indirizzo URL inserendo due parametri, il valore analogico acquisito e la località:

/arduino/index.php?valore=120&localita=Sardegna

La pagina index.php ha il compito di recuperare i parametri e di caricarli sul database. Questo è il codice PHP:

<?php
//controllo se sono presenti i parametri valore e localita
if(isset($_GET['valore']) && isset($_GET['localita']))
{
//Recupero il valore del parametro "valore"
$valore = $_GET['valore'];

//Recupero il valore del parametro "localita"
$localita = $_GET['localita'];

//eseguo la connessione al database sul server locale
//inserendo nome utente e password
$link = mysql_connect('localhost', 'root', 'root');

//gestione degli errori
if (!$link) {die('Impossibile connettersi: ' . mysql_error());}

//seleziono il databse di nome arduino
mysql_select_db("arduino") or die( "Impossibile selezionare il database.");

//creo una stringa sql di inserimento con i valori
//recuperati dall'url
$sql = "INSERT INTO `arduino`.`tbl_temperature`
(
`ID` ,
`Tempo_Server` ,
`Tempo_Locale` ,
`Valore` ,
`Localita`
)
VALUES
(
NULL , CURRENT_TIMESTAMP , NULL , '" . $valore . "', '" . $localita . "'
);";

//eseguo la query
$retval = mysql_query( $sql, $link );

//gestione degli errori
if(! $retval ){die('Impossibile eseguire la query: ' . mysql_error());}

//chiudo la connessione al db
mysql_close($link);
}
?>

Tramite phpMyAdmin ho creato un database di nome Arduino e una tabella di nome tbl_Temperature. Il codice sql per creare la tabella è il seguente:

CREATE TABLE `tbl_temperature` (
`ID` int(11) NOT NULL AUTO_INCREMENT,
`Tempo_Server` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
`Tempo_Locale` datetime DEFAULT NULL,
`Valore` int(11) NOT NULL,
`Localita` varchar(50) NOT NULL,
PRIMARY KEY (`ID`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1;

Utilizzando Arduino, PHP e Mysql siamo riusciti a realizzare un piccolo sistema IOT. Certamente bisogna imparare ad utilizzare anche le tecnologie lato server per far interagire Arduino, ma con un po di impegno è possibile realizzare applicazione molto interessanti.

In questo tutorial non ho approfondito l’installazione e la configurazione di XAMPP, ne l’uso di PHP e MySql perché sarebbe stato necessario un tutorial dedicato, molto più lungo e forse dispersivo.

The post Memorizzare dati su un sito web con PHP e Mysql appeared first on Esperimenti con logiche programmabili.

Ora che sapiamo creare un Pachube feed aggiornabile non ci resta che sviluppare una piccola app, da far girare sul Netduino Plus, che acquisisce dei dati tramite le sue porte in ingresso e li invia al servizio web.
Sul sito Pachube sono presenti diversi esempi che illustrano come scrivere delle applicazioni basate sul .Net framework. Tra queste è presente un listato di codice che mostra come aggiornare un feed tramite codice C#.
Per utilizzare questo esempio è necessario aggiungere alla soluzione la libreria System.Http (Progetto->Aggiungi riferimento->System.Http.dll) e, tramite la clausola using , aggiungere i namespace System.Text e System.IO.

Il codice seguente mostra come aggiornare il nostro feed con un valore statico.

WebRequest rq;
HttpWebResponse hwr;

//eventuale proxy aziendale
//WebProxy wp = new WebProxy("nome server proxy", 8080);

//creo un buffer contenente la chiave e il valore per il feed
byte[] buffer = Encoding.UTF8.GetBytes("CpuLoad,10");

//riferimento al feed in formato csv
rq = WebRequest.Create("http://api.pachube.com/v2/feeds/28933.csv");

//assegnazione eventuale server proxy
//rq.Proxy = wp;
rq.Timeout = 5000;
rq.Method = "PUT";

//request headers
rq.ContentLength = buffer.Length;
rq.ContentType = "text/csv";
rq.Headers.Add("X-PachubeApiKey", "API KEY PACHUBE");

try
{
Stream stm = rq.GetRequestStream();
stm.Write(buffer, 0, buffer.Length);
stm.Close();
hwr = (HttpWebResponse)rq.GetResponse();
Debug.Print("response " + hwr.StatusCode);
}
catch (Exception ex)
{
Debug.Print("ERRORE: " + ex.Message);
}

Il listato è molto sintetico e mostra come eseguire l’aggiornamento del feed. Nell’articolo precedente ho utilizzato XML per eseguire le operazioni di lettura e scrittura del feed. In questo caso, invece, è stato utilizzato il metodo che impiega un semplice file di testo csv (comma-separated values).

Le prime istruzioni istanziano un oggetto WebRequest e uno HttpWebResponse (fornisce un’implementazione specifica di HTTP della classe WebResponse). Tutto il lavoro viene eseguito dall’oggetto WebRequest che, dopo aver settato le varie proprietà relative al feed csv, crea uno stream IO per aggiornare il file csv remoto.

Impieghiamo le porte del Netduino per creare qualcosa di utile e dinamico. Tramite gli ingressi analogici acquisiamo delle grandezze, provenienti da diversi sensori, che possono essere graficate tramite feed Pachube.

Faccio riferimento all’articolo che illustrava l’utilizzo del sensore di temperatura analogico MCP9700a per monitorare l’ambiente e memorizzare i dati su Pachube.
Il codice viene così modificato:

WebRequest rq;
HttpWebResponse hwr;

//Impostop il pin A0 come ingresso analogico
AnalogInput AN0 = new AnalogInput(Pins.GPIO_PIN_A0);
Int16 Analog0 = 0;

while (true)
{
//acquisisci il valore analogico
Analog0 = (Int16)AN0.Read();

//creo una webrequest passando come argomento l'indirizzo del file csv
rq = WebRequest.Create("http://api.pachube.com/v2/feeds/XXXXX.csv");

//setto i parametri per l'oggetto webrequest
rq.Timeout = 3000;
byte[] buffer = Encoding.UTF8.GetBytes("Temp," + Analog0.ToString());
rq.ContentLength = buffer.Length;
rq.Method = "PUT";
rq.ContentType = "text/csv";
rq.Headers.Add("X-PachubeApiKey", "LA TUA API KEY");

//creo uno stream e scrivo i nuovi valori acquisiti
try
{
Stream stm = rq.GetRequestStream();
stm.Write(buffer, 0, buffer.Length);
stm.Close();
hwr = (HttpWebResponse)rq.GetResponse();
hwr.Close();
Debug.Print("response " + hwr.StatusCode);
}
catch (Exception ex)
{
Debug.Print("ERRORE: " + ex.Message);
}

//distruggo l'oggetto
rq.Dispose();

//attendi 30 secondi
Thread.Sleep(30000);
}

Il listato è autodescrittivo e permette con poco studio di capire come avviene il meccanismo di aggiornamento.

Prima di caricare il codice sul Netduino è necessario impostare il suo indirizzo ip attraverso l’uso di MFDeploy (C:\Programmi\Microsoft .NET Micro Framework\v4.1\Tools\MFDeploy.exe).

Una volta selezionato il dispositivo tramite la porta usb clicchiamo sul menu Target->Configuration->Network.

Nella finestra seguente possiamo configurare l’indirizzo ip del Netduino Plus, la subnet mask e il gateway. Questi dati dobbiamo recuperarli dal router.

E’ possibile abilitare il flag DHCP per recuperare automaticamente questi valori ma con alcuni router questa procedura non funziona correttamente e quindi vi consiglio di utilizzare, almeno per le prove, un indirizzo statico.

Tutto molto semplice e veloce. Con le restanti porte possiamo sperimentare con l’aggiunta di altri sensori per creare applicazioni più evolute ed interessanti.

The post Netduino Plus interazione Pachube appeared first on Esperimenti con logiche programmabili.