Progetto 02 - IoE con Cisco Packet Tracer e HTTP Real - Invio dati a server reale | Prof. Giagnotti

🟦 PROGETTI · IoT & Packet Tracer · Progetto 2

Docente: Prof. Giagnotti · IoE con Cisco Packet Tracer e HTTP Real

Progetto 02 — IoE con Cisco Packet Tracer e HTTP Real: Invio dati a server reale

Progetto avanzato: integrazione tra simulazione Packet Tracer e componenti reali (PHP + MySQL + Dashboard). Il dispositivo simulato acquisisce dati, li invia via HTTP a un server reale e riceve comandi per attuatori. Architettura completa end-to-end.

⏱ ~40 min laboratorio 🎯 Livello: Intermedio / Avanzato 🧩 Stack: Packet Tracer · Python · PHP · MySQL · Chart.js 🟢 Progetto completo ↗🎥 Video laboratorio ↗

✓Acquisire un dato da potenziometro in Packet Tracer e visualizzarlo su display simulato

✓Trasmettere il dato in JSON via HTTP Real POST a un server reale XAMPP

✓Memorizzare i dati con API PHP e MySQL (IoT_database → sensor_data)

✓Visualizzare i dati con dashboard PHP + Bootstrap + Chart.js e refresh automatico

✓Inviare comandi da dashboard a MCU (Accendi/Spegni LED) tramite HTTP GET su porta 8765

✓Integrare simulazione, rete, API REST, persistenza e UI in un'unica architettura IoE

💬 Tip del docente — Approccio ibrido

In questo progetto Packet Tracer non è più l'intero sistema. È una parte virtuale di un'architettura più grande. Mantieni sempre separati i layer: simulazione → rete → API → database → UI. Se testi isolatamente ogni hop, il debug diventa banale.

// Indice del progetto

1. Architettura del progetto — flusso simulato → reale 2. Creazione del database MySQL con XAMPP 3. Le API REST in PHP — iot_data.php e control_led.php 4. Realizzazione parte IoE in Packet Tracer — Real HTTP Client/Server 5. Sviluppo della dashboard — PHP, Bootstrap, Chart.js 6. Il flusso completo del progetto e inversione ruoli client/server 7. Test finale — checklist laboratorio 8. Troubleshooting — dove cercare il problema 9. Cosa si impara realmente — competenze integrate 10. Possibili estensioni del progetto 11. Download del progetto completo ✓ Verifica / Autovalutazione 📌 Riepilogo e concetti chiave

1. L'architettura del progetto

Prima di entrare nel codice è utile osservare il progetto come un insieme di componenti che collaborano tra loro. Il potenziometro rappresenta la sorgente del dato, mentre il LED rappresenta un attuatore che può essere comandato da remoto. Il dispositivo simulato acquisisce il valore di un potenziometro, lo visualizza sul display e lo invia attraverso una richiesta HTTP a un server reale. Il server PHP riceve i dati, li registra in un database MySQL e li rende disponibili a una dashboard web. Dalla stessa dashboard è inoltre possibile inviare un comando all'MCU simulato per accendere o spegnere un LED.

PACKET TRACER

Simulazione dispositivo IoT

MCU, potenziometro, display, LED collegati e programmabili in Python.

HTTP

Comunicazione client ↔ server

JSON trasportato via POST e GET tra mondo simulato e reale.

PHP + MYSQL

Ricezione e memorizzazione

API REST che decodifica JSON e scrive in sensor_data.

DASHBOARD

Visualizzazione e controllo

Tabella, grafico Chart.js e pulsanti per comandare il LED.

POTENZIOMETRO
dato 0-1023

→

MCU
Packet Tracer

→

HTTP POST
JSON

→

PHP
API REST

→

MYSQL
database

→

DASHBOARD
Chart.js

Dal dispositivo simulato al server reale e ritorno: il progetto integra più livelli tecnologici.

💡 Idea da ricordare

In questo progetto Packet Tracer non rappresenta più l'intero sistema. La simulazione diventa una parte di un'architettura più ampia: l'MCU comunica realmente con software eseguito sul computer attraverso il protocollo HTTP.

2. Creazione del database MySQL

La prima componente reale del progetto è il database. Utilizziamo XAMPP per avviare Apache e MySQL e phpMyAdmin per creare il database e la tabella che conterrà i dati provenienti dal dispositivo IoT.

✓ Avviare Apache dal pannello di controllo XAMPP.

✓ Avviare MySQL.

✓ Cliccare su Admin in corrispondenza di MySQL.

✓ Aprire il tab SQL di phpMyAdmin.

Creiamo il database IoT_database e la tabella sensor_data.

SQL · creazione database e tabella

CREATE DATABASE IoT_database;USE IoT_database;CREATE TABLE sensor_data (
id INT AUTO_INCREMENT PRIMARY KEY,
valore INT(5),
led_status VARCHAR(10),
timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

La tabella contiene tre informazioni fondamentali oltre alla chiave primaria:

CAMPO

valore

Contiene il valore letto dal potenziometro. Nell'esempio viene utilizzato un valore compreso tra 0 e 1023.

CAMPO

led_status

Memorizza lo stato corrente del LED, ad esempio acceso oppure spento.

CAMPO

timestamp

Registra automaticamente data e ora dell'inserimento del dato.

🔢 Perché il valore arriva fino a 1023?

Nel progetto il valore del potenziometro viene letto tramite un ADC a 10 bit. Con 10 bit sono disponibili 2¹⁰ = 1024 livelli numerici, rappresentati dall'intervallo 0–1023. Questo intervallo è tipico dei convertitori di Packet Tracer e di molti microcontrollori reali (es. Arduino).

3. Le API REST in PHP

Il database da solo non comunica direttamente con Packet Tracer. Abbiamo bisogno di un componente intermedio che riceva le richieste HTTP, interpreti i dati e interagisca con MySQL. Questo ruolo viene svolto da due script PHP:

API 01

iot_data.php

Riceve dal dispositivo il valore del potenziometro e lo stato del LED attraverso una richiesta HTTP POST. I dati arrivano in formato JSON e vengono memorizzati nel database.

API 02

control_led.php

Riceve dalla dashboard il comando per accendere o spegnere il LED e inoltra una richiesta HTTP all'MCU.

CONCETTO

Endpoint

Un URL che espone una funzionalità del server. Es. /test/IoT/iot_data.php è l'endpoint di scrittura dati.

3.1 API per la ricezione dei dati — iot_data.php

Creiamo il file iot_data.php all'interno della directory utilizzata da XAMPP, ad esempio:

Percorso di esempio

C:\xampp\htdocs\test\IoT

L'API stabilisce prima la connessione al database. Successivamente controlla che la richiesta ricevuta sia una richiesta POST e legge il contenuto del body.

PHP · iot_data.php — ricezione e salvataggio

<?php$servername = "localhost";
$username = "root";
$password = "";
$dbname = "iot_database";// Connessione al database
$conn = new mysqli(
$servername,
$username,
$password,
$dbname
);// Controllo connessione
if ($conn->connect_error) {
die("Connessione fallita: " . $conn->connect_error);
}// Ricezione del valore dal dispositivo MCU in formato JSON
if ($_SERVER["REQUEST_METHOD"] == "POST") {// Legge il JSON inviato dal client
$json = file_get_contents("php://input");// Decodifica il JSON
$data = json_decode($json, true);// Controlla che i dati siano presenti
if (isset($data["valore"]) && isset($data["led_status"])) {$statoPot = $data["valore"];
$led_status = $data["led_status"];// Inserimento nel database
$sql = "INSERT INTO sensor_data
(valore, led_status)
VALUES ('$statoPot', '$led_status')";if ($conn->query($sql) === TRUE) {
echo "Dati salvati con successo";
} else {
echo "Errore: " . $sql . "<br>" . $conn->error;
}} else {echo "Errore: valore o stato del LED non ricevuti";
}
}$conn->close();?>

3.2 Che cos'è un endpoint?

Nel contesto delle API REST, un endpoint è un URL attraverso il quale un'applicazione può accedere a una determinata funzionalità del server. Nel nostro progetto l'MCU utilizza, ad esempio, questo endpoint:

Python · richiesta POST verso endpoint reale

request = client.post(
"http://127.0.0.1/test/IoT/iot_data.php",
json_data,
"application/json"
)

L'MCU, in questo momento, svolge il ruolo di client: prepara i dati e li invia al server.

💬 Tip del docente — json e content-type

Quando invii JSON da Packet Tracer, specifica sempre il content-type application/json. In PHP leggi il body con php://input perché $_POST rimane vuoto con JSON raw: è un dettaglio che fa perdere ore se non lo conosci.

3.3 Ricevere il JSON con php://input

Una parte particolarmente importante dell'API è:

PHP · lettura del body HTTP

$json = file_get_contents("php://input");

La funzione file_get_contents() viene normalmente utilizzata per leggere il contenuto di una risorsa. In questo caso lo stream php://input permette di accedere al corpo della richiesta HTTP. Il risultato viene quindi memorizzato nella variabile $json e successivamente trasformato in una struttura PHP attraverso json_decode().

🧠 Il passaggio fondamentale

Il dato compie questo percorso: valore del sensore → oggetto Python → JSON → HTTP POST → PHP → array PHP → SQL → MySQL. Ogni passaggio deve preservare tipo e struttura.

3.4 API per il controllo del LED — control_led.php

La comunicazione può avvenire anche nella direzione opposta. In questo caso è la dashboard a generare un comando. Quando l'utente preme "Accendi" oppure "Spegni", la dashboard richiama l'API control_led.php. L'API legge il parametro comando e invia una richiesta HTTP GET all'MCU.

PHP · control_led.php — inoltro comando verso MCU

<?php$servername = "localhost";
$username = "root";
$password = "";
$dbname = "iot_database";// Connessione al database
$conn = new mysqli($servername, $username, $password, $dbname);if ($conn->connect_error) {
die("Connessione fallita: " . $conn->connect_error);
}// Gestione del comando
if ($_SERVER["REQUEST_METHOD"] == "GET") {if (isset($_GET['comando'])) {$comando = $_GET['comando'];// Invio della richiesta all'MCU
$url = "http://127.0.0.1:8765/control_led?comando=$comando";file_get_contents($url);header("Location: dashboard.php");
}
}$conn->close();?>

DASHBOARD

→

control_led.php

→

HTTP GET

→

MCU :8765

→

LED

🔁 Cambio ruolo dell'MCU — client e server

Quando l'MCU invia i dati al server si comporta come client. Quando invece riceve una richiesta HTTP e deve rispondere, svolge il ruolo di server. Comprendere questa doppia natura è la chiave dell'architettura IoE moderna: ogni nodo può essere sia produttore che consumatore di richieste.

4. Realizzazione della parte IoE in Packet Tracer

La rete e il collegamento dei dispositivi sono già stati illustrati nel progetto introduttivo IoT e IoE con Cisco Packet Tracer. In questo progetto non è quindi necessario ripetere tutti i passaggi di costruzione della rete. Qui ci concentriamo invece sull'aspetto nuovo: la possibilità di utilizzare le funzionalità Real HTTP offerte da Packet Tracer.

📌 Nota didattica — perché non rifacciamo la rete

Il primo progetto insegna a costruire e programmare il dispositivo IoT simulato. Questo secondo progetto parte da quella base e aggiunge un livello applicativo: la comunicazione con un server reale. Se parti da zero, realizza prima il progetto 01, poi estendilo con Real HTTP.

4.1 I template Real HTTP

Aprendo la scheda Programming dell'MCU possiamo osservare i template dedicati alla comunicazione HTTP reale.

TEMPLATE

Real HTTP Client - Python

Permette al dispositivo di inviare richieste HTTP verso un server reale.

TEMPLATE

Real HTTP Server - Python

Permette al dispositivo di ricevere richieste HTTP e fornire una risposta attraverso una propria route.

Nel nostro progetto utilizziamo entrambe le modalità: l'MCU invia dati al server reale e contemporaneamente espone un endpoint per ricevere il comando relativo al LED.

4.2 Creazione del progetto Python

Creiamo il progetto IoT Real HTTP utilizzando un template Python vuoto. Importiamo le funzioni necessarie:

Python · import moduli MCU

from realhttp import *
from gpio import *
from time import *
import json

4.3 Configurazione dell'MCU

Configuriamo i pin utilizzati dal progetto e inizializziamo sia il client HTTP sia il server HTTP.

Python · setup pin e HTTP

# ---------------- SETUP ----------------# Configurazione dei pin
pinMode(1, OUT)  # LED
pinMode(2, OUT)  # Display# Inizializzazione del client HTTP
client = RealHTTPClient()# Avvio del server HTTP
server = RealHTTPServer()print("Server started: %s" % (server.start(8765)))
print("Server listening: %s" % (server.isListening()))# Stato iniziale del LED
stato_led = "spento"

L'MCU ascolta sulla porta 8765. Questo permette al server PHP di raggiungere l'MCU attraverso l'endpoint dedicato al controllo del LED.

4.4 La route per il controllo del LED

Definiamo ora la funzione Python che riceve la richiesta HTTP. Il parametro comando determina se il LED deve essere acceso oppure spento.

Python · route control_led con parsing query string

#-------------- CONTROLLO LED -------------#def control_led(context, request, reply):global stato_ledprint("Ricevuto comando per LED:", request.url())# Lettura dell'URL
url = request.url()comando = None# Estrazione della query string
if "?" in url:query_string = url.split("?")[1]params = dict(
param.split("=")
for param in query_string.split("&")
if "=" in param
)comando = params.get("comando")# Controllo del comando
if comando == "1":digitalWrite(1, HIGH)stato_led = "acceso"reply.setContent("LED acceso!")elif comando == "0":digitalWrite(1, LOW)stato_led = "spento"reply.setContent("LED spento!")else:reply.setContent(
"Comando non valido! Usa "
"'comando=1' per accendere "
"o 'comando=0' per spegnere."
)reply.setStatus(200)
reply.end()#------------ ROUTE CONTROLLO LED ----------#server.route(
"/control_led",
["GET"],
control_led
)

La route viene registrata con:

Python · registrazione endpoint MCU

server.route(
"/control_led",
["GET"],
control_led
)

Di conseguenza, una richiesta come:

HTTP · esempio accensione

http://127.0.0.1:8765/control_led?comando=1

determina l'accensione del LED, mentre:

HTTP · esempio spegnimento

http://127.0.0.1:8765/control_led?comando=0

determina lo spegnimento.

4.5 Il ciclo principale

Nel ciclo principale leggiamo il potenziometro, aggiorniamo il display, prepariamo l'oggetto JSON e inviamo i dati al server reale. In questo progetto il ciclo viene eseguito in modo sequenziale. Dopo ogni invio attendiamo due secondi prima di effettuare la lettura successiva.

Python · ciclo principale — lettura, JSON, POST

#----- Ciclo principale senza threading -----#while True:# Legge il valore del potenziometro
valPot = analogRead(A0)# Scrive il valore sul display
customWrite(2, valPot)# Creazione dell'oggetto JSON
data = {
"valore": valPot,
"led_status": stato_led
}json_data = json.dumps(data)# Invio HTTP POST
try:request = client.post(
"http://127.0.0.1/test/IoT/iot_data.php",
json_data,
"application/json"
)print("Dati inviati:", json_data)except Exception as e:print("Errore nell'invio dei dati:", e)# Attesa prima del prossimo invio
sleep(2)

🔄 Il ciclo completo in 2 secondi

Ogni due secondi il sistema legge il sensore, aggiorna il display, crea un JSON e lo invia al server. Se nel frattempo dalla dashboard viene inviato un comando per il LED, l'MCU aggiorna la variabile stato_led. Questo valore verrà incluso nel prossimo POST e quindi storicizzato nel database.

5. Sviluppo della dashboard

La dashboard costituisce l'interfaccia attraverso la quale possiamo osservare i dati acquisiti e interagire con il dispositivo simulato. Viene realizzata utilizzando:

BACKEND

PHP

Per la connessione al database e l'elaborazione dei dati.

Bootstrap

Per organizzare il layout e i componenti dell'interfaccia.

CHART

Chart.js

Per rappresentare graficamente l'andamento dei valori del potenziometro.

5.1 Connessione al database

PHP · connessione MySQL

<?php$servername = "localhost";
$username = "root";
$password = "";
$dbname = "iot_database";$conn = new mysqli(
$servername,
$username,
$password,
$dbname
);if ($conn->connect_error) {
die("Connessione fallita: " . $conn->connect_error);
}

5.2 Recupero dei dati

La dashboard recupera, ad esempio, gli ultimi dieci valori presenti nel database.

PHP · query ultimi 10 + stato LED

$sql = "
SELECT *
FROM sensor_data
ORDER BY id DESC
LIMIT 10
";$result = $conn->query($sql);$data = [];if ($result->num_rows > 0) {while ($row = $result->fetch_assoc()) {$data[] = $row;
}
}// Ottieni lo stato più recente del LED
$sql_led_status = "
SELECT led_status
FROM sensor_data
ORDER BY id DESC
LIMIT 1
";$result_led_status =
$conn->query($sql_led_status);$led_status =
($result_led_status->num_rows > 0)
? $result_led_status->fetch_assoc()['led_status']
: 'spento';$conn->close();

5.3 Struttura della dashboard

La dashboard contiene tre elementi principali:

01 · CONTROLLO

Pulsanti on/off

Pulsanti per inviare il comando di accensione o spegnimento del LED chiamando control_led.php.

02 · MONITORAGGIO

Tabella dati

Tabella con gli ultimi valori ricevuti e lo stato del LED ordinati per timestamp.

03 · GRAFICO

Andamento tempo-reale

Visualizzazione dell'andamento del potenziometro attraverso Chart.js.

5.4 Refresh automatico

La dashboard viene aggiornata automaticamente ogni due secondi, in modo da mostrare i dati più recenti ricevuti dal dispositivo.

JS · refresh automatico

<script>function refreshPage() {
location.reload();
}setInterval(refreshPage, 2000);</script>

5.5 Controllo e visualizzazione del LED

I pulsanti inviano il parametro comando all'API control_led.php.

HTML / PHP · form Accendi/Spegni

<!-- Accensione --><form method="get"
action="control_led.php"><input type="hidden"
name="comando"
value="1"><button type="submit">
Accendi
</button></form><!-- Spegnimento --><form method="get"
action="control_led.php"><input type="hidden"
name="comando"
value="0"><button type="submit">
Spegni
</button></form>

Per rappresentare visivamente lo stato del LED possiamo utilizzare una semplice espressione PHP:

PHP · stato visuale LED

background-color:
<?= $led_status == 'acceso'
? 'yellow'
: '#ccc'; ?>;

5.6 Tabella dei dati

I dati recuperati dal database possono essere mostrati attraverso un ciclo PHP.

PHP / HTML · tabella sensor_data

<table><thead><tr>
<th>Timestamp</th>
<th>Potenziometro</th>
<th>LED</th>
</tr></thead><tbody><?php foreach ($data as $row): ?><tr><td>
<?= $row['timestamp'] ?>
</td><td>
<?= $row['valore'] ?>
</td><td>
<?= $row['led_status'] ?>
</td></tr><?php endforeach; ?></tbody></table>

5.7 Grafico con Chart.js

L'ultimo elemento della dashboard è il grafico lineare. Utilizziamo i timestamp come etichette dell'asse orizzontale e i valori del potenziometro come dati.

JS · Chart.js — labels + values

let labels =
<?= json_encode(
array_column($data, 'timestamp')
) ?>.reverse();let values =
<?= json_encode(
array_column($data, 'valore')
) ?>.reverse();const ctx =
document
.getElementById('iotChart')
.getContext('2d');const chart = new Chart(ctx, {type: 'line',data: {labels: labels,datasets: [{label: 'Valore Potenziometro',data: values,borderColor: 'rgb(75, 192, 192)',tension: 0.1}]
},options: {responsive: true,scales: {x: {
title: {
display: true,
text: 'Tempo'
}
},y: {
title: {
display: true,
text: 'Valore'
}
}
}
}
});

Il risultato è un grafico lineare che permette di osservare come varia il valore del potenziometro nel tempo.

💬 Tip del docente — reverse() per ordine cronologico

La query prende gli ultimi 10 con ORDER BY id DESC. Per il grafico serve l'ordine cronologico: .reverse() dopo json_encode sistema la timeline. Senza reverse vedresti il grafico al contrario.

6. Il flusso completo del progetto

A questo punto possiamo ricostruire l'intero percorso dell'informazione.

1
SENSORE

→

2
MCU

→

3
JSON

→

4
HTTP POST

→

5
PHP

→

6
MYSQL

DATABASE

→

DASHBOARD

→

CONTROL_LED.PHP

→

HTTP GET

→

MCU

→

LED

🎯 La cosa importante da capire

Il progetto non consiste semplicemente nel "mandare un valore a un database". È un esempio completo di comunicazione tra dispositivi, servizi web e database. Il dato percorre più livelli: acquisizione → elaborazione → trasmissione → memorizzazione → visualizzazione. Il comando percorre invece il percorso inverso: interfaccia → API → HTTP → dispositivo → attuatore.

7. Test finale

Dopo aver avviato tutte le componenti del sistema possiamo verificare il funzionamento completo.

✓ Avviare Apache e MySQL tramite XAMPP.

✓ Verificare che il database IoT_database sia disponibile.

✓ Avviare il programma Python dell'MCU in Packet Tracer.

✓ Muovere il potenziometro e verificare il valore sul display.

✓ Controllare che i dati vengano inseriti nella tabella sensor_data.

✓ Aprire la dashboard e verificare la presenza dei dati.

✓ Verificare l'aggiornamento del grafico.

✓ Premere Accendi e verificare il LED nell'MCU.

✓ Premere Spegni e verificare nuovamente il LED.

8. Troubleshooting: dove cercare il problema?

Un progetto che coinvolge simulazione, rete, server, PHP e database può fallire in punti differenti. Un metodo utile consiste nel controllare il percorso del dato un livello alla volta.

ISSUE

Il valore non arriva al DB

Controllare prima l'MCU, poi l'URL dell'endpoint, quindi Apache e infine la connessione PHP/MySQL.

ISSUE

Il grafico è vuoto

Controllare se la tabella contiene effettivamente dati e se la query SQL restituisce risultati.

ISSUE

Il LED non cambia stato

Verificare il parametro comando, la route /control_led e la porta utilizzata dal server dell'MCU (8765).

⚠️ Errore comune — test a cascata

Non modificare contemporaneamente tutti i componenti. Se qualcosa non funziona, verifica prima un singolo collegamento: MCU → HTTP, HTTP → PHP, PHP → MySQL, oppure Dashboard → PHP → MCU. Lavora su un link alla volta, non sull'intero sistema.

⚠️ Errore comune — porta e firewall

Se control_led.php non raggiunge l'MCU, controlla che la porta 8765 sia effettivamente in listening (print in Python) e che il firewall di Windows non blocchi le connessioni locali. Inoltre, verifica che l'IP in realhttp sia 127.0.0.1 e non l'IP della rete simulata.

9. Cosa si impara realmente con questo progetto?

Il valore didattico del progetto non è soltanto nel risultato finale, ma nell'integrazione di competenze normalmente studiate separatamente.

RETI

Client/Server HTTP

Comunicazione client/server e utilizzo del protocollo HTTP con metodi POST e GET.

PROGRAMMAZIONE

Python, PHP, JS

Python per MCU, PHP per API, JavaScript per dashboard e gestione dati in JSON.

DATABASE

MySQL CRUD

Creazione di database, tabelle, inserimento e interrogazione dei dati con timestamp automatico.

WEB

Dashboard interattiva

Realizzazione di una dashboard capace di leggere dati e inviare comandi con Bootstrap e Chart.js.

IoT / IoE

Ecosistema connesso

Collegamento tra dispositivo, rete, servizi e applicazioni: il cuore dell'Internet of Everything.

DEBUG

Analisi del flusso

Analisi del percorso dei dati per individuare progressivamente eventuali errori in architetture distribuite.

10. Possibili estensioni

Una volta completato il progetto di base, è possibile utilizzarlo come punto di partenza per attività più complesse.

aggiungere altri sensori (temperatura, umidità, luce);
memorizzare più grandezze nella stessa tabella o in tabelle correlate;
realizzare più grafici nella dashboard (uno per grandezza);
aggiungere soglie e notifiche (alert se valore supera soglia);
introdurre ulteriori attuatori (relè, buzzer, servomotore);
separare maggiormente API, database e interfaccia in MVC;
utilizzare il progetto come base per una semplice architettura IoT completa con autenticazione.

11. Download del progetto

Il progetto completo può essere scaricato e utilizzato come base per la sperimentazione in laboratorio.

📦 Repository ufficiale — IoT Real HTTP

Scarica il file ZIP con progetto Packet Tracer, script PHP, dashboard e database di esempio. Puoi usarlo come base per estensioni e come template per nuovi sensori.

✓ Verifica / Autovalutazione

□ Sai spiegare perché php://input è necessario per leggere JSON raw e perché $_POST è vuoto?

□ Sai descrivere il doppio ruolo dell'MCU (client quando fa POST, server quando espone /control_led)?

□ Hai verificato che la tabella sensor_data registra correttamente valore, led_status e timestamp?

□ Riesci a tracciare il flusso completo sia in direzione sensore → DB che dashboard → attuatore?

□ Hai testato refresh automatico dashboard e controllo LED con pulsanti Accendi/Spegni?

📌 Riepilogo e concetti chiave

Con questo progetto abbiamo fatto un passo ulteriore rispetto alla semplice simulazione di un dispositivo IoT. Cisco Packet Tracer viene utilizzato per simulare il dispositivo e la sua rete, mentre il computer reale ospita il server web, le API PHP, il database MySQL e la dashboard.

Il risultato è una piccola architettura IoE nella quale dispositivi, protocolli, servizi web e database collaborano per realizzare un sistema completo. Il progetto permette di osservare concretamente una caratteristica fondamentale dei sistemi moderni: un dispositivo non opera necessariamente da solo. Può acquisire informazioni, comunicarle a servizi remoti, conservarle in un database e ricevere a sua volta comandi provenienti da un'interfaccia web.

🏫 Dal laboratorio alla progettazione reale

Questo pattern — sensore → MCU → HTTP → API → DB → dashboard → comando → attuatore — è lo stesso usato in sistemi IoT industriali, cambiando solo scala e sicurezza. Padroneggiarlo in Packet Tracer ti permette di affrontare progetti reali con ESP32, Raspberry Pi, MQTT e cloud.

Componente	Ruolo nel progetto	Tecnologia
MCU simulato	Acquisisce, visualizza, invia e riceve comandi	Python + realhttp + gpio
Canale real HTTP	Ponte tra mondo simulato e host reale	HTTP POST/GET + JSON
iot_data.php	Riceve JSON e scrive su MySQL	PHP + mysqli + php://input
control_led.php	Inoltra comando GET a MCU	PHP + file_get_contents
MySQL	Persistenza dati sensore e stato LED	XAMPP + sensor_data
Dashboard	Monitor e controllo	Bootstrap + PHP + Chart.js

IoE con Cisco Packet Tracer e HTTP Real — Progetto didattico · Packet Tracer · HTTP · Python · PHP · MySQL · Chart.js · Prof. Giagnotti