342 réponses à ce sujet

[Telson]

ça va venir t'inquiète tu t'approches doucement du casses tête..........Désolé pour ton post.

 

Olivier nous continuerons cette conversation sur Glenn ou HumaOne....

[Amhnemus]

Vous pouvez la continuer ici y'a pas de problème. Et j'espère ne jamais à avoir me casser la tête comme sa.

Pour le moment j'ai enfin réussi à faire millis() avec deux servos mais je dois avoir un soucis avec mes conditions ou mes variables pour faire revenir mon servo 1 à la position original. Mais bon on va creuser encore et mettre tout sa a plat.

[Path]

Fais passer ton code. Je te promets pas de conclusion mais de regarder.

[Amhnemus]

Je vais pas pouvoir te le passé la je suis parti bossé mais en réfléchissant en voiture j'ai sûrement trouver la solution pour faire faire des aller retour au servo. Là je pense que ça sera plus à travailler les conditions sinon effectivement y'a tout qui fait tout au même moment donc mon servo doit aller de 1en 1 de 0 à 90 degrés puis je le faire revenir vers 0 degrés de 1 en 1 mais arrivé à 89 il doit retourner à 90 immédiatement donc avec un booléen le tour est joué enfin je pense

[Oliver17]

@ Telson : pas de soucis, mais là déjà, cela peut donner des pistes à Amhnemus pour plus tard.

 

@ Amhnemus : ooooohhhhhh que si tu vas bien te prendre la tête par moment, es tu n'a pas fini, en même temps, si tout était simple il n'y aurait aucune satisfaction personnel à réaliser un robot après un dur travail effectué dessus

[Amhnemus]

@ Oliver17 ouais ça pourra me servir pour plus tard effectivement. Et oui la satisfaction personnelle d'y arriver elle est bonne quand elle est là.

[Amhnemus]

Salut les makers et bien on avance dans les erreurs de code mais on avance quand même mdr. Je commence à comprendre tout ce vous disiez sur la prise de tête et le reste surtout Path quand il me disait que c'était pas simple à faire. Mais comme on dit c'est en faisant des erreurs qu'on apprend. Il me reste encore des hypothèses à essayer pour que mon servo fasse des aller retour avec millis. Pourquoi avec delay() on pas faire la même chose qu'avec millis, ça serait plus simple ?

Parce que millis() existe sinon ça s'appellerait delay()...

Saloperie de programmeur...

[Path]

il faut y aller étape par étape. Si tu es confortable avec delay, utilise le. Tu feras autrement avec une futur version ou avec un futur robot. Il est important de pas rester bloqué.

[Amhnemus]

@Path avec delay() y'a pas de soucis et heureusement sinon on fait pas grand chose avec l'arduino. Mais faut absolument que je maîtrise millis () avec mes servo pour la suite de mon projet parce que j'aimerais dans un premier temps mettre un capteur de distance et qu'il faut qu'il vérifie la distance avec des obstacles à tout moment pour moi c'est le ba.ba d'un robot autonome. Donc pour le moment ça me bloque pour continuer c'est sûr mais je dois absolument réussir avant de commencer un nouveau projet de bipède plus performant et mieux penser. Mon plus gros point faible c'est la programmation et qui prend aussi le plus de temps... parce que le reste surtout la mécanique et les systèmes d'assemblages y'a pas de soucis

La réponse à toute mes attentes n'est pas loin mais elle est n'est pas simple.

[arobasseb]

Je te propose mon point de vue (que j'ai pu voir dans l'étude de developement de jeu vidéo), je n'ai pas encore essayé par moi-même, mais je vais essayer ce weekend.

 

Donc ma théorie : 

 

Vu que millis correspond au temps écoulé, et ton programme est une boucle sans fin.

 

Dans ta boucle tout ce qui dépend du temps doit être une formule qui représente un ratio entre le point de départ le point d'arrivée et le temps que tu veux que dure l'action avec le temps déjà écoulé. Cela te permet de garantir que ton action sera terminé à temps même si tu rajoute de nouvelles instructions dans la boucle. (Dans la limite bien qu'il y ai pas un traitement plus long que le temps voulu d'un action (je ne sais pas si c'est très clair )) D'un point de vue extérieur les mouvements devraient être fluide, même si par exemple d'un tour à l’autre de la boucle la delta est légèrement différent. 

 

Voilà, si quelqu'un veux rectifier, confirmer, détruire, ... ce que je viens de dire pas de soucis  

[maximusk]

Sinon au lieu d'utiliser millis, et de faire une boucle infinie pour compter le temps, tu devrais te pencher sur la librairie simpleTimer, c'est fait exprès pour ça.

Tu peux appeller une fonction au bout de x millisecondes, ou toutes les y millisecondes, et le mieux, c'est que ça utilise les interruptions timer, donc ton programme est pas planté a attendre un temps et peut faire autre chose en même temps.

[Telson]

L'utilisation du Timer est une très bonne solution...Il me semble que j'avais abordé le sujet dans ce topic :: http://www.robot-maker.com/forum/topic/10815-defis-comment-commander-la-vitesse-dun-servomoteur-avec-arduino/?p=75055

 

https://learn.adafru...o-part-2/timers

[arobasseb]

 

Je te propose mon point de vue (que j'ai pu voir dans l'étude de developement de jeu vidéo), je n'ai pas encore essayé par moi-même, mais je vais essayer ce weekend.

 

Donc ma théorie : 

 

Vu que millis correspond au temps écoulé, et ton programme est une boucle sans fin.

 

Dans ta boucle tout ce qui dépend du temps doit être une formule qui représente un ratio entre le point de départ le point d'arrivée et le temps que tu veux que dure l'action avec le temps déjà écoulé. Cela te permet de garantir que ton action sera terminé à temps même si tu rajoute de nouvelles instructions dans la boucle. (Dans la limite bien qu'il y ai pas un traitement plus long que le temps voulu d'un action (je ne sais pas si c'est très clair )) D'un point de vue extérieur les mouvements devraient être fluide, même si par exemple d'un tour à l’autre de la boucle la delta est légèrement différent. 

 

Voilà, si quelqu'un veux rectifier, confirmer, détruire, ... ce que je viens de dire pas de soucis

 

 

voici l'exemple de code qui illustre que je disais, après il vaut ce qu'il vaut.

 

Pour le faire fonctionner, avec la console arduino il faut entrer une des commande suivante : 

 

stop : detache les servos

start : attache les servos

zero : met les 2 servos en position zéro (à faire avant de lancer chaque commande de mouvement (je n'ai pas gérer le mouvement retour))

180 : met les 2 servos en position 180

avant1 : cas exemple où les deux servos parcours deux angles différents sur le même laps de temps

avant2 : cas exemple , comme avant1 mais sur une période plus courte

avant3 : cas exemple où les deux servos parcours le même angle mais avant un temps différent

delais : simule un traitement bloquant. 

 

 

Ceci fonctionne dans la limite de la vitesse des servos.

 

En espérant que ça réponde aussi à la demande lol.

 

Le code : (j'aurai pu le simplifier mais là je trouve que pour la lecture c'est plus facile pour d'éventuels novices)

#include <Servo.h>

//Constantes qui définissent le numéro des broches des servomoteurs
#define MONSERVO1 9
#define MONSERVO2 10

//les variable qui correspondent aux servomoteurs
Servo monServomoteur;
Servo monServomoteur2;

//Constantes d'information d'angle et de temps pour les deux servomoteurs.
//Pourrai être un tableau à deux dimensions s'il y a plus de servomoteurs.
int angle;
int angleCourrant;
int temps;
int angle2;
int angleCourrant2;
int temps2;

long tempsPrecedent = 0;

/*
 * Enumeration des différents état du système
 */
enum Etat : byte
{
  Arret,
  Pause,
  MiseAZero,
  MiseA180,
  Marche,
  Avant
};

//Initialise l'état courant
Etat etatCourant = Arret;

/*
 * indique l'état dans lequel est le système
 * en fonction de ce qui est envoyé dans la console
 */ 
void ObtenirEtat();


void setup() {
  Serial.begin(9600); 
}

void loop() {

  ObtenirEtat();
 
  switch (etatCourant)
  {
    case Arret:
      monServomoteur.detach();
      monServomoteur2.detach();
      break;
    case Marche:
      if (!monServomoteur.attached())
      {
        monServomoteur.attach(MONSERVO1);
      }
      if (!monServomoteur2.attached())
      {
        monServomoteur2.attach(MONSERVO2);
      }
      break;
    case MiseAZero:
      monServomoteur.write(0);
      monServomoteur2.write(0);
      break;
    case MiseA180:
      monServomoteur.write(180);
      monServomoteur2.write(180);
      break;
    case Avant:
      angleCourrant = (millis()- tempsPrecedent)*angle/temps;
      if(angleCourrant >= angle) 
      {
        angleCourrant = angle;
      }
      angleCourrant2 = (millis()- tempsPrecedent)*angle2/temps2;
      if(angleCourrant2 >= angle2) 
      {
        angleCourrant2 = angle2;
      }
      if(angleCourrant == angle && angleCourrant2 == angle2)
      {
        etatCourant = Pause;
      }
      monServomoteur.write(angleCourrant);
      monServomoteur2.write(angleCourrant2);
      break;
    case Pause:
      // ne rien faire
      break;
  } 
}


/*
 * indique l'état dans lequel est le système
 * en fonction de ce qui est envoyé dans la console
 */ 
void ObtenirEtat()
{
  if (Serial.available() > 0) {
    String cmd = Serial.readString(); 
   
    if (cmd == "stop")
    {
      etatCourant = Arret;
    }
    else if(cmd == "start")
    {
      etatCourant = Marche;
    }
    else if(cmd == "zero")
    {
      etatCourant = MiseAZero;
    }
    else if(cmd == "180")
    {
      etatCourant = MiseA180;
    }
    else if(cmd == "avant1")
    {
      etatCourant = Avant;
      angle = 180;
      temps = 10000;

      angle2 = 90;
      temps2 = 10000;

      tempsPrecedent = millis();
    }
    else if(cmd == "avant2")
    {
      etatCourant = Avant;
      angle = 90;
      temps = 1000;

      angle2 = 180;
      temps2 = 1000;

      tempsPrecedent = millis();
    }
    else if(cmd == "avant3")
    {
      etatCourant = Avant;
      angle = 60;
      temps = 10000;

      angle2 = 60;
      temps2 = 1000;

      tempsPrecedent = millis();
    }
    else if(cmd == "delais")
    {
      delay(200);
    }
  }
}

Une photo du montage : 

[Mike118]

#include <Servo.h>

//Constantes qui définissent le numéro des broches des servomoteurs
#define MONSERVO1 9
#define MONSERVO2 10

//les variable qui correspondent aux servomoteurs
Servo monServomoteur;
Servo monServomoteur2;

//Constantes d'information d'angle et de temps pour les deux servomoteurs.
//Pourrai être un tableau à deux dimensions s'il y a plus de servomoteurs.
int angle;
int angleCourrant;
int temps;
int angle2;
int angleCourrant2;
int temps2;

long tempsPrecedent = 0;

/*
 * Enumeration des différents état du système
 */
enum Etat : byte
{
  Arret,
  Pause,
  MiseAZero,
  MiseA180,
  Marche,
  Avant
};

//Initialise l'état courant
Etat etatCourant = Arret;

/*
 * indique l'état dans lequel est le système
 * en fonction de ce qui est envoyé dans la console
 */ 
void ObtenirEtat();


void setup() {
  Serial.begin(9600); 
}

void loop() {

  ObtenirEtat();
 
  switch (etatCourant)
  {
    case Arret:
      monServomoteur.detach();
      monServomoteur2.detach();
      break;
    case Marche:
      if (!monServomoteur.attached())
      {
        monServomoteur.attach(MONSERVO1);
      }
      if (!monServomoteur2.attached())
      {
        monServomoteur2.attach(MONSERVO2);
      }
      break;
    case MiseAZero:
      monServomoteur.write(0);
      monServomoteur2.write(0);
      break;
    case MiseA180:
      monServomoteur.write(180);
      monServomoteur2.write(180);
      break;
    case Avant:
      angleCourrant = (millis()- tempsPrecedent)*angle/temps;
      if(angleCourrant >= angle) 
      {
        angleCourrant = angle;
      }
      angleCourrant2 = (millis()- tempsPrecedent)*angle2/temps2;
      if(angleCourrant2 >= angle2) 
      {
        angleCourrant2 = angle2;
      }
      if(angleCourrant == angle && angleCourrant2 == angle2)
      {
        etatCourant = Pause;
      }
      monServomoteur.write(angleCourrant);
      monServomoteur2.write(angleCourrant2);
      break;
    case Pause:
      // ne rien faire
      break;
  } 
}


/*
 * indique l'état dans lequel est le système
 * en fonction de ce qui est envoyé dans la console
 */ 
void ObtenirEtat()
{
  if (Serial.available() > 0) {
    String cmd = Serial.readString(); 
   
    if (cmd == "stop")
    {
      etatCourant = Arret;
    }
    else if(cmd == "start")
    {
      etatCourant = Marche;
    }
    else if(cmd == "zero")
    {
      etatCourant = MiseAZero;
    }
    else if(cmd == "180")
    {
      etatCourant = MiseA180;
    }
    else if(cmd == "avant1")
    {
      etatCourant = Avant;
      angle = 180;
      temps = 10000;

      angle2 = 90;
      temps2 = 10000;

      tempsPrecedent = millis();
    }
    else if(cmd == "avant2")
    {
      etatCourant = Avant;
      angle = 90;
      temps = 1000;

      angle2 = 180;
      temps2 = 1000;

      tempsPrecedent = millis();
    }
    else if(cmd == "avant3")
    {
      etatCourant = Avant;
      angle = 60;
      temps = 10000;

      angle2 = 60;
      temps2 = 1000;

      tempsPrecedent = millis();
    }
    else if(cmd == "delais")
    {
      delay(200);
    }
  }
}

Une photo du montage : 

montage_test_servo.jpg

 

Le code d'arobasseb  est très propre et il utilise

=> une " machine à état " dans un switch case, 

=> 0 code bloquant ( = pas de delay )

=> Des enum 

=> Des #define 

=> Des commentaires

 

Fref un bel exemple pour faire du beau code

 

le seul truc que je pourrais redire (et encore c'est un détail ) ... c'est l'utilisation du " int " et "long " 
j'ai une préférence pour l'utilisation des variables adaptées   =) 

[Amhnemus]

Salut les makers et merci à tous pour m'aider à résoudre certains problèmes.

Oui les codes sont très pro faut que je les étudie de plus près certainement demain pas trop le temps le weekend. Don ouais plein de truc à regarder cette semaine vivement que mon bipède marche parfaitement bien (fluidité et rapidité).

Merci encore à tous

[Amhnemus]

Salut les makers bon et bien on progresse avec mon problème de commander mes servos avec millis en faisant des aller retour avec incrémentation.

J'ai pas pris la solution d'arobasseb, parce que .... J'ai rien compris (trop faible niveau en programmation mais ça donne envie de progresser).

Donc j'ai opté avec mes connaissances de bases et ça marche !!!
Ce qui est bien en programmation c'est de pouvoir passer par différents chemin pour arriver au même résultat ( plus ou moins crade).
Donc avec des if a la suite et un bon debugage avec serial.print et bien ça marche bien c'est loin d'être pro c'est sur mais ça marche quand même.

Plus qu'à transposer tout ça sur mon bipède.

Grâce au serial.print j'ai pu voir des choses intéressantes comme des servos qui font leur courses degrés par degrés comme prévu mais arrivé à 88 degrés il passe d'un coup à 92 degrés puis en relançant pareille mais à 91 degrés c'est lui qui choisit mdr.

Enfin bon j'y suis arrivé ça me redonne de l'espoir 😉

[Amhnemus]

Salut salut, ce matin j'ai commencé à coder pour mon bipède (pas si simple ) je sais pas si j'aurais fini demain matin pour faire une vidéo sinon ça sera dans 2 semaine.

J'ai remarqué une chose , enfin je trouve qu'avec la fonction millis c'est plus lent qu'avec la fonction delay. Après j'ai mis 15 ms avec millis au lieu de 10 ms avec delay pour faire des boucles pour le mouvements des servos je sais pas si ça joue beaucoup les 5 ms de plus, et je ne sais pas si ça vient de la fonction millis en elle même comme elle vérifie l'état des servos toutes en même temps ce qui pourrait être normal que ça prenne du temps.

[Amhnemus]

Salut les makers,
 
Ce matin j'ai pu faire une vidéo de mon bipède avec mon nouveau code (avec millis() et non plus delay)



Bon c'est pas géniale avec millis(), y'a un manque évidant de puissance pour les servos puisqu'elle se partage les 5 volts de la carte quand elle tourne à deux a la fois j'ai essayer avec 3 servos en même temps et là c'était n'importe quoi (retour des servos à zero d'un seul coup) (au moins on peux voir que la fonction millis() fais son travail), donc faudrait une alimentation externe pour les servos et les servos en elles-même sont pas top ( trop peu précise et trop fragile ), je suis arrivé au limite de ce bipède.
 
Mais bon il se déplace à vitesse réduite mais il se déplace quand même sans trop faire importe quoi.
 
Tout ceci pour dire qu'on va arrêter ce bipède là pour en commencer un nouveau, avec de nouvelles servos plus robuste et de meilleur qualité,une nouvelle carte, des batteries suffisantes avec régulateur et prévoir pas mal de truc pour le rendre autonome niveau alimentation électrique.
 
Celui m'a permis déjà de me lancé dans le monde de la robotique, de la programmation et de l'arduino alors que je n'y comprenais rien, il m'en reste encore beaucoup à apprendre mais ça viendra avec le 2ème.
 
Merci à tous de m'avoir fait progresser, et à bientôt.....Genre dans quelques jours

[Path]

Tu les alimente comment tes servos ?

[Oracid]

Tu les alimente comment tes servos ?

Tu y es presque !
Mais effectivement, la réponse à la question de Path est une bonne voie vers un début de solution.
A mon avis, pour l'instant, le problème n'est pas la puissance des servos.
Je pense que, indépendamment du bipède, tu dois savoir faire fonctionner un servo avec son alimentation propre.