411 réponses à ce sujet

[Oracid]

Merci Bubu. Je vais essayer de voir cela dans la matinée.

 

Petites remarques :

 

- Il est préférable d'utiliser le bouton en bas à droite, "Plus d'options de réponse".

- Dans l'éditeur Arduino, pour éditer du code, tu fais "édition", puis "copier pour le forum".  Puis tu colle dans ton post. Ainsi le code se trouve entre deux balises code, même si cela ne se voit pas.

- tu peux également encadrer ton code par deux balises spoiler, pour ouvrir et fermer un volet. Attention, entre les balises code et spoiler, il ne doit pas y avoir de ligne.

- tu peux copier/coller n'importe quel texte, la log par exemple, entre deux balises code, puis mettre deux balises spoiler.

 

           

[Oracid]

Cela fonctionne assez bien, même si je n'ai pas réussi à paramétrer le PID pour avoir une rotation bien continu.

 

- Ma principale modification, c'est maxPID=255. Avec 50, cela ne fonctionnait pas du tout.

- J'ai fait pas mal de modification sur le nom des variables dans la parti PID pour me rapprocher du code ici, https://www.robot-ma...board/?p=118300 qui semble être une référence.

- j'ai commenté le if (millis() >= nextTimepid) , pour au contraire calculer le PID un maximum de fois.

- dans la fonction interrupt1() , je ne comprends pas pourquoi tu divises par 45, rpm = freq/ 45 * 60;

- je n'utilise pas le frein.

 

Voici la log :

Spoiler

12:35:09.835 ->   To start pgm, click on the Start button
12:35:11.711 ->   Started
12:35:11.711 ->     Freq:0.00  RPM:0.00   km/h:0.00  err:100.00  serr:100.00  prev_tick:35  new_tick:0  pid:168.00  
12:35:11.898 ->     Freq:50.82  RPM:67.76   km/h:2.11  err:32.24  serr:1000.00  prev_tick:2068884  new_tick:2068884  pid:70.29  
12:35:12.133 ->     Freq:37.76  RPM:50.34   km/h:1.57  err:49.66  serr:1000.00  prev_tick:2273648  new_tick:2273648  pid:92.07  
12:35:12.320 ->     Freq:25.38  RPM:33.84   km/h:1.06  err:66.16  serr:1000.00  prev_tick:2471228  new_tick:2471228  pid:112.69  
12:35:12.508 ->     Freq:10416.67  RPM:28.21   km/h:0.88  err:71.79  serr:1000.00  prev_tick:2665412  new_tick:2665412  pid:119.74  
12:35:12.742 ->     Freq:25.09  RPM:33.46   km/h:1.04  err:66.54  serr:1000.00  prev_tick:2839800  new_tick:2839800  pid:113.18  
12:35:12.930 ->     Freq:10416.67  RPM:42.31   km/h:1.32  err:57.69  serr:1000.00  prev_tick:3066500  new_tick:3066500  pid:102.11  
12:35:13.117 ->     Freq:24.76  RPM:33.01   km/h:1.03  err:66.99  serr:1000.00  prev_tick:3269664  new_tick:3269664  pid:113.73  
12:35:13.305 ->     Freq:27.26  RPM:36.35   km/h:1.13  err:63.65  serr:1000.00  prev_tick:3457084  new_tick:3457084  pid:109.56  
12:35:13.539 ->     Freq:20.62  RPM:27.49   km/h:0.86  err:72.51  serr:1000.00  prev_tick:3656596  new_tick:3656596  pid:120.63  
12:35:13.727 ->     Freq:30.17  RPM:40.23   km/h:1.26  err:59.77  serr:1000.00  prev_tick:3860544  new_tick:3860544  pid:104.71  
12:35:13.914 ->     Freq:20.57  RPM:27.43   km/h:0.86  err:72.57  serr:1000.00  prev_tick:4026676  new_tick:4026676  pid:120.72  
12:35:14.102 ->     Freq:30.69  RPM:40.92   km/h:1.28  err:59.08  serr:1000.00  prev_tick:4258732  new_tick:4258732  pid:103.84  
12:35:14.337 ->     Freq:19.47  RPM:25.96   km/h:0.81  err:74.04  serr:1000.00  prev_tick:4467996  new_tick:4467996  pid:122.55  
12:35:14.524 ->     Freq:32.25  RPM:42.99   km/h:1.34  err:57.01  serr:1000.00  prev_tick:4656136  new_tick:4656136  pid:101.26  
12:35:14.712 ->     Freq:20.14  RPM:26.86   km/h:0.84  err:73.14  serr:1000.00  prev_tick:4857536  new_tick:4857536  pid:121.43  
12:35:14.899 ->     Freq:33.23  RPM:44.31   km/h:1.38  err:55.69  serr:1000.00  prev_tick:5051272  new_tick:5051272  pid:99.61  
12:35:15.135 ->     Freq:21.66  RPM:28.89   km/h:0.90  err:71.11  serr:1000.00  prev_tick:5242132  new_tick:5242132  pid:118.89  
12:35:15.323 ->     Freq:33.39  RPM:44.52   km/h:1.39  err:55.48  serr:1000.00  prev_tick:5451444  new_tick:5451444  pid:99.36  
12:35:15.510 ->     Freq:23.67  RPM:31.56   km/h:0.98  err:68.44  serr:1000.00  prev_tick:5632108  new_tick:5632108  pid:115.55  
12:35:15.698 ->     Freq:30.86  RPM:41.15   km/h:1.28  err:58.85  serr:1000.00  prev_tick:5857240  new_tick:5857240  pid:103.57  
12:35:15.932 ->     Freq:20.80  RPM:27.73   km/h:0.87  err:72.27  serr:1000.00  prev_tick:6054084  new_tick:6054084  pid:120.34  
12:35:16.119 ->     Freq:28.12  RPM:37.50   km/h:1.17  err:62.50  serr:1000.00  prev_tick:6260616  new_tick:6260616  pid:108.13  
12:35:16.307 ->     Freq:17.99  RPM:23.99   km/h:0.75  err:76.01  serr:1000.00  prev_tick:6446128  new_tick:6446128  pid:125.01  
12:35:16.542 ->     Freq:29.21  RPM:38.95   km/h:1.22  err:61.05  serr:1000.00  prev_tick:6653432  new_tick:6653432  pid:106.32  
12:35:16.729 ->     Freq:20.07  RPM:26.76   km/h:0.83  err:73.24  serr:1000.00  prev_tick:6823864  new_tick:6823864  pid:121.55  
12:35:16.917 ->     Freq:30.57  RPM:40.75   km/h:1.27  err:59.25  serr:1000.00  prev_tick:7048564  new_tick:7048564  pid:104.06  
12:35:17.104 ->     Freq:10416.67  RPM:24.01   km/h:0.75  err:75.99  serr:1000.00  prev_tick:7268108  new_tick:7268108  pid:124.99  
12:35:17.339 ->     Freq:27.75  RPM:37.00   km/h:1.15  err:63.00  serr:1000.00  prev_tick:7453332  new_tick:7453332  pid:108.75  
12:35:17.526 ->     Freq:17.59  RPM:23.45   km/h:0.73  err:76.55  serr:1000.00  prev_tick:7642800  new_tick:7642800  pid:125.68  
12:35:17.714 ->     Freq:28.60  RPM:38.13   km/h:1.19  err:61.87  serr:1000.00  prev_tick:7847864  new_tick:7847864  pid:107.33  
12:35:17.901 ->     Freq:19.37  RPM:25.83   km/h:0.81  err:74.17  serr:1000.00  prev_tick:8023668  new_tick:8023668  pid:122.72  
12:35:18.135 ->     Freq:25.14  RPM:33.52   km/h:1.05  err:66.48  serr:1000.00  prev_tick:8262756  new_tick:8262756  pid:113.10  
12:35:18.323 ->     Freq:23.42  RPM:31.23   km/h:0.97  err:68.77  serr:1000.00  prev_tick:8457356  new_tick:8457356  pid:115.97  
12:35:18.511 ->     Freq:27.22  RPM:36.30   km/h:1.13  err:63.70  serr:1000.00  prev_tick:8651504  new_tick:8651504  pid:109.63  
12:35:18.698 ->     Freq:17.29  RPM:23.05   km/h:0.72  err:76.95  serr:1000.00  prev_tick:8845932  new_tick:8845932  pid:126.18  
12:35:18.933 ->     Freq:29.06  RPM:38.74   km/h:1.21  err:61.26  serr:1000.00  prev_tick:9070584  new_tick:9070584  pid:106.57  
12:35:19.120 ->     Freq:19.89  RPM:26.52   km/h:0.83  err:73.48  serr:1000.00  prev_tick:9241784  new_tick:9241784  pid:121.85  
12:35:19.308 ->     Freq:30.89  RPM:41.19   km/h:1.29  err:58.81  serr:1000.00  prev_tick:9467596  new_tick:9467596  pid:103.51  
12:35:19.542 ->     Freq:21.03  RPM:28.04   km/h:0.87  err:71.96  serr:1000.00  prev_tick:9630356  new_tick:9630356  pid:119.94  
12:35:19.730 ->     Freq:28.80  RPM:38.40   km/h:1.20  err:61.60  serr:1000.00  prev_tick:9871968  new_tick:9871968  pid:107.00  
12:35:19.917 ->     Freq:18.38  RPM:24.51   km/h:0.76  err:75.49  serr:1000.00  prev_tick:10053064  new_tick:10053064  pid:124.36  
12:35:20.105 ->     Freq:28.24  RPM:37.65   km/h:1.17  err:62.35  serr:1000.00  prev_tick:10272152  new_tick:10272152  pid:107.94  
12:35:20.339 ->     Freq:18.71  RPM:24.95   km/h:0.78  err:75.05  serr:1000.00  prev_tick:10451604  new_tick:10451604  pid:123.81  
12:35:20.527 ->     Freq:28.35  RPM:37.80   km/h:1.18  err:62.20  serr:1000.00  prev_tick:10642768  new_tick:10642768  pid:107.75  
12:35:20.714 ->     Freq:17.71  RPM:23.62   km/h:0.74  err:76.38  serr:1000.00  prev_tick:10827976  new_tick:10827976  pid:125.48  
12:35:20.902 ->     Freq:27.78  RPM:37.04   km/h:1.16  err:62.96  serr:1000.00  prev_tick:11069428  new_tick:11069428  pid:108.70  
12:35:21.136 ->     Freq:17.66  RPM:23.55   km/h:0.73  err:76.45  serr:1000.00  prev_tick:11259476  new_tick:11259476  pid:125.57  
12:35:21.324 ->     Freq:27.53  RPM:36.71   km/h:1.15  err:63.29  serr:1000.00  prev_tick:11468400  new_tick:11468400  pid:109.12  
12:35:21.512 ->     Freq:18.13  RPM:24.17   km/h:0.75  err:75.83  serr:1000.00  prev_tick:11654048  new_tick:11654048  pid:124.79  
12:35:21.699 ->     Freq:25.99  RPM:34.65   km/h:1.08  err:65.35  serr:1000.00  prev_tick:11846196  new_tick:11846196  pid:111.68  
12:35:21.933 ->     Freq:19.38  RPM:25.85   km/h:0.81  err:74.15  serr:1000.00  prev_tick:12044108  new_tick:12044108  pid:122.69  
12:35:22.121 ->     Freq:26.37  RPM:35.16   km/h:1.10  err:64.84  serr:1000.00  prev_tick:12244756  new_tick:12244756  pid:111.05  
12:35:22.310 ->     Freq:18.64  RPM:24.86   km/h:0.78  err:75.14  serr:1000.00  prev_tick:12441380  new_tick:12441380  pid:123.93  
12:35:22.496 ->     Freq:23.33  RPM:31.11   km/h:0.97  err:68.89  serr:1000.00  prev_tick:12659676  new_tick:12659676  pid:116.11  
12:35:22.730 ->     Freq:29.08  RPM:38.77   km/h:1.21  err:61.23  serr:1000.00  prev_tick:12843848  new_tick:12843848  pid:106.54  
12:35:22.918 ->     Freq:21.81  RPM:29.08   km/h:0.91  err:70.92  serr:1000.00  prev_tick:13034884  new_tick:13034884  pid:118.65  
12:35:23.105 ->     Freq:31.93  RPM:42.58   km/h:1.33  err:57.42  serr:1000.00  prev_tick:13273184  new_tick:13273184  pid:101.78  
12:35:23.340 ->     Freq:21.24  RPM:28.32   km/h:0.88  err:71.68  serr:1000.00  prev_tick:13469420  new_tick:13469420  pid:119.60  
12:35:23.528 ->     Freq:32.10  RPM:42.80   km/h:1.34  err:57.20  serr:1000.00  prev_tick:13672432  new_tick:13672432  pid:101.50  
12:35:23.716 ->     Freq:20.00  RPM:26.67   km/h:0.83  err:73.33  serr:1000.00  prev_tick:13874828  new_tick:13874828  pid:121.66  
12:35:23.903 ->     Freq:33.16  RPM:44.21   km/h:1.38  err:55.79  serr:1000.00  prev_tick:14067208  new_tick:14067208  pid:99.74  
12:35:24.137 ->     Freq:21.57  RPM:28.76   km/h:0.90  err:71.24  serr:1000.00  prev_tick:14258744  new_tick:14258744  pid:119.05  
12:35:24.325 ->     Freq:28.28  RPM:37.71   km/h:1.18  err:62.29  serr:1000.00  prev_tick:14472732  new_tick:14472732  pid:107.86  
12:35:24.513 ->     Freq:18.94  RPM:25.25   km/h:0.79  err:74.75  serr:1000.00  prev_tick:14651304  new_tick:14651304  pid:123.44  
12:35:24.700 ->   Operator Interrupt !!!
12:35:25.122 ->   To start pgm, click on the Start button

 

Le code :

Spoiler

void(* resetFunc) (void) = 0;                                             // soft reset function
 
int pb = A0;                                                              // Start pgm button
// Pin Declarations
int PIN_DIR = 10;                            // Motor direction signal
int PIN_PWM = 5;                            // PWM motor speed control
int HALL_PIN = 2;
 
// Variables used in ReadSpeed function
double freq;                                      // Frequency of the signal on the speed pin
double rpm;                                       // Wheel speed in revolutions per minute
double kph;                                       // Wheel speed in kilometers per hour
int consigne = 100;                         //vitesse en tours/mn demander 
double err=0, errSum=0, errDif=0, lastErr=0;
 
const double WHEEL_CIRCUMFERENCE_CM = 52;         // Motor wheel circumference (roue de 10 pouce en centimeters)
 
volatile unsigned long prev_tick;                 // Interrupt variables
volatile unsigned long new_tick;
volatile double Period = 0;
 
unsigned long nextTimepid = 0;
unsigned long nextTimeInfo = 0;
int inc, maxPID=255;
//float kp = 0.35, ki = 0.05, pid = 0;   // valeurs d'origines de Bubu
float kp = 1.25, ki = 0.03, kd=0.4, pid = 0;   
 
void setup() {
  Serial.begin(115200);
  pinMode(pb,INPUT_PULLUP);                                               // Start pgm button
  pinMode(PIN_PWM, OUTPUT);
  pinMode(PIN_DIR, OUTPUT);
  // Set initial pin states
  digitalWrite(PIN_DIR, 1);
  analogWrite(PIN_PWM, 0);
 
  attachInterrupt(digitalPinToInterrupt(HALL_PIN), interrupt1,  RISING);
  
  prev_tick = micros()-1; 
  Serial.print("\n\t To start pgm, click on the Start button"); while(digitalRead(pb)); delay(400); Serial.print("\n\t Started");
}
 
 
void loop() {
  if (! digitalRead(pb)) { Serial.print("\n\t Operator Interrupt !!!"); delay(400); analogWrite(PIN_PWM,0); resetFunc(); }
 
//  if (millis() >= nextTimepid){                    
//      nextTimepid = millis() + 20;
      consigne+=inc;
      if (consigne >= 800) {inc = -1;}
      if (consigne <= 15) {inc =  1;}
      err = consigne - rpm; // pour le proportionnel
      errSum = errSum + err; // pour l'intégrateur
      errSum = constrain(errSum, -100, 1000);
      errDif = err - lastErr; // pour le dérivateur
      lastErr = err;
      pid = kp*err + ki*errSum + kd*errDif;
      pid = constrain(pid,-8, maxPID);
      if (pid <= 0){ digitalWrite(PIN_DIR, 0); pid = -pid;  }
      else{ digitalWrite(PIN_DIR, 1); }
      
      analogWrite(PIN_PWM, pid);
      // Calculate the km per hour (kph) based on the wheel diameter or circumference
      kph = (WHEEL_CIRCUMFERENCE_CM * rpm * 60) / 100000;
//  } 
 
  if (millis() >= nextTimeInfo){                    
    nextTimeInfo = millis() + 200;     
    Serial.print((String) "\n  " +
                          "  Freq:" + freq +
                          "  RPM:" + rpm + " " +
                          "  km/h:" + kph +
                          "  err:" + err +
                          "  serr:" + errSum +
                          "  prev_tick:" + prev_tick +
                          "  new_tick:" + new_tick + 
                          "  pid:" + pid +
                          "  ");
  }
}
 
void interrupt1(){
      new_tick = micros();
      Period = (new_tick - prev_tick);      
      freq = (1 / Period ) * 1E6;
      if (freq > 800){                             //sécurité en cas de lecture érronèe, ne tient pas compte de la mesure
         prev_tick = new_tick;
         return;                             
        }
      rpm = freq/ 45 * 60;
      prev_tick = new_tick;
}

[bubu17]

le 45 correspond au nombre de période par tour de roue: 90 ticks (haut + bas)/ 2

 

je n'arrive pas à copier-coller la log.

 

ton pid a besoin d'être 10x supérieur au miens pour la même vitesse et fréquence.

ou été le problème? valeur du pid?

[Oracid]

Sur mon moteur, il y a 15 ticks.

Attention, avec le paramètre RISING dans la fonction attachInterrup(), il ne faut pas diviser par 2. 

https://reference.ar...ttachinterrupt/

• RISING to trigger when the pin goes from low to high,

 

Je ne sais pas où sont les problèmes et encore moins les solutions.

Néanmoins, quelque chose me trouble. Moi, je pensais que le PID était un traitement de l'erreur. Et donc, qu'il fallait ajouter le PID à la valeur de consigne.

Il semblerait que ce ne soit pas le cas.

Et donc, je ne comprends pas.

 

Pour la log, avec ta souris, tu sélectionnes une zone de ta log et tu copies/colles entre les balises "code" que tu auras écrit préalablement.

[Mike118]

Un rapide résumé du correcteur PID : 

=> Correcteur, le but c'est de corriger quelque chose => on a une Consigne et une Mesure, et à partir de là on a une Erreur qui par convention est Erreur = Consigne - Mesure. 
Pour corriger cette erreur il nous faut un moyen d'action sur lequel va intervenir notre correcteur . 

=> PID, Proportionnel, Intégral, Dérivé, ce sont les méthode de calculs qui vont s'appliquer sur l'erreur. 

Parfois un simple correcteur proportionnel suffit souvent ça ne suffit pas ... Cela va dépendre du système qu'on cherche à corriger ( on parle d'ordre du système mais on va pas rentrer dans ce détail là pour notre rapide résumé ) 

Cas classique d'un correcteur sur la vitesse de rotation de notre moteur. 

On a une consigne ( si possible on fait en sorte de l'avoir dans une unité compréhensible ) dans notre cas je pars sur des RPM. 
On a une mesure ( il nous faudra la mettre dans la même unité que notre consigne ) je prends aussi des RPM. 

Notre moyen d'action sur la vitesse de notre moteur c'est le PWM. 

Dans notre cas, le but du correcteur c'est de donner une valeur de PWM en fonction de la valeur de l'Erreur de sorte à ce que notre erreur diminue et si possible reste stable à 0 ( = Consigne atteinte, Mesure = Consigne ) 

Le cas d'un correcteur uniquement proportionnel on un calcule du genre PWM = KP * Erreur . 

Quelque soit notre gain KP fixe on se rend vite compte qu'avec une formule du genre c'est pas suffisant pour avoir un système stable
Si à un moment donné l'erreur est nulle ( ce qui est l'objectif ) la forumule nous donnera PWM = 0   et donc notre moteur va vouloir s'arrêter ... Donc la seule consigne "potentiellement stable " c'est l'ordre d'arrêt ... Consigne = 0 , si Mesure = 0, Pwm = 0 et le moteur est bien à l'arrêt ... 

Quelque soit les autres cas on aura soit un système " oscillant " soit un système avec une erreur statique constante ( et plus la vitesse demandée sera élevée et plus l'erreur statique sera grande ... ) 

Exemples si on demande 100 RPM

Cas oscillant : 
 le gain KP est tellement grand que la PWM est mis directement à 100%, le moteur part trop vite, la mesure indique 150 RPM, du coup le PID change le PWM pour le mettre à - 100% en marche arrière ... puis la mesure indique qu'on est à -10 RPM .... Le PID met le PWM à 100%  et rebelote ... 

Cas stabilisé : 
après une phase " transistoire " le moteur atteint une vitesse de 80 RPM, il resulte une erreur statique de 20 RPM, avec un KP de 4 le calcul du PID donne un PWM de 80% ( les chiffres sont arbitraire juste pour l'exemple ) ce PWM de 80% est tout juste suffisant pour maintenir la vitesse de 80 RPM... Si le moteur accélère un peu, l'erreur diminue et le pwm va baisser un peu et le moteur retourne à 80 RPM et pid à 80% à l'inverse si le moteur ralentit un peu l'erreur va augmenter et le pwm va augmenter... 

Afin de corriger cette erreur statique on peut imaginer une formule du style : 

PWM = KP * Erreur + "Constante de maintient de vitesse quand l'Erreur est nulle ".... 

Malheureusement, cette constante n'est pas " constante " est dépend de la consigne demandé ... Avec les chiffre arbitraires de l'exemple ci dessus on peut imaginer qu'il faut mettre le PWM  à 100% pour atteindre les 100 RPM, 80% pour les 80RPM etc ... 

Mais si on avait une relation magique qui lie directement la vitesse du moteur au pwm qui marche tout le temps ça serait plus simple ... Et comme on a pas cette relation on utilise la partie I de notre correcteur . L'intégrale ( qui n'est rien d'autre qu'une somme à chaque fois qu'on fait le calcul : erreur 0 + erreur 1 + ... + erreur n 

"Constante de maintient de vitesse quand l'Erreur est nulle" =  Ki * ( Somme des erreur )  afin d'avoir une valeur qui se calcule automatiquement ... 

=> En régime stable Si on a une erreur nulle alors PWM = Ki * ( Somme des erreur ) , La somme n'est pas nulle et ne change pas... On a notre super constante qui se calcule toute seule automatiquement indépendamment de la consigne demandé ... Mais en fonction du système le calcule peut osciller un peu autour de la bonne valeur ( le terme en intégrale peut " overshot" pendant sa phase de calcule et il faudra que l'erreur reste négative assez longtemps pour que la somme des erreurs diminue ... )


Et le D ça sert à quoi ?  => Le terme dérivé c'est pour essayer de rajouter un peu de prévision. grosso mode, c'est la différence entre ton erreur précédente et ton erreur actuelle. 
Si tu vois que ton erreur à augmenter, alors tu es en train de t'éloigner de ta consigne il va falloir accélérer un peu plus. Par contre si ton erreur est en train de se rapprocher de 0 tu peux commencer à progressivement ralentir .... 

 

[Oracid]

Merci Mike.

 

Concentrons nous sur Kp, pour faire plus simple.

On a  P = erreur * Kp , donc P est égal à l'erreur multiplié par un coefficient. Je comprends parfaitement que l'on corrige l'erreur, proportionnellement à sa hauteur. Plus l'erreur est importante, plus la correction est grande.

Donc, si on parle de vitesse, la nouvelle vitesse est égale à P.

 

Et là, je décroche, car pour moi, la nouvelle vitesse est égale à la somme de la consigne et de P. Soit  vitesse = consigne + P

[bubu17]

 

Oracid a écrit hier, 19:38

Sur mon moteur, il y a 15 ticks.

Attention, avec le paramètre RISING dans la fonction attachInterrup(), il ne faut pas diviser par 2. 

 

15 ticks, ca m'étonne!

j'ai fais un code pour les mesurer:

 

Spoiler

int HALL_PIN = 2;
unsigned int ticks = 0;
unsigned long nextTimeInfo = 0;


void setup() {

Serial.begin(115200);
Serial.println("go");
attachInterrupt(digitalPinToInterrupt(HALL_PIN), interrupt1, RISING);
// attachInterrupt(digitalPinToInterrupt(HALL_PIN), interrupt1, CHANGE);
}

void loop() {

if (millis() >= nextTimeInfo){
nextTimeInfo = millis() + 100;

Serial.println((String)"ticks:" + ticks + " ");
}
}

void interrupt1(){
ticks++;
}

 

sur mon moteur j'ai 45 ticks avec RISING et 90 avec CHANGE

 

pour faire la mesure il faut tourner la roue à la main

[Mike118]

 

 

Et là, je décroche, car pour moi, la nouvelle vitesse est égale à la somme de la consigne et de P. Soit  vitesse = consigne + P

 

Non si tu reprends ce que j'ai écrit plus haut : 

Il faut bien distinguer
" ta nouvelle vitesse obtenue / viesse de sortie " = la mesure de vitesse, ta mesure réelle
" ta consigne " = la vitesse souhaitée.
" ton moyen d'action " = pwm. 

Le but du correcteur est de calculer la valeur de contrôle de ton moyen d'action => Ton Pwm. 

Dans le cas d'un correcteur P classique : PWM = KP * erreur   ( = KP * ( Consigne - mesure ) ).  

Ta vitesse de sortie , (ta mesure), va fluctuer en fonction de ce PWM et des éléments extérieurs couple résistants etc ... 



Si tu remet ta consigne dans le calcul de ton PWM ( autrement que dans le calcul de l'erreur ) tu n'es plus dans le cas d'un correcteur proportionnel classique... 

Tu peux choisir de faire un correcteur à ta sauce de la forme  PWM = Kp * erreur + Kc * consigne   

Ce genre de correcteur " non classique" est utilisé quand on connait la relation théorique entre la consigne ( des RPM )  et la valeur de contrôle ( PWM )  il suffit de choisir Kc qui correspond à la valeur théorique PWM = KC * consigne... ( l'ajout de l'erreur avec un kp permettra de faire des corrections autour de cette relation théorique )... 

 

[Oracid]

Désolé Mike, je te remercie, mais je ne comprends pas.

Ce n'est pas grave. Je ferai comme si j'avais compris.

[Oracid]

Merci Bubu.

Je vais tester ton code ce matin.

[Oracid]

Bubu, il est génial, ton programme !

Je viens de tester ma roue. Elle fait bien 15 ticks en un tour.

 

Ton code:

Spoiler

// teste le nombre de tics d'une roue d'Hoverboard - Code Bubu17 - 18/04/2023
// https://www.robot-maker.com/forum/topic/13733-ugv-a-base-delements-de-trottinette-ou-dhoverboard/?p=118353
 
int HALL_PIN = 2;
unsigned int ticks = 0;
unsigned long nextTimeInfo = 0;
 
 
void setup() {
  Serial.begin(115200);
  Serial.println("go");
  attachInterrupt(digitalPinToInterrupt(HALL_PIN), interrupt1, RISING);
  // attachInterrupt(digitalPinToInterrupt(HALL_PIN), interrupt1, CHANGE);
}
 
void loop() {
  if (millis() >= nextTimeInfo){
    nextTimeInfo = millis() + 100;
    Serial.println((String)"ticks:" + ticks + " ");
  }
}
 
void interrupt1(){
  ticks++;
}

 

La log:

Spoiler

07:56:37.149 -> ticks:0 
07:56:37.224 -> ticks:0 
07:56:37.345 -> ticks:0 
07:56:37.421 -> ticks:0 
07:56:37.559 -> ticks:0 
07:56:37.650 -> ticks:0 
07:56:37.735 -> ticks:0 
07:56:37.851 -> ticks:0 
07:56:37.934 -> ticks:0 
07:56:38.045 -> ticks:0 
07:56:38.167 -> ticks:0 
07:56:38.257 -> ticks:0 
07:56:38.332 -> ticks:1 
07:56:38.449 -> ticks:1 
07:56:38.566 -> ticks:1 
07:56:38.649 -> ticks:1 
07:56:38.723 -> ticks:1 
07:56:38.848 -> ticks:1 
07:56:38.929 -> ticks:1 
07:56:39.031 -> ticks:1 
07:56:39.134 -> ticks:1 
07:56:39.223 -> ticks:1 
07:56:39.354 -> ticks:1 
07:56:39.428 -> ticks:1 
07:56:39.544 -> ticks:1 
07:56:39.634 -> ticks:1 
07:56:39.759 -> ticks:1 
07:56:39.855 -> ticks:1 
07:56:39.930 -> ticks:1 
07:56:40.067 -> ticks:1 
07:56:40.156 -> ticks:1 
07:56:40.244 -> ticks:1 
07:56:40.332 -> ticks:1 
07:56:40.450 -> ticks:1 
07:56:40.558 -> ticks:1 
07:56:40.633 -> ticks:1 
07:56:40.756 -> ticks:1 
07:56:40.845 -> ticks:1 
07:56:40.931 -> ticks:1 
07:56:41.038 -> ticks:1 
07:56:41.154 -> ticks:2 
07:56:41.250 -> ticks:2 
07:56:41.339 -> ticks:2 
07:56:41.425 -> ticks:2 
07:56:41.549 -> ticks:2 
07:56:41.633 -> ticks:2 
07:56:41.753 -> ticks:2 
07:56:41.849 -> ticks:2 
07:56:41.929 -> ticks:2 
07:56:42.053 -> ticks:2 
07:56:42.149 -> ticks:2 
07:56:42.238 -> ticks:2 
07:56:42.320 -> ticks:2 
07:56:42.450 -> ticks:2 
07:56:42.524 -> ticks:2 
07:56:42.661 -> ticks:2 
07:56:42.752 -> ticks:2 
07:56:42.834 -> ticks:2 
07:56:42.924 -> ticks:2 
07:56:43.067 -> ticks:2 
07:56:43.155 -> ticks:2 
07:56:43.230 -> ticks:2 
07:56:43.349 -> ticks:2 
07:56:43.457 -> ticks:2 
07:56:43.548 -> ticks:2 
07:56:43.639 -> ticks:2 
07:56:43.733 -> ticks:2 
07:56:43.823 -> ticks:2 
07:56:43.953 -> ticks:2 
07:56:44.041 -> ticks:2 
07:56:44.130 -> ticks:2 
07:56:44.252 -> ticks:3 
07:56:44.340 -> ticks:3 
07:56:44.429 -> ticks:3 
07:56:44.540 -> ticks:3 
07:56:44.622 -> ticks:3 
07:56:44.745 -> ticks:3 
07:56:44.835 -> ticks:3 
07:56:44.924 -> ticks:3 
07:56:45.066 -> ticks:3 
07:56:45.153 -> ticks:3 
07:56:45.242 -> ticks:3 
07:56:45.329 -> ticks:3 
07:56:45.419 -> ticks:3 
07:56:45.533 -> ticks:3 
07:56:45.623 -> ticks:4 
07:56:45.746 -> ticks:4 
07:56:45.824 -> ticks:4 
07:56:45.933 -> ticks:4 
07:56:46.048 -> ticks:4 
07:56:46.119 -> ticks:4 
07:56:46.249 -> ticks:4 
07:56:46.338 -> ticks:4 
07:56:46.422 -> ticks:4 
07:56:46.551 -> ticks:4 
07:56:46.632 -> ticks:4 
07:56:46.723 -> ticks:4 
07:56:46.848 -> ticks:4 
07:56:46.938 -> ticks:4 
07:56:47.047 -> ticks:4 
07:56:47.136 -> ticks:4 
07:56:47.251 -> ticks:4 
07:56:47.335 -> ticks:4 
07:56:47.450 -> ticks:4 
07:56:47.558 -> ticks:4 
07:56:47.634 -> ticks:4 
07:56:47.743 -> ticks:4 
07:56:47.824 -> ticks:4 
07:56:47.950 -> ticks:4 
07:56:48.024 -> ticks:5 
07:56:48.122 -> ticks:5 
07:56:48.237 -> ticks:5 
07:56:48.324 -> ticks:5 
07:56:48.433 -> ticks:5 
07:56:48.522 -> ticks:5 
07:56:48.618 -> ticks:5 
07:56:48.756 -> ticks:5 
07:56:48.841 -> ticks:5 
07:56:48.957 -> ticks:6 
07:56:49.043 -> ticks:6 
07:56:49.144 -> ticks:6 
07:56:49.233 -> ticks:6 
07:56:49.349 -> ticks:6 
07:56:49.431 -> ticks:6 
07:56:49.540 -> ticks:6 
07:56:49.665 -> ticks:6 
07:56:49.751 -> ticks:6 
07:56:49.833 -> ticks:6 
07:56:49.952 -> ticks:6 
07:56:50.033 -> ticks:6 
07:56:50.157 -> ticks:6 
07:56:50.232 -> ticks:6 
07:56:50.347 -> ticks:6 
07:56:50.434 -> ticks:6 
07:56:50.556 -> ticks:6 
07:56:50.645 -> ticks:6 
07:56:50.766 -> ticks:6 
07:56:50.841 -> ticks:6 
07:56:50.950 -> ticks:7 
07:56:51.024 -> ticks:7 
07:56:51.146 -> ticks:7 
07:56:51.227 -> ticks:7 
07:56:51.350 -> ticks:7 
07:56:51.435 -> ticks:7 
07:56:51.523 -> ticks:7 
07:56:51.647 -> ticks:7 
07:56:51.720 -> ticks:7 
07:56:51.856 -> ticks:7 
07:56:51.936 -> ticks:8 
07:56:52.024 -> ticks:8 
07:56:52.151 -> ticks:8 
07:56:52.235 -> ticks:8 
07:56:52.324 -> ticks:8 
07:56:52.421 -> ticks:8 
07:56:52.531 -> ticks:8 
07:56:52.621 -> ticks:8 
07:56:52.750 -> ticks:8 
07:56:52.840 -> ticks:8 
07:56:52.938 -> ticks:8 
07:56:53.055 -> ticks:8 
07:56:53.147 -> ticks:8 
07:56:53.227 -> ticks:8 
07:56:53.334 -> ticks:8 
07:56:53.422 -> ticks:8 
07:56:53.558 -> ticks:8 
07:56:53.654 -> ticks:8 
07:56:53.730 -> ticks:8 
07:56:53.854 -> ticks:8 
07:56:53.929 -> ticks:8 
07:56:54.029 -> ticks:8 
07:56:54.144 -> ticks:8 
07:56:54.254 -> ticks:8 
07:56:54.328 -> ticks:9 
07:56:54.451 -> ticks:9 
07:56:54.532 -> ticks:9 
07:56:54.646 -> ticks:9 
07:56:54.727 -> ticks:9 
07:56:54.850 -> ticks:9 
07:56:54.939 -> ticks:9 
07:56:55.017 -> ticks:10 
07:56:55.139 -> ticks:10 
07:56:55.235 -> ticks:10 
07:56:55.318 -> ticks:10 
07:56:55.440 -> ticks:10 
07:56:55.533 -> ticks:10 
07:56:55.623 -> ticks:10 
07:56:55.728 -> ticks:10 
07:56:55.828 -> ticks:10 
07:56:55.957 -> ticks:10 
07:56:56.054 -> ticks:10 
07:56:56.130 -> ticks:10 
07:56:56.249 -> ticks:10 
07:56:56.333 -> ticks:10 
07:56:56.449 -> ticks:10 
07:56:56.520 -> ticks:10 
07:56:56.639 -> ticks:10 
07:56:56.728 -> ticks:10 
07:56:56.828 -> ticks:10 
07:56:56.966 -> ticks:10 
07:56:57.057 -> ticks:10 
07:56:57.140 -> ticks:10 
07:56:57.231 -> ticks:10 
07:56:57.354 -> ticks:10 
07:56:57.434 -> ticks:10 
07:56:57.523 -> ticks:10 
07:56:57.655 -> ticks:10 
07:56:57.734 -> ticks:11 
07:56:57.822 -> ticks:11 
07:56:57.952 -> ticks:11 
07:56:58.040 -> ticks:11 
07:56:58.133 -> ticks:11 
07:56:58.223 -> ticks:11 
07:56:58.320 -> ticks:11 
07:56:58.457 -> ticks:11 
07:56:58.524 -> ticks:11 
07:56:58.649 -> ticks:11 
07:56:58.724 -> ticks:12 
07:56:58.833 -> ticks:12 
07:56:58.956 -> ticks:12 
07:56:59.029 -> ticks:12 
07:56:59.119 -> ticks:12 
07:56:59.248 -> ticks:12 
07:56:59.331 -> ticks:12 
07:56:59.448 -> ticks:12 
07:56:59.549 -> ticks:12 
07:56:59.624 -> ticks:12 
07:56:59.747 -> ticks:12 
07:56:59.827 -> ticks:12 
07:56:59.945 -> ticks:12 
07:57:00.030 -> ticks:12 
07:57:00.121 -> ticks:12 
07:57:00.230 -> ticks:12 
07:57:00.356 -> ticks:12 
07:57:00.433 -> ticks:12 
07:57:00.532 -> ticks:12 
07:57:00.650 -> ticks:12 
07:57:00.732 -> ticks:12 
07:57:00.855 -> ticks:12 
07:57:00.935 -> ticks:12 
07:57:01.031 -> ticks:12 
07:57:01.160 -> ticks:12 
07:57:01.240 -> ticks:12 
07:57:01.349 -> ticks:12 
07:57:01.445 -> ticks:12 
07:57:01.520 -> ticks:12 
07:57:01.656 -> ticks:12 
07:57:01.736 -> ticks:13 
07:57:01.864 -> ticks:13 
07:57:01.960 -> ticks:13 
07:57:02.041 -> ticks:13 
07:57:02.149 -> ticks:13 
07:57:02.231 -> ticks:13 
07:57:02.349 -> ticks:13 
07:57:02.432 -> ticks:13 
07:57:02.547 -> ticks:13 
07:57:02.637 -> ticks:13 
07:57:02.725 -> ticks:13 
07:57:02.828 -> ticks:13 
07:57:02.935 -> ticks:13 
07:57:03.024 -> ticks:13 
07:57:03.121 -> ticks:13 
07:57:03.242 -> ticks:13 
07:57:03.344 -> ticks:13 
07:57:03.419 -> ticks:13 
07:57:03.540 -> ticks:13 
07:57:03.625 -> ticks:13 
07:57:03.718 -> ticks:13 
07:57:03.847 -> ticks:13 
07:57:03.922 -> ticks:13 
07:57:04.016 -> ticks:13 
07:57:04.128 -> ticks:13 
07:57:04.218 -> ticks:13 
07:57:04.356 -> ticks:14 
07:57:04.445 -> ticks:14 
07:57:04.527 -> ticks:14 
07:57:04.648 -> ticks:14 
07:57:04.723 -> ticks:14 
07:57:04.855 -> ticks:14 
07:57:04.936 -> ticks:14 
07:57:05.028 -> ticks:14 
07:57:05.118 -> ticks:14 
07:57:05.232 -> ticks:14 
07:57:05.349 -> ticks:14 
07:57:05.432 -> ticks:14 
07:57:05.520 -> ticks:14 
07:57:05.652 -> ticks:14 
07:57:05.740 -> ticks:14 
07:57:05.816 -> ticks:14 
07:57:05.946 -> ticks:14 
07:57:06.024 -> ticks:14 
07:57:06.151 -> ticks:14 
07:57:06.226 -> ticks:14 
07:57:06.348 -> ticks:14 
07:57:06.438 -> ticks:14 
07:57:06.524 -> ticks:14 
07:57:06.649 -> ticks:14 
07:57:06.737 -> ticks:14 
07:57:06.825 -> ticks:14 
07:57:06.926 -> ticks:14 
07:57:07.056 -> ticks:15 
07:57:07.149 -> ticks:15 
07:57:07.232 -> ticks:15 
07:57:07.355 -> ticks:15 
07:57:07.449 -> ticks:15 
07:57:07.539 -> ticks:15 
07:57:07.618 -> ticks:15 
07:57:07.739 -> ticks:15 
07:57:07.837 -> ticks:15 
07:57:07.924 -> ticks:15 
07:57:08.057 -> ticks:15 
07:57:08.145 -> ticks:15 
07:57:08.228 -> ticks:15 
07:57:08.345 -> ticks:15 
07:57:08.420 -> ticks:15 
07:57:08.545 -> ticks:15 
07:57:08.622 -> ticks:15 
07:57:08.747 -> ticks:15 
07:57:08.857 -> ticks:15 
 

 

[Mike118]

Désolé Mike, je te remercie, mais je ne comprends pas.

Ce n'est pas grave. Je ferai comme si j'avais compris.

 

Ha ça non alors ! =) 

Je vais reformuler. =) 

Quelle est la partie que tu ne comprends pas ? 

A  ) Dans le cadre de ton exemple le but du correcteur c'est de calculer la valeur de PWM qu'il faut envoyer à ton moteur pour qu'il tourne à la bonne vitesse.  +> Le résultat du PID c'est le calcul de la valeur du PWM à appliquer à ton moteur

B ) Dans le cadre d'un correcteur proportionnel ( un classique ) la formule indiqué dans les livres c'est PWM = KP * Erreur. 

C ) L'Erreur c'est la différence entre la Consigne ( la vitesse souhaitée ) et la Mesure ( La vitesse réelle mesurée ) : Erreur = Consigne - Mesure .


Je peux essayer de détailler et reformuler autant que besoin les 3 points A  B et C ), le quel n'est pas bien compris ? Si ces 3 points sont bien compris alors c'est moi qui n'ai pas compris ce que toi tu n'as pas compris =) et dans ce cas là je veux bien plus d'explications.
 

[Oracid]

Merci Mike.

 

Ce que je ne comprends pas, c'est ton  point B

La théorie dit que PWM = P = Kp * erreur

 

Alors que pour moi, cela devrait être PWM = consigne + P

[pat92fr]

Bonjour,

 

Quand on écrit "PWM = PID(erreur)", il faut bien comprendre que le but est de trouver (de manière simple et approximative) une valeur de PWM qui va permettre de réduire l'erreur entre la vitesse réelle et la vitesse de consigne.

 

On ne peut pas manipuler cette formule pour tenter de modéliser un système aussi complexe qu'une voiture. Ce n'est pas une relation mathématique qui modélisme la physique entre la vitesse réelle à la valeur de PWM moteur.

 

Ta formule n'est pas plus erronée que celle du PID de base. Elle se rapproche d'ailleurs de ce que je fais dans mes robots (PID + Feed-Forward) : "PWM = Kff * Consigne + PID(erreur)" avec un Kff=1.

 

De toute façon, toutes ces "techniques" (PID, PID+FF, PID², etc) sont relativement simplistes et approchées, et l'essentiel est de trouver une technique qui donne un bon résultat.

 

Donc, si tu implémentes "ta technique" et que ton résultat te semble optimal, alors c'est une bonne solution ! C'est juste qu'il faut garder à l'esprit quelle ne sera pas transposable à l'diénique dans un autre robot.... enfin pas plus qu'un PID au passage.

 

Patrick.

[Oracid]

Quand on écrit "PWM = PID(erreur)", il faut bien comprendre que le but est de trouver (de manière simple et approximative) une valeur de PWM qui va permettre de réduire l'erreur entre la vitesse réelle et la vitesse de consigne.

Donc si je comprends bien, on attribut un coefficient à l'erreur, mais également à la consigne, pour qu'au final le total soit approximativement égal à la somme de la consigne et de l'erreur.

 

Je ne trouve pas cela très logique.

Il n'y a aucune raison d'apporter une correction à la consigne. A mon avis, seul l'erreur devrait être corrigée.

 

Est que si on diminue le coefficient Kp et que l'on fait PWM = P = consigne + (Kp * erreur) , on pourrait s'approcher d'un meilleur résultat ?

Il est vrai que c'est ce que tu suggères dans ton avant dernière phrase.

[pat92fr]

Faut-il vraiment chercher une 'logique' dans un PID. C'est une technique d'asservissement de base, dont le réglage peut se faire de manière empirique. Ça convient parfaitement, pour nous roboticiens du dimanche ! :-)

Tu noteras que faire une somme de vitesses pondérées donne un % (PWM). En termes d'unités, la formule peut paraître curieuse aussi !

En pratique,on cherche les quelques coefficients PID pour obtenir un asservissement satisfaisant et on passe a la suite.

Patrick.

[Oracid]

Faut-il vraiment chercher une 'logique' dans un PID. 

Pour tout dire, je voulais comprendre.

Alors, j'ai acheté ce bouquin, https://www.elektor....uino-uno-e-book

Je l'ai feuilleté pour regarder les images. Il n'y en avait pas beaucoup . . . 

[pat92fr]

Je trouve que l'analogie du conducteur qui appuie sur les pédales pour maintenir sa vitesse était claire (cf. https://www.ufrjnaut...lizando-arduino).

 

Il n'y a pas de relation mathématique entre la vitesse en km/h et le degré de pression sur la pédale. Enfin, ce n'est pas le calcul que je fais au volant !

 

Sandro avait expliqué en faisant le lien avec le PID (https://www.robot-ma...board/?p=118295)

[Oracid]

Il n'y a pas vraiment de difficulté à faire une fonction PID.

Le problème, c'est de trouver les bons paramètres.

Je me demande si je ne vais pas utiliser 3 potentiomètres, c'était mon idée de départ.

Ainsi, je pourrai voir la dynamique de toute modification.

[pat92fr]

Oui, il faut trouver le moyen d'ajuster les paramètres sans avoir besoin de recompiler. Après, chacun sa technique. Les potentiomètres, c'est simple !