formation-arduino/modules/11-mqtt.qmd

---
title: "Module 11 — IoT & Cloud : le protocole MQTT"
---

## Objectifs du module

- Comprendre le principe du protocole MQTT (publish/subscribe) et son intérêt en IoT.
- Connecter l'ESP32-S3 à un broker MQTT.
- Publier des données de capteurs et s'abonner à des commandes.
- Visualiser les données dans un tableau de bord (Node-RED ou Home Assistant).

## 1. Pourquoi MQTT plutôt qu'HTTP pour l'IoT ?

Le modèle HTTP vu au Module 7 fonctionne bien pour des requêtes ponctuelles, mais devient lourd pour des objets connectés qui doivent échanger fréquemment de petits messages (température toutes les secondes, changement d'état instantané). MQTT (Message Queuing Telemetry Transport) est un protocole léger conçu spécifiquement pour l'IoT, basé sur un modèle publish/subscribe (publication/abonnement) plutôt que sur des requêtes/réponses.

## 2. Le modèle publish/subscribe

| Élément | Rôle |
|-------------|----------------------------------------|
| Broker | Serveur central qui reçoit les messages publiés et les redistribue aux abonnés (ex : Mosquitto, HiveMQ) |
| Topic (sujet) | Chaîne hiérarchique identifiant un flux de données (ex : maison/salon/temperature) |
| Publish | Envoyer un message sur un topic donné |
| Subscribe | S'abonner à un topic pour recevoir tous les messages publiés dessus |

Avantage clé : les appareils ne communiquent jamais directement entre eux — tout transite par le broker, ce qui simplifie grandement l'architecture (un capteur ne connaît pas l'adresse du tableau de bord qui affichera ses données, il publie simplement sur un topic).

## 3. Choisir un broker MQTT

- Mosquitto : broker open-source, installable localement (Raspberry Pi, PC, serveur domestique) ou utilisable en test public (test.mosquitto.org).
- HiveMQ Cloud : offre gratuite hébergée, pratique pour démarrer sans installation.
- Le broker intégré à Home Assistant : pratique si vous utilisez déjà cette plateforme domotique.

::: {.callout-important title="Sécurité en production"}
Pour un usage de test/formation, un broker public non sécurisé (comme test.mosquitto.org) est acceptable. Pour un déploiement réel, utilisez toujours une connexion chiffrée (MQTTS, port 8883) avec authentification par identifiants ou certificat.
:::

## 4. Connexion MQTT avec PubSubClient

Installez la bibliothèque « PubSubClient » (Nick O'Leary) depuis le gestionnaire de bibliothèques.

```cpp
#include <WiFi.h>
#include <PubSubClient.h>

const char* ssid = "NomDuReseau";
const char* motDePasse = "MotDePasse";
const char* brokerMQTT = "test.mosquitto.org";
const int portMQTT = 1883;

WiFiClient espClient;
PubSubClient client(espClient);

void connecterMQTT() {
  while (!client.connected()) {
    Serial.print("Connexion au broker MQTT...");
    String idClient = "ESP32S3-" + String(random(0xffff), HEX);
    if (client.connect(idClient.c_str())) {
      Serial.println(" connecte !");
    } else {
      Serial.printf(" echec, code erreur: %d. Nouvelle tentative dans 2s.\n", client.state());
      delay(2000);
    }
  }
}

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, motDePasse);
  while (WiFi.status() != WL_CONNECTED) { delay(500); }

  client.setServer(brokerMQTT, portMQTT);
  connecterMQTT();
}

void loop() {
  if (!client.connected()) connecterMQTT();
  client.loop();  // A appeler en permanence, comme handleClient() pour le serveur web
}
```

## 5. Publier des données de capteur

```cpp
unsigned long dernierEnvoi = 0;
const unsigned long intervalle = 5000;

void loop() {
  if (!client.connected()) connecterMQTT();
  client.loop();

  unsigned long maintenant = millis();
  if (maintenant - dernierEnvoi >= intervalle) {
    dernierEnvoi = maintenant;

    float temperature = bme.readTemperature();
    char message[10];
    dtostrf(temperature, 4, 1, message);  // conversion float -> texte

    client.publish("formation/esp32s3/temperature", message);
    Serial.printf("Publie: %s\n", message);
  }
}
```

## 6. S'abonner à un topic (recevoir des commandes)

Réutilisons la LED NeoPixel : elle pourra être pilotée à distance en s'abonnant à un topic de commande.

```cpp
#include <Adafruit_NeoPixel.h>
#define NEOPIXEL_PIN 48
Adafruit_NeoPixel pixel(1, NEOPIXEL_PIN, NEO_GRB + NEO_KHZ800);

void callbackMQTT(char* topic, byte* payload, unsigned int longueur) {
  String message;
  for (unsigned int i = 0; i < longueur; i++) message += (char)payload[i];

  Serial.printf("Message recu sur %s: %s\n", topic, message.c_str());

  if (message == "rouge") pixel.setPixelColor(0, pixel.Color(255,0,0));
  else if (message == "vert") pixel.setPixelColor(0, pixel.Color(0,255,0));
  else if (message == "bleu") pixel.setPixelColor(0, pixel.Color(0,0,255));
  else if (message == "off") pixel.setPixelColor(0, pixel.Color(0,0,0));
  pixel.show();
}

void connecterMQTT() {
  while (!client.connected()) {
    String idClient = "ESP32S3-" + String(random(0xffff), HEX);
    if (client.connect(idClient.c_str())) {
      client.subscribe("formation/esp32s3/commande");
    } else {
      delay(2000);
    }
  }
}

void setup() {
  pixel.begin();
  // ... connexion WiFi ...
  client.setServer(brokerMQTT, portMQTT);
  client.setCallback(callbackMQTT);
  connecterMQTT();
}
```

## 7. Visualiser les données : Node-RED ou Home Assistant

Une fois les données publiées sur le broker, il est possible de les visualiser sans écrire de code supplémentaire :

- Node-RED : outil de programmation visuelle par flux, avec un nœud MQTT natif et un tableau de bord (dashboard) configurable en quelques clics.
- Home Assistant : plateforme domotique qui peut découvrir automatiquement les topics MQTT et générer des cartes de suivi (courbes de température, boutons de commande).

::: {.callout-note title="Portée pédagogique"}
La mise en place détaillée de Node-RED ou Home Assistant dépasse le cadre strict de la programmation Arduino/ESP32 ; ce module se concentre sur la partie « objet connecté » (ESP32-S3). L'installation et la configuration de l'outil de visualisation pourront faire l'objet d'un support complémentaire selon les besoins du groupe.
:::

## 8. Exercice final du module : station météo connectée

En combinant tous les modules précédents, réalisez une station météo IoT complète :

- Lecture température/humidité via le BME280 (Module 5).
- Publication MQTT toutes les 30 secondes sur un topic dédié.
- Abonnement à un topic de commande pilotant la couleur de la LED NeoPixel.
- Affichage local sur l'écran OLED de la dernière valeur publiée et de l'état de connexion MQTT.

## Checklist de fin de module

- [ ] Je comprends le modèle publish/subscribe et le rôle du broker.
- [ ] Je sais connecter l'ESP32-S3 à un broker MQTT.
- [ ] Je sais publier une donnée de capteur sur un topic.
- [ ] Je sais m'abonner à un topic et réagir à un message reçu.
- [ ] J'ai réalisé la station météo connectée combinant capteur, MQTT, OLED et LED NeoPixel.