Asservissement PID d'une Articulation Robotique - TIPE 2026

THÈME : CYCLE ET BOUCLE

Asservissement en position d'une articulation robotique

Modélisation, synthèse PID et validation expérimentale

Nom : EL AQANI Mohamed Taha

Numéro de candidat : ___________

Filière : MP

Année : 2026

TIPE — Oral de présentation

[IMAGE 10] — Le cycle fondamental : mesure, comparaison, correction — Fichier : ChatGPT Image May 27, 2026, 05_48_00 PM.png

1

Plan de la présentation

Introduction et contexte (slides 1–8)

Modélisation du moteur DC (slides 9–16)

Synthèse du correcteur PID (slides 17–24)

Simulation numérique (slides 25–30)

Implémentation expérimentale (slides 31–36)

Résultats et confrontation modèle/expérience (slides 37–43)

Conclusion et perspectives (slides 44–47)

TIPE 2026

2

Motivation : contexte des prothèses robotiques

Développement des prothèses myoélectriques actives (cf. Armiger et al., 2013)

Besoin de contrôle précis de la position angulaire

Moteur DC : actionneur courant dans les prothèses légères

Correcteur PID : solution robuste et implémentable sur microcontrôleur

Enjeu : reproduire le mouvement naturel avec précision et rapidité

Réf. [1] : Armiger et al., 'Enabling Closed-Loop Control of the Modular Prosthetic Limb', 2013

[IMAGE 1] — Maquette expérimentale : moteur DC, driver L298N, potentiomètre, Arduino Uno — Fichier : Image_20260601_130543.png

3

Objectif de l'étude

1

Établir la fonction de transfert du moteur DC

2

Synthétiser un correcteur PID par la méthode de Ziegler-Nichols puis optimisation

3

Simuler la réponse indicielle sous Python (intégration temporelle)

4

Implémenter le correcteur PID sur Arduino Uno

5

Confronter les résultats de simulation et d'expérience

Fil conducteur : de la modélisation à la validation expérimentale

4

Problématique

Système : articulation motorisée 1 DDL

Entrée : consigne angulaire θ_c

Sortie : position angulaire θ(t)

Critères : rapidité, précision, stabilité

5

Positionnements thématiques

1. Automatique

Asservissement en position

Correcteur PID (synthèse, réglage)

Stabilité, précision, rapidité

Critère de Routh

2. Génie électrique

Moteur à courant continu

Modèle électrique (loi des mailles)

Driver L298N, PWM

Arduino Uno (microcontrôleur)

3. Génie mécanique

Théorème du moment dynamique

Frottements visqueux

Moment d'inertie J

Articulation 1 degré de liberté

6

Démarche scientifique

Modélisation physique

Lois électriques et mécaniques

Synthèse du correcteur

Méthode Ziegler-Nichols + optimisation

Simulation numérique

Python, intégration temporelle

Implémentation

Arduino Uno, boucle temps réel

Confrontation

Écarts modèle / expérience

Cycle itératif : toute divergence entre simulation et expérience alimente une révision du modèle

7

Présentation du système physique

Moteur DC 12 V : actionneur rotatif (1 DDL)

Driver L298N : amplificateur de puissance (PWM)

Potentiomètre 10 kΩ : capteur de position angulaire

Arduino Uno : calculateur temps réel (f_éch = 100 Hz)

Alimentation stabilisée 12 V / 2 A

Composant

Rôle

Moteur DC

Actionneur rotatif

Driver L298N

Amplificateur de puissance

Potentiomètre

Capteur de position angulaire

Arduino Uno

Calculateur temps réel

[IMAGE 1] — Maquette expérimentale : moteur DC, driver L298N, potentiomètre, Arduino Uno — Fichier : Image_20260601_130543.png

8

PARTIE B — MODÉLISATION

Hypothèses de modélisation

Corps rigide : pas de déformation de l'arbre moteur

Inductance L négligée : régime électrique quasi-statique (L/R ≈ 0)

Frottements visqueux uniquement : modèle linéaire f·ω (Coulomb négligé en première approche)

Alimentation idéale : tension d'entrée u(t) = signal de commande

Capteur parfait : pas de retard ni de bruit (première approche)

Ces hypothèses simplifient le modèle et permettent d'obtenir une fonction de transfert linéaire. Les effets non modélisés seront discutés lors de la confrontation expérimentale.

9

PARTIE B — MODÉLISATION

Équation électrique du moteur

u(t) = R·i(t) + L·di/dt + e(t)

e(t) = Ke·ω(t)

u(t) = R·i(t) + Ke·ω(t)

i(t) = [u(t) − Ke·ω(t)] / R

Cm(t) = Km·i(t)

R = 2,5 Ω

Km = 0,02 N·m/A

Ke = 0,02 V·s/rad

[IMAGE 3] — Modèle électrique du moteur à courant continu — Fichier : Capture d'écran 2026-06-01 133100.png

10

PARTIE B — MODÉLISATION

Équation mécanique du moteur

Théorème du moment dynamique : J·dω/dt = Cm(t) − f·ω(t)

Intégration pour la position : dθ/dt = ω(t)

Couple moteur : Cm(t) = Km·i(t)

Substitution : J·dω/dt = Km·i(t) − f·ω(t)

Paramètres : J = 0,001 kg·m² | f = 0,01 N·m·s/rad

Système d'état :

J·θ̈(t) + f·θ̇(t) = Km·i(t)

u(t) = R·i(t) + Ke·θ̇(t)

Sortie : θ(t) — Position angulaire (rad)

Ces deux équations (électrique + mécanique) constituent le modèle d'état du système.

11

PARTIE B — MODÉLISATION

Fonction de transfert en boucle ouverte

Application de la transformée de Laplace (avec L ≈ 0)

Élimination de i(p) entre les deux équations

Sortie : Θ(p) — position angulaire

H(p) = Θ(p)/U(p) = Km / (R · p · (J·p + f + Km·Ke/R))

H(p) = K / [p · (τ·p + 1)]

K = Km/(f·R + Km·Ke) = 0,02/(0,01×2,5 + 0,02×0,02) = 0,784 rad/V

τ = J·R/(f·R + Km·Ke) = 0,001×2,5/0,0254 ≈ 0,098 s

Système de type 1 (intégrateur pur en p)

Pôles : p = 0 et p = −(f·R + Km·Ke)/(J·R) ≈ −10,2 rad/s

12

PARTIE B — MODÉLISATION

Identification des paramètres

Gain statique : K = Km/(f·R + Km·Ke) ≈ 0,784 rad/V·s

Constante de temps mécanique : τ ≈ 0,098 s

Ces paramètres sont utilisés dans toute la simulation Python

13

PARTIE B — MODÉLISATION

Frottements secs : modèle de Coulomb

<strong>Modèle de Coulomb :</strong> Cf = Cf₀ · sign(ω)

<strong>Non linéaire :</strong> non pris en compte dans le modèle linéaire initial

<strong>Effet principal :</strong> zone morte (dead-zone) autour de ω = 0

<strong>Conséquence :</strong> erreur statique résiduelle en expérience

<strong>Compensation possible :</strong> terme de compensation feedforward

En première approche, seuls les frottements visqueux f·ω sont modélisés &rarr; erreur statique nulle en simulation mais résiduelle en expérience (0,002 rad)

Frottement total :

Cf_total = f·ω + Cf₀·sign(ω)

14

PARTIE B — MODÉLISATION

Modèle final retenu

Fonction de transfert en boucle ouverte

H(p) = 0,784 / [p · (0,098·p + 1)]

Gain K = 0,784 rad/V·s

K = Km / (f·R + Km·Ke)

Constante τ = 0,098 s

τ = J·R / (f·R + Km·Ke)

Type 1 (intégrateur)

→ erreur statique nulle (théorique)

Système linéaire, continu, monovariable

Hypothèses : L ≈ 0, frottements visqueux uniquement

Validé par les simulations Python

15

PARTIE B — MODÉLISATION

Stabilité en boucle ouverte

Pôles de H(p) : p₁ = 0 et p₂ = −(f·R + K_m·K_e)/(J·R) ≈ −10,2 rad/s

p₁ = 0 : pôle sur l'axe imaginaire → système marginalement stable en boucle ouverte

p₂ &lt; 0 : pôle à partie réelle négative → stable

Réponse indicielle en boucle ouverte : rampe (diverge vers +∞)

Nécessité d'un correcteur pour garantir la stabilité en boucle fermée

⚠ Un système de type 1 en boucle ouverte est marginalement stable : l'intégrateur garantit l'annulation de l'erreur statique mais impose une conception soigneuse du correcteur.

Correcteur PID : introduit un zéro pour déplacer les pôles vers la gauche

Critère de Routh appliqué en boucle fermée (cf. diapositive 24)

16

PARTIE C — SYNTHÈSE DU CORRECTEUR PID

Structure du correcteur PID

Domaine temporel

u(t) = Kp·e(t) + Ki·∫e(t)dt + Kd·de(t)/dt

Transformée de Laplace

C(p) = Kp + Ki/p + Kd·p

e(t) = θc(t) − θ(t) : erreur de position

Kp : gain proportionnel — action immédiate

Ki : gain intégral — annule l'erreur statique

Kd : gain dérivé — anticipe les variations

Gains finaux optimisés : Kp = 1,00 | Ki = 0,01 | Kd = 0,0255

17

PARTIE C — SYNTHÈSE DU CORRECTEUR PID

Rôle de chaque action PID

Action

Formule

Effet principal

Risque si trop grand

P

Kp·e(t)

Réduction de l'erreur, rapidité

Dépassement, oscillations

I

Ki·∫e dt

Annulation erreur statique

Saturation (windup), lenteur

D

Kd·de/dt

Amortissement, anticipation

Amplification du bruit

P seul : erreur statique résiduelle

PI : erreur nulle mais risque de dépassement

PID : compromis rapidité/stabilité/précision

Gains optimaux : Kp = 1,00 | Ki = 0,01 | Kd = 0,0255

Réglage itératif nécessaire pour respecter le cahier des charges

18

PARTIE C — SYNTHÈSE DU CORRECTEUR PID

Cahier des charges du correcteur

D%

Dépassement

D% < 5 %

Éviter les à-coups mécaniques sur l'articulation

tr

Temps de réponse à 5%

tr5% < 0,5 s

Assurer une réponse rapide aux changements de consigne

ε

Erreur statique

ε∞ = 0 rad

Positionnement précis : atteindre exactement la consigne angulaire

19

PARTIE C — SYNTHÈSE DU CORRECTEUR PID

Méthode de Ziegler-Nichols (boucle fermée)

Méthode empirique de réglage en boucle fermée

Étape 1 : désactiver l'action I et D (Ki = 0, Kd = 0)

Étape 2 : augmenter Kp jusqu'aux oscillations entretenues → Kp = Kcrit

Étape 3 : mesurer la période des oscillations → Tcrit

Étape 4 : calculer les gains selon le tableau de Ziegler-Nichols

Correcteur

Kp

Ti

Td

P

0,5·Kcrit

—

—

PI

0,45·Kcrit

Tcrit/1,2

—

PID

0,6·Kcrit

Tcrit/2

Tcrit/8

ne nécessite pas de modèle mathématique précis

gains initiaux souvent sous-optimaux → nécessite une optimisation

20

PARTIE C — SYNTHÈSE DU CORRECTEUR PID

Détermination de K_crit et T_crit par simulation

Simulation Python en boucle fermée avec correcteur P pur

Augmentation progressive de Kp (pas de 0,05) jusqu'aux oscillations entretenues

Oscillations détectées pour Kp ≈ Kcrit = 0,40

Période mesurée sur la courbe simulée : Tcrit ≈ 0,314 s

K_crit = 0,40 T_crit = 0,314 s

Déterminés par simulation Python (boucle P pur + analyse de la réponse)

Application des formules PID de Ziegler-Nichols :

Kp = 0,6 × 0,40 = 0,24

Ki = Kp / (Tcrit/2) = 0,24 / 0,157 ≈ 0,96

Kd = Kp × (Tcrit/8) = 0,24 × 0,039 ≈ 0,015

Ces gains initiaux seront ensuite optimisés

(Courbe d'oscillation critique — texte seulement, pas d'image sur cette diapositive)

21

PARTIE C — SYNTHÈSE DU CORRECTEUR PID

Gains calculés par Ziegler-Nichols

Kp (Proportionnel)

0,24

0,6 × Kcrit = 0,6 × 0,40

Gain de base, réduction de l'erreur

Ki (Intégral)

0,96

Kp / (Tcrit/2) = 0,24 / 0,157

Annulation de l'erreur statique

Kd (Dérivé)

0,015

Kp × (Tcrit/8) = 0,24 × 0,039

Amortissement des oscillations

⚠ Résultat : dépassement = 37,73 % → trop élevé. Une optimisation automatique est nécessaire.

22

PARTIE C — SYNTHÈSE DU CORRECTEUR PID

Optimisation automatique des gains

Méthode : descente de gradient sur la fonction coût J = D%² + (tr/0,5)² + ε²

Point de départ : gains Ziegler-Nichols (Kp=0,24, Ki=0,96, Kd=0,015)

Convergence après ~200 itérations

Critère d'arrêt : D% < 5% et tr < 0,5s et ε = 0

Gain

ZN initial

Optimisé

Cahier des charges respecté en simulation après optimisation

23

PARTIE C — SYNTHÈSE DU CORRECTEUR PID

Vérification de stabilité : critère de Routh

Polynôme caractéristique en boucle fermée avec PID :

P(p) = J·R·p³ + (f·R + Km·Ke + Kd·Km)·p² + (Km·Kp)·p + Km·Ki

Application numérique avec gains optimisés :

P(p) = 0,0025·p³ + (0,0254 + 0,02×0,0255)·p² + 0,02·p + 0,02×0,01

P(p) ≈ 0,0025·p³ + 0,02591·p² + 0,02·p + 0,0002

Tableau de Routh :

b₁ = (0,02591×0,02 − 0,0025×0,0002)/0,02591 ≈ 0,01998 > 0

0,0002 > 0

Tous les coefficients de la première colonne sont positifs

✓ Système stable en boucle fermée (critère de Routh-Hurwitz satisfait)

Pôles à partie réelle strictement négative

24

PARTIE D — SIMULATION NUMÉRIQUE

Outil de simulation : Python

Langage : Python 3 (bibliothèques : NumPy, Matplotlib)

Méthode : intégration temporelle par différences finies (Euler explicite)

Pas de temps : Δt = 1 ms (1000 points par seconde)

Durée de simulation : 2 s (réponse indicielle à échelon unitaire)

Modèle utilisé : H(p) = 0,784 / [p·(0,098·p + 1)] avec correcteur PID

# Boucle principale de simulation for k in range(N): erreur = consigne - theta[k] integrale += Ki * erreur * dt derivee = (erreur - erreur_prec) / dt u = Kp*erreur + integrale + Kd*derivee omega_dot = (Km*((u - Ke*omega[k])/R) - f*omega[k]) / J omega[k+1] = omega[k] + omega_dot * dt theta[k+1] = theta[k] + omega[k] * dt

25

PARTIE D — SIMULATION NUMÉRIQUE

Discrétisation et implémentation de la boucle

Discrétisation Euler explicite (ordre 1) : x[k+1] = x[k] + Δt·f(x[k])

Action intégrale : I[k] = I[k-1] + K_i·e[k]·Δt

Action dérivée : D[k] = K_d·(e[k] − e[k-1])/Δt

Commande : u[k] = K_p·e[k] + I[k] + D[k]

Saturation de la commande : u ∈ [−12 V, +12 V]

Consigne θ_c

Calcul erreur e[k] = θ_c − θ[k]

PID numérique → u[k]

Modèle moteur → ω[k+1], θ[k+1]

Mesure θ[k+1] → boucle suivante

26

PARTIE D — SIMULATION NUMÉRIQUE

Résultat simulé : réponse indicielle

Consigne : échelon unité θc = 1 rad

Gains : Kp = 1,00 | Ki = 0,01 | Kd = 0,0255

Dépassement : 4,93 % ✓ (< 5%)

Temps de réponse à 5% : 0,062 s ✓ (< 0,5 s)

Erreur statique : 0 rad ✓

✓ Cahier des charges respecté en simulation

[IMAGE 4] — Réponse indicielle simulée (PID optimal) : dépassement 4,93% — Fichiers : Capture d'écran 2026-06-01 124446.png (valeurs) + Capture d'écran 2026-06-01 124508.png (courbe)

27

PARTIE D — SIMULATION NUMÉRIQUE

Simulation avec perturbation (couple résistant)

<strong>Perturbation simulée :</strong> couple résistant C_r = 0,02 N&middot;m appliqué à t = 0,5 s

<strong>Effet visible :</strong> déviation temporaire de la position angulaire

<strong>Rôle de l'action intégrale :</strong> accumulation de l'erreur &rarr; retour à la consigne

<strong>Temps de retour à &plusmn;5% de la consigne :</strong> < 0,1 s après perturbation

<strong>Erreur statique nulle</strong> maintenue grâce à l'intégrateur

Rôle de l'action intégrale :

En présence d'une perturbation constante, seul le terme intégral peut annuler l'erreur en régime permanent. L'action P seule laisserait une erreur résiduelle.

Résultat : robustesse du correcteur PID face aux perturbations constantes — validée en simulation

28