Sonde Météorologique

// Projet : SAE 204 - Sonde Météo (Mode UV & Lumière)
#include <STM32duinoBLE.h>

#define PIN_A A0   // Capteur UV  (GUVA-S12D)
#define PIN_B A1   // Capteur Lumière (Grove v1.2)

// ── Service BLE et 2 caractéristiques GATT ──────────────────────────
BLEService meteoService("19B10000-E8F2-537E-4F6C-D104768A1214");

BLEFloatCharacteristic uvCharacteristic   ("19B10001-E8F2-537E-4F6C-D104768A1214", BLERead | BLENotify);
BLEFloatCharacteristic lightCharacteristic("19B10002-E8F2-537E-4F6C-D104768A1214", BLERead | BLENotify);

// ── Table officielle Seeed GUVA-S12D : tension (mV) → indice UV ─────
int tensionVersUVIndex(float mV) {
  if (mV < 50)   return 0;  else if (mV < 227)  return 1;
  else if (mV < 318)  return 2;  else if (mV < 408)  return 3;
  else if (mV < 503)  return 4;  else if (mV < 606)  return 5;
  else if (mV < 696)  return 6;  else if (mV < 795)  return 7;
  else if (mV < 881)  return 8;  else if (mV < 976)  return 9;
  else if (mV < 1079) return 10; else if (mV < 1170) return 11;
  else return 12;
}

// ── Lecture lissée (moyenne sur N itérations) ────────────────────────
float lireMoyenne(int pin, int iterations) {
  long somme = 0;
  for (int i = 0; i < iterations; i++) {
    somme += analogRead(pin);
    delay(5);
  }
  return (float)somme / iterations;
}

void setup() {
  Serial.begin(115200);
  unsigned long debut = millis();
  while (!Serial && millis() - debut < 3000);
  Serial.println("\n=== SAE 204 Sonde V3 — Mode UV & Lumière ===");

  analogReadResolution(12); // ADC 12 bits → 0 à 4095
  pinMode(PIN_A, INPUT);
  pinMode(PIN_B, INPUT);

  // Initialisation BLE
  if (!BLE.begin()) {
    Serial.println("[ERREUR] BLE en panne !");
    while (1);
  }
  BLE.setLocalName("Sonde_V3");
  BLE.setAdvertisedService(meteoService);
  meteoService.addCharacteristic(uvCharacteristic);
  meteoService.addCharacteristic(lightCharacteristic);
  BLE.addService(meteoService);

  uvCharacteristic.writeValue(0.0);
  lightCharacteristic.writeValue(0.0);
  BLE.advertise();
  Serial.println("[OK] BLE actif — En attente de connexion...");
}

void loop() {
  BLEDevice central = BLE.central();
  if (central) {
    Serial.print("Connecté : ");
    Serial.println(central.address());

    while (central.connected()) {
      float rawA = lireMoyenne(PIN_A, 10);
      float rawB = lireMoyenne(PIN_B, 10);

      float mV_A     = rawA * (3300.0 / 4095.0);
      float indiceUV = (float)tensionVersUVIndex(mV_A);
      float lumPct   = (rawB / 4095.0) * 100.0;

      // Envoi BLE
      uvCharacteristic.writeValue(indiceUV);
      lightCharacteristic.writeValue(lumPct);

      // Diagnostic série
      Serial.println("─────────────────────────────────────────");
      Serial.print("A0 brut: "); Serial.print(rawA, 0);
      Serial.print(" | A1 brut: "); Serial.println(rawB, 0);
      Serial.print("UV (A0): "); Serial.print(indiceUV, 0);
      Serial.print(" | Lum (A1): "); Serial.print(lumPct, 1); Serial.println("%");
      delay(1000);
    }
    Serial.println("Déconnecté.");
  }
}

// Auteur : Unsal
// Projet : SAE 204 - Affichage Météo sur M5Core2 (Wi-Fi + MQTT VPS)
#include <M5Core2.h>
#include <WiFi.h>
#include <PubSubClient.h>

// --- Configuration Réseau Wi-Fi ---
const char* ssid     = "VOTRE_SSID";      // Remplacer par votre réseau
const char* password = "VOTRE_PASSWORD";  // Remplacer par votre mot de passe

// --- Configuration MQTT (Mosquitto sur VPS) ---
const char* mqtt_server = "ADRESSE_VPS";  // IP du VPS Ionos
const int   mqtt_port   = 1883;
const char* mqtt_user   = "sae204";
const char* mqtt_pass   = "VOTRE_PASS";   // Mot de passe MQTT

// --- Topic MQTT ---
const char* topic_meteo = "sonde/meteo";

WiFiClient   espClient;
PubSubClient client(espClient);

// --- Interface Graphique ---
void dessinerInterface() {
  M5.Lcd.clear(BLACK);
  M5.Lcd.setTextSize(2);

  // Bandeau Titre
  M5.Lcd.fillRect(0, 0, 320, 30, BLUE);
  M5.Lcd.setTextColor(WHITE, BLUE);
  M5.Lcd.setCursor(10, 5);
  M5.Lcd.print("Sonde Meteo V3 - R&T");

  // Labels fixes
  M5.Lcd.setTextColor(YELLOW, BLACK);
  M5.Lcd.setCursor(20, 80);
  M5.Lcd.print("Indice UV  :");
  M5.Lcd.setTextColor(CYAN, BLACK);
  M5.Lcd.setCursor(20, 140);
  M5.Lcd.print("Luminosite :");
}

// --- Callback : déclenché à chaque message MQTT reçu ---
void callback(char* topic, byte* payload, unsigned int length) {
  // Reconstruction du message texte
  String message = "";
  for (int i = 0; i < length; i++) {
    message += (char)payload[i];
  }
  Serial.print("Message recu [");
  Serial.print(topic);
  Serial.print("] : ");
  Serial.println(message);

  // Traitement uniquement sur le bon topic
  if (String(topic) == topic_meteo) {
    int indexVirgule = message.indexOf(',');
    if (indexVirgule != -1) {
      // Découpage  "UV:4,LUM:36.3"
      String partieUV  = message.substring(0, indexVirgule);
      String partieLum = message.substring(indexVirgule + 1);
      partieUV.replace("UV:", "");
      partieLum.replace("LUM:", "");

      // Mise à jour de l'écran
      M5.Lcd.fillRect(180, 80,  100, 30, BLACK);
      M5.Lcd.setCursor(180, 80);
      M5.Lcd.setTextColor(YELLOW, BLACK);
      M5.Lcd.print(partieUV);

      M5.Lcd.fillRect(180, 140, 100, 30, BLACK);
      M5.Lcd.setCursor(180, 140);
      M5.Lcd.setTextColor(CYAN, BLACK);
      M5.Lcd.print(partieLum);
      M5.Lcd.print(" %");
    } else {
      Serial.println("Format non reconnu (virgule manquante).");
    }
  }
}

// --- Reconnexion MQTT automatique ---
void reconnect() {
  while (!client.connected()) {
    Serial.print("Connexion au broker Mosquitto...");
    M5.Lcd.fillRect(0, 210, 320, 30, BLACK);
    M5.Lcd.setTextColor(RED, BLACK);
    M5.Lcd.setCursor(10, 215);
    M5.Lcd.print("MQTT Deconnecte...");

    if (client.connect("M5Core2_sae204", mqtt_user, mqtt_pass)) {
      Serial.println("Connecte !");
      M5.Lcd.fillRect(0, 210, 320, 30, BLACK);
      M5.Lcd.setTextColor(GREEN, BLACK);
      M5.Lcd.setCursor(10, 215);
      M5.Lcd.print("MQTT Connecte (VPS) !");
      client.subscribe(topic_meteo);
    } else {
      Serial.print("Echec, code : ");
      Serial.print(client.state());
      Serial.println(" → Nouvel essai dans 5s");
      delay(5000);
    }
  }
}

void setup() {
  M5.begin();
  dessinerInterface();

  M5.Lcd.setTextColor(WHITE, BLACK);
  M5.Lcd.setCursor(10, 215);
  M5.Lcd.print("Connexion Wi-Fi...");

  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  M5.Lcd.fillRect(0, 210, 320, 30, BLACK);
  M5.Lcd.setTextColor(GREEN, BLACK);
  M5.Lcd.setCursor(10, 215);
  M5.Lcd.print("Wi-Fi OK !");
  delay(1500);

  client.setServer(mqtt_server, mqtt_port);
  client.setCallback(callback);
}

void loop() {
  M5.update();
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
}

import asyncio
import struct
import paho.mqtt.client as mqtt
from bleak import BleakClient, BleakScanner

# ── Configuration BLE ────────────────────────────────────────────────
DEVICE_NAME     = "Sonde_V3"
UV_CHAR_UUID    = "19B10001-E8F2-537E-4F6C-D104768A1214"
LIGHT_CHAR_UUID = "19B10002-E8F2-537E-4F6C-D104768A1214"

# ── Configuration MQTT ───────────────────────────────────────────────
MQTT_BROKER = "localhost"   # IP du VPS Ionos en prod
MQTT_PORT   = 1883

try:
    mqtt_client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2)
except AttributeError:
    mqtt_client = mqtt.Client()

async def main():
    try:
        mqtt_client.connect(MQTT_BROKER, MQTT_PORT, 60)
        mqtt_client.loop_start()
        print(f"✅ Connecté au broker MQTT ({MQTT_BROKER})")
    except Exception as e:
        print(f"❌ Erreur MQTT : {e}")
        return

    print(f"🔍 Recherche de la sonde BLE '{DEVICE_NAME}'...")
    devices = await BleakScanner.discover(timeout=10.0)

    target_device = None
    for d in devices:
        if d.name == DEVICE_NAME:
            target_device = d
            break

    if not target_device:
        print("❌ Sonde introuvable.")
        mqtt_client.loop_stop()
        return

    print(f"✅ Sonde trouvée ! Connexion BLE en cours...")

    async with BleakClient(target_device, timeout=20.0) as client:
        print("🚀 Connecté ! Transfert des données vers Mosquitto...")

        while True:
            try:
                # Lecture des 2 caractéristiques GATT
                uv_bytes    = await client.read_gatt_char(UV_CHAR_UUID)
                light_bytes = await client.read_gatt_char(LIGHT_CHAR_UUID)

                # Décodage float little-endian
                uv_val    = struct.unpack('<f', uv_bytes)[0]
                light_val = struct.unpack('<f', light_bytes)[0]

                # Formatage payload → "UV:4,LUM:36.3"
                payload = f"UV:{uv_val:.0f},LUM:{light_val:.1f}"
                mqtt_client.publish("sonde/meteo", payload)
                print(f"[MQTT ✅] {payload}")

            except Exception as e:
                print(f"[⚠] Erreur lecture BLE : {e}")
                break

            await asyncio.sleep(1)

asyncio.run(main())

#!/usr/bin/env python3
"""
SAE 204 — Monitoring VPS Mosquitto
Affiche en temps réel les données reçues du RPi.
Jonathan
"""
import paho.mqtt.client as mqtt
from datetime import datetime

MQTT_HOST  = "localhost"
MQTT_PORT  = 1883
MQTT_TOPIC = "sonde/meteo"
# Identifiants définis via variables d'environnement sur le VPS

compteur = 0

def on_connect(client, userdata, connect_flags, reason_code, properties=None):
    if reason_code == 0:
        print("╔══════════════════════════════════════════════════╗")
        print("║      SAE204 — Monitoring VPS Mosquitto           ║")
        print("╚══════════════════════════════════════════════════╝")
        print(f"[✅] Connecté au broker ({MQTT_HOST}:{MQTT_PORT})")
        client.subscribe(MQTT_TOPIC)
        print(f"[📡] En écoute sur : {MQTT_TOPIC}")
        print("[⏳] En attente des données du RPi...\n")
    else:
        print(f"[❌] Erreur connexion : {reason_code}")

def on_message(client, userdata, msg):
    global compteur
    compteur += 1
    payload = msg.payload.decode("utf-8")
    ts = datetime.now().strftime("%H:%M:%S")

    try:
        parties = dict(p.split(":") for p in payload.split(","))
        uv  = parties.get("UV",  "—")
        lum = parties.get("LUM", "—")

        print(f"┌─ [{ts}] Message #{compteur} reçu du RPi ──────────────")
        print(f"│  📦 Payload brut  : {payload}")
        print(f"│")
        print(f"│  ☀️  UV Index      : {uv}")
        print(f"│  💡 Luminosité    : {lum}%")
        print(f"│")
        print(f"│  → Dispatché aux VMs (MariaDB, InfluxDB) ✅")
        print(f"│  → Dispatché au M5Stack (WiFi MQTT)      ✅")
        print(f"└───────────────────────────────────────────────────\n")

    except Exception as e:
        print(f"[⚠] Données mal formées : {payload} ({e})")

try:
    client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2)
except AttributeError:
    client = mqtt.Client()

client.on_connect = on_connect
client.on_message = on_message
client.connect(MQTT_HOST, MQTT_PORT, 60)
client.loop_forever()