SchreinSerialPaser

🎯 Introduction

La librairie SchreinSerialParser est un analyseur de trames série robuste pour Arduino, conçu pour parser des messages au format <[controlName|propertyName|value]&checksum>. Elle offre une gestion d’erreurs avancée, des callbacks et une validation de checksum.

Installation de la Bibliothèque

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

SchreinSerialParser v1.0.0 Télécharger

📦 Installation

Structure des fichiers

SchreinSerialParser/
├── examples/
│   └── Basic_Usage
│       └── Basic_Usage.ino
├── src/
│   ├── SchreinSerialParser.h
│   └── SchreinSerialParser.cpp
│   
│ 
├── library.json
├── README.md
├── library.properties
└── keywords.txt

Inclusion dans le projet

#include "SchreinSerialParser.h"

🔧 Initialisation

Création de l’instance

// Avec Serial standard
SchreinSerialParser parser(Serial);

// Avec Serial1, Serial2, etc.
SchreinSerialParser parser(Serial1);

// Avec SoftwareSerial
SoftwareSerial mySerial(10, 11);
SchreinSerialParser parser(mySerial);

📖 Utilisation Basique

Exemple minimal

#include "SchreinSerialParser.h"

SchreinSerialParser parser(Serial);

void setup() {
    Serial.begin(9600);
    parser.enableChecksum(true); // Optionnel
}

void loop() {
    parser.loop(); // À appeler régulièrement
    
    if (parser.isFrameAvailable()) {
        String value = parser.getValue("motor", "speed");
        if (value != "") {
            Serial.println("Vitesse: " + value);
        }
        parser.resetFrame();
    }
}

📡 Format des Trames

Structure de la trame

<[controlName|propertyName|value]&checksum>

Exemples de trames valides

<[motor|speed|255]&04>
<[led|state|on]&1A>
<[sensor|temperature|23.5]&FF>

🛠️ API Complète

Méthodes Principales

🔄 Gestion du cycle de vie

void loop(); // À appeler dans loop() principal
bool isFrameAvailable() const;
void resetFrame();

📨 Réception de données

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

📤 Envoi de données

// Création de commande
String cmd = SchreinSerialParser::command("motor", "speed", "255");

// Envoi simple
parser.sendFrame(cmd);

// Envoi multiple
String frames[] = {
    parser.command("motor", "speed", "255"),
    parser.command("led", "state", "on")
};
parser.sendFrames(frames, 2);

⚙️ Configuration

// Timeout (défaut: 1000ms)
parser.setTimeout(2000);

// Activation checksum (défaut: false)
parser.enableChecksum(true);

// Taille du buffer (défaut: 256)
parser.setBufferSize(512);

🎛️ Callbacks

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

// Données brutes reçues
parser.onDataReceived([](String data) {
    Serial.println("📥 Donnée: " + data);
});

// Frame parsée
parser.onFrameParsed([](String controlName, String key, String value) {
    Serial.println(controlName + "." + key + " = " + value);
});

🐛 Débogage

debugOutput()

// Affichage dans le moniteur série
parser.debugOutput("receiveMessage");    // Message brut reçu
parser.debugOutput("parsedFrame");       // Frame parsée
parser.debugOutput("completeFrame");     // Frame complète
parser.debugOutput("error");             // Dernière erreur

// Récupération comme String
String debugInfo = parser.debugOutput("parsedFrame", true);

Codes d’erreur

ErrorCode::NO_ERROR           // Aucune erreur
ErrorCode::BUFFER_OVERFLOW    // Buffer trop petit
ErrorCode::INVALID_FRAME      // Format de trame invalide
ErrorCode::TIMEOUT            // Timeout dépassé
ErrorCode::CHECKSUM_ERROR     // Checksum invalide

📋 Exemples Complets

Exemple 1: Communication Bidirectionnelle

#include "SchreinSerialParser.h"

SchreinSerialParser parser(Serial);

void setup() {
    Serial.begin(9600);
    
    parser.onFrameParsed(handleParsedFrame);
    parser.onError(handleError);
}

void loop() {
    parser.loop();
    
    // Envoi périodique
    static unsigned long lastSend = 0;
    if (millis() - lastSend > 5000) {
        String cmd = parser.command("sensor", "request", "data");
        parser.sendFrame(cmd);
        lastSend = millis();
    }
}

void handleParsedFrame(String controlName, String key, String value) {
    Serial.println("🎯 Frame reçue:");
    Serial.println("  Control: " + controlName);
    Serial.println("  Key: " + key);
    Serial.println("  Value: " + value);
    
    if (controlName == "sensor" && key == "temperature") {
        float temp = value.toFloat();
        // Traitement de la température...
    }
}

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

Exemple 2: Contrôle Moteur

#include "SchreinSerialParser.h"

SchreinSerialParser parser(Serial);

void setup() {
    Serial.begin(115200);
    parser.enableChecksum(true);
}

void loop() {
    parser.loop();
    
    if (parser.isFrameAvailable()) {
        String speed = parser.getValue("motor", "speed");
        String direction = parser.getValue("motor", "direction");
        
        if (speed != "") {
            int motorSpeed = speed.toInt();
            controlMotor(motorSpeed);
        }
        
        if (direction != "") {
            setMotorDirection(direction);
        }
        
        parser.resetFrame();
    }
}

void controlMotor(int speed) {
    // Implémentation contrôle moteur
    analogWrite(9, speed);
}

⚠️ Bonnes Pratiques

✅ À faire

Toujours appeler parser.loop() dans la boucle principale
Vérifier isFrameAvailable() avant de lire les données
Appeler resetFrame() après traitement
Utiliser les callbacks pour une architecture événementielle
Activer le checksum pour les communications critiques

❌ À éviter

Ne pas bloquer dans loop() principal
Ne pas oublier de libérer avec resetFrame()
Éviter les délais longs qui causent des timeouts

🔧 Dépannage

Problèmes courants

Test de communication

void testCommunication() {
    // Test d'envoi/réception
    String testFrame = parser.command("test", "ping", "hello");
    parser.sendFrame(testFrame);
    
    // Vérification debug
    Serial.println(parser.debugOutput("receiveMessage", true));
}

📈 Performance

Buffer configurable selon les besoins
Timeout adaptable à l’application
Gestion mémoire optimisée
Callbacks non-bloquants

Cette documentation couvre l’ensemble des fonctionnalités de la librairie SchreinSerialParser. La structure modulaire et les callbacks permettent une intégration flexible dans divers projets Arduino.

A Propos

Articles Récents

Catégories

Archives

Commentaires récents

Tags