Arduino dispone di diverse shield che permettono di collegarci a una rete lan cablata come ad esempio la MKR ETH. Esistono sul mercato altri dispositivi che svolgono la stessa funzione con costi contenuti e form factor molto piccoli. Uno di questi e la scheda WIZ850io prodotta da WIZnet, dotata di chip wiznet w5500 lo stesso utilizzato per la MKR ETH.

Questa scheda ha una dimensione del pcb di 25mm X 23mm e un costo di circa 20 euro. Di seguito la pin function della scheda:

Come possiamo vedere l’alimentazione della scheda richiede una tensione di 3.3V, è quindi consigliato utilizzare schede con tensione di funzionano di 3.3v, questo per avere i livelli logici con questa tensione. Il bus di comunicazione è affidato all’interfaccia SPI. La figura seguente mostra i collegamenti tra una Arduino MKR Zero e la scheda WIZ850io:

in dettaglio i collegamenti descritti nella tabella seguente:

Per verificare se tutti i collegamenti sono stati eseguiti correttamente possiamo utilizzare il codice seguente (esempio linkstatus della libreria Arduino ethernet):

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

void setup() {
  //inizializzo la wiz850io
  //il pin chip select è stato collegato al pin 7
  //della scheda arduino. se lo collegate in un altro pin dovete
  //modificare il numero del pin all'interno del metodo init()
  Ethernet.init(7);
  
  //inizializzazione seriale
  Serial.begin(9600);
}

void loop() {
  //verifico se il cavo lan è collegato e se esiste un link
  //con una periferica ethernet
  auto link = Ethernet.linkStatus();
  Serial.print("Link status: ");
  switch (link) {
    case Unknown:
      Serial.println("Unknown");
      break;
    case LinkON:
      Serial.println("ON");
      break;
    case LinkOFF:
      Serial.println("OFF");
      break;
  }
  delay(1000);
}

Questa scheda permette di implementare una interfaccia di rete cablata in tutte le schede Arduino dotate di porta SPI.

The post Arduino MKR Zero e WIZ850io appeared first on Esperimenti con logiche programmabili.

• Codice Python sul Raspberry SQLite
• Codice sull’Arduino MKR Zero

Il progetto che ho realizzato riguarda il monitoraggio di temperatura e umidità all’interno di un locale tecnico. I dati rilevati da un sensore DHT22 vengono acquisti da una Arduino MKR Zero e tramite una shield MKR ETH inviati a un computer Raspberry PI 4 che dopo averli acquisiti li memorizza all’interno di una tabella SQLite.

Il protocollo utilizzato per l’invio dei dati si basa su UDP come abbiamo visto in questo articolo.

I dati sarebbero potuti essere memorizzati in un semplice file di testo ma ho preferito usare un database in modo tale da estrarli in modo rapido utilizzando semplici query. Il database contiene per ora una tabella contenente i seguenti campi:

Il codice seguente gira sul Raspberry Pi 4; ho inserito diversi commenti che spiegano le varie istruzioni contenute nel programma:

import sqlite3
import socket
import threading
import time

#IP computer locale
UDP_IP_ADDR = "192.168.178.50"
#Porta computer locale
UDP_PORT_NUMBER = 20002

ip_port_Data = (UDP_IP_ADDR, UDP_PORT_NUMBER)
   
def client_Receive_Data():
    print("Avvio THREAD Receive Data...")
    serversocket1 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    serversocket1.bind(("192.168.178.30", 20001))
    msgToSend = str.encode("DB_OK")
    
    #crea connessione al database
    connection = sqlite3.connect('lopro.db')
    cursor = connection.cursor()
        
    try:            
        while True:            
            data, address = serversocket1.recvfrom(1024)
            strData = bytes.decode(data).split(":")
         
            sql = """ INSERT INTO tbl_log(Temperatura, Umidita) VALUES ('{}', '{}');""".format(strData[0], strData[1])
            
            print(sql)
            
            cursor.execute(sql)
            connection.commit()

            #invia al device una risposta
            serversocket1.sendto(msgToSend, ip_port_Data)
            time.sleep(1)
    except:
        print("errore")
        msgToSend = str.encode("ERRORE")
        serversocket1.sendto(msgToSend, ip_port_Data)
        connection.close()

def crea_tabella():
    #una volta creata la tabella possiamo evitare di chiamare
    #questa funzione ad ogni esecuzione del programma
    #crea connessione al database
    connection = sqlite3.connect('lopro.db')
    cursor = connection.cursor()
 
    #Se esiste la tabella cancellala
    #cursor.execute("DROP TABLE IF EXISTS tbl_log")
 
    # Crea la tabella se non esiste
    table = """ CREATE TABLE IF NOT EXISTS tbl_log (
            ID INTEGER PRIMARY KEY AUTOINCREMENT,
            Data TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
            Temperatura VARCHAR(50) NOT NULL,
            Umidita VARCHAR(50) NOT NULL      
        ); """
 
    cursor.execute(table)
    cursor.close()
    connection.close()

 
def list_rows():
    print("list rows..")
    #crea connessione al database
    connection = sqlite3.connect('lopro.db')

    sql = """ SELECT * FROM tbl_log;"""

    cursor = connection.cursor()
    cursor.execute(sql)
    rows = cursor.fetchall()

    for row in rows:
        print(row)

    # Close the connection
    connection.close()

if __name__=="__main__":
    #Rimuovere il commento per creare la tabella
    #crea_tabella()
    #list_rows()
    #Avvio un thred
    print("Start program")
    t1 = threading.Thread(target=client_Receive_Data)
    t1.start()

Questo è invece il codice che gira sulla Arduino MKR Zero; ho inserito diversi commenti che spiegano le varie istruzioni contenute nel programma:

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

#define DHTPIN 6
#define DHTTYPE DHT22

// creo un MAC address e un IP address per la scheda Arduino
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192, 168, 178, 50);

//creo un ip address per il raspberry
IPAddress ip_remote(192, 168, 178, 30);
//creo una porta per la scheda Arduino
unsigned int localPort = 20002; 

//creo degli array di char per la ricezione e l'invio dei
//dati via udp
char packetBuffer[UDP_TX_PACKET_MAX_SIZE];
char chrBuffer[11];

//altre variabili 
String strTempUmid = "";
byte ciclo = 0;

// Creo degli oggetti per l'utilizzo di udp e del 
//sensore dht
EthernetUDP Udp;
DHT dht(DHTPIN, DHTTYPE);

void setup() {
  //inizializzo lo shield mkr eth
  Ethernet.init(5);

  //inizializzo la scheda di rete
  Ethernet.begin(mac, ip);

  //inizializzo la seriale
  Serial.begin(9600);
  
  // verifico la ethernet shield
  if (Ethernet.hardwareStatus() == EthernetNoHardware) {
    Serial.println("MKR ETH non presente o configurata in modo errato!");
    while (true) {
      delay(1);
    }
  }

  //inizializzo l'oggetto udp
  Udp.begin(localPort);
  //inizializzo l'oggetto dht
  dht.begin();
}

void loop() {

  //verifico presenza pacchetti udp in arrivo
  int packetSize = Udp.parsePacket();
  
  //se coi sono pacchetti
  if (packetSize) {
    //Serial.println(packetSize);
    //leggo i pacchetti e gli inserisco nell'array di char
    Udp.read(packetBuffer, UDP_TX_PACKET_MAX_SIZE);
    //printo i dati ricevuti
    Serial.println(packetBuffer);
  }

  //leggo umidità e temperatura dal sensore dht
  float h = dht.readHumidity();
  float t = dht.readTemperature();

  //creo una stringa del tipo temp:umid
  strTempUmid = "";
  strTempUmid.concat(t);
  strTempUmid.concat(":");
  strTempUmid.concat(h);
  //printo la stringa sul ser mon
  Serial.println(strTempUmid);
  //converto la stringa in un array di char
  strTempUmid.toCharArray(chrBuffer, strTempUmid.length());

  //inizializzo la connessione con ip e porta del Raspberry
  Udp.beginPacket(ip_remote, 20001);
  //Scrivo i dati nel buffer
  Udp.write(chrBuffer);
  //invio i dati
  Udp.endPacket();

  //attendo un minuto prima del prossimo invio
  for (ciclo = 0; ciclo < 60; ciclo++)
    delay(1000);

}

Ogni minuto viene inviata una unica stringa contenente i dati di temperatura e umidita che il codice python provvederà a separate in due dati distinti per essere caricati sul database.

Memorizzare solo le variazioni significative su Raspberry SQLite

Possiamo ottimizzare lo spazio sulla tabella (e di conseguenza sul filesystem del Raspberry) memorizzando solo i dati che hanno una variazione significativa. In questo modo il monitoraggio rimane costante perché comunque l’Arduino legge e invia i dati ogni minuto ma posso risparmiare spazio sul database salvando solo le variazioni significative. Sulla tabella memorizzo anche il timestamp e quindi posso ricostruire l’andamento di temperatura e umidità interpolando i dati.

Il codice seguente mostra la modifica alla funzione client_Receive_Data() in modo tale da memorizzare solo i dati che hanno una variazione di 0.5 rispetto ai dati della lettura precedente rilevata dalla scheda Arduino:

def client_Receive_Data():
    print("Avvio THREAD Receive Data...")
    serversocket1 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    serversocket1.bind(("192.168.178.30", 20001))
        
    # crea connessione al database
    connection = sqlite3.connect('lopro.db')
    cursor = connection.cursor()
    #creo due variabili per memorizzare i dati delle 
    #letture di temp e umid
    temp_prec = 0
    umid_prec = 0
    
    try:
        while True:
            data, address = serversocket1.recvfrom(1024)
            strData = bytes.decode(data).split(":")

            #verifico se i dati appena letti differiscono di 0.5 dai valori della lettuare precedente
            if (abs(temp_prec - float(strData[0])) > 0.5) or (abs(umid_prec - float(strData[1])) > 0.5) :
                print("Variazione di Temp e Hum")  
                sql = """ INSERT INTO tbl_log(Temperatura, Umidita) VALUES ('{}', '{}');""".format(strData[0], strData[1])

                #memorizzo i dati per poterli confrontare con quelli
                #che arrivano dalla scheda arduino
                temp_prec = float(strData[0])
                umid_prec = float(strData[1])
                #visualizzo la stringa sql
                print(sql)
                #eseguo la stringa sql insert avviando una transazione
                cursor.execute(sql)
                #confermo la transazione
                connection.commit()
                
                # invia al device una risposta
                msgToSend = str.encode("DB_OK")
                serversocket1.sendto(msgToSend, ip_port_Data)
            else:
                print("Nessuna variazione di Temp e Hum")  
                # invia al device una risposta
                msgToSend = str.encode("DB_NOK")
                serversocket1.sendto(msgToSend, ip_port_Data)
            
            time.sleep(1)
    except:
        print("errore")
        msgToSend = str.encode("ERRORE")
        serversocket1.sendto(msgToSend, ip_port_Data)
        connection.close()

L’utilizzo congiunto di Raspberry e Arduino ci permette di realizzare progetti che superano i limiti dati dalle singole schede.

The post Datalogger con Raspberry SQLite e Arduino appeared first on Esperimenti con logiche programmabili.

Esistono diverse librerie che tendono a risolvere o a migliorare alcune classi base implementate in Arduino 1.0. Webduino è sicuramente una di queste, il nome è un chiaro riferimento al mondo ethernet/web e le sue principali funzioni sono elencate di seguito:

• elaborazione dei parametri racchiusi in un URL
• elaborazione dei metodi HTTP come GET, POST, PUT, HEAD, DELETE e PATCH
• gestione dei FORM
• Gestione di Immagini
• interfaccia JSON/REST
• autenticazione BASE64

Attualmente, la versione disponibile è la 1.7  prelevabile direttamente da Github seguendo questo indirizzo https://github.com/sirleech/Webduino

Una volta scaricato il file zip possiamo scompattarlo posizionandolo all’interno della cartella libraries cercando di non modificare la struttura interna della cartella

Per eseguire il codice ho usato l’Arduino Ethernet, ma è possibile utilizzare benissimo la Arduino UNO con lo shield ethernet.

Passiamo direttamente alla pratica creando un nuovo sketch ed inserendo, per prima, le seguenti librerie

[c]
#include <Ethernet.h>
#include <SPI.h>
#include <WebServer.h> //libreria webduino
[/c]

e subito di seguito le variabili e gli oggetti necessari al corretto funzionamento del modulo ethernet e della libreria Webduino:

[c]
//variabili statiche per il mac address e l’ip address
static byte mac_Add[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
//cambiare l’ip in funzione della propria rete
static byte ip_Add[] = { 192, 168, 1, 220 };
//creazione oggetto Webduino
WebServer webserver("", 80);
[/c]

Il mac address e l’ip address sono definiti come per la libreria nativa Ethernet. L’oggetto webserver invece è relativo alla libreria Webduino ed accetta due parametri, il primo, che in questo caso è vuoto, permette di specificare un percorso (URL), mentre il secondo rappresenta la porta in cui il server rimarrà in ascolto.
Ad esempio potremmo avere :

[c]
//il web server risponde sulla porta 80 e richiama la root page /
WebServer webserver("", 80);
//il web server risponde sulla porta 80 e richiama la pagina digital.html
WebServer webserver("digital.html", 80);
//il web server risponde sulla porta 80 e richiama la pagina analog.html
WebServer webserver("analog.html", 80);
//il web server risponde sulla porta 8085 e richiama la root page predefinita
WebServer webserver("/test", 8085);
[/c]

qui devo fare una precisazione. le pagine specificare non sono in effetti come le conosciamo (codice html) ma sono dei riferimenti, delle stringhe, che richiamano funzioni contenenti codice html. Vedremo meglio negli esempi successivi cosa intendo.

Nel blocco setup inseriamo il codice per inizializzare gli oggetti dichiarati precedentemente e, con alcune istruzioni aggiuntive, permettiamo di elaborare le richieste provenienti dal browser

[c]
void setup()
{
//inizializzo l’ethernet shield con il mac e il address
Ethernet.begin(mac_Add, ip_Add);

//definisci l’azione di default che verrà eseguita quando l’utente
//naviga nella root del sito (192.168.1.220/)
webserver.setDefaultCommand(&Start);

//avvia il web server
webserver.begin();

}
[/c]

il metodo setDefaultCommand permette di eseguire la funzione Start (inserita come parametro) in modo da elaborare la richiesta del browser.

All’interno del blocco loop bisogna inserire l’istruzione che ‘si accorge’ delle richieste del client e ne gestisce i relativi processi:

[c]
void loop()
{
//elabora costantemente tutte le richieste provenienti dal browser
webserver.processConnection();
}
[/c]

Per completare il codice, ed eseguire quindi un test operativo, scriviamo le istruzioni che compongono la funzione Start, che in questo esempio verrà eseguita come operazione di default quando un utente si collega al webserver semplicemente digitando nel browser l’indirizzo ip dell’Arduino.

[c]
//funzione Start
void Start(WebServer &server, WebServer::ConnectionType type, char *, bool)
{
//restituisce al browser l’intestazione http 200 OK
server.httpSuccess();

//gestisco il tipo di richiesta HEAD
if (type != WebServer::HEAD)
{
//Memorizzo nella memoria programma la stringa html e gli assegno il nome strMsg
P(strMsg) = "<h1>Logicaprogrammabile</h1>";

//recupero dalla memoria programma la stringa contrassegnata con il nome strMsg
//e la invio come output al browser
server.printP(strMsg);
}
}
[/c]

Il codice completo permette di eseguire, caricandolo nell’Arduino ethernet, il test della libreria

[c]
#include <Ethernet.h>
#include <SPI.h>
#include <WebServer.h> //libreria webduino</code>

//variabili statiche per il mac address e l’ip address
static byte mac_Add[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
//cambiare l’ip in funzione della propria rete
static byte ip_Add[] = { 192, 168, 1, 220 };
//creazione oggetto Webduino
WebServer webserver("", 80);

//funzione Start
void Start(WebServer &server, WebServer::ConnectionType type, char *, bool)
{
//restituisce al browser l’intestazione http 200 OK
server.httpSuccess();

//gestisco il tipo di richiesta HEAD
if (type != WebServer::HEAD)
{
//Memorizzo nella memoria programma la stringa html e gli assegno il nome strMsg
P(strMsg) = "<h1>Logicaprogrammabile</h1>";

//recupero dalla memoria programma la stringa contrassegnata con il nome strMsg
//e la invio come output al browser
server.printP(strMsg);
}
}

void setup()
{
//inizializzo l’ethernet shield con il mac e il address
Ethernet.begin(mac_Add, ip_Add);

//definisci l’azione di default che verrà eseguita quando l’utente
//naviga nella root del sito
webserver.setDefaultCommand(&Start);

//avvia il web server
webserver.begin();

}

void loop()
{
//elabora costantemente tutte le richieste provenienti dal browser
webserver.processConnection();
}
[/c]

Tramite il nostro browser preferito digitiamo l’indirizzo ip dell’Arduino; dovremmo visualizzare qualcosa del genere

Fatte diverse prove, modificando il codice, e leggendo i commenti per capire i vari passi da eseguire per iniziare ad usare la libreria Webduino. Nei prossimi articoli inseriremo alcune funzioni aggiuntive.

The post Utilizzare la libreria Webduino 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.