1. Le dilemme physique de la mesure de vitesse sur microcontrôleur

Dans les systèmes embarqués de contrôle de moteurs, évaluer la vitesse ne se résume pas à lire l'état d'un encodeur. Il s'agit de créer un pont entre un mouvement continu et des signaux discrets. Lorsqu'une rotation mécanique est convertie en impulsions électriques via des capteurs à effet Hall ou optiques, une quantification irréversible se produit, introduisant des marges d'erreur inhérentes au monde réel.

Sur l'ESP32, lors du contrôle en boucle fermée de moteurs à courant continu, le goulet d'étranglement provient rarement du PID, mais bien de l'acquisition de la vitesse. Un problème typique survient : au-dessus de 150 tr/min, les retours sont stables. En revanche, sous les 60 tr/min, les valeurs oscillent entre des entiers (ex: 10, 11, 10...), rendant impossible une résolution fine de 0.1 tr/min. Le système entre alors en oscillation. Ce n'est pas un bug logiciel, mais une inadéquation fondamentale entre la méthode de mesure et la physique.

La cause racine est la méthode classique M (mesure de fréquence sur fenêtre temporelle fixe). On compte les impulsions de l'encodeur pendant une durée fixe (ex: 50 ms), puis on calcule : vitesse_rpm = (comptage_impulsions * 60) / (lignes_par_tour * duree_fenetre). Cela repose sur deux hypothèses fausses : l'uniformité des impulsions et la synchronisation parfaite. En réalité, les variations de charge, l'aimantation inégale et le jitter détruisent ce modèle. À 30 tr/min avec un encodeur 11 PPR, une fenêtre de 50 ms capture 0 ou 1 impulsion. La vitesse calculée saute alors de 0 à 109 tr/min, rendant le contrôle chaotique. L'instabilité à basse vitesse est une défaillance de la résolution de mesure.

2. Méthode M contre Méthode T : Deux paradigmes de mesure

2.1 Méthode M (Fréquence sur temps fixe)

Le système utilise un timer matériel pour déclencher une interruption à intervalles réguliers. La vitesse est déduite du delta d'impulsions.

rotation_speed = (pulse_delta * 60.0) / (pulses_per_revolution * window_duration_sec);

Excellente à haute vitesse : si le nombre d'impulsions est grand, l'erreur de quantification (±1) est négligeable. Cependant, à basse vitesse, le numérateur devient minuscule, et l'erreur relative explose. De plus, choisir la taille de la fenêtre est un compromis : trop courte, l'erreur augmente ; trop longue, la latence brise la boucle de retour.

2.2 Méthode T (Temps sur angle fixe)

Ici, chaque front de l'encodeur déclenche une interruption. On mesure le temps écoulé entre deux impulsions grâce à un timer haute fréquence.

rotation_speed = 60.0 / (pulses_per_revolution * pulse_interval_sec);

Idéale pour les basses vitesses : l'intervalle temporel devient très long, minimisant l'erreur relative du timer. À 30 tr/min, une période d'impulsion de ~181 ms mesurée avec un timer de 100 kHz offre une précision excellente. Mais à 3000 tr/min, la période tombe à ~1.82 ms. Le temps de réponse de l'interruption de l'ESP32 devient le facteur d'erreur dominant, rendant la méthode T moins fiable que la méthode M en régime rapide.

2.3 Le triangle d'impossibilité

Ces deux méthodes illustrent le compromis entre la bande passante (réponse temporelle), la précision (résolution fréquentielle) et la résolution physique (PPR de l'encodeur). Les systèmes industriels utilisent des encodeurs à très haute résolution pour contourner cela. Avec des encodeurs à effet Hall bon marché (11 PPR), il faut une approche algorithmique hybride.

3. La méthode MT : Architecture adaptative hybride

La méthode M/T ne se contente pas d'exécuter M et T en parallèle. C'est une architecture spatio-temporelle couplée qui conserve le cadencement de M pour la prévisibilité, tout en empruntant la précision événementeille de T pour éliminer les erreurs à bas régime. Sa philosophie : corriger un comptage d'événements imprécis par une mesure temporelle de haute précision.

Le modèle s'appuie sur deux couches de déclenchement :

1. Couche externe (Timer Maître) : Un timer basse fréquence (ex: 20 ms) définit le cycle de contrôle de base.
2. Couche interne (Capture d'événements) : Un timer haute fréquence (ex: 1 MHz) enregistre le timestamp exact de chaque impulsion de l'encodeur.

Lors de l'interruption du timer maître, le système n'utilise pas seulement le nombre brut d'impulsions. Il calcule le temps exact entre la première et la dernière impulsion survenue dans la fenêtre, affinant ainsi la mesure.

#define PULSES_PER_REV 11
#define TIMER_CLOCK_HZ 1000000

volatile uint32_t last_pulse_ts = 0;
volatile uint32_t first_pulse_ts = 0;
volatile uint32_t pulse_count_window = 0;

void IRAM_ATTR on_encoder_pulse() {
    uint32_t current_ts = read_high_freq_timer();
    if (pulse_count_window == 0) {
        first_pulse_ts = current_ts;
    }
    last_pulse_ts = current_ts;
    pulse_count_window++;
}

float compute_mt_speed(uint32_t window_duration_us) {
    if (pulse_count_window < 2) {
        // Bascule en méthode T pure si trop peu d'impulsions
        if (last_pulse_ts == 0) return 0.0f;
        uint32_t dt = read_high_freq_timer() - last_pulse_ts;
        if (dt == 0) return 0.0f;
        return (60.0f * TIMER_CLOCK_HZ) / (PULSES_PER_REV * (float)dt);
    }
    
    // Méthode M/T : utilisation du temps exact entre la première et la dernière impulsion
    uint32_t exact_time = last_pulse_ts - first_pulse_ts;
    if (exact_time == 0) return 0.0f;
    
    float speed_rpm = ((pulse_count_window - 1) * 60.0f * TIMER_CLOCK_HZ) 
                      / (PULSES_PER_REV * (float)exact_time);
    
    // Réinitialisation pour la prochaine fenêtre
    pulse_count_window = 0;
    
    return speed_rpm;
}

Cette approche garantit que, indépendamment de la vitesse de rotation, l'erreur de quantification de ±1 impulsion de la méthode M est compensée par la précision inférieure à la microseconde du timer de capture, offrant un retour fluide et continu pour l'algorithme PID.