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.

Continuiamo la serie di articolo per il controllo da remoto del nostro Arduino. Negli articoli precedenti abbiamo visto come sia semplice leggere lo stato dei pin digitali e come acquisire dei segnali con gli ingressi analogici della scheda.
Questo articolo vedrà di utilizzare il browser per inviare dei comandi alla board Arduino UNO, tramite protocollo http, per pilotare le uscite dei in digitali.

La prima operazione da decidere riguarda la scelta dei pin che intendiamo impiegare come uscite in questo esempio ho decido di configurare i pin2 e il pin3.

void setup()
{
//inizializza lo shield con il mac e l'ip
Ethernet.begin(mac, ip);
//inizializza l'oggetto server
ArduinoServer.begin();
//definisco i pin6 e pin7 come ingressi
pinMode(6, INPUT);
pinMode(7, INPUT);

//definisco i pin2 e pin3 come uscite
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
}

Adesso dobbiamo capire come inviare via browser dei comandi all’Arduino. Questo è possibile utilizzando la barra degli indirizzi del browser, infatti inserendo del testo dopo l’indirizzo ip della board possiamo recuperarlo utilizzando la funzione read(). Per capire meglio, l’esempio seguente illustra le varie fasi:

inserisco, nel browser, l’indirizzo ip della board e del testo aggiuntivo:

http://10.192.1.251/testo_personalizzato

dopo aver premuto il tasto invio o il pulsante vai, il browser invierà alla board questa informazione:

GET /testo_personalizzato HTTP/1.0

I singoli byte letti dalla funzione read() vengono concatenati per ricostruire l’intera stringa http. Questo avviene creando un oggetto String  e utilizzando l’istruzione di concatenamento +=

//Dichiaro un oggetto String
String msg = "";

...

//leggo i byte disponibili
//provenienti dal client
Data_RX = pc_client.read();

//ricostruisco la stringa ricevuta concatenando i singoli byte
msg += Data_RX;

...

Quando termino di leggere tutti i byte inviati dal browser, l’oggetto msg conterrà l’intero dato, così come inviato dal browser

GET /testo_personalizzato HTTP/1.0

utilizzando il metodo indexOf() dell’oggetto msg posso controllare se all’interno di questa stinga è presente un particolare teso, ad esempio per verificare la presente del testo HTTP dovrò scrivere

int occorrenza = msg.indexOf(“HTTP”);

il valore restituito rappresenta il numero di occorrenze trovate all’interno della stringa msg, in questo caso il testo HTTP è presente una sola volta quindi la variabile occorrenza conterrà il valore 1.

Di conseguenza per pilotare l’uscita pin2 al livello alto potremmo scrivere sulla barra dell’indirizzo del browser qualcosa del tipo

http://10.192.1.251/PIN2ON

in questo caso la stringa msg sarà uguale a

GET /PIN2ON HTTP/1.0

il metodo indexOf dovrà cercare la stringa PIN2ON e, in base al risultato, attivare o meno l’uscita dell’Arduino. Il codice seguente realizza quanto esposto

...

//cerco all'interno della stringa il parametro che mi interessa
cmd = msg.indexOf("LEDON");

if (cmd > 0)
digitalWrite(2, HIGH);
else
digitalWrite(2, LOW);

...

Per chiarezza inserisco tutto il codice dello sketch :

/*
Semplice Controllo remoto
Settembre 2011
Marco Lai
*/

//Librerie impiegate per il progetto
#include <SPI.h>
#include <Ethernet.h>

//Creao un array di byte per specificare il mac address
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
//creo un array di byte per specificare l'indirizzo ip
byte ip[] = {10, 192, 1, 251}; //modificate questo valore in base alla vostra rete

char Data_RX;

String msg = "";
int cmd = 0;

//creao un oggetto server che rimane in ascolto sulla porta
//specificata
Server ArduinoServer(80);

void setup()
{
//inizializza lo shield con il mac e l'ip
Ethernet.begin(mac, ip);
//inizializza l'oggetto server
ArduinoServer.begin();

//definisco i pin2 e pin3 come uscite
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);

}

void loop()
{
//IMPORTANTE pulisco la variabile msg
msg = "";

Client pc_client = ArduinoServer.available();

//controllo se pc_client è true
if (pc_client != false)
{
//controllo continuamente che il client sia connesso
while (pc_client.connected())
{
//Controllo se ci sono byte disponibili per la lettura
if (pc_client.available())
{
//leggo i byte disponibili
//provenienti dal client
Data_RX = pc_client.read();

//ricostruisco la stringa ricevuta concatenando i singoli byte
msg += Data_RX;

//Attendo che tutti i byte siano letti
//quando Data_RX contiene il carattere
//di nuova line capisco tutti i byte sono
//stati letti
if (Data_RX == '\n')
{
//cerco all'interno della stringa il parametro che mi interessa
cmd = msg.indexOf("LEDON");

//Invio la risposta al client
//invio lo status code
pc_client.println("HTTP/1.1 200 OK");
//imposto il data type
pc_client.println("Content-Type: text/html");
pc_client.println();
//invio codice html
pc_client.print("<html><body>");
pc_client.print("<head>");
//questo codice html permette di eseguireil refresh automatico
//della pagina html
pc_client.print("<META HTTP-EQUIV='refresh' CONTENT='5; /'>");
pc_client.print("</head>");

//Piloto l'uscita e invio lo stato al browser
if (cmd > 0)
{
digitalWrite(2, HIGH);
pc_client.print("<p>PIN2 Attivo</p>");
}
else
{
digitalWrite(2, LOW);
pc_client.print("<p>PIN2 NON Attivo</p>");
}

pc_client.print("</body></html>");

//aspetto 1 ms affinche la risposta giunga al browser del client
delay(1);
//esco dal ciclo while una volta completato l'invio della risposta
break;
}
}
}
//chiudo la connessione
pc_client.stop();
}
}

Utilizzando questo metodo possiamo attivare le uscite dell’Arduino ma anche inviare altri comandi che ad esempio generano un segnale pwm piuttosto che inviare dati tramite la porta UART ad altri dispositivi; le possibilità sono tante e permettono un controllo remoto completo ed efficiente.

The post Ethernet shield usare un browser per pilotare Arduino appeared first on Esperimenti con logiche programmabili.

Il mondo è sempre più connesso, non solo le persone sono presenti su internet ma anche gli oggetti, tramite semplici circuiti, possono collegarsi alla rete, condividendo dati ed interagendo con l’ambiente, acquisendo grandezze fisiche (tramite sensori) o pilotando carichi utilizzando degli attuatori.

Controllare da remoto uno di questi dispositivi è una operazione affascinante sia per l’utilità di questa tecnica sia, perché no, far stupire i nostri amici accendendo una luce di casa tramite web!

Per chi è alle prime esperienze con Arduino, potrebbe pensare che la realizzazione di questo circuito possa essere complicato e costoso.

Fortunatamente il materiale necessario si riduce a una board Arduino UNO e all’Ethernet shield, più qualche componente esterno.

In questo articolo preferisco fare un piccolo accenno nel descrivere il funzionamento del sistema all’interno della rete lan.

Per il controllo remoto, bisogna eseguire alcune configurazioni aggiuntive che vedremmo successivamente.
Lo schema illustra il funzionamento del progetto:

I pc della rete e l’Arduino UNO (con ethernet shield) sono collegati tra loro tramite uno switch.

Il pc eseguirà, usando un browser, delle richieste http, per recuperare, ad esempio, il valore di una tensione applicata su un pin analogico, oppure accendere o spegnere un led, applicato su un pin digitale in uscita.

Colleghiamo la shield ethernet al nostro Arduino UNO, inseriamo un cavo lan dritto, (che dal connettore rg45 dello shield si collega ad una porta qualsiasi dello switch), inseriamo il cavo USB (che dall’Arduino UNO si collega alla porta del pc) e diamo alimentazione a tutto il sistema.

Apriamo l’IDE di Arduino e scriviamo questo codice:

//Librerie impiegate per il progetto
#include <SPI.h>
#include <Ethernet.h>

//Creao un array di byte per specificare il mac address
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
//creo un array di byte per specificare l'indirizzo ip
byte ip[] = {10, 192, 1, 251};

//creo una variabile char per memorizzare i byte letti dal client
char Data_RX;

//creao un oggetto server che rimane in ascolto sulla porta
//specificata
Server ArduinoServer(80);

void setup()
{
  //inizializza lo shield con il mac e l'ip
  Ethernet.begin(mac, ip);
  //inizializza l'oggetto server
  ArduinoServer.begin();
}

void loop()
{
  //fai qualcosa!
  delay(10);
}

I commenti nel codice spiegano a grandi linee il funzionamento dello stesso. Dopo aver inserito le due librerie che permettono di interfacciarsi all’ethernet shield, definiamo due array di byte, uno che contiene l’indirizzo fisico della scheda di rete (MAC address) e l’altro che contiene l’indirizzo ip.

Successivamente ho creato un oggetto Server che permette di rimanere in ascolto sulla porta specificata, in questo caso la porta 80, proprio quella utilizzata dal protocollo http.

La variabile Data_RX verrà impiegata successivamente per memorizzare i byte provenienti dal client.

Dentro il blocco setup() ci sono due importanti funzioni, la prima (Ethernet.begin(mac, ip);) serve per inizializzare il chip WIZnet con l’indirizzo mac e l’indirizzo IP, la seconda (ArduinoServer.begin();) avvia il server e lo mette in ascolto sulla porta 80 per le avvenutali richieste dei client.

Nel blocco loop() ho inserito un ritardo di 10ms, per il momento non eseguiamo altro.

Questo codice è utile per verificare, tramite un semplice ping, se l’ethernet shield è correttamente configurata e se risponde alle interrogazioni dei client.

Apriamo una finestra dei prompt dei comandi (Start->Esegui->cmd.exe)

Digitiamo il comando ping seguito dall’indirizzo ip che abbiamo specificato nel codice dello skecth, nel mio caso:

ping 10.192.1.251

se i collegamenti sono corretti, e il codice viene caricato senza intoppi, otterremo la risposta della scheda come illustrato di seguito:

Questo semplice test ci permette di escludere problemi di alimentazione della board o errori doviti al cavo di collegamento.

Informazioni base su come configurare l’indirizzo ip

Certamente tutti voi sapete come configurare un indirizzo ip nella rete, ma penso sia necessario, per chi è alle prime armi, scrivere una piccola nota.
L’indirizzo ip identifica univocamente un dispositivo nella rete, probabilmente se utilizzate un router, questo assegnerà in modo automatico un indirizzo ad ogni dispositivo collegato (DHCP).

Per eseguire questi esperimenti dobbiamo disattivare il DHCP (sebbene sia possibile sfruttare questa funzione con Arduino ritengo, per semplicità, di non impiegarla) ed assegnare un indirizzo ip statico univoco ad ogni dispositivo della vostra rete.
Per fare ciò dovete andare nelle impostazioni del router e disattivare DHCP, poi per ogni pc della vostra rete, assegnate un indirizzo ip utilizzando le impostazioni della connessione di rete, tramite il pannello di controllo. Potete seguire questo link che mostra un video su come eseguire questa operazione

http://www.webip.info/cambiare_ip_windows_xp.php

Questo tutorial, invece, è per chi possiede Windows 7

Come Impostare un Indirizzo IP Statico su Windows

Ad esempio potremmo impostare il nostro pc con l’indirizzo 192.168.1.10 e la nostra Ethernet Shield con indirizzo 192.168.1.20

Come rispondere ai client

Una volta definiti gli indirizzi ip dei dispositivi della rete, possiamo iniziare a scrivere il codice che effettivamente risponde alle richieste dei client.
All’interno del blocco loop() bisogna creare un oggetto dalla classe Client, necessario ad ascoltare (listening) le richieste dei client.

L’idea di base è che il server aspetta la connessione di un client, controlla se ci sono dati da leggere e di conseguenza crea un oggetto Client.

//Ascolto le richieste dei client controllo se ci sono dati da leggere
//e creo un oggetto relativo a client che sta interrogando l'Ethernet shield
Client pc_client = ArduinoServer.available();

La funzione ArduinoServer.available() non è bloccante quindi viene eseguita ciclicamente all’interno del blocco loop(), di conseguenza il valore restituito dalla funzione in mancanza di una richiesta client è false.

E’ necessario quindi controllare se l’oggetto pc_client istanziato sia diverso da false prima di poter instaurare la connessione.

//Ascolto le richieste dei client controllo se ci sono dati da leggere
//e creo un oggetto relativo a client che sta interrogando l'Ethernet shield
Client pc_client = ArduinoServer.available();

//controllo se pc_client è true
if (pc_client != false)
{
  //se pc_client è true continuo ad utilizzarlo...
}

All’interno del blocco if utilizzo un ciclo while per eseguire il codice necessario a scambiare dati tra client e server fintanto che la connessione con il client è attiva

//Ascolto le richieste dei client controllo se ci sono dati da leggere
//e creo un oggetto relativo a client che sta interrogando l'Ethernet shield
Client pc_client = ArduinoServer.available();

//controllo se pc_client è diverso da false
if (pc_client != false)
{
  //controllo se il client è connesso
  while (pc_client.connected())
  {
    //eseguo questo codice fintanto che il client è connesso...
  }
}

Riassumendo, quando la connessione è stabilita, Arduino esegue il codice all’interno del blocco while, questa è la parte più interessante perchè possiamo leggere e scrivere dati attraverso il protocollo di comunicazione http.

Continuiamo controllando se effettivamente ci sono byte da leggere impiegando la funzione read() dell’oggetto pc_client:

//Ascolto le richieste dei client controllo se ci sono dati da leggere
//e creo un oggetto relativo a client che sta interrogando l'Ethernet shield
Client pc_client = ArduinoServer.available();

//controllo se pc_client è true
if (pc_client != false)
{
  //controllo continuamente che il client sia connesso
  while (pc_client.connected())
  {
    //Controllo se ci sono byte disponibili per la lettura
    if (pc_client.available())
    {
      //leggo i byte disponibili
      //provenienti dal client
      Data_RX = pc_client.read();
    }
  }
}

Ora eseguiamo un semplice test per verificare che il codice sin qui scritto funzioni.

Per avere un riscontro utilizziamo la classe Serial per inviare informazioni di debug tramite Serial Monitor. Inizializziamo, tramite Serial.Begin(9600), la porta seriale nel blocco setup().

Adesso posso controllare il contenuto della variabile Data_RX inviandoli al Serial Monitor.

//Ascolto le richieste dei client controllo se ci sono dati da leggere
//e creo un oggetto relativo a client che sta interrogando l'Ethernet shield
Client pc_client = ArduinoServer.available();

//controllo se pc_client è true
if (pc_client != false)
{
  //controllo continuamente che il client sia connesso
  while (pc_client.connected())
  {
    //Controllo se ci sono byte disponibili per la lettura
    if (pc_client.available())
    {
      //leggo i byte disponibili
      //provenienti dal client
      Data_RX = pc_client.read();

      //invio i dati letti al Serial Monitor
      Serial.write(Data_RX);
    }
  }
}

Apriamo Serial Monitor con il relativo pulsante

Avviamo il nostro browser preferito, su un pc nella rete dove è collegato l’Arduino con Ethernet shield, e nella barra degli indirizzi digitiamo l’ip assegnato via codice all’ethernet shield.

Il browser eseguirà una richiesta GET che sarà elaborata dall’Arduino e visualizzata sul serial monitor.

Ecco il risultato:

Anche in questo caso questo semplice test ci da la conferma che il codice appena scritto funziona egregiamente.

Continuiamo ad aggiungere il codice di risposta che l’Arduino invierà al browser che ha effettuato la richiesta GET

//Ascolto le richieste dei client controllo se ci sono dati da leggere
//e creo un oggetto relativo a client che sta interrogando l'Ethernet shield
Client pc_client = ArduinoServer.available();

//controllo se pc_client è true
if (pc_client)
{
  //controllo continuamente che il client sia connesso
  while (pc_client.connected())
  {
    //Controllo se ci sono byte disponibili per la lettura
    if (pc_client.available())
    {
      //leggo i byte disponibili
      //provenienti dal client
      Data_RX = pc_client.read();

      //Attendo che tutti i byte siano letti
      //quando Data_RX contiene il carattere
      //di nuova line capisco tutti i byte sono
      //stati letti
      if (Data_RX == '\n')
      {
        //Invio la risposta al client
        //invio lo status code
        pc_client.println("HTTP/1.1 200 OK");
        //imposto il data type
        pc_client.println("Content-Type: text/html");
        pc_client.println();
        //invio codice html
        pc_client.print("<html><body><h1>");
        pc_client.print("Hello world Arduino Web Server</h1></body>   </html>");
        //aspetto 1 ms affinche la risposta giunga al browser del client
        delay(1);
        //esco dal ciclo while una volta completato l'invio della risposta
        break;
      }
    }
  }
  //chiudo la connessione
  pc_client.stop();
}

Verifico il valore di ogni byte letto, tramite l’istruzione if, fino a quando non ricevo un carattere di nuova linea \n (ox0A in esadecimale). Quando si verifica questa condizione la richiesta del client è stata letta completamente e quindi possiamo iniziare ad inviare la nostra risposta tramite la funzione println() dell’oggetto pc_client.

La prima stringa da inviare riguarda lo status code del protocollo http, composta dalla versione del protocollo http(HTTP/1.1) e dal codice 200 OK che specifica al client la corretta elaborazione dei dati.
La seconda stringa specifica il tipo di dati (http Content types) che stiamo inviando al client con il protocollo http.
Queste due stringhe costituiscono l’header della risposta http.

A questo punto inviamo la stringa con il codice html che compone la pagina che verrà inviata al browser sul client. Terminata anche questa operazione non ci resta che uscire dal blocco while con l’istruzione break, e terminare la chiusura della connessione con la funzione stop() per predisporci ad elaborare ulteriori richieste.

Nel prossimo articolo vedremmo come sfruttare gli ingressi analogici per acquisire dei segnali e i pin digitali per attivare dei led.

The post Arduino Ethernet Shield controllo remoto via web con http appeared first on Esperimenti con logiche programmabili.