Réseaux & Protocoles IoT

#include <WiFi.h>

void setup() {
  Serial.begin(115200);

  WiFi.mode(WIFI_STA);
  WiFi.disconnect();
  delay(100);
  Serial.println("Scan WiFi en cours...");
}

void loop() {
  int n = WiFi.scanNetworks();
  if (n == 0) {
    Serial.println("Aucun réseau trouvé");
  } else {
    Serial.printf("%d réseau(x) trouvé(s)\n", n);
    for (int i = 0; i < n; i++) {
      Serial.printf("  %d: %s | RSSI: %d dBm | %s\n",
        i + 1,
        WiFi.SSID(i).c_str(),
        WiFi.RSSI(i),
        WiFi.encryptionType(i) == WIFI_AUTH_OPEN ? "Ouvert" : "Sécurisé"
      );
    }
  }
  delay(10000);
}

#include <WiFi.h>

const char* SSID     = "MUST_IoT_Lab";
const char* PASSWORD = "MotDePasseWiFi";

void setup() {
  Serial.begin(115200);
  Serial.printf("Connexion à %s...\n", SSID);

  WiFi.begin(SSID, PASSWORD);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("\n✓ Connecté !");
  Serial.printf("IP : %s\n", WiFi.localIP().toString().c_str());
  Serial.printf("RSSI : %d dBm\n", WiFi.RSSI());
}

void loop() {
  long rssi = WiFi.RSSI();
  Serial.printf("RSSI: %d dBm — ", rssi);

  if (rssi > -50)       Serial.println("Excellent");
  else if (rssi > -70)  Serial.println("Bon");
  else if (rssi > -80)  Serial.println("Moyen");
  else                    Serial.println("Mauvais");

  delay(5000);
}

# Installation broker Mosquitto (macOS)
brew install mosquitto

# Démarrer le broker
mosquitto -v

# Dans un autre terminal — s'abonner à un topic
mosquitto_sub -h localhost -t "must/toliara/#" -v

# Publier un message
mosquitto_pub -h localhost -t "must/toliara/batiment-A/salle-1/temperature" \
  -m "28.5" -r

# Avec wildcards
mosquitto_sub -h localhost -t "must/+/temperature" -v
mosquitto_sub -h localhost -t "must/toliara/#" -v

#include <WiFi.h>
#include <PubSubClient.h>
#include <DHT.h>

const char* SSID        = "MUST_IoT_Lab";
const char* PASSWORD    = "MotDePasseWiFi";
const char* MQTT_BROKER = "192.168.1.100";
const int   MQTT_PORT   = 1883;
const char* TOPIC_TEMP  = "must/toliara/batiment-A/salle-1/temperature";
const char* TOPIC_HUM   = "must/toliara/batiment-A/salle-1/humidite";
const char* CLIENT_ID   = "esp32-salle1";

WiFiClient espClient;
PubSubClient mqtt(espClient);
DHT dht(4, DHT22);

void reconnect() {
  while (!mqtt.connected()) {
    Serial.print("MQTT...");
    if (mqtt.connect(CLIENT_ID)) {
      Serial.println(" OK");
      mqtt.subscribe("must/toliara/batiment-A/commande");
    } else {
      Serial.printf(" Echec (%d)\n", mqtt.state());
      delay(5000);
    }
  }
}

void setup() {
  Serial.begin(115200);
  dht.begin();
  WiFi.begin(SSID, PASSWORD);
  while (WiFi.status() != WL_CONNECTED) { delay(500); }
  mqtt.setServer(MQTT_BROKER, MQTT_PORT);
}

void loop() {
  if (!mqtt.connected()) reconnect();
  mqtt.loop();

  float temp = dht.readTemperature();
  float hum  = dht.readHumidity();

  mqtt.publish(TOPIC_TEMP, String(temp, 1).c_str(), true);
  mqtt.publish(TOPIC_HUM,  String(hum, 1).c_str(),  true);

  Serial.printf("Publié : T=%.1f°C H=%.1f%%\n", temp, hum);
  delay(10000);
}

import paho.mqtt.client as mqtt

BROKER = "localhost"
TOPICS = [("must/toliara/#", 0)]

def on_message(client, userdata, msg):
    print(f"[{msg.topic}] {msg.payload.decode()}")

client = mqtt.Client()
client.on_message = on_message
client.connect(BROKER, 1883, 60)
client.subscribe(TOPICS)
print("En écoute sur must/toliara/# ...")
client.loop_forever()

#include <LoRa.h>

const long FREQUENCE = 868E6;  // 868 MHz (Europe/Madagascar)
const int SF = 12;             // Facteur d'étalement max portée
const int CS_PIN = 5;
const int RST_PIN = 14;
const int DIO0_PIN = 2;

void setup() {
  Serial.begin(115200);
  LoRa.setPins(CS_PIN, RST_PIN, DIO0_PIN);

  if (!LoRa.begin(FREQUENCE)) {
    Serial.println("Erreur LoRa !");
    while (1);
  }

  LoRa.setSpreadingFactor(SF);
  Serial.println("Émetteur LoRa prêt (868 MHz)");
}

int compteur = 0;

void loop() {
  float temperature = 28.5 + random(-10, 10) / 10.0;
  float humidite    = 65.0 + random(-5, 5) / 10.0;

  LoRa.beginPacket();
  LoRa.print("MUST_IOT,");
  LoRa.print(compteur);  LoRa.print(",");
  LoRa.print(temperature, 1); LoRa.print(",");
  LoRa.print(humidite, 1);
  LoRa.endPacket();

  Serial.printf("Paquet %d envoyé : T=%.1f H=%.1f\n",
    compteur, temperature, humidite);
  compteur++;
  delay(60000);
}

#include <LoRa.h>

const long FREQUENCE = 868E6;

void setup() {
  Serial.begin(115200);
  if (!LoRa.begin(FREQUENCE)) {
    Serial.println("Erreur LoRa !");
    while (1);
  }
  LoRa.setSpreadingFactor(12);
  Serial.println("Récepteur LoRa prêt");
}

void loop() {
  int taille = LoRa.parsePacket();
  if (taille == 0) return;

  String message = "";
  while (LoRa.available()) {
    message += (char)LoRa.read();
  }

  Serial.printf("Reçu [RSSI=%d dBm | SNR=%.1f dB] : %s\n",
    LoRa.packetRssi(),
    LoRa.packetSnr(),
    message.c_str());
}

# Configuration Mosquitto avec TLS
listener 8883
certfile /etc/mosquitto/certs/server.crt
keyfile  /etc/mosquitto/certs/server.key
tls_version tlsv1.2

# Authentification par certificat client optionnelle
require_certificate false
use_identity_as_username false

# Authentification par mot de passe
password_file /etc/mosquitto/passwd

#include <WiFi.h>
#include <PubSubClient.h>
#include <WiFiClientSecure.h>

const char* MQTT_BROKER = "broker.must-iot.mg";
const int   MQTT_PORT   = 8883;

// Certificat CA (Let's Encrypt, AutoSign, etc.)
static const char* CA_CERT = R"EOF(
-----BEGIN CERTIFICATE-----
MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
...
-----END CERTIFICATE-----
)EOF";

WiFiClientSecure espClient;
PubSubClient mqtt(espClient);

void setup() {
  Serial.begin(115200);
  WiFi.begin("SSID", "PASS");
  while (WiFi.status() != WL_CONNECTED) delay(500);

  espClient.setCACert(CA_CERT);
  // Optionnel : certificat client
  // espClient.setCertificate(CLIENT_CERT);
  // espClient.setPrivateKey(PRIVATE_KEY);

  mqtt.setServer(MQTT_BROKER, MQTT_PORT);
  mqtt.connect("esp32-must-01", "username", "password");
  Serial.println("MQTT TLS connecté sur port 8883 ✓");
}

version: "3.8"
services:
  mosquitto:
    image: eclipse-mosquitto
    ports:
      - "1883:1883"
      - "8883:8883"

  telegraf:
    image: telegraf
    depends_on: [mosquitto, influxdb]
    volumes:
      - ./telegraf.conf:/etc/telegraf/telegraf.conf

  influxdb:
    image: influxdb:2
    ports:
      - "8086:8086"
    environment:
      DOCKER_INFLUXDB_INIT_MODE: setup
      DOCKER_INFLUXDB_INIT_USERNAME: admin
      DOCKER_INFLUXDB_INIT_PASSWORD: password
      DOCKER_INFLUXDB_INIT_ORG: MUST
      DOCKER_INFLUXDB_INIT_BUCKET: iot

  grafana:
    image: grafana/grafana
    ports:
      - "3000:3000"
    depends_on: [influxdb]

[[inputs.mqtt_consumer]]
  servers     = ["tcp://mosquitto:1883"]
  topics      = ["must/toliara/#"]
  data_format = "value"
  name_override = "capteurs"

[[outputs.influxdb_v2]]
  urls        = ["http://influxdb:8086"]
  token       = "mon_token_influxdb"
  organization = "MUST"
  bucket      = "iot"