Configurazione Server

1 Assemblaggio del Circuito e Connessione

L'Ethernet Shield si collega a incastro sopra l'Arduino. I pin utilizzati per la comunicazione SPI (10, 11, 12, 13) vengono gestiti automaticamente dalla Shield.

• Montaggio: Incastra la Shield sull'Arduino.
• LED: Collega il **Pin 8** (o un altro pin digitale libero non usato dalla Shield) al LED (tramite resistenza) e poi a $\text{GND}$. Questo sarà il nostro attuatore di output.
• Rete: Collega il cavo Ethernet dalla Shield al tuo router o switch di rete.

Verifica che la libreria Ethernet sia installata nel tuo IDE di Arduino.

2 Configurazione della Rete (Setup)

Per rendere il tuo server accessibile, devi definire il suo **indirizzo MAC** e un **indirizzo IP statico** all'interno della tua rete locale. È cruciale che l'IP scelto sia libero.

#include <Ethernet.h> // Include la libreria Ethernet

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; // Indirizzo MAC (puoi usarne uno a caso)
IPAddress ip(192, 168, 1, 177); // *** IMPORTANTE: Modifica questo IP in base alla tua rete! ***
EthernetServer server(80); // Server in ascolto sulla porta 80 (standard HTTP)

const int PIN_LED = 8;
int statoLed = LOW;
 

Nel blocco

setup()

void setup() {
 Serial.begin(9600);
 pinMode(PIN_LED, OUTPUT);

 // Inizializzazione Ethernet
 Ethernet.begin(mac, ip);

 // Avvia il server in ascolto
 server.begin();

 Serial.print("Server pronto. Indirizzo IP: ");
 Serial.println(Ethernet.localIP());
}
 

3 Lo Sketch Completo: Gestione Richieste e Parsing

La logica del Web Server risiede nel loop(). Il server deve:

• 1) accettare la connessione,
• 2) leggere l'intestazione (header) per trovare il comando,
• 3) eseguire l'azione,
• 4) inviare la risposta HTML
• 5) chiudere la connessione.

void loop() {
 EthernetClient client = server.available(); // Cerca un client che si è connesso

 if (client) {
 String comando = "";
 boolean currentLineIsBlank = true;

// 1. Legge la richiesta HTTP, linea per linea
 while (client.connected()) {
 if (client.available()) {
 char c = client.read();
 // La prima riga contiene il comando GET (es. "GET /LEDON HTTP/1.1")
 if (comando.length() < 150) { // Limita la dimensione della stringa
 comando += c;
 }

 // 2. Alla fine dell'intestazione HTTP ('\r\n\r\n'), esegue l'azione
 if (c == '\n' && currentLineIsBlank) {
 Serial.print("Richiesta: ");
 Serial.println(comando);
 statoLed = EseguiComando(comando);
 digitalWrite(PIN_LED, statoLed);

 // 3. Invia la risposta HTML al Client
 InviaPaginaHtml(client, statoLed);
 break; // Esci dal ciclo WHILE per chiudere la connessione
 }
 if (c == '\n') {
currentLineIsBlank = true;
} else if (c != '\r') {
 currentLineIsBlank = false;
 }
 }
}
 delay(1);
 client.stop(); // 4. Chiude la connessione
 }
}

Funzione: EseguiComando(String cmd)

Questa funzione esamina la stringa della richiesta HTTP (cmd) e restituisce il nuovo stato che il LED deve assumere (HIGH o LOW).

 int EseguiComando(String cmd) { 
// 1. Analizza la richiesta per il comando di ACCENSIONE
if (cmd.indexOf("GET /ON") > 0) { 
Serial.println("-> COMANDO ACCENDI Eseguito"); 
return HIGH; // Restituisce il valore per Accendere il LED }

// 2. Analizza la richiesta per il comando di SPEGNIMENTO 
else if (cmd.indexOf("GET /OFF") > 0) { 
Serial.println("-> COMANDO SPEGNI Eseguito"); 
return LOW; // Restituisce il valore per Spegnere il LED 
}

// 3. Caso predefinito: nessun comando valido trovato 
return statoLed; // Mantiene lo stato LED attuale (variabile globale) 
} 

Il Metodo Chiave: indexOf()

Il cuore di questa funzione è il metodo

indexOf()

indexOf("stringa")

Il browser invia una richiesta HTTP completa come questa (tutto su una riga).

La condizione chiave

cmd.indexOf("GET /ON") > 0

• Se l'Arduino trova la sequenza "GET /ON" nella richiesta cmd, indexOf() restituisce la posizione iniziale della sequenza (che è sempre $\ge 0$).
• Se il comando non viene trovato, indexOf() restituisce -1.
• Verificando se il risultato è maggiore di 0 (> 0), ci assicuriamo che il comando sia stato trovato.

Se la condizione è vera, la funzione restituisce

HIGH

, e il ciclo

loop()

di Arduino aggiornerà il pin fisico del LED.

---

4 Funzioni di Supporto (Parsing e HTML)

Queste funzioni gestiscono l'interpretazione del comando e la creazione della pagina web da inviare al Client.

int EseguiComando(String cmd) {
if (cmd.indexOf("GET /ON") > 0) {
 Serial.println("-> COMANDO ACCENDI Eseguito");
 return HIGH;
 } else if (cmd.indexOf("GET /OFF") > 0) {
 Serial.println("-> COMANDO SPEGNI Eseguito");
 return LOW;
}
 return statoLed; // Nessun comando trovato, mantiene lo stato
}

void InviaPaginaHtml(EthernetClient client, int stato) {
 String stato_testo = (stato == HIGH) ? ACCESO : SPENTO;

 // Risposta standard HTTP (intestazione)
 client.println("HTTP/1.1 200 OK");
 client.println("Content-Type: text/html");
 client.println("Connection: close");
 client.println(); // Riga vuota obbligatoria

 // Corpo HTML
 client.println("<!DOCTYPE HTML>");
 client.println("<html>");
 client.print("<h1>LED Attualmente: ");
 client.print(stato_testo);
 client.println("</h1>");

 client.println("<p>Premi per controllare il LED:</p>");
 client.println("<a href=\"/ON\"><button style=\"background-color: green; color: white; padding: 10px;\">ACCENDI</button></a>");
 client.println("<a href=\"/OFF\"><button style=\"background-color: red; color: white; padding: 10px;\">SPEGNI</button></a>");
 client.println("</html>");
}
 

---

5 Analisi e Testing del Server

Carica lo sketch completo e apri il Monitor Seriale. Dopo l'inizializzazione, dovresti vedere l'indirizzo IP assegnato (es. 192.168.1.177).

• Accesso: Apri un browser (Client) sul tuo computer o smartphone e digita l'indirizzo IP di Arduino nella barra degli indirizzi (es. http://192.168.1.177).
• Interazione: Dovresti vedere una semplice pagina HTML con lo stato del LED e i pulsanti ACCENDI e SPEGNI.
• Comando: Clicca sul pulsante ACCENDI. Osserva l'URL del browser cambiare in

  http://192.168.1.177/ON

  e il LED fisico accendersi.
• Debug: Controlla il Monitor Seriale. Dovresti vedere la richiesta GET /ON e il messaggio -> COMANDO ACCENDI Eseguito.

Questo laboratorio dimostra il meccanismo Client-Server su cui si basa l'IoT: il Client invia una richiesta tramite URL e il Server la interpreta per controllare un attuatore.