411 réponses à ce sujet

[Oracid]

Tu veux dire la rotation de la roue arrière droite est inverssée par rapport à la roue avant droite (et même problème à gauche)?

Exactement !

 

Ce problème est lié au type de contrôleur que j'utilise. Même si je modifiais le raccordement, cela pourrait se reproduire.

En résumé, il y a une commande "Self Study" qui permet au contrôleur de trouver tout seul, la bonne combinaison de raccordement du moteur. Il va falloir que je fouille dans ce sens. 

C'est vraiment la misère. Je n'avais pas besoin de cela.

[Oracid]

J'ai tripatouillé la commande "Self Study". Résultat, j'ai inversé tous les moteurs, mais avec un peu d'acharnement, j'ai réussi à faire tourner tous les moteurs dans le même sens.

Cela veut dire que les moteurs droits tournent à l'inverse des moteurs gauches. C'est normal !

J'ai donc inversé la commande pour les moteurs droits et ça à l'air de tenir.

J'ai quand même perdu pas mal de temps avec ça, à visualiser un paquet de vidéos.

 

Bon, je vais donc reprendre mes tests, là où je les avais arrêtés.

[Mike118]

Quand tu as un moteur brushless 3 phases, sur le principe il te suffit d'inverser deux phases dans ton câblage pour inverser le sens de rotation. 
(Et si tu as des capteurs à effet hall il te faut aussi inverser les 2 capteurs hall correspondant aux deux phases ... )

[Oracid]

Quand tu as un moteur brushless 3 phases, sur le principe il te suffit d'inverser deux phases dans ton câblage pour inverser le sens de rotation. 
(Et si tu as des capteurs à effet hall il te faut aussi inverser les 2 capteurs hall correspondant aux deux phases ... )

Oui, je comprends bien.

 

En fait, la difficulté est de contrôler . . . . . les contrôleurs moteur e-Bike.

Ces petites bêtes sont "intelligentes", et leurs réactions ne sont pas toujours évidentes.

Pour moi, il est extrêmement important de maitriser la technologie e-Bike.

Je pense que c'est avec ce matériel que l'on pourra réaliser des gros robots roulants, à des prix raisonnables.

 

[pat92fr]

Bonsoir,

 

Réutiliser la carte de puisse des hoverboards pour construire un UGV à 4 ou 6 roues de 6.5 pouces (mode tank) vous semble une solution viable (vitesse, couple, odométrie) ?

J'ai 10 wagons de retard. Je viens de flasher la carte de puissance avec le firmware hoverboard hack FOC, et je peux contrôler les moteurs avec une Rpi avec le retour de vitesse des deux roues.

Patrick.

[Mike118]

Les cartes rouges sur tes moteurs c'est des cartes custom ? Ou bien c'est les cartes que tu avais de base sur ton overboard?

[pat92fr]

Les cartes rouges sur tes moteurs c'est des cartes custom ? Ou bien c'est les cartes que tu avais de base sur ton overboard?

 

Dans ce type d'hoverboard, il y a trois cartes en tout : une carte de puissance et deux cartes capteurs (gyro, bluetooth). Je ne sais réutiliser que le première. 

Elle dispose de deux connecteurs permettant de communiquer avec les cartes capteur droite et gauche et on peut configurer ces connecteurs en liaison série pour brancher une Arduino ou RPi par exemple.

 

-

 

Sinon, il existe un autre type d'hoverboard, dit Gen2, avec seulement deux cartes (split board). Le résultat est le même, à la différence est que le logiciel fonctionne en mode 6 phases et non en FOC.

 

J'ai fait une petite modification du firmware Gen2 pour pouvoir envoyer la valeur de PWM de chaque moteur via la liaison série (-1000..+1000). On récupère aussi la vitesse des roues via la liaison série (m/s). L'estimation de vitesse se fait sur une rotation de l'angle électrique complète. Je pense pouvoir modifier pour mesurer la vitesse sur une rotation de 60° (x6 plus précis). J'attends de voir comment la stack de navigation ROS se débrouille avec l'odométrie pour éventuelle faire la modification pour améliorer la préciison.

https://youtu.be/FrDwRiouCk4

 

A suivre.

[Oracid]

Bonsoir,

Réutiliser la carte de puisse des hoverboards pour construire un UGV à 4 ou 6 roues de 6.5 pouces (mode tank) vous semble une solution viable (vitesse, couple, odométrie) ?

J'ai 10 wagons de retard. Je viens de flasher la carte de puissance avec le firmware hoverboard hack FOC, et je peux contrôler les moteurs avec une Rpi avec le retour de vitesse des deux roues.

Patrick.

C'est la solution royale !

Le problème, c'est qu'il faut des compétences en STM32, et même plus, mais cela ne saurait te gêner.

 

Il y a quand même un inconvénient, c'est que cette carte est spécifique à l'Hoverboard. Ce n'est pas un contrôleur e-Bike.

Hors toute la technique des trottinettes, des Skateboards et des vélos électriques, est basée sur ces fameux contrôleurs e-Bike.

Si tu vas sur Ali et que tu cherches "contrôleur e-bike", ça tombe en pluie fine.

 

J'ai acheté 2 Hoverboards neufs, avec des nouvelles cartes qui sont beaucoup plus petites et qui sont à la place des cartes des capteurs de pression (les cartes dont tu parles, Mike) et de la même taille. Si cela t'intéresse, je peux t'en fournir une paire.

 

Bienvenue au club. 

[pat92fr]

J'ai acheté 2 Hoverboards neufs, avec des nouvelles cartes qui sont beaucoup plus petites et qui sont à la place des cartes des capteurs de pression (les cartes dont tu parles, Mike) et de la même taille. Si cela t'intéresse, je peux t'en fournir une paire.

 

Bienvenue au club. 

Merci.

 

Ca ressemble à ca tes cartes ? Ca m'interesse.

 

Le seul défaut, c'est l'absence de FOC dans le firmware disponible actuellement. Ajouter le FOC est un projet dans le projet. A voir, ca viendra peut être de la communauté un jour.

 

On habite en RP, tu n'es pas loin. Tu veux que je te dépanne pour programmer ton hoverboard ?

[Oracid]

Grillé !

Je pense que tu as le même type d'Hoverboard que moi, et que tu as déjà découpé. 

[pat92fr]

J'ai relu tous vos messages. La première étape est de monter les moteurs sur un châssis et de tester la commande de direction. Voir si ca tourne ! 

Je vous fais un retour rapidement et si ca fonctionne, on avise. On est plusieurs en RP à bidouiller ce type de cartes. On peut s'entraider pour la partie programmation/hack.

C'est 4 fils à raccorder et un logiciel de programmation STM32 à installer sur PC. Contre un café et une madeleine, je me déplace pour donner un coup de main, si besoin ... :-)

[Oracid]

Tu veux que je te dépanne pour programmer ton hoverboard ?

Pas encore ! 

 

Je suis en plein dedans et c'est un vrai défi pour moi d'aller au bout. 

Mais en cas de blocage, je sais qu'ici, j'aurais de l'aide. 

 

Je t'envoie ça ! (en MP pour la communication)

[Oracid]

Dans deux semaines, je pars au Mexique pour trois semaines, puis une semaine dans les Alpes.

Je vais peut-être pouvoir communiquer, mais pas bricoler dans ma cave.

C'est donc la course pour moi d'atteindre mon objectif, mais je ne désespère pas.

 

C'est super que cette techno intéresse de plus en plus de monde.

Perso, j'y crois beaucoup. Sur YouTube, il y a vraiment beaucoup de monde, de tous les niveaux, sur le sujet.

[pat92fr]

Ce design là me plait bien .... y compris le modèle à deux roues (diff).

 

[Oracid]

Ce design là me plait bien ....

Oui, je suis d'accord avec toi.

Cela fait partie des plus belles réalisations.

[pat92fr]

Comme les moteurs ne sont pas réductés, le couple au démarrage n'est pas énorme, même avec le firmware FOC.

Pour faire un robot qui peut tourner sur place avec 4 moteurs, mieux vaut le faire plus large que long...

Je pars sur un châssis avec seulement deux moteurs pour commencer, avec la carte hoverboard la plus répandue. Je vais essayer de coder le pilotage au gamepad, vite fait.

 

 

edit : Décalage des roues.

 

NB: Je viens de monter sur mon châssis et j'ai traversé le salon avec la radiocommande dans les mains ! Finalement, le couple et la vitesse sont plutôt bons !

[Oracid]

Voici la conférence fondatrice du mouvement de Hacking de la carte mère des Hoverboards, dans laquelle Niklas Fauth expose son travail.

Niklas Fauth est souvent considéré comme le gourou qui a permis à la communauté de mettre les gros UGV à la porté de tous.

Parfois, on compare ses études avec celles d'Emanuel Feru dont Patrick fait référence dans sa dernière vidéo.

 

 

 

 

[Oracid]

Voici un premier jet de mon programme.

 

Le robot est sur un support, les roues tournent librement. La consigne PWM est fixée à 122.

Pour l'instant, je ne m'intéresse qu'aux roues gauches.

A l'oscilloscope, une période du signal d'un capteur Hall s'étend sur environ 13 divisions de 10ms, soit 130ms, soit 1000/130 = 7.69Hz (environ 7 Hz à 8Hz).

 

Une fonction d'interruption (IRS) est déclenché sur front montant. La fréquence calculée par la fonction est d'environ du double de la consigne à 7Hz-8Hz.

C'est là que réside mon problème. Avant d'aller plus loin, j'aimerais bien le résoudre.

 

Le lien vers la fonction attachInterrupt() - Arduino Reference , à voir, les réserves sur l'utilisation de la fonctions micros() qui à priori ne me concernent pas.

 

Voici une image de la trace.

La fonction RC (Radio Commande) envoie une consigne de rotation à environ 8Hz aux roues gauche et droite ( L et R ).

La fonction ISR (interruption) récupère le TimesStamp des fronts montants d'un capteur Hall, alternativement aux temps A et B, et calcule la période et la fréquence.

Malheureusement, cette fréquence est d'environ du double de la consigne.

 RC brk Order Hz: L 8  R 8 ISR: A 11894988  B 11963588  Period 68600 Hall Hz: L 14  R 0
 RC brk Order Hz: L 8  R 8 ISR: A 12034464  B 11963588  Period 70876 Hall Hz: L 15  R 0
 RC brk Order Hz: L 8  R 8 ISR: A 12034464  B 12099320  Period 71588 Hall Hz: L 13  R 0
 RC brk Order Hz: L 8  R 8 ISR: A 12170908  B 12238840  Period 67932 Hall Hz: L 14  R 0
 RC brk Order Hz: L 8  R 8 ISR: A 12310620  B 12238840  Period 71780 Hall Hz: L 14  R 0
 RC brk Order Hz: L 8  R 8 ISR: A 12310620  B 12379224  Period 71312 Hall Hz: L 14  R 0
 RC brk Order Hz: L 8  R 8 ISR: A 12450536  B 12516784  Period 66248 Hall Hz: L 15  R 0
 RC brk Order Hz: L 8  R 8 ISR: A 12588052  B 12516784  Period 71268 Hall Hz: L 14  R 0
 RC brk Order Hz: L 8  R 8 ISR: A 12588052  B 12655780  Period 70580 Hall Hz: L 14  R 0
 RC brk Order Hz: L 8  R 8 ISR: A 12726360  B 12794600  Period 68240 Hall Hz: L 14  R 0
 RC brk Order Hz: L 8  R 8 ISR: A 12864268  B 12794600  Period 69668 Hall Hz: L 14  R 0
 RC brk Order Hz: L 8  R 8 ISR: A 12864268  B 12929116  Period 69624 Hall Hz: L 14  R 0
 RC brk Order Hz: L 8  R 8 ISR: A 12998740  B 13065144  Period 66404 Hall Hz: L 15  R 0
 RC brk Order Hz: L 8  R 8 ISR: A 13134512  B 13065144  Period 69368 Hall Hz: L 15  R 0

Le programme.

Spoiler

// BigRoverIRQ-V3 - 05/02/2023
void(* resetFunc) (void) = 0;                             // soft reset function
const int pb = A0;                                        // Start pgm button
const int PWM_OUT_L = 5, PWM_OUT_R = 6;                   // Pins PWM 976Hz Output
const int DIR_OUT_L = 10, DIR_OUT_R = 11;                 // Pins Direction Output
volatile int Hall_L_pin = 2, Hall_R_pin = 3;              // interrupt left and right 
volatile unsigned long Hall_Hz_L, Hall_Hz_R;              // Hall sensors frequency left and right
volatile unsigned long High, Low, Period, ISR_A, ISR_B;   // IRS function variables 
int SPEED = 122;                                          // speed state (PWM value) about 8Hz
int c1=0, c2=0;                                           // Radio Control channels
int Order_L=0, Order_R=0;                                 // left and right PWM orders
int Order_Hz_L, Order_Hz_R;                               // left and right Hz orders
 
void setup() {
  delay(500);                                                 // for reset consideration
  Serial.begin(9600);
  pinMode(pb,INPUT_PULLUP);                                   // Stop/Start button
  pinMode(A1,INPUT);  pinMode(A2,INPUT);                      // channels 1 and 2 receiver input
  pinMode(Hall_L_pin, INPUT);                                 // Hall sensor Left wheels
  pinMode(Hall_R_pin, INPUT);                                 // Hall sensor Right wheels
  pinMode(DIR_OUT_R, OUTPUT); digitalWrite(DIR_OUT_R, HIGH);  // Direction order forward or backward, right wheels
  pinMode(DIR_OUT_L, OUTPUT); digitalWrite(DIR_OUT_L, HIGH);  // Direction order forward or backward, left wheels
  pinMode(PWM_OUT_R, OUTPUT); analogWrite(PWM_OUT_R, 0);      // PWM order right wheels
  pinMode(PWM_OUT_L, OUTPUT); analogWrite(PWM_OUT_L, 0);      // PWM order right wheels
  attachInterrupt(digitalPinToInterrupt(Hall_L_pin), ISR_Hz_Hall_L, HIGH);    // Attach Interrupt for Hall sensor left wheel
  Serial.print("\n To start pgm, click on the Start button"); while(digitalRead(pb)); delay(400); Serial.print("\n Started"); delay(100);
}
 
void loop() {
  if (! digitalRead(pb)) { Serial.print("\n Operator Application Interrupt !!!"); delay(400); resetFunc(); }
  RC();
  DBG();
}
 
void RC() {   // Radio Control
  static int old_Order_L;
  c1  = pulseIn(A1,HIGH,30000);       // receiver channel 1 getting value turn Left and Right 
  c2  = pulseIn(A2,HIGH,30000);       // receiver channel 2 getting value Forward and Backward
 
  if (c1==0 || c2==0) { Serial.print("\n RC off !!!"); DBG(); delay(500); resetFunc(); } // if RC off then reset
  
  if (c2 >= 1600) Forward();
  if (c2 <  1400) Backward();
  if (c2 >= 1400 && c2 < 1600) Stop();
 
  if (Order_L == old_Order_L){ Serial.print("\n RC brk"); return;}    // if same order, return
  else {old_Order_L = Order_L; Serial.print("\n RC newVal #############################\n");}
  analogWrite(PWM_OUT_R,Order_R);       // write PWM value to output with LowPass Filter
  analogWrite(PWM_OUT_L,Order_L);       // write PWM value to output with LowPass Filter 
}
 
void Stop(){
  Order_L = 0;    Order_R = 0;
  Order_Hz_L = 0; Order_Hz_R = 0;
  digitalWrite(DIR_OUT_L, HIGH);
  digitalWrite(DIR_OUT_R, HIGH);  
}
 
void Forward(){
  Order_L = SPEED;    Order_R = Order_L;
  Order_Hz_L = map(Order_L,115,130,0,18); Order_Hz_R = Order_Hz_L;
  digitalWrite(DIR_OUT_L, HIGH);
  digitalWrite(DIR_OUT_R, HIGH);
}
 
void Backward(){
  Order_L = SPEED;    Order_R = Order_L;
  Order_Hz_L = map(Order_L,115,130,0,18); Order_Hz_R = Order_Hz_L;
  digitalWrite(DIR_OUT_L, LOW);
  digitalWrite(DIR_OUT_R, LOW);
}
 
void DBG(){
  Serial.print("\tOrder Hz: L ");Serial.print(Order_Hz_L); Serial.print("  R ");Serial.print(Order_Hz_R);
  Serial.print("\tISR: A ");Serial.print(ISR_A); Serial.print("  B ");Serial.print(ISR_B);Serial.print("  Period ");Serial.print(Period);
  Serial.print("\tHall Hz: L ");Serial.print(Hall_Hz_L); Serial.print("  R ");Serial.print(Hall_Hz_R);
}
 
void ISR_Hz_Hall_L(){     // Interrupt Service Routine
  static bool i=HIGH;
  if (i)  { ISR_A = micros(); Period = ISR_A - ISR_B;  Hall_Hz_L = 1000000 / Period; }
  else    { ISR_B = micros(); Period = ISR_B - ISR_A;  Hall_Hz_L = 1000000 / Period; }
  i = !i;
}

 

Merci d'avance pour vos remarques.

[Sandro]

Bonsoir,

pas sûr, mais une idée :

tu écris :

  attachInterrupt(digitalPinToInterrupt(Hall_L_pin), ISR_Hz_Hall_L, HIGH);    // Attach Interrupt for Hall sensor left wheel

hors, d'après la documentation de la fonction attachInterupt (cf lien que tu as donné), la valeur "HIGH" n'est utilisable que pour les arduinos Due, Zero et MKR1000 (il me semble que tu utilises une Arduino Nano).

Normalement, les interruptions se font sur front montant (RISING) ou desendant (FALLING). Essaye un de ces deux pour voir si ça résout le problème.

 

Sinon, tu peux aussi utiliser CHANGE, mais dans ce cas tu vas mesurer la demi-période au lieu de la période (ça peut être utile pour augmenter ta fréquence de lecture de ta vitesse). Dans ce cas, la période, c'est 2 fois la différence.

 

 

Sinon, vu que tu demandais des remarques : dans la routine ISR, est-ce que ça sert à quelque chose d'utiliser la variable i, plutôt que de juste stocker la valeur précédente. Que dirais tu de :

void ISR_Hz_Hall_L(){     // Interrupt Service Routine
  static long int prev_tick=micros();
  long int new_tick = micros();
  Period = new_tick - prev_tick;
  Hall_Hz_L = 1000000 / Period;
  prev_tick=new_tick ;
}

Du coup, ça t'évite les variables globales ISR_A et ISR_B : au lieu de 2 varialbes globales + 1 static, tu as maintenant 1 variable local + 1 static. Et je trouve ça plus lisible.

[Oracid]

Bravo Sandro ! ! !

T'es le meilleur ! ! ! 

 

 RC brk Order Hz: L 8  R 8 ISR: A 10066536  B 10204360  Period 137824 Hall Hz: L 7  R 0
 RC brk Order Hz: L 8  R 8 ISR: A 10066536  B 10204360  Period 137824 Hall Hz: L 7  R 0
 RC brk Order Hz: L 8  R 8 ISR: A 10342692  B 10204360  Period 138332 Hall Hz: L 7  R 0
 RC brk Order Hz: L 8  R 8 ISR: A 10342692  B 10478236  Period 135544 Hall Hz: L 7  R 0
 RC brk Order Hz: L 8  R 8 ISR: A 10342692  B 10478236  Period 135544 Hall Hz: L 7  R 0
 RC brk Order Hz: L 8  R 8 ISR: A 10617632  B 10478236  Period 139396 Hall Hz: L 7  R 0
 RC brk Order Hz: L 8  R 8 ISR: A 10617632  B 10758108  Period 140476 Hall Hz: L 7  R 0
 RC brk Order Hz: L 8  R 8 ISR: A 10617632  B 10758108  Period 140476 Hall Hz: L 7  R 0

 
Demain, je vais étudier ton code d'interruption.
Pour ce soir, je voulais te donner le résultat du RISING.

 

Merci encore