Régulation PID
et suivi de ligne.

• Expliquer avec les mains ce que font P, I et D, et le montrer en simulation.
• Régler un PID méthodiquement sur un vrai robot.
• Asservir la vitesse des roues, puis le suivi de ligne, puis les deux ensemble.
• Reconnaître les pièges : saturation, bruit sur D, retard.

Matériel : le robot des séances 27–28 avec encodeurs et capteurs de ligne. Les simulations tournent dans la page.

Séance 15 (chariot P et PD), séance 23 (luminosité), séance 27 (aller droit avec les encodeurs), séance 28 (suiveur de ligne proportionnel). Cette séance donne le cadre général et la méthode de réglage.

Un moteur réel ressemble à ce premier ordre : sa vitesse rejoint la valeur d’équilibre avec une constante de temps τ (séance 21, la charge d’un condensateur suit la même loi). Zone morte, bruit de mesure (encodeur grossier), retard de mesure (60 ms : le temps de compter les ticks et de filtrer) et perturbation (pente à t = 3 s) sont là pour rendre le problème réaliste — c’est le retard qui rend l’oscillation possible (séance 26). Tout ce qui suit s’exécute sur ce banc ; les cellules partagent leurs définitions, exécutez-les dans l’ordre.

Avec P seul, la commande est nulle quand l’erreur est nulle : or il faut une PWM non nulle pour tenir 20 cm/s. Le système s’équilibre donc avec une erreur (d’autant plus petite que kp est grand) : c’est l’erreur statique. Augmenter kp la réduit mais amplifie le bruit et finit par faire osciller (à cause de l’inertie τ : la commande arrive « en retard »). Et la pente ajoute une erreur permanente que P ne peut pas annuler.

L’intégrale accumule l’erreur : tant qu’il reste une erreur, la commande continue de monter. À l’équilibre, l’erreur est forcément nulle — et l’intégrale a mémorisé la PWM nécessaire pour tenir la consigne, pente comprise. Trop de ki : l’intégrale a « trop d’élan » et dépasse (comme un thermostat qui chauffe trop). C’est le terme qui rend le robot exact ; c’est aussi celui qui pose le plus de problèmes (saturation, plus loin).

La dérivée mesure la vitesse de variation : si la mesure fonce vers la consigne, D freine avant le dépassement. C’est l’amortisseur. Mais dériver une mesure bruitée amplifie le bruit (la commande devient hachée : mauvais pour les moteurs) : on filtre D, ou on le calcule sur plusieurs échantillons. Beaucoup de robots réels se contentent d’un PI ; D est indispensable pour les systèmes « rapides » (équilibre d’un drone, d’un pendule inversé).

1. ki = kd = 0. Monter kp jusqu’à une réponse rapide qui oscille un peu, puis réduire de moitié.
2. Monter ki jusqu’à ce que l’erreur statique disparaisse en ~1 s sans trop de dépassement.
3. Si ça dépasse ou oscille : un peu de kd, filtré.
4. Tester avec des perturbations (pousser le robot, pente, batterie faible). Recommencer.

Ziegler-Nichols (1942) donne un point de départ agressif (dépassement de ~25 %) ; on affine ensuite. Chaque réglage est propre à un système : celui du robot A ne va pas au robot B. Notez vos gains dans un fichier de configuration, pas dans le code.

Pendant les 2 s de consigne inatteignable, la PWM est saturée à 255 mais l’intégrale continue de grossir (« s’enrouler »). Quand la consigne redescend, il faut des secondes pour la « dérouler » : le robot reste à fond bien après. Correction : ne pas intégrer quand la commande est saturée. C’est le bug PID le plus fréquent — un robot qui « ne s’arrête plus » après avoir été bloqué. Toujours : borner la commande et l’intégrale.

À 50 Hz avec 1 cm par tick, une roue à 20 cm/s donne 0,4 tick par cycle : la mesure de vitesse est très bruitée (0, 1 ou 2 ticks). Solutions : cadence du PID à 10–20 Hz (plus de ticks par cycle), ou mesurer la durée entre ticks avec ticks_us dans l’ISR, ou encodeurs plus fins. Les gains ci-dessus sont des ordres de grandeur pour une commande normalisée −1…1 : à régler avec la méthode manuelle et le tableau de bord (séance 26) qui trace consigne et mesure.

Le PID de ligne produit une rotation w ; il suppose que le robot tourne exactement de w. Or les roues ont leur propre dynamique. D’où la cascade : le PID de ligne (lent, 20 Hz) donne des consignes de vitesses v ± wL/2 aux PID de roues (rapides, 50 Hz) qui les réalisent. Chaque boucle est plus simple à régler, et la boucle interne absorbe pente et batterie. On règle toujours l’interne d’abord. Les drones ont trois niveaux : position → vitesse → attitude → vitesse angulaire des moteurs.

def score(ctrl):
    t, v, u = essai(ctrl)
    montee = t[np.argmax(v > 18)] if (v > 18).any() else np.inf
    depassement = max(0, v[:150].max() - 20) / 20 * 100
    apres_pente = np.sqrt(np.mean((v[t > 4] - 20) ** 2))
    return montee, depassement, apres_pente

for nom, c in (("PI 8/80", PI(8, 80)), ("PID 12/100/0.4", PID_antiwindup(12, 100, 0.4)), ("PID 20/150/0.6", PID_antiwindup(20, 150, 0.6))):
    m, d, a = score(c)
    print(f"{nom:16} montée {m:.2f} s  dépassement {d:4.1f} %  RMS après pente {a:.2f}")

Un score chiffré permet de comparer des réglages sans se fier à l’œil, et même de lancer une recherche automatique (grille ou optimisation) : c’est ce que font les outils d’auto-réglage industriels.

def aller_a(cible_x, cible_y, cap_final, dt=0.05):
    pid_d, pid_cap = PIDsim(0.8, 0.0, 0.1, u_max=25), PIDsim(3.0, 0.0, 0.2, u_max=3.0)   # version Python de la classe PID
    x, y, cap = 0.0, 0.0, 0.0; phase = "aller"
    for _ in range(600):
        dx, dy = cible_x - x, cible_y - y; dist = math.hypot(dx, dy)
        if phase == "aller":
            err_cap = (math.atan2(dy, dx) - cap + math.pi) % (2 * math.pi) - math.pi
            v = pid_d.calculer(0, -dist, dt) * max(0.0, math.cos(err_cap))   # ne pas avancer si on pointe à l'opposé
            w = pid_cap.calculer(0, -err_cap, dt)
            if dist < 2: phase = "aligner"
        else:
            err_cap = (cap_final - cap + math.pi) % (2 * math.pi) - math.pi
            v, w = 0.0, pid_cap.calculer(0, -err_cap, dt)
            if abs(err_cap) < math.radians(3): break
        x += v * math.cos(cap) * dt; y += v * math.sin(cap) * dt; cap += w * dt
    return math.hypot(cible_x - x, cible_y - y), math.degrees(abs(cap_final - cap))

Le facteur cos(err_cap) empêche d’avancer tant que le robot ne regarde pas vers la cible : c’est une petite machine à états implicite. Avec du bruit d’odométrie, l’erreur d’arrivée reflète la dérive (séance 27) : ~3–5 cm pour un trajet d’un mètre. Pour faire mieux, il faut un repère externe (balise, ligne au sol, caméra).

Avec P seul, l’équation devient θ'' = (g/l − kp/l)·θ : si kp < g, ça diverge ; si kp > g, c’est un oscillateur harmonique sans amortissement : ça oscille pour toujours (et le moindre retard fait diverger). Le terme D ajoute l’amortissement : θ'' + (kd/l)θ' + ((kp − g)/l)θ = 0, une équation du second ordre stable dès que kd > 0 et kp > g. En prépa, vous étudierez exactement cette équation (oscillateur amorti) et le critère de stabilité par les racines du polynôme caractéristique — puis, plus tard, la commande optimale (LQR) qui calcule les meilleurs gains. Le retard limite kd : trop de D avec un retard, et l’on corrige une pente périmée. C’est le problème que résout un gyropode 400 fois par seconde.