SchreinWiFiParser

Table des Matières

Introduction
Installation et Configuration
Architecture et Concepts
API Référence
Guide d’Utilisation
Cas d’Usage par Domaine
Best Practices
Dépannage

1. Introduction

Présentation

La bibliothèque SchreinWiFiParser est une solution complète de communication WiFi pour systèmes embarqués, conçue pour les plateformes Arduino (ESP8266, ESP32, RP2040). Elle combine gestion d’énergie avancée, protocole de communication robuste et architecture modulaire.

Installation de la Bibliothèque

Téléchargez les fichiers .h et .cpp
Créez un dossier SchreinWiFiParser dans votre dossier libraries/Arduino
Copiez les fichiers dans ce dossier
Redémarrez l’IDE Arduino

SchreinWiFiParser v1.0.0 Télécharger

Caractéristiques Principales

Double mode Client/Serveur UDP
Gestion d’énergie adaptive avec deep sleep
Protocole sécurisé avec checksum
Système de callbacks extensible
Parsing robuste de trames structurées
Surveillance automatique de la connexion
Support multi-plateforme

Formats de Trame Supportés

//Envoi-From Desktop Application to ESP

// Format sécurisé
<[control|key|value]&checksum>

// Exemple concret
<[temperature|sensor1|23.5]&4F>

// Format no sécurisé
<[control|key|value]>

// Exemple concret
<[temperature|sensor1|23.5]>

//Envoi-From ESP to desktop application

// Format sécurisé
controlName=property:value;&checksum

// Exemple concret
SchreinLabel1=Text:23.5;*4F

// Format no sécurisé
controlName=property:value;

// Exemple concret
SchreinLabel1=Text:23.5;

2. Installation et Configuration

Installation

Téléchargement : Copier les fichiers .h et .cpp dans votre projet
Inclusion : Ajouter dans votre sketch principal

#include "SchreinWiFiParser.h"

Configuration de Base

// Définition des paramètres (optionnel)
#define POWER_SAVING_MODE 1        // Mode économie activé
#define DEEP_SLEEP_DURATION 300    // Deep sleep de 5 minutes
#define MAX_FRAME_SIZE 256         // Taille maximale des trames

3. Architecture et Concepts

Diagramme d’Architecture

États du Parser

enum class ParserState {
    WAITING_START,    // Attente du caractère '<'
    READING_FRAME     // Lecture de la trame jusqu'au '>'
};

Gestion d’Énergie

La bibliothèque implémente trois niveaux de gestion d’énergie :

Mode Normal : Performance maximale
Mode Économie : Optimisations WiFi
Deep Sleep : Économie extrême

4. API Référence

Constructeur et Initialisation

SchreinWiFiParser()

SchreinWiFiParser wifiParser;

begin()

bool begin(const String& ssid, const String& password);

Paramètres:

ssid : Nom du réseau WiFi
password : Mot de passe du réseau

Retour:

true : Connexion réussie
false : Échec de connexion

Exemple:

if (wifiParser.begin("MonWiFi", "MonMotDePasse")) {
    Serial.println("✅ Connecté au WiFi");
} else {
    Serial.println("❌ Échec connexion WiFi");
}

initAsClient()

void initAsClient(IPAddress serverIP, uint16_t serverPort, uint16_t localPort = 0);

initAsServer()

void initAsServer(uint16_t listenPort);

Méthodes Principales

loop()

void loop();

Description : Méthode à appeler régulièrement dans la boucle principale.

Exemple:

void loop() {
    wifiParser.loop();
    
    if (wifiParser.isFrameAvailable()) {
        // Traiter les données reçues
    }
}

sendFrame()

bool sendFrame(const String &frame);

getValue()

String getValue(const String &controlName, const String &key);

Gestion d’Énergie

setPowerSaving()

void setPowerSaving(bool enabled);

enterDeepSleep()

void enterDeepSleep();

Callbacks Disponibles

// Gestion d'erreurs
wifiParser.onError([](const String &error) {
    Serial.println("Erreur: " + error);
});

// Réception de données parsées
wifiParser.onFrameParsed([](const String &control, const String &key, const String &value) {
    Serial.printf("Reçu - Control:%s, Key:%s, Value:%s\n", 
                  control.c_str(), key.c_str(), value.c_str());
});

// Surveillance qualité connexion
wifiParser.onConnectionQualityUpdate([](int quality) {
    if (quality < 50) {
        Serial.println("⚠️  Qualité réseau faible");
    }
});

5. Guide d’Utilisation

5.1 Configuration de Base

Mode Client

#include "SchreinWiFiParser.h"

SchreinWiFiParser wifi;

void setup() {
    Serial.begin(115200);
    
    // Connexion WiFi
    if (wifi.begin("MonReseau", "MonPassword")) {
        // Configuration client
        wifi.initAsClient(IPAddress(192, 168, 1, 100), 7777, 8080);
        
        // Activation callbacks
        wifi.onFrameParsed(handleReceivedData);
        wifi.onError(handleError);
        
        Serial.println("✅ Système client initialisé");
    }
}

void handleReceivedData(const String &control, const String &key, const String &value) {
    Serial.printf("📨 Reçu: %s|%s|%s\n", control.c_str(), key.c_str(), value.c_str());
}

void handleError(const String &error) {
    Serial.println("❌ Erreur: " + error);
}

void loop() {
    wifi.loop();
}

Mode Serveur

void setup() {
    Serial.begin(115200);
    
    if (wifi.begin("MonReseau", "MonPassword")) {
        // Configuration serveur
        wifi.initAsServer(8888);
        
        wifi.onNewClient([](IPAddress ip, uint16_t port) {
            Serial.printf("👤 Nouveau client: %s:%d\n", 
                         wifi.ipToString(ip).c_str(), port);
        });
        
        Serial.println("✅ Serveur initialisé sur port 8888");
    }
}

5.2. Envoi de Données

Envoi Simple

String frame = wifi.command("capteur", "temperature", "23.5");
if (wifi.sendFrame(frame)) {
    Serial.println("✅ Données envoyées");
} else {
    Serial.println("❌ Échec envoi");
}

Envoi Multiple

String frames[] = {
    wifi.command("system", "uptime", String(millis())),
    wifi.command("sensor", "humidity", "45.2"),
    wifi.command("status", "battery", "85")
};

if (wifi.sendFrames(frames, 3)) {
    Serial.println("✅ Trames multiples envoyées");
}

5.3. Réception et Traitement

Méthode Polling

void loop() {
    wifi.loop();
    
    if (wifi.isFrameAvailable()) {
        String valeur = wifi.getValue("contrôle", "commande");
        if (valeur != "") {
            Serial.println("Commande reçue: " + valeur);
            wifi.markFrameAsProcessed();
        }
    }
}

Méthode Callback (Recommandée)

void setup() {
    wifi.onFrameParsed([](const String &control, const String &key, const String &value) {
        if (control == "motor" && key == "speed") {
            int vitesse = value.toInt();
            controlerMoteur(vitesse);
            Serial.println("🎛️  Vitesse moteur ajustée: " + String(vitesse));
        }
    });
}

5.4. Gestion d’Énergie Avancée

Configuration Power Saving

void setup() {
    wifi.begin("MonWiFi", "Password");
    
    // Activation mode économie
    wifi.setPowerSaving(true);
    
    // Configuration deep sleep
    wifi.setDeepSleepDuration(600); // 10 minutes
    
    // Surveillance automatique
    wifi.onConnectionQualityUpdate([](int quality) {
        // Adaptation dynamique selon la qualité
        if (quality > 70) {
            wifi.setPowerSaving(true);
        } else if (quality < 40) {
            wifi.setPowerSaving(false);
        }
    });
}

Mode Deep Sleep Automatique

void loop() {
    wifi.loop();
    
    // Après traitement, entrée en deep sleep
    if (traitementTermine) {
        Serial.println("💤 Entrée en deep sleep");
        wifi.enterDeepSleep();
    }
}

5.5. Diagnostic et Debug

Sortie Debug Complète

void diagnostic() {
    // Statut WiFi
    Serial.println(wifi.debugOutput("wifiStatus"));
    
    // Clients connectés
    Serial.println(wifi.debugOutput("clients"));
    
    // Statistiques connexion
    Serial.println(wifi.debugOutput("connectionStats"));
}

// Appel périodique
void loop() {
    static unsigned long lastDiag = 0;
    if (millis() - lastDiag > 30000) {
        diagnostic();
        lastDiag = millis();
    }
    
    wifi.loop();
}

Cas d’Usage par Domaine

1. Industrie 4.0 – Supervision d’Usine Connectée

Problématique : Surveillance en temps réel des machines avec maintenance prédictive

class UsineConnectee {
private:
    SchreinWiFiParser wifi;
    
public:
    void initialiser() {
        wifi.begin("Usine_4.0", "SecurePass123");
        wifi.initAsClient(IPAddress(192,168,1,100),5555, 502);
        
        wifi.onFrameParsed([this](const String& c, const String& k, const String& v) {
            this->traiterDonneesUsine(c, k, v);
        });
        
        wifi.onError([](const String& err) {
            Serial.println("🚨 Alerte Usine: " + err);
        });
    }
    
    void traiterDonneesUsine(const String& machine, const String& parametre, const String& valeur) {
        if (parametre == "vibration" && valeur.toFloat() > 8.5) {
            envoyerAlerteMaintenance(machine, "Vibrations excessives: " + valeur);
        }
        else if (parametre == "temperature" && valeur.toFloat() > 85.0) {
            envoyerAlerteMaintenance(machine, "Surchauffe: " + valeur + "°C");
        }
    }
    
    void envoyerAlerteMaintenance(const String& machine, const String& message) {
        String alerte = wifi.command("maintenance", machine, message);
        wifi.sendFrame(alerte);
        Serial.println("🔧 Alerte maintenance: " + machine + " - " + message);
    }
};

2. Automatisation – Robotique Industrielle

Problématique : Contrôle précis de bras robotisés avec feedback temps réel

class ControleurRobot {
private:
    SchreinWiFiParser wifi;
    struct Position { float x, y, z; } positionActuelle;
    
public:
    void initialiser() {
        wifi.begin("Robot_Cell", "AutoPass456");
        wifi.initAsServer(9090);
        
        wifi.onFrameParsed([this](const String& c, const String& k, const String& v) {
            if (c == "commande") executerCommande(k, v);
        });
    }
    
    void executerCommande(const String& action, const String& parametres) {
        if (action == "deplacer") {
            Position cible = parserPosition(parametres);
            deplacerVers(cible);
            envoyerConfirmation();
        }
        else if (action == "urgence") {
            arretUrgence();
            envoyerStatut("ARRET_URGENCE");
        }
    }
    
    void envoyerTelemetrie() {
        String telemetrie = wifi.command("robot", "position", 
                            String(positionActuelle.x) + "," + 
                            String(positionActuelle.y) + "," + 
                            String(positionActuelle.z));
        telemetrie += wifi.command("robot", "charge", String(calculerCharge()));
        
        wifi.sendFrame(telemetrie);
    }
};

3. Smart Agriculture – Serre Intelligente

Problématique : Optimisation automatique des conditions de croissance

class SerreIntelligente {
private:
    SchreinWiFiParser wifi;
    float temperature, humidite, luminosite;
    
public:
    void initialiser() {
        wifi.begin("Serre_Connectee", "AgriTech2024");
        wifi.initAsServer(8888);
        wifi.setPowerSaving(true); // Économie d'énergie
        
        wifi.onFrameParsed([this](const String& c, const String& k, const String& v) {
            if (c == "controle") controlerSerre(k, v);
        });
    }
    
    void controlerSerre(const String& equipement, const String& action) {
        if (equipement == "irrigation") {
            action == "ON" ? activerIrrigation() : desactiverIrrigation();
        }
        else if (equipement == "eclairage") {
            reglerEclairage(action.toInt());
        }
    }
    
    void surveillerConditions() {
        // Lecture capteurs
        temperature = lireTemperature();
        humidite = lireHumidite();
        luminosite = lireLuminosite();
        
        // Envoi données
        String donnees = wifi.command("serre", "temperature", String(temperature, 1));
        donnees += wifi.command("serre", "humidite", String(humidite, 1));
        donnees += wifi.command("serre", "luminosite", String(luminosite));
        
        if (wifi.sendFrame(donnees)) {
            Serial.println("📊 Données serre transmises");
        }
        
        // Actions automatiques
        if (temperature > 30.0) activerVentilation();
        if (humidite < 40.0) activerBrunnisation();
    }
};

4. Énergies Renouvelables – Monitoring de Parc Solaire

Problématique : Surveillance de performance et détection de défauts

class ParcSolaire {
private:
    SchreinWiFiParser wifi;
    struct Panneau {
        String id;
        float production, tension, courant;
        bool defaut;
    };
    
public:
    void initialiser() {
        wifi.begin("Parc_Solaire", "SolarMonitor");
        wifi.initAsClient(IPAddress(192,168,10,50),1000, 7070);
        
        // Configuration pour environnement extérieur
        wifi.setDeepSleepDuration(3600); // Deep sleep 1h si problèmes
    }
    
    void envoyerRapportProduction() {
        for (auto& panneau : panneaux) {
            String rapport = wifi.command("panneau", panneau.id, 
                                "P:" + String(panneau.production, 1) +
                                "V:" + String(panneau.tension, 1) +
                                "A:" + String(panneau.courant, 2));
            
            if (panneau.defaut) {
                rapport += wifi.command("alerte", panneau.id, "DEFAUT_DETECTE");
            }
            
            wifi.sendFrame(rapport);
        }
    }
    
    void analyserPerformance() {
        for (auto& panneau : panneaux) {
            // Détection sous-performance
            if (panneau.production < productionAttendue * 0.7) {
                envoyerAlerteMaintenance(panneau.id, "Production anormale");
            }
            
            // Détection court-circuit
            if (panneau.tension < 5.0 && panneau.courant > 8.0) {
                envoyerAlerteUrgence(panneau.id, "COURT_CIRCUIT");
            }
        }
    }
};

5. Smart Building – Gestion Énergétique Intelligente

Problématique : Optimisation de la consommation énergétique dans les bâtiments

class GestionnaireBatiment {
private:
    SchreinWiFiParser wifi;
    
public:
    void initialiser() {
        wifi.begin("Smart_Building", "BuildingMgt");
        wifi.initAsServer(9999);
        
        wifi.onFrameParsed([this](const String& c, const String& k, const String& v) {
            if (c == "energie") optimiserEnergie(k, v);
        });
    }
    
    void optimiserEnergie(const String& zone, const String& consigne) {
        if (zone == "eclairage") {
            ajusterEclairage(consigne.toInt());
        }
        else if (zone == "climatisation") {
            reglerTemperature(consigne.toFloat());
        }
        else if (zone == "ventilation") {
            controlerVentilation(consigne == "ON");
        }
    }
    
    void surveillerConsommation() {
        float consommationTotal = 0;
        
        for (auto& zone : zones) {
            float conso = mesurerConsommation(zone);
            consommationTotal += conso;
            
            String donnees = wifi.command("consommation", zone.nom, String(conso, 2));
            wifi.sendFrame(donnees);
            
            // Alerte surconsommation
            if (conso > zone.seuilAlerte) {
                envoyerAlerte("SURCONSOMMATION", zone.nom);
            }
        }
        
        // Rapport global
        String rapport = wifi.command("batiment", "consommation_total", String(consommationTotal, 2));
        wifi.sendFrame(rapport);
    }
};

6. Domotique – Maison Connectée

Problématique : Centralisation du contrôle des équipements domestiques

class MaisonConnectee {
private:
    SchreinWiFiParser wifi;
    
public:
    void initialiser() {
        wifi.begin("Maison_Connectee", "HomeSecure");
        wifi.initAsServer(7777);
        
        wifi.onFrameParsed([this](const String& c, const String& k, const String& v) {
            this->executerScenario(c, k, v);
        });
        
        wifi.onNewClient([](IPAddress ip, uint16_t port) {
            Serial.println("🏠 Nouvel appareil connecté: " + 
                         wifi.ipToString(ip) + ":" + String(port));
        });
    }
    
    void executerScenario(const String& piece, const String& action, const String& parametre) {
        if (piece == "salon") {
            if (action == "lumiere") controlerLumiereSalon(parametre);
            else if (action == "temperature") reglerThermostat(parametre.toFloat());
        }
        else if (piece == "chambre") {
            if (action == "volet") controlerVolet(parametre);
        }
        else if (piece == "securite") {
            if (action == "alarme") parametrerAlarme(parametre);
        }
    }
    
    void envoyerNotification(const String& evenement, const String& details) {
        String notif = wifi.command("notification", evenement, details);
        wifi.sendFrame(notif);
        Serial.println("📢 Notification: " + evenement + " - " + details);
    }
};

7. Automobile – Système de Diagnostic Embarqué

Problématique : Surveillance en temps réel des paramètres véhicule

class DiagnosticAutomobile {
private:
    SchreinWiFiParser wifi;
    
public:
    void initialiser() {
        wifi.begin("Vehicule_Network", "AutoDiag2024");
        wifi.initAsClient(IPAddress(192,168,0,10),2563, 5050);
        
        // Priorité à la fiabilité
        wifi.setPowerSaving(false);
        wifi.enableChecksum(true);
    }
    
    void surveillerVehicule() {
        // Lecture capteurs OBD2
        float tempMoteur = lireTemperatureMoteur();
        int regime = lireRegimeMoteur();
        float pressionHuile = lirePressionHuile();
        
        String telemetrie = wifi.command("vehicule", "temp_moteur", String(tempMoteur, 1));
        telemetrie += wifi.command("vehicule", "regime", String(regime));
        telemetrie += wifi.command("vehicule", "pression_huile", String(pressionHuile, 1));
        
        // Détection anomalies
        if (tempMoteur > 105.0) {
            telemetrie += wifi.command("alerte", "surchauffe", "CRITIQUE");
        }
        if (pressionHuile < 1.5) {
            telemetrie += wifi.command("alerte", "pression_huile", "BASSE");
        }
        
        wifi.sendFrame(telemetrie);
    }
    
    void recevoirMaintenance(const String& composant, const String& action) {
        if (composant == "freins" && action == "USURE") {
            programmerRevisionFreins();
        }
        else if (composant == "batterie" && action == "FAIBLE") {
            alerterRemplacementBatterie();
        }
    }
};

8. Véhicules Connectés – Logistique Intelligente

Problématique : Traçabilité et optimisation des flottes de transport

class SystemeLogistique {
private:
    SchreinWiFiParser wifi;
    
public:
    void initialiser() {
        wifi.begin("Flotte_Connectee", "Logistics2024");
        wifi.initAsClient(IPAddress(10,0,1,100), 8000, 6060);
    }
    
    void envoyerPositionGPS(float lat, float lon, float vitesse) {
        String position = String(lat, 6) + "," + String(lon, 6);
        String donnees = wifi.command("gps", "position", position);
        donnees += wifi.command("gps", "vitesse", String(vitesse, 1));
        donnees += wifi.command("vehicule", "carburant", String(lireNiveauCarburant(), 1));
        
        wifi.sendFrame(donnees);
    }
    
    void recevoirInstructions(const String& instruction, const String& parametres) {
        if (instruction == "itineraire") {
            mettreAJourItineraire(parametres);
        }
        else if (instruction == "livraison") {
            preparerLivraison(parametres);
        }
        else if (instruction == "maintenance") {
            programmerMaintenance(parametres);
        }
    }
    
    void alerterIncident(const String& type, const String& localisation) {
        String alerte = wifi.command("incident", type, localisation);
        alerte += wifi.command("vehicule", "statut", "INCIDENT");
        wifi.sendFrame(alerte);
    }
};

9. Électronique – Banc de Test Automatisé

Problématique : Automatisation des tests de composants électroniques

class BancTestAutomatise {
private:
    SchreinWiFiParser wifi;
    
public:
    void initialiser() {
        wifi.begin("Lab_Test", "ElectronicsLab");
        wifi.initAsServer(5555);
        
        wifi.onFrameParsed([this](const String& c, const String& k, const String& v) {
            if (c == "test") executerTest(k, v);
        });
    }
    
    void executerTest(const String& typeTest, const String& parametres) {
        if (typeTest == "continuite") {
            bool resultat = testContinuite(parametres);
            envoyerResultat("continuite", resultat ? "PASS" : "FAIL");
        }
        else if (typeTest == "isolation") {
            float resistance = testIsolation(parametres.toFloat());
            envoyerResultat("isolation", String(resistance, 2));
        }
        else if (typeTest == "fonctionnel") {
            bool resultat = testFonctionnel(parametres);
            envoyerResultat("fonctionnel", resultat ? "PASS" : "FAIL");
        }
    }
    
    void envoyerResultat(const String& test, const String& resultat) {
        String rapport = wifi.command("resultat", test, resultat);
        rapport += wifi.command("test", "timestamp", String(millis()));
        wifi.sendFrame(rapport);
    }
};

10. Test des Systèmes Embarqués – Validation Protocole

Problématique : Test et validation des communications embarquées

class TesteurProtocol {
private:
    SchreinWiFiParser wifi;
    int tramesEnvoyees = 0;
    int tramesRecues = 0;
    
public:
    void initialiser() {
        wifi.begin("Test_Embedded", "Validation");
        wifi.initAsServer(4444);
        
        wifi.onDataReceived([](const String& data, IPAddress ip, uint16_t port) {
            Serial.println("📨 Trame reçue: " + data);
        });
    }
    
    void testPerformance() {
        unsigned long debut = micros();
        
        for (int i = 0; i < 1000; i++) {
            String trameTest = wifi.command("test", "performance", String(i));
            if (wifi.sendFrame(trameTest)) {
                tramesEnvoyees++;
            }
            delay(1);
        }
        
        unsigned long duree = micros() - debut;
        float debit = (tramesEnvoyees * 1000000.0) / duree;
        
        Serial.println("📊 Performance: " + String(debit, 1) + " trames/sec");
    }
    
    void testRobustesse() {
        // Test avec trames corrompues
        wifi.sendFrame("<[test|corrupted|data]&XX>"); // Checksum invalide
        wifi.sendFrame("trame_incomplete");
        wifi.sendFrame("<[test|trop_long|" + String('X', 300) + "]>");
    }
};

11. Internet des Objets – Station Météo Connectée

Problématique : Collecte et transmission de données environnementales

class StationMeteoIoT {
private:
    SchreinWiFiParser wifi;
    
public:
    void initialiser() {
        wifi.begin("IoT_Weather", "WeatherStation");
        wifi.initAsClient(IPAddress(192,168,1,200), 80, 8080);
        
        // Optimisation batterie
        wifi.setPowerSaving(true);
        wifi.setDeepSleepDuration(1800); // 30 minutes
    }
    
    void collecterDonnees() {
        float temperature = lireCapteurTemperature();
        float humidite = lireCapteurHumidite();
        float pression = lireCapteurPression();
        float pluie = lirePluviometre();
        
        String donnees = wifi.command("meteo", "temperature", String(temperature, 1));
        donnees += wifi.command("meteo", "humidite", String(humidite, 1));
        donnees += wifi.command("meteo", "pression", String(pression, 1));
        donnees += wifi.command("meteo", "pluie", String(pluie, 1));
        
        if (wifi.sendFrame(donnees)) {
            Serial.println("🌤️  Données météo transmises");
            
            // Deep sleep après transmission
            if (wifi.isPowerSavingEnabled()) {
                wifi.enterDeepSleep();
            }
        }
    }
    
    void detecterEvenementsExtremes() {
        if (temperature > 40.0 || temperature < -10.0) {
            envoyerAlerte("TEMPERATURE_EXTREME", String(temperature, 1));
        }
        if (pluie > 50.0) { // mm/h
            envoyerAlerte("FORTES_PLUIES", String(pluie, 1));
        }
    }
};

12. Réseaux Intelligents – Gestion de Micro-réseau

Problématique : Équilibrage charge/demande dans les micro-réseaux électriques

class GestionnaireMicroReseau {
private:
    SchreinWiFiParser wifi;
    
public:
    void initialiser() {
        wifi.begin("Smart_Grid", "GridManagement");
        wifi.initAsServer(3333);
        
        wifi.onFrameParsed([this](const String& c, const String& k, const String& v) {
            if (c == "production") ajusterProduction(k, v);
            else if (c == "consommation") optimiserDistribution(k, v);
        });
    }
    
    void surveillerReseau() {
        float productionTotale = 0;
        float consommationTotale = 0;
        
        // Collecte données production
        for (auto& source : sourcesProduction) {
            float production = source.mesurerProduction();
            productionTotale += production;
            
            String donnees = wifi.command("production", source.nom, String(production, 2));
            wifi.sendFrame(donnees);
        }
        
        // Collecte données consommation
        for (auto& charge : charges) {
            float consommation = charge.mesurerConsommation();
            consommationTotale += consommation;
            
            String donnees = wifi.command("consommation", charge.nom, String(consommation, 2));
            wifi.sendFrame(donnees);
        }
        
        // Équilibrage automatique
        if (productionTotale > consommationTotale * 1.1) {
            // Excédent - stockage ou vente
            optimiserStockage(productionTotale - consommationTotale);
        }
        else if (productionTotale < consommationTotale * 0.9) {
            // Déficit - déstockage ou achat
            compenserDeficit(consommationTotale - productionTotale);
        }
    }
    
    void envoyerAlerteReseau(const String& type, const String& details) {
        String alerte = wifi.command("alerte_reseau", type, details);
        wifi.sendFrame(alerte);
        Serial.println("⚡ Alerte réseau: " + type + " - " + details);
    }
};

💡 Best Practices

1. Gestion des Erreurs

void setup() {
    wifi.onError([](const String& error) {
        Serial.println("❌ Erreur: " + error);
        
        // Actions selon le type d'erreur
        if (error.indexOf("WiFi") != -1) {
            tentativesReconnexion++;
            if (tentativesReconnexion > 3) {
                wifi.enterDeepSleep();
            }
        }
    });
}

2. Optimisation Mémoire

// Utiliser des String réservées pour éviter la fragmentation
String frame;
frame.reserve(128); // Pré-allocation

// Nettoyer périodiquement
void loop() {
    wifi.loop();
    
    static unsigned long dernierNettoyage = 0;
    if (millis() - dernierNettoyage > 60000) {
        wifi.debugOutput("reset", true);
        dernierNettoyage = millis();
    }
}

3. Sécurité des Communications

void setup() {
    // Activation checksum
    wifi.enableChecksum(true);
    
    // Validation côté réception
    wifi.onFrameParsed([](const String& c, const String& k, const String& v) {
        if (!wifi.validateChecksum(derniereTrame)) {
            Serial.println("🚨 Trame corrompue détectée");
            return;
        }
        // Traitement sécurisé...
    });
}

🔧 Dépannage

Problèmes Courants et Solutions

❌ Échec Connexion WiFi

// Vérification étape par étape
void diagnostiquerWiFi() {
    Serial.println("🔍 Diagnostic WiFi:");
    Serial.println("- RSSI: " + String(wifi.getWiFiSignalStrength()) + " dBm");
    Serial.println("- Qualité: " + String(wifi.getConnectionQuality()) + "%");
    Serial.println("- Statut: " + wifi.getConnectionStatus());
    
    if (wifi.getConnectionQuality() < 30) {
        Serial.println("💡 Solution: Rapporcher le point d'accès");
    }
}

📡 Problèmes de Réception

// Test de communication
void testerCommunication() {
    String testFrame = wifi.command("test", "ping", String(millis()));
    
    if (wifi.sendFrame(testFrame)) {
        Serial.println("✅ Envoi fonctionnel");
    } else {
        Serial.println("❌ Problème d'envoi - Vérifier la configuration réseau");
    }
}

🔋 Consommation Élevée

void optimiserEnergie() {
    // Activation mode économie
    wifi.setPowerSaving(true);
    
    // Réduction fréquence envoi
    unsigned long dernierEnvoi = 0;
    void loop() {
        wifi.loop();
        
        if (millis() - dernierEnvoi > 30000) { // Toutes les 30s
            envoyerDonnees();
            dernierEnvoi = millis();
        }
    }
}

📞 Support et Resources

Documentation Additionnelle

Contacts

Email: support@schreiken.tech
WhatsApp : (+237) 671959237

A Propos

Articles Récents

Catégories

Archives

Commentaires récents

Tags