Corso di Robotica: 7 Internet of Things

7 — Internet of Things (IoT)

Laboratorio A — ESP32 + MQTT (3–4 h)

Obiettivo: leggere un sensore (es. DHT22) su ESP32 e pubblicare telemetria a un broker MQTT; creare semplice dashboard (Node-RED/Grafana).

Hardware minimo:

  • ESP32 dev board
  • DHT22 o sensore analogico/TMP36
  • Breadboard, cavi, alimentazione USB

Passi pratici (sintesi):

  1. Configurare broker MQTT locale (Mosquitto su Raspberry Pi o broker cloud).
  2. Caricare sketch Arduino su ESP32 (Wi-Fi + MQTT) — vedi esempio sotto.
  3. Pubblicare su robots/esp32_01/telemetry payload JSON con temperatura/umidità/timestamp.
  4. Configurare Node-RED per sottoscrivere il topic e inviare i dati a Grafana o dashboard semplice.

Esempio di codice (Arduino/ESP32 con PubSubClient):

#include <WiFi.h>
#include <PubSubClient.h>
#include <DHT.h>
#define DHTPIN 4
#define DHTTYPE DHT22
const char* ssid = "YOUR_SSID";
const char* pass = "YOUR_PASS";
const char* mqtt_server = "192.168.1.50"; // broker IP/hostname
WiFiClient espClient;
PubSubClient client(espClient);
DHT dht(DHTPIN, DHTTYPE);
void setup_wifi() {
delay(10);
WiFi.begin(ssid, pass);
while (WiFi.status() != WL_CONNECTED) { delay(500); }
}
void reconnect() {
while (!client.connected()) {
if (client.connect("esp32_01","mqtt_user","mqtt_pass")) {
// connected
} else {
delay(1000);
}
}
}
void setup() {
Serial.begin(115200);
dht.begin();
setup_wifi();
client.setServer(mqtt_server, 1883);
}
void loop() {
if (!client.connected()) reconnect();
client.loop();
float h = dht.readHumidity();
float t = dht.readTemperature();
char payload[128];
snprintf(payload, sizeof(payload), "{\"temp\":%.2f,\"hum\":%.2f}", t, h);
client.publish("robots/esp32_01/telemetry", payload, true);
delay(5000);
}

Note didattiche:

  • Spiegare retain e QoS; perché usare JSON.
  • Mostrare come visualizzare in Node-RED e salvare su InfluxDB per Grafana.

Laboratorio B — Controllo remoto via smartphone (3–4 h)

Obiettivo: costruire un’interfaccia smartphone che comanda il robot (start/stop, velocità) usando MQTT over WebSockets oppure WebSocket server su Raspberry Pi.

Alternative pratiche:

  • Opzione 1: usare MQTT over WebSockets + libreria MQTT.js o PahoJS in pagina web mobile.
  • Opzione 2: app mobile con framework (es. Ionic/React Native) che si connette a WebSocket/MQTT.

Snippet minimale (HTML + MQTT.js) per controllo:

<!doctype html>
<html>
<head><meta charset="utf-8"></head>
<body>
<button onclick="sendCmd('forward')">Avanti</button>
<button onclick="sendCmd('stop')">Stop</button>
<script src="https://unpkg.com/mqtt/dist/mqtt.min.js"></script>
<script>
const client = mqtt.connect('wss://broker.example.com:8083', {
username: 'mqtt_user',
password: 'mqtt_pass'
});
function sendCmd(cmd){
const topic = 'robots/esp32_01/cmd';
const msg = JSON.stringify({cmd: cmd, ts: Date.now()});
client.publish(topic, msg);
}
</script>
</body>
</html>

Lato robot (subscriber): microcontroller oppure Raspberry Pi sottoscrive robots/{id}/cmd e interpreta i comandi, inviando segnali ai driver motore.

Laboratorio C — ROS e integrazione IoT (3–4 h)

Obiettivo: collegare un nodo ROS con un broker MQTT (bridge) e mostrare come telemetria ROS (es. odometry) può essere pubblicata su topic MQTT e viceversa.

Concetti chiave:

  • ROS (Robot Operating System): nodi, topic, messaggi, servizi, action, tf.
  • ROS1 vs ROS2: ROS2 porta supporto nativo DDS e migliorata per sistemi distribuiti; per corsi introduttivi usare ROS1/Noetic o ROS2 Foxy in funzione dell’ambiente.
  • Bridge: rosbridge_suite (WebSocket interface per ROS) o pacchetti che traducono tra ROS topics e MQTT.

Esempio minimalissimo (ROS Python publisher):

talker.py

#!/usr/bin/env python
import rospy
from std_msgs.msg import String
rospy.init_node('simple_talker')
pub = rospy.Publisher('/robot/status', String, queue_size=10)
rate = rospy.Rate(1)
while not rospy.is_shutdown():
msg = "alive"
pub.publish(msg)
rate.sleep()

Integrazione MQTT: utilizzare rosbridge_server per esporre ROS via WebSocket oppure tool di bridging che pubblicano su MQTT.


Sicurezza, privacy e gestione operativa

Un buon progetto IoT/robotico non è completo senza sicurezza:

  1. Crittografia dei canali: usare TLS per MQTT (MQTTS) o WebSockets WSS.
  2. Autenticazione forte: autenticazione con certificati o token (evitare username/password statiche in produzione).
  3. Network segmentation: isolare reti di produzione (robot) dalla rete IT principale.
  4. Aggiornamenti OTA (over-the-air): prevedere meccanismi di aggiornamento firmati per ESP/RPi.
  5. Logging e monitoring: tenere traccia degli accessi e delle telemetrie anomale per intrusion detection.
  6. Fail-safe: sul robot predisporre routine che arrestino movimenti in caso di perdita connessione o errore.

Architetture avanzate e pipeline dati

  • Edge processing: elaborare dati (filtraggio, compressione) sul robot per ridurre traffico.
  • Broker MQTT (locale) + Cloud: pubblicare su broker locale e sincronizzare a cloud per scalabilità.
  • Time series DB + Grafana: InfluxDB/Prometheus per metriche e Grafana per dashboards.
  • Orchestrazione low-code: Node-RED per prototipazione rapida (flussi di trasformazione e dashboard).

Esempi di strutture topic e payload

Topic naming (consistente, gerarchico):

robots/{robot_id}/telemetry/{sensor}
robots/{robot_id}/status
robots/{robot_id}/cmd
robots/{robot_id}/alerts
fleet/{fleet_id}/health

Payload JSON consigliato (telemetry):

{
"robot_id":"esp32_01",
"ts":1629876543210,
"sensors": { "temp": 23.4, "hum": 45.1 },
"battery": 87
}


Commenti

Post popolari in questo blog

La scienza delle piccole grandi cose: Teoria della doppia copia: gravità e gauge a confronto

Corso di Algebra Elementare e Strutture Algebriche: 1 Polinomi

CORSO DI MECCANICA QUANTISTICA: 2 Misura Quantistica Sovrapposizione e Spin