Wiki de Sébastien TACK

Outils pour utilisateurs

Outils du site

Piste : • ssi_fiches_de_synthese • concevoir_un_chassis_pour_le_robot • ssi_elec_regulation_asservissement • 3._le_pont_diviseur_de_tension
ssi_elec_regulation_asservissement

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Les deux révisions précédentesRévision précédente
Prochaine révision		Révision précédente
ssi_elec_regulation_asservissement [2025/11/29 13:56] – mistert2ssi_elec_regulation_asservissement [2025/12/09 13:54] (Version actuelle) – mistert2
Ligne 1: Ligne 1:
-=====REGULATION ET ASSERVISSEMENT=====+===== REGULATION ET ASSERVISSEMENT =====
  
-====COURS====+==== COURS ====
  
 {{https://mistert.freeboxos.fr/cours/_/_herbin/TSI-2022/régulation - asservissement/TSSI cours  asservissement.pdf}} {{https://mistert.freeboxos.fr/cours/_/_herbin/TSI-2022/régulation - asservissement/TSSI cours  asservissement.pdf}}
  
 +==== MODELES MATLAB  A SAUVEGARDER ====
 +
 +{{https://mistert.freeboxos.fr/cours/_/_herbin/TSI-2022/régulation - asservissement/regulationPID_2022a.slx}}
 +
 +{{https://mistert.freeboxos.fr/cours/_/_herbin/TSI-2022/régulation - asservissement/filtreNumerique_2022a.slx}}
 +
 +
 +----
  
 ==== TP – Régulation de vitesse d’un moteur à courant continu avec PID ==== ==== TP – Régulation de vitesse d’un moteur à courant continu avec PID ====
Ligne 10: Ligne 18:
 === Objectifs du TP === === Objectifs du TP ===
  
-    * Mesurer la vitesse d’un moteur CC avec un codeur incrémental. +  * Mesurer la vitesse d’un moteur CC avec un codeur incrémental 
-    * Comprendre la différence entre boucle ouverte et boucle fermée. +  * Comprendre la différence entre boucle ouverte et boucle fermée 
-    * Mettre en œuvre progressivement un correcteur P, puis PI, puis PID. +  * Mettre en œuvre progressivement un correcteur P, puis PI, puis PID 
-    * Observer l’erreur statique, le dépassement et la sensibilité au bruit. +  * Observer l’erreur statique, le dépassement et la sensibilité au bruit 
-   + 
-  +---- 
 + 
 +=== Travail demandé === 
 + 
 +  * Décrire la réponse du moteur en boucle ouverte 
 +  * Tracer ou décrire la courbe vitesse / consigne pour P 
 +  * Expliquer pourquoi un écart statique persiste 
 +  * Montrer comment I supprime cet écart 
 +  * Comparer les dépassements pour P, PI et PID 
 +  * Conclure sur l’intérêt des trois termes du PID 
 + 
 +---- 
 === 1) Commande du moteur en boucle ouverte === === 1) Commande du moteur en boucle ouverte ===
  
 Manipulations : Manipulations :
  
-  * Envoyer une commande PWM fixe (ex : 50 %, puis 80 %). +  * Choisir le mode boucle ouverte 
-  * Observer la vitesse indiquée par le programme. +  * Choisir une consigne en <mt>tr/min</mt> 
-  * Bloquer légèrement l’axe du moteur avec le doigt (sans forcer).+  * Observer la vitesse indiquée par le programme 
 +  * Bloquer légèrement l’axe du moteur avec le doigt
  
 Observations attendues : Observations attendues :
  
-  * La vitesse chute immédiatement lorsque l’axe est freiné. +  * La vitesse chute immédiatement lorsque l’axe est freiné 
-  * Le moteur ne corrige pas cette chute : c’est normal en boucle ouverte. +  * Le moteur ne corrige pas cette chute : c’est normal en boucle ouverte 
-  * La vitesse dépend de la charge, des frottements et de la tension.+  * La vitesse dépend de la charge, des frottements et de la tension
  
 Conclusion : Conclusion :
-La boucle ouverte ne permet pas de maintenir une vitesse constante.+La boucle ouverte ne permet pas de maintenir une vitesse constante 
 + 
 +----
  
 === 2) Mise en place d’un correcteur P (Proportionnel) === === 2) Mise en place d’un correcteur P (Proportionnel) ===
Ligne 37: Ligne 60:
 Manipulations : Manipulations :
  
-  * Activer le correcteur proportionnel : +  * Activer le correcteur proportionnel : <mt>u = K_p \cdot e</mt> 
-<mt>u = K_p \cdot e</mt> +  * Fixer une consigne (ex : 1500 tr/min) 
-  *  Fixer une consigne (ex : 200 ticks/s). +  * Le programme convertit automatiquement en ticks/s 
-  *  Freiner légèrement le moteur avec le doigt. +  * Freiner légèrement le moteur avec le doigt 
-  * Augmenter progressivement Kp : 0.2 → 0.5 → 1.0 → 2.0.+  * Augmenter progressivement K_p : 0.2 → 0.5 → 1.0 → 2.0
  
 Observations attendues : Observations attendues :
-  * Le moteur augmente la PWM pour compenser la perturbation. 
-  *  La vitesse remonte partiellement. 
-  * Il reste un écart statique : 
-<mt>\text{vitesse réelle} < \text{consigne}</mt> 
- *  Si Kp devient trop grand : oscillations, vibrations, instabilité. 
  
-**Conclusion** : Le correcteur P réduit l’erreur, mais ne la supprime pas.+  * Le moteur augmente la PWM pour compenser la perturbation 
 +  * La vitesse remonte partiellement  
 +  * Il reste un écart statique : <mt>\text{vitesse réelle} < \text{consigne}</mt> 
 +  * Si K_p devient trop grand : oscillations, vibrations, instabilité 
 + 
 +Conclusion : Le correcteur P réduit l’erreur, mais ne la supprime pas 
 + 
 +----
  
 === 3) Mise en place du correcteur I (Intégral) === === 3) Mise en place du correcteur I (Intégral) ===
  
 Manipulations : Manipulations :
-  * Ajouter le terme intégral : + 
-<mt>u = K_p e ;+; K_I \int e(t),dt</mt> +  * Ajouter le terme intégral : <mt>u = K_p e + K_I \int e(t)\,dt</mt> 
-  * Débuter avec Ki = 0.05, puis 0.1 max. +  * Débuter avec <mt>K_I</mt> = 0.05, puis 0.1 max 
-  * Freiner l’axe puis relâcher.+  * Freiner l’axe puis relâcher
  
 Observations attendues : Observations attendues :
-  * L’erreur statique disparaît. 
-  * La vitesse atteint précisément la consigne. 
-  * Si Ki trop fort : dépassement, oscillations lentes, instabilité. 
  
-Conclusion : +  * L’erreur statique disparaît 
-Le correcteur I supprime l’erreur statique, mais ne doit jamais être trop fort.+  * La vitesse atteint précisément la consigne 
 +  * Si <mt>K_I</mt> trop fort : dépassement, oscillations lentes, instabilité 
 + 
 +Conclusion : Le correcteur I supprime l’erreur statique, mais ne doit jamais être trop fort 
 + 
 +----
  
 === 4) Mise en place du correcteur D (Dérivé) === === 4) Mise en place du correcteur D (Dérivé) ===
  
 Manipulations : Manipulations :
--- Ajouter le terme dérivé : + 
-<mt>u = K_p e ;+; K_I \int e,dt ;+; K_D \frac{de}{dt}</mt> +  * Ajouter le terme dérivé : <mt>u = K_p e + K_I \int e\,dt + K_D \frac{de}{dt}</mt> 
--- Tester avec Kd = 0.01, puis 0.05. +  * Tester avec <mt>K_D</mt> = 0.01, puis 0.05 
--- Freiner l’axe pour observer la réaction.+  * Freiner l’axe pour observer la réaction
  
 Observations attendues : Observations attendues :
--- Le système est mieux amorti. 
--- Le dépassement diminue. 
--- La stabilité augmente. 
  
-Attention : +  * Le système est mieux amorti 
--- Si Kd trop élevé → bruit, vibrations, instabilité.+  * Le dépassement diminue 
 +  * La stabilité augmente
  
-Conclusion : +Attention : Si <mt>K_D</mt> trop élevé → bruit, vibrations, instabilité 
-Le terme D stabilise le système, mais n’améliore pas la précision.+ 
 +Conclusion : Le terme D stabilise le système, mais n’améliore pas la précision 
 + 
 +----
  
 === Synthèse des rôles P / I / D === === Synthèse des rôles P / I / D ===
Ligne 94: Ligne 122:
 | D | amortit, stabilise | amplification du bruit | | D | amortit, stabilise | amplification du bruit |
  
-=== Travail demandé === +---- 
--- Décrire la réponse du moteur en boucle ouverte. + 
--- Tracer ou décrire la courbe vitesse / consigne pour P. +==== Code Arduino du TP (consigne en tr/min, PID en ticks/s) ==== 
--- Expliquer pourquoi un écart statique persiste. + 
--- Montrer comment I supprime cet écart. +<code C++> 
--- Comparer les dépassements pour P, PI et PID. +/* 
--- Conclure sur l’intérêt des trois termes du PID.+   ====================================== 
 +      TP REGULATION : MODE BO / MODE PID 
 +   ====================================== 
 + 
 +   MODE BO : 
 +     - PWM = conversion(consigne_tr/min) 
 +     - codeur mesure mais NE corrige PAS 
 +     - aucune régulation 
 + 
 +   MODE PID : 
 +     - consigne tr/min convertie en ticks/s 
 +     - codeur mesure vitesse 
 +     - PID corrige PWM 
 +*/
  
-<code> +const int TICKS_PAR_TOUR = 90;  // à ajuster selon le codeur
-// === TP : PID pour régulation de VITESSE d’un moteur CC === +
-// Mesure vitesse = codeur incrémental sur interruption +
-// Consigne reçue par le Moniteur Série (en tr/min ou en ticks/s)+
  
 // --- Pont en H --- // --- Pont en H ---
Ligne 111: Ligne 149:
 const int M_AR = 6;   // PWM reverse const int M_AR = 6;   // PWM reverse
  
-// --- Codeur incrémental --- +// --- Codeur --- 
-const int canalA = 2;   // interruption 0+const int canalA = 2;
 const int canalB = 11; const int canalB = 11;
  
-volatile long ticks = 0;  // compteur modifié par ISR+volatile long ticks = 0;
  
-// === PID === +// --- PID --- 
-float consigne = 0;        // vitesse ciblée (ex : en ticks/s) +float kp = 0.8;
-float kp = 0.8;            // gains PID : à régler en TP+
 float ki = 0.1; float ki = 0.1;
 float kd = 0.05; float kd = 0.05;
Ligne 126: Ligne 163:
 float integral = 0; float integral = 0;
  
-// === Mesure période ===+float consigne_rpm = 0;      // consigne entrée par Serial (tr/min) 
 +float consigne_ticks_s = 0;  // consigne convertie pour le PID 
 + 
 +// --- Modes --- 
 +enum Mode { BO, PID_MODE }; 
 +Mode mode = BO; 
 + 
 +// --- Mesure ---
 unsigned long lastMeasure = 0; unsigned long lastMeasure = 0;
-const unsigned long period = 100;  // calcul vitesse toutes les 100 ms+const unsigned long period = 100; // 100 ms
  
-// === Prototypes === 
-void ISR_codeur(); 
-void commandeMoteur(float pwm); 
-float lireConsigne(); 
  
 +// ============ INTERRUPTIONS CODEUR ============
 +void ISR_codeur() {
 +  if (digitalRead(canalB))
 +    ticks++;
 +  else
 +    ticks--;
 +}
  
 +
 +// ============ CONVERSION tr/min -> PWM (BO) ============
 +int rpmToPWM(float rpm) {
 +  // Ajuste selon ton moteur
 +  // Ex : 0–150 tr/min -> 0–255 PWM
 +  if (rpm < 0) rpm = 0;
 +  if (rpm > 150) rpm = 150;
 +
 +  return map(rpm, 0, 150, 0, 255);
 +}
 +
 +
 +// ============ CONVERSION tr/min -> ticks/s (PID) ============
 +float rpmToTicksSec(float rpm) {
 +  return (rpm * TICKS_PAR_TOUR) / 60.0;
 +}
 +
 +
 +// ============ COMMANDE MOTEUR ============
 +void setPWM(int pwm) {
 +  if (pwm >= 0) {
 +    digitalWrite(M_AR, LOW);
 +    analogWrite(M_AV, pwm);
 +  } else {
 +    digitalWrite(M_AV, LOW);
 +    analogWrite(M_AR, -pwm);
 +  }
 +}
 +
 +
 +// =============================================
 +//                    SETUP
 +// =============================================
 void setup() { void setup() {
   Serial.begin(9600);   Serial.begin(9600);
Ligne 141: Ligne 221:
   pinMode(M_AV, OUTPUT);   pinMode(M_AV, OUTPUT);
   pinMode(M_AR, OUTPUT);   pinMode(M_AR, OUTPUT);
- 
   pinMode(canalB, INPUT);   pinMode(canalB, INPUT);
  
   attachInterrupt(digitalPinToInterrupt(canalA), ISR_codeur, RISING);   attachInterrupt(digitalPinToInterrupt(canalA), ISR_codeur, RISING);
  
-  Serial.println("=== TP : Regulation PID de vitesse ==="); +  Serial.println("=== TP REGULATION : BO / PID ==="); 
-  Serial.println("Entrez une consigne en ticks/s (ex : 200):");+  Serial.println("Tapez BO ou PID pour changer de mode."); 
 +  Serial.println("Tapez une consigne en tr/min (ex : 150)");
 } }
  
  
-// ====================== BOUCLE PRINCIPALE ===========================+// ============================================= 
 +//                    LOOP 
 +// =============================================
 void loop() { void loop() {
-  // --- Lecture consigne si disponible ---+ 
 +  // ----------- Lecture mode / consigne ------------
   if (Serial.available() > 0) {   if (Serial.available() > 0) {
-    consigne = lireConsigne(); +    String txt = Serial.readStringUntil('\n'); 
-    Serial.print("Nouvelle consigne = "); +    txt.trim(); 
-    Serial.println(consigne);+ 
 +    if (txt.equalsIgnoreCase("BO")) { 
 +      mode = BO; 
 +      Serial.println("Mode = BOUCLE OUVERTE"); 
 +      return; 
 +    } 
 + 
 +    if (txt.equalsIgnoreCase("PID")) { 
 +      mode = PID_MODE; 
 +      Serial.println("Mode = PID"); 
 +      return; 
 +    } 
 + 
 +    // Sinon c'est une consigne tr/min 
 +    consigne_rpm = txt.toFloat(); 
 +    consigne_ticks_s = rpmToTicksSec(consigne_rpm); 
 + 
 +    Serial.print("Consigne = "); 
 +    Serial.print(consigne_rpm); 
 +    Serial.print(" tr/min  -> "); 
 +    Serial.print(consigne_ticks_s); 
 +    Serial.println(" ticks/s");
   }   }
  
-  // --- Boucle PID toutes les 100 ms ---+ 
 +  // ----------- Mesure toutes les 100 ms -----------
   unsigned long now = millis();   unsigned long now = millis();
-  if (now - lastMeasure >= period) { +  if (now - lastMeasure < period) return; 
-    lastMeasure = now;+  lastMeasure = now; 
 + 
 +  long ticks_mes = ticks; 
 +  ticks = 0; 
 + 
 +  float vitesse_ticks_s = ticks_mes * (1000.0 / period); 
 +  float vitesse_rpm = (vitesse_ticks_s * 60.0) / TICKS_PAR_TOUR; 
 + 
 + 
 +  // ============================================ 
 +  //                 MODE BO 
 +  // ============================================ 
 +  if (mode == BO) { 
 + 
 +    int pwm = rpmToPWM(consigne_rpm);  // conversion directe consigne → PWM 
 +    setPWM(pwm); 
 + 
 +    Serial.print("[BO] consigne = "); 
 +    Serial.print(consigne_rpm); 
 +    Serial.print(" tr/min | vitesse = "); 
 +    Serial.print(vitesse_ticks_s); 
 +    Serial.print(" ticks/s | "); 
 +    Serial.print(vitesse_rpm); 
 +    Serial.print(" tr/min | PWM = "); 
 +    Serial.println(pwm); 
 + 
 +    return; 
 +  }
  
-    long ticksMesures = ticks; // copie atomique 
-    ticks = 0;                 // RAZ pour prochaine fenêtre 
  
-    float vitesse = ticksMesures * (1000.0 / period);  // en ticks/s+  // ============================================ 
 +  //                 MODE PID 
 +  // ============================================ 
 +  if (mode == PID_MODE) {
  
-    // ================= PID ================= +    erreur = consigne_ticks_s - vitesse_ticks_s;
-    erreur = consigne - vitesse;+
     integral += erreur * (period / 1000.0);     integral += erreur * (period / 1000.0);
     float deriv = (erreur - erreurPrec) / (period / 1000.0);     float deriv = (erreur - erreurPrec) / (period / 1000.0);
Ligne 178: Ligne 310:
     float commande = kp * erreur + ki * integral + kd * deriv;     float commande = kp * erreur + ki * integral + kd * deriv;
  
-    // Limiter entre -255 et 255+    // saturation
     if (commande > 255) commande = 255;     if (commande > 255) commande = 255;
     if (commande < -255) commande = -255;     if (commande < -255) commande = -255;
  
-    commandeMoteur(commande);+    setPWM(commande);
  
-    // --- Affichage TP --- +    Serial.print("[PID] consigne = "); 
-    Serial.print("Consigne="); +    Serial.print(consigne_rpm); 
-    Serial.print(consigne); +    Serial.print(" tr/min | vitesse = "); 
-    Serial.print("  | Vitesse="); +    Serial.print(vitesse_ticks_s); 
-    Serial.print(vitesse); +    Serial.print(" ticks/s | "); 
-    Serial.print("  | PWM=");+    Serial.print(vitesse_rpm); 
 +    Serial.print(" tr/min | PWM = ");
     Serial.println(commande);     Serial.println(commande);
-  } 
-} 
  
- +    return;
-// ========== INTERRUPTIONS CODEUR ========== +
-void ISR_codeur() { +
-  if (digitalRead(canalB)) +
-    ticks++; +
-  else +
-    ticks--; +
-} +
- +
- +
-// ========== COMMANDE MOTEUR ========== +
-void commandeMoteur(float pwm) { +
-  if (pwm >= 0) { +
-    digitalWrite(M_AR, LOW); +
-    analogWrite(M_AV, pwm); +
-  } else { +
-    digitalWrite(M_AV, LOW); +
-    analogWrite(M_AR, -pwm);+
   }   }
-} 
- 
- 
-// ========== LECTURE CONSIGNE ========== 
-float lireConsigne() { 
-  String txt = Serial.readStringUntil('\n'); 
-  txt.trim(); 
-  return txt.toFloat(); 
 } }
  
 </code> </code>
ssi_elec_regulation_asservissement.1764424586.txt.gz · Dernière modification : de mistert2