Code robot Makeblock

Bonjour,

J’utilise des robots de la marque Makeblock. Pour les coder, j’utilise donc Arduino (même si les cartes ne sont pas d’Arduino, d’ailleurs c’est l’équivalent des cartes Mega 2560 je crois)
Le but de ce robot est de sortir d’un labyrinthe. Le problème c’est que pour tourner, je rencontre des difficultés : j’actionne le moteur 1 à la vitesse x et le moteur 2 à la vitesse y (sachant que le 2 est à l’envers donc y est positif dans ce cas, de plus les vitesses ne sont pas égales à cause de la différence de vitesse des 2 moteurs) je met donc un délai (t). Je n’arrive pas à avoir la bonne précision en essayant de tatonner (où j’ai l’impression que c’est un peu le hasard : des fois c’est bien 90° des fois un peu plus/moins).

Y’a t-il donc un moyen de calculer ce délai précisément, ou une fonction qui permet de régler la “position” peut etre de sorte à ce qu’il tourne de 90° à gauche ou à droite. J’ai oublié de précisé que nous utilisons des chenilles pour le mode de déplacement et non des roues.

#include "MeMegaPi.h"

MeMegaPiDCMotor moteurG(PORT1B);

MeMegaPiDCMotor moteurD(PORT2B);

MeUltrasonicSensor USg(PORT_7);
MeUltrasonicSensor USa(PORT_8);
MeUltrasonicSensor USd(PORT_6);



void setup() {
moteurG.run(100);
moteurD.run(-80);
delay(500);
}

void loop() {
  // put your main code here, to run repeatedly:
int g = USg.distanceCm();
int a = USa.distanceCm();
int d = USd.distanceCm();


if (a > 12 && g < 15 && d < 15 or a > 12 && g > 15 && d < 15) //tout droit
 {
moteurG.run(100);
moteurD.run(-80);
 }
else if (a < 12 && d > 15 && g < 15 or a < 12 && d > 15 && g > 15) //droite
{
    moteurG.run(100);
    moteurD.run(-80);
    delay(1600);
    moteurG.stop();
    moteurD.stop();
    delay(1000);
    moteurG.run(100);
    moteurD.run(100);
    delay(2250);
    moteurG.stop();
    moteurD.stop();
    moteurG.run(100);
    moteurD.run(-80);
    delay(2000);
    moteurG.stop();
    moteurD.stop();
 }
 else if (a > 12 && d > 15 && g < 15 or a > 12 && d > 15 && g > 15) //droite
 {
    moteurG.run(100);
    moteurD.run(-80);
    delay(1600);
    moteurG.stop();
    moteurD.stop();
    delay(1000);
    moteurG.run(100);
    moteurD.run(100);
    delay(2250);
    moteurG.stop();
    moteurD.stop();
    moteurG.run(100);
    moteurD.run(-80);
    delay(2000);
    moteurG.stop();
    moteurD.stop();
 }
 
 else if (a < 12 && d < 15 && g > 15) //gauche
  {
    moteurG.run(100);
    moteurD.run(-80);
    delay(1000);
    moteurG.stop();
    moteurD.stop();
    delay(1000);
    moteurG.run(-100);
    moteurD.run(-100);
    delay(2000);
    moteurG.stop();
    moteurD.stop();
    moteurG.run(100);
    moteurD.run(-80);
    delay(2000);
    moteurG.stop();
    moteurD.stop();
 
 }
 else if (a < 12 && d < 15 && g < 15) //demi tour 
 {
    moteurG.stop();
    moteurD.stop();
    delay(1000);
    moteurG.run(-100);
    moteurD.run(-100);
    delay(3400);
    moteurG.stop();
    moteurD.stop();
    moteurG.run(100);
    moteurD.run(-80);
    delay(2000);
    moteurG.stop();
    moteurD.stop();
 }
 
 
}

Voila le code
Merci à tous :slight_smile:

J’ai pas regardé le code en détail mais ce que vous décrivez semble forcément approximatif. vous moteurs ne sont sans doute pas de super qualité et le déplacement effectif va dépendre de la puissance restante dans la batterie et de la rugosité du sol… donc si vous voulez être précis rajoutez une «boussole» (version électronique of course) sur votre robot de façon à mesurer plus précisément l’orientation

(En survolant le code cependant je trouve que ce if est assez aberrant…

if (a < 12 && d > 15 && g < 15 or a < 12 && d > 15 && g > 15)

Regardez bien vos conditions en gros vous voules dire (a < 12 && d > 15 && g != 15) non ?

Les conditions me semblent bien complexes êtes vous sûr d’avoir couverts tous les cas ? (Avez vous fait un tableau avec a d et g et les limites de chacune et regardé les ordres à donner ?

Bonjour,

Tout d’abord merci de votre réponse. Ceci est un projet que je réalise en TPE donc je ne pense pas que rajouter une boussole soit possible … Y’a t-il d’autre moyen ?
Ensuite en ce qui concerne la ligne :

if (a < 12 && d > 15 && g < 15 or a < 12 && d > 15 && g > 15)

Pour moi c’est si il y’a un mur devant et à gauche mais pas à droite OU si il y’a un mur devant mais pas à gauche et à droite ALORS il va à droite; donc selon moi non pas g = 15 mais bien g > 15 (il n’y a pas de mur à gauche). Après je débute seulement dans ce qui est codage donc vous avez surement raison ^^

Et enfin pour les conditions il y’a 8 cas possibles et j’ai bien 8 conditions.

Merci encore pour votre aide

if ([color=red]a < 12 && d > 15[/color] && [color=blue]g < 15[/color] or [color=red]a < 12 && d > 15[/color] && [color=blue]g > 15[/color])

les 2 parties en rouges étant identiques, si elles sont vérifiées alors c’est g < 15 ou g > 15 qui décide de la valeur de vérité. Si je ne suis ni strictement inférieur à 15 ni strictement supérieur à 15 alors c’est que je suis égal à 15, non ? :slight_smile:

Et enfin pour les conditions il y’a 8 cas possibles et j’ai bien 8 conditions.

OK oui j’ai pas regardé dans le détail. souvent c’est plus lisible de coder comme cela

si a < 12 alors
   si d < 15 alors
       si g < 15 alors  cas #1 sinon cas #2
  sinon
       si g < 15 alors  cas #3 sinon cas #4
sinon 
   si d < 15 alors
       si g < 15 alors  cas #5 sinon cas #6
  sinon
       si g < 15 alors  cas #7 sinon cas #8

sinon notez que dans votre approche vous excluez quand une des variable est pile égale à votre seuil de test.

Dans l’absolu on écrirait des fonctions avec un petit nom parlant qui retournent un booléen

si murDevant() alors
   si murADroite() alors
       si murAGauche() alors  cas #1 sinon cas #2
  sinon
       si murAGauche() alors  cas #3 sinon cas #4
sinon 
   si murADroite() alors
       si murAGauche()  alors  cas #5 sinon cas #6
  sinon
       si murAGauche() alors  cas #7 sinon cas #8

ainsi que des fonctions avance(), recule(), tourneDroite(), tourneGauche(), demiTour() éventuellement prenant en compte un timing.

si vous ne pouvez pas rajouter de boussole, c’est pas simple… faut peut être essayer de tourner moins vite, faire des tests pour vos moteurs

Je change un peu de sujet, car j'ai bien compris ce que vous m'avez expliqué et je vous en remercie.
J'aimerai par la suite utiliser le PID au sein de mon programme mais c'est totalement incompréhensible pour moi. Pouvez-vous m'expliquer comment faire, à quoi sert chaque fonction ... J'ai vu q'uil y'a une fonction PID automatique : le PID n'a donc pas besoin d'être calculé dans ce cas ?

Merci de votre réponse encore un fois

expliquer ce qu’est un Régulateur PID c’est un peu long et déjà bien fait ailleurs… Pour la librairie arduino, vous avez lu cela ?

Oui j'ai jeté un oeil mais je ne comprend pas tout clairement. Et je pense que c'est utile dans notre cas de l'utilisé car les vitesses des 2 moteurs ne sont clairement pas les mêmes bien qu'on les mette de sorte à ce qu'elles soient équilibrées

Un PID est un algorithme de calcul qui délivre un signal de commande à partir de la différence entre la consigne et la mesure.

Pour faire cette différence, il vous faut donc la mesure. --> comment mesurez vous la vitesse réelle de votre roue? il y a un capteur de vitesse intégré?

Non on a pas de capteur comme ca
Par contre on a plusieurs exemples qui utilisent le PID et qui montre la vitesse des moteurs mais pas en vitesse réelle juste en vitesse Arduino

Vitesse arduino c’est la consigne ... pour faire un PID il faut mesurer où on en est réellement par rapport à la consigne afin de la modifier

Donc par exemple on peut faire avancer le robot à une vitesse x pour le moteur 1 et une vitesse y pour le moteur 2 (qui est la même du coup ?) et donc on fait une ligne de 10m on mesure le temps qu'il fait et donc on trouve la vitesse réelle ?

Tout dépend de ce que vous voulez faire - s’il s’agit de faire tourner les roues à la même vitesse pour aller droit alors ça n’est pas l’approche. Si c’est pour afficher une vitesse en m/s oui pourquoi pas à condition que le robot se comporte toujours de la même façon

Il s'agit plutôt de faire tourner les roues à la même vitesse pour aller droit comment doit-on faire du coup ?

par exemple une fourche optique et une roue dentée sur l’axe du moteur ça permettrait de faire un PID (un autre exemple en anglais)

Si vous n’avez rien d’autre il faut calibrer au mieux les moteurs - laissez le robot allez droit sur 20 ou 30m de plat (un grand couloir au lycée ?) s’il dévie un peu d’un côté alors il faut compenser un peu en ralentissant la roue de ce côté - en essayant plusieurs fois de suite vous trouvez quels sont les 2 valeurs de vitesse à donner pour qu’il aille bien droit sur une assez grande distance

Rebonjour,

Nous avons trouvé toute nos valeurs pour le pid mais nous n'arrivons pas à faire tourner le robot comme il le faut etc ... tandis que quand on prend le programme juste pour le faire tourner il marche parfaitement et l'angle est de 90°.
Pouvez-vous nous aider ?
Merci

Expliquez comment fonctionne votre PID...postez du code.