411 réponses à ce sujet

[Oracid]

Me revoilà, après une longue absence.

Je découvre vos réalisations.

Magnifique !

 

Heureusement qu'il y en a qui bossent pour me payer ma retraite, au soleil. 

[dakota99]

C'est super de pouvoir utiliser l'hoverboard tel quel avec carte et batterie. Je vais m'intéresser au firmware hoverboard hack FOC.

Ca va sûrement intéresser Oracid.

 

Et ton bras manipulateur tu vas l'interfacer comment avec le NUC ?

[Oracid]

Ca va sûrement intéresser Oracid.

Pas vraiment !

Je continue à penser que la solution, contrôleur d'e-Bike, a plus d'avenir que la carte mère, spécifique aux Hoverboard.

Mais cela ne m'empêche pas d'apprécier le bel ouvrage de Patrick, et du tien, également.

[pat92fr]

Oracid réalise son 4x4 avec des contrôleurs e-Bike plus puissants. Je cherche à voir si la carte de puissance Hoverboard peut atteindre le niveau de puissance qu'il vise, et ce n'est pas sûr encore... à suivre !

 

Pour le bras, je démarre de "zéro" ou presque. Pour l'instant, ma principale contrainte est que l'installation du bras sur le robot soit la plus simple possible. Cela se traduit par :

- un demie douzaine de boulons pour la fixation du bras sur le toit du robot,

- un seul connecteur 4 broches "alimentation + liaison série" pour le raccordement électrique.

 

La batterie hoverboard va alimenter le bras (carte de contrôle, drivers pas à pas, moteurs et capteurs).

 

Exact, le NUC pilote la liaison série à destination de la carte de contrôle au bras, via un adaptateur USB/Serie. La carte de contrôle sera surement un Arduino ou équivalent, avec assez de GPIO pour piloter ENA/PULSE/DIR des 6 axes.

 

Le premier axe est un plateau tournant, qui sera donc fixé au toit du robot. Je veux que tous les moteurs soient dans le bras, ainsi que les drivers et la carte de contrôle. Je ne veux pas d' "armoire électrique" à coté ou sous le bras... challenge !

 

Me connaissant, le truc va peser 10kg au moins... et je ne saurais plus où le ranger chez moi. L'essentiel, c'est la réalisation !

 

Patrick.

[dakota99]

Ok l'intérêt des contrôleurs e-bike est donc la puissance...

Pour ma part je continue mon robot de nettoyage avec des moteurs DC car avec les moteurs d'hoverboard je n'arrive pas à stabiliser les trajectoires quand le terrain est en pente....

Mais le problème se pose quand même avec les moteurs DC : quand le robot est bien chargé avec un pulvérisateur plein et qu'il doit faire un demi-tour dans une pente, c'est pas évident. Il est quand même entraîné par son poids. Donc même dans ce cas il faut pouvoir maîtriser l'asservissement en vitesse. Ce qui n'est pas encore évident pour moi.

(J'utilise un smartphone Android et un Arduino Mega)

.

Le but du bras est de manipuler une charge de quel poids ?

[pat92fr]

Le but du bras est de manipuler une charge de quel poids ?

 

Un ordre de grandeur 150 à 500g ! Je vais faire un thread dans la bonne catégorie... Voir : https://www.robot-ma...ase-hoverboard/

[Oracid]

Pour ma part je continue mon robot de nettoyage avec des moteurs DC car avec les moteurs d'hoverboard je n'arrive pas à stabiliser les trajectoires quand le terrain est en pente....

Ah, oui, désolé ! J'avais oublié que tu étais revenu au moteur DC. L'important pour toi, il me semble, c'est que tu réussisses à maitriser le parcours. Le reste n'est que détails.

 

Oui, les contrôleurs e-bike sont sans doute plus puissants. Il n'est qu'à voir comment un vélo à assistance électrique monte les pentes.

Il y a une belle pente, à coté de chez moi. Régulièrement, je vois un gars monter cette pente avec un mono roue. C'est très impressionnant !

[Oracid]

J'ai mis en œuvre le filtre RC proposé par Sandro, https://www.robot-maker.com/forum/topic/13733-ugv-a-base-delements-de-trottinette-ou-dhoverboard/?p=117746  avec R=470ohm et C=100uF

Je ne l'ai pas mis en œuvre sur le robot lui-même, mais sur ma base de test, ceci afin de tester plus facilement le PID, ultérieurement.

 

Le filtre est parfait, même avec la charge sont amplitude va de 0V à 4.75V, avec une ondulation triangulaire d'environ 0.5V.

Le moteur démarre à environ 1V, mais bizarrement, il décroche à environ 3.5V (tension, en bas de l'ondulation).

Il ne reste plus qu'à mettre en œuvre le PID. 

 

Voici le code, ultra simple.

Spoiler

// Test-PotControl-V1 is based on HBM-LPF- HoverBoard LowPass Filter and Potentiometer Control with e-bike controller - 03/04/2023
void(* resetFunc) (void) = 0;         // soft reset function
int pb = A0;                          // Start pgm button
int PWM_PIN_OUT = 5;                  // 976Hz PWM Output
int POT_PIN_IN = A7;                  // Analog potentiomer input
int DIR_PIN_BT = A2;                  // Direction button 
int DIR_PIN_OUT = 10;                 // Direction Output
 
void setup() {
  Serial.begin(9600);
  pinMode(pb,INPUT_PULLUP);           // Start pgm button
  pinMode(DIR_PIN_BT,INPUT_PULLUP);   // Direction button
  pinMode(DIR_PIN_OUT, OUTPUT);       // Direction Output
  pinMode(PWM_PIN_OUT, OUTPUT);       // 976Hz PWM Output
  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 Operator Application Interrupt !!!"); delay(400); resetFunc(); }
 
  int potValue = analogRead(POT_PIN_IN);                // read the potentiometer value
  int PWM = map(potValue,0,1023,0,255);                 // convert potentiometer value to PWM value
  analogWrite(PWM_PIN_OUT, PWM);                        // write PWM value to output with LowPass Filter
  digitalWrite(DIR_PIN_OUT, digitalRead(DIR_PIN_BT));   // change direction when button enabled
}

[Oracid]

Sandro.

 

Dans la fonction ISR_Hz_Hall_L() que tu m'as proposée ici, https://www.robot-ma...board/?p=117884 j

je pense que la première ligne :  static long int prev_tick=micros();   devrait être:   static long int prev_tick;

 

Qu'en penses tu ?

[Sandro]

Ce que tu mets après le égal, c'est la valeur avec laquelle prev_tick est initialisée au premier appel de la fonction. Si tu ne mets rien, alors c'est initializé à 0.

 

Si tu initialises à 0, tu vas obtenir une grande période à la première exécution. Si tu initialise à micros(), tu vas obtenir une toute petite période. Dans les deux cas, la première valeur que tu obtiendras sera non représentative.

 

Et dans les deux cas, il y a un danger de division par zéro qui peut te faire planter le programme :

- dans le cas de micros, si le programme est assez rapide pour que la valeur de micros n'ait pas changée (ce qui risque d'arriver, surtout que de mémoie la valeur de micros change par bonds de quelques (4?) microseccondes)

- dans le cas de zéro, si le premier appel a lieu un multiple de 2^32 microsecondes (ie un peu plus d'une heure) après le démarrage de l'arduino.

 

Du coup, je te propose de mettre micros()-N : de cette manière, tu ne risques pas la division par zéro. Avec N=1 si tu veux que la première fois tu mesures une période très courte, ou N grand (par exemple 600000000L (ie 10 minutes)) si tu veux mesurer une très longue période la première fois

[Mike118]

Oui micros() fait des bons de 4 microsecondes 

[Oracid]

prev_tick est initialisée au premier appel de la fonction. 

C'est pas mal le C, quand même !

Merci.

[Oracid]

Je suis encore en train de tester un moteur sur mon banc de tests.

 

Voici le résultat que j'obtiens.

 loop:  Throttle: 110  ISR: prev_tick 150976416 µs   new_tick 151009928 µs   Period: 33512 µs   HallSpeed Hz: 29.91
 loop:  Throttle: 110  ISR: prev_tick 151110376 µs   new_tick 151110376 µs   Period: 33476 µs   HallSpeed Hz: 29.80
 loop:  Throttle: 110  ISR: prev_tick 151210972 µs   new_tick 151244312 µs   Period: 33340 µs   HallSpeed Hz: 29.80
 loop:  Throttle: 110  ISR: prev_tick 151344952 µs   new_tick 151378684 µs   Period: 33344 µs   HallSpeed Hz: 29.99
 loop:  Throttle: 110  ISR: prev_tick 151478980 µs   new_tick 151478980 µs   Period: 33496 µs   HallSpeed Hz: 29.90
 loop:  Throttle: 110  ISR: prev_tick 151579492 µs   new_tick 151612940 µs   Period: 33464 µs   HallSpeed Hz: 29.83
 loop:  Throttle: 110  ISR: prev_tick 151713472 µs   new_tick 151746816 µs   Period: 33256 µs   HallSpeed Hz: 30.07
 

 

Il ne faut tenir compte que de Period et de HallSpeed. Le reste est souvent erroné, en raison de la vitesse des interruptions et des print qui ne sont pas en phases.

 

Si on considère la dernière ligne avec une période de 33256 µs, on a bien 1 000 000 / 33256 = 30,07Hz

Sur l'oscilloscope, avec un carreau à 5ms, j'ai bien une période de 6,5 carreaux, soit 6,5 x 5 = 32,5Hz

Jusqu'à là, c'est cohérent !

 

Le problème, c'est qu'avec deux tachymètres différents, braqués sur la roue, j'obtiens environ 120 RPM. Soit 2Hz !

 

Je ne comprends pas cette différence entre 30Hz et 2Hz !

J'ai compté le nombre de tours avec le minuteur de mon smartphone, il y a bien 120 tours par minute.

 

 

[Sandro]

Je penses que c'est normal.

Dans le message https://www.robot-ma...788#entry117788 j'avais compté 15 périodes par tour.

 

Donc si tu veux le nombre de tours, et pas de 1/15 de tours, il faut divisier par 15 (soit dans l'ISR si tu veux avoir directement la période et fréquence par tour et en Hz), soit ensuite dans ton code

[Oracid]

Super ! Merci Sandro.

 

J'en étais arrivé à la conclusion que je ne mesurais pas la même chose, et effectivement j'avais relevé ce rapport de 15, mais je n'avais fait le lien avec ton lien que j'avais déjà trouvé génial.

Du coup, j'ai une plus grande précision. Je me souviens que tu étais favorable à une plus grande précision.

Sur mon robot, ce ne sont pas les mêmes moteurs, mais avec mes vidéos, tu avais déjà constaté qu'il y avait 15 impulsions par tours.

 

Bon, et bien voilà un problème résolu. Je vais donc me mettre au codage du PID. 

 

Merci encore, Sandro.

[Oracid]

Voici la version de mon programme avec PID.

Cela ne fonctionne pas, mais alors, pas du tout.

J'ai mis toutes les variables en Global pour pouvoir les utiliser dans la fonction Trace().

 

A mon avis, c'est la ligne suivante, dan la fonction P_I_D()  qui pose problème :

  pid_Speed = map((unsigned int)pid_Speed,0,max_Hz,0,max_PWM);                                        // convert pid_Speed from Hz to PWM

 

Le programme :

Spoiler

// Test-P_I_D-V2 - 10/04/2023
void(* resetFunc) (void) = 0;                                             // soft reset function
 
int pb = A0;                                                              // Start pgm button
int PWM_PIN_OUT = 5;                                                      // 976Hz PWM Output
int POT_PIN_IN = A7;                                                      // Analog potentiomer input
int DIR_PIN_BT = A2;                                                      // Direction button 
int DIR_PIN_OUT = 10;                                                     // Direction Output
int HALL_PIN = 2;                                                         // interrupt feedback pin 
 
volatile unsigned long prev_tick = micros()-1;                            // Interrupt variables
volatile unsigned long new_tick;                                          // Interrupt variables
volatile float HallSpeed;                                                 // Hall feedback speed, rotation wheel frequency
volatile float prev_HallSpeed;                                            // 
volatile unsigned long Period;                                            // period of rotation frequency 
 
unsigned int Throttle=0, pid_Speed=0, max_Hz = 50, max_PWM = 110;
 
float Kp = 0.2, Ki = 0.000, Kd = 0.00, pid, p=0, i=0, d=0;                // PID constants and variables
int err=0, lastErr=0;                                                     // PID variables
 
void setup() {
  Serial.begin(9600);
  pinMode(pb,INPUT_PULLUP);                                               // Start pgm button
  pinMode(DIR_PIN_BT,INPUT_PULLUP);                                       // Direction button
  pinMode(DIR_PIN_OUT, OUTPUT);                                           // Direction Output
  pinMode(PWM_PIN_OUT, OUTPUT);                                           // 976Hz PWM Output
  attachInterrupt(digitalPinToInterrupt(HALL_PIN), ISR_Hall, RISING);     // Attach Interrupt for Hall sensor wheel
  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(PWM_PIN_OUT,0); resetFunc(); }
 
  Throttle = map(analogRead(POT_PIN_IN),0,1023,0,max_PWM);                // the Throttle is determined by the potentiometer
  if ( new_tick == prev_tick) { Period = 0; HallSpeed = 0; }              // stop the wheel if no order
  if (Throttle < pid_Speed){                                              // if Throttle < pid_Speed, Throttle take the hand
    analogWrite(PWM_PIN_OUT, pid_Speed);                                  // the pid_Speed is determined by the P_I_D()
  }
  else {
    analogWrite(PWM_PIN_OUT, Throttle);                                   // Throttle is determined by the potentiometer
  }
  digitalWrite(DIR_PIN_OUT, digitalRead(DIR_PIN_BT));                     // change direction of the wheel when button enabled
  P_I_D();
  Trace();
}
 
void P_I_D(){  
  err=prev_HallSpeed-HallSpeed;                                                                       // getting err
  p=Kp*err;  i=Ki*(i+err);  d=Kd*(err-lastErr);  pid=p+i+d;  lastErr=err;  pid_Speed=HallSpeed+pid;   // calculation of the PID
  pid_Speed = map((unsigned int)pid_Speed,0,max_Hz,0,max_PWM);                                        // convert pid_Speed from Hz to PWM
}
 
void ISR_Hall(){     //  Sandro Interrupt Service Routine
  prev_HallSpeed = HallSpeed;
  new_tick = micros();                                                    // feedback of the Hall sensor
  Period = new_tick - prev_tick;                                          // time between 2 feedbacks
  HallSpeed = 1000000.0 / Period;                                         // HallSpeed, rotation wheel frequency 
  prev_tick = new_tick ;                                                  // previous feedback of the Hall sensor
}
 
void Trace(){
  Serial.print("\n loop: "); Serial.print(" Throttle: ");Serial.print(Throttle);
  Serial.print("\t ISR:");
  Serial.print(" prev_tick "); Serial.print(prev_tick); Serial.print(" µs   new_tick "); Serial.print(new_tick);
  Serial.print(" µs   Period: ");Serial.print(Period); Serial.print(" µs   HallSpeed Hz: ");Serial.print(HallSpeed);
  Serial.print("\t P_I_D:"); Serial.print("   pid_Speed: ");Serial.print(pid_Speed);Serial.print("  pid: ");Serial.print(pid);
}
 

 

Voici un morceau de la trace:

 

 loop:  Throttle: 110  ISR: prev_tick 50323180 µs   new_tick 50323180 µs   Period: 32940 µs   HallSpeed Hz: 30.46  P_I_D:   pid_Speed: 13  pid: 6.00
 loop:  Throttle: 110  ISR: prev_tick 50487552 µs   new_tick 50487552 µs   Period: 32648 µs   HallSpeed Hz: 30.64  P_I_D:   pid_Speed: 13  pid: 6.00
 loop:  Throttle: 110  ISR: prev_tick 50618680 µs   new_tick 50651680 µs   Period: 32696 µs   HallSpeed Hz: 30.54  P_I_D:   pid_Speed: 13  pid: 6.00
 loop:  Throttle: 110  ISR: prev_tick 50782612 µs   new_tick 50815372 µs   Period: 32908 µs   HallSpeed Hz: 30.39  P_I_D:   pid_Speed: 13  pid: 6.00
 loop:  Throttle: 110  ISR: prev_tick 50946856 µs   new_tick 50979744 µs   Period: 32888 µs   HallSpeed Hz: 30.61  P_I_D:   pid_Speed: 13  pid: 6.00
 loop:  Throttle: 110  ISR: prev_tick 51110928 µs   new_tick 51143912 µs   Period: 32984 µs   HallSpeed Hz: 20833.33  P_I_D:   pid_Speed: 13  pid: 6.00
 loop:  Throttle: 110  ISR: prev_tick 51274872 µs   new_tick 51274872 µs   Period: 32728 µs   HallSpeed Hz: 30.35  P_I_D:   pid_Speed: 13  pid: 6.00
Operator Interrupt !!!
To start pgm, click on the Start button

 

[bubu17]

depuis mon dernier message j'ai mis les moteurs d'un hoverboard de 10 pouces, la tondeuse passe mieux les difficultés du terrain.

j'ai aussi modifier le code pour lire la vitesse, je suis parti du code de madd ee et j'ai rajouter le pid.

en piéce-joint le code que j'utilise pour faire des essais avec un moteur fixer sur une table:

 

le pid réagit bien à l'effort, quant je freine la roue avec les mains,

 

à partir d'un certain effort le moteur décroche, à ce moment la lecture de la vitesse est erronée donc le moteur ralenti ou ce bloque!!!!

 

par contre quant j'entraine le moteur plus vite que la consigne , le moteur saccade et ne respecte pas la consigne.

Fichier(s) joint(s)

•  hoverboard_lecture_vitesse_et_test_pid.ino   5,88 Ko   28 téléchargement(s)

[bubu17]

voici une copie du serial pour un essai rapide, le serial n'enregistre pas toute les lectures ,ce qui entraine les variations brutale d'une ligne sur l'autre.

 

sur les 2 premiéres lignes la vitesse est erroné, pwm = 0

 

lignes 3 à 6 sans effort , pwm = 11 à 13   pour une vitesse de 1,2 km/h

 

lignes 7à 16 je freine progressivement la roue, le pwm monte à 45

 

ligne 17 le moteur décroche

 

lignes 18 à 28 je fais tourner la roue plus vite que la consigne, pwm = 0, le moteur saccade

 

ligne 29 je relâche l'entrainement

 

lignes 30 à 32 le moteur revient à la vitesse de consigne

Fichier(s) joint(s)

•  essai moteur hoverboard1.pdf   127,13 Ko   43 téléchargement(s)

[Sandro]

Bonsoir,

je penses que ton erreur vient de la ligne suivante (dans la fonction PID) :

  err=prev_HallSpeed-HallSpeed;                                                                       // getting err

Si on prends cette ligne, l'erreur est nulle lorsque la vitesse est constante (peu importe la vitesse).

 

La formule normale pour un PID est

  err=target_HallSpeed-HallSpeed;                                                                       // getting err

donc l'erreur est nulle lorsque tu vas à la vitesse voulue (target_HallSpeed)

 

 

 

La ligne suivante me semble aussi erronée :

  p=Kp*err;  i=Ki*(i+err);  d=Kd*(err-lastErr);  pid=p+i+d;  lastErr=err;  pid_Speed=HallSpeed+pid;   // calculation of the PID

Pour l'intégrale, la formule est :

i = i + (Ki * err);

Et la vitesse, c'est directement la valeur du PID :

 pid_Speed=pid;

(ou tu peux juste utiliser une seule variable
 

 

 

 

[Oracid]

Pour l'intégrale, la formule est :

i = i + (Ki * err);

Aïe ! Cela veut dire que le programme de ce robot n'est pas bon. https://www.robot-ma...ylens/?p=115607

 

Je vais tester tes corrections dans la foulée.

Merci Sandro.