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.
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.
Interests:Robotique, Entrepreneuriat, Innovation, Programmation, Résolution de problème, Recherche de solutions, Mécanique, Electronique, Créer, Concevoir
Posté 31 janvier 2023 - 01:09
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 ... )
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.
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.
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.
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.
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 ?
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 ... :-)
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 !
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;
}
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.
Aidez-nous à vous aider : partagez toutes les informations pertinentes : description précise du problème, contexte, schéma de câblage, liens vers la documentation des composants, votre code (ou encore mieux un code minimal reproduisant le bug), ...
Vous recevrez ainsi plus de réponses, et elles seront plus pertinentes.
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.
