29 réponses à ce sujet

[Path]

@JEF, @Guigz, Je me suis aussi lancé dans un petit Bob.

• 4 servo
• un arduino micro
• un capteur ultra-son sr04 (J'ai dépouillé celui de Ash)

J'imprime ce Bob : http://www.thingiverse.com/thing:43708

 

Et je commence à vouloir programmer l'arduino micro. Et ... impossible de voir l'arduino sur le port usb. Le port série USB est grisé.

 

C'est un arduino officiel, normalement le bootloader est dessus, si je ne dis pas de bêtise.

 

Si j'en crois la doc, il n'y a rien à faire pour que ce soit reconnu  : https://www.arduino....noLeonardoMicro. On y apprend que le micro n'a qu'un microcontroler (contrairement au uno et au mega). Bien, si on reset, ça coupe la liaison série usb. Ok noté. Mais ça n'explique pas.

Cela ressemble au pb de Nino : http://www.robot-maker.com/forum/topic/10561-probleme-de-driver-arduino-nano/

 

J'ai creusé dans google. D'autres on aussi ce problème. Je lis qu'il faudrait un driver FTDI (http://www.ftdichip.com/Drivers/VCP.htm). J'installe ce fameux driver mais sans succès.

 

Je lis aussi que des mecs ont résolu le pb en changeant de câble usb. Câble défectueux ?

 

Bah non pas moi Je tente quand même le truc. Alors pour les prochaines fois, faire gaffe : il y a des câbles usb qui ne servent qu'à alimenter. Les fils data ne sont pas reliés !!!

 

pfff ... quel me.de ces câbles micro usb !!

 

Alors on continue, voilà ce que j'ai en tête. Le Bob aura une position fonction de la distance qu'il lira via le capteur ultrason.

 

 

[Edit] Le schéma est modifié. Le arduino micro de fritzing est faux. le D12 n'est pas une sortie PWM. J'ai changé le pin. Et le nez (led rouge)n'est plus commandé par l'arduino mais c'est un témoin d'alimentation.

Modifié par Path, 12 juillet 2016 - 02:33 .

[Mike118]

serait il possible d'avoir un " tuto d'assemblage " complet ? Genre les photo avec toutes les pièces visserie comprise et les différentes étapes du montage ? =)
Je pense que ça peut être un robot sympas pour les débutant du forum =) 

Sinon ... pour ton problème d'arduino je sais pas trop quoi te dire là jutilise pas de micro... Tu en as une autre pour tester ? 
Sinon je pense quand même à un problème de driver, essaye peut être de regarder des posts avec des problèmes concernant les arduino léonardo, car c'est le même chip d'intégré et donc le même driver à utiliser ...

[Path]

J'ai passé mon après-midi à ça

Mon problème est réglé. J'utilise un câble usb. un vrai.

 

Prochaine étape : réglage des servos.

[Path]

J'ai testé unitairement les limites des 4 servos avec ce petit montage. Il utilise le capteur ultrason de Bob.

• De 0 à 5 cm -> 0°
• de 5 à 10 cm -> 90°
• à 10 cm et plus -> 180 (valeur à définir)

Prochaine étape, assemblage et définition des limites mécanique.
 
A noter : j'ai voulu mettre un noInterrupt dans la lecture de distance. Servo.h n'aime pas du tout !
 
 

#include <Servo.h>

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Pin definitions
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#define PIN_PIED_GAUCHE 11
#define PIN_ECHO 2
#define PIN_TRIG 3

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Plage servos
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#define MAX_PIED_GAUCHE 179
#define MID_PIED_GAUCHE 90
#define MIN_PIED_GAUCHE 0

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Variables
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Servo servoPiedGauche;


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Fonctions
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

long lectureDistanceCm() {
  digitalWrite(PIN_TRIG, HIGH); 
  delayMicroseconds(10); 
  digitalWrite(PIN_TRIG, LOW);
  long lecture_echo = pulseIn(PIN_ECHO, HIGH, 60000); // 60ms
  return(lecture_echo / 58); 
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// SETUP
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

 
void setup() {
 // Setup servos
 servoPiedGauche.attach(PIN_PIED_GAUCHE);
 servoPiedGauche.write(MID_PIED_GAUCHE);
 // Setup capteur US
 pinMode(PIN_TRIG, OUTPUT);
 digitalWrite(PIN_TRIG, LOW);
 pinMode(PIN_ECHO, INPUT);
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// LOOP
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
void loop() {
 long distanceCm = lectureDistanceCm();
 byte angle = MID_PIED_GAUCHE;
 if(distanceCm <= 5) {
   angle = MIN_PIED_GAUCHE;
 }
 else {
   if(distanceCm <= 10) {
     angle = MID_PIED_GAUCHE;
   }
   else {
     angle = MAX_PIED_GAUCHE;
   }
 }
 servoPiedGauche.write(angle);
 delay(100);
}

[Path]

Parce que c'est les vacances, qu'on est en finale, et que je suis en un fou, j'ai refait le banc de test avec un potentiomètre. Le premier était nul. Disons qu'il m'a permit de re-tester le capteur ultrason.

 

#include <Servo.h>

#define PIN_POTENTIOMETRE 0
Servo myservo;

int analogValue = 0;
byte angle = 90;

void setup() {
  Serial.begin(9600);
  myservo.attach(11);
}

void loop() {
  analogValue = analogRead(PIN_POTENTIOMETRE);
  angle = map(analogValue, 0, 1023, 0, 180);
  myservo.write(angle);
  Serial.print("[Pot : ");
  Serial.print(analogValue);
  Serial.print("] [Ang : ");
  Serial.print(angle);
  Serial.println("]");
  delay(100);
}

[Path]

Alors juste pour Mike 

 

Pour la visserie, j'ai utilisé celle fournie avec les servo Tower Pro SG90. J'ai ajouté des M2 de 10 mm de long pour fixer les servo sur le chassis. mais c'est un peu trop long. 8 aurait été parfait.

 

Dans les jambes, j'ai fait les avant trous pour les vis et plus larges pour encaster les têtes autant que possible. (La longueur des vis fournies ne passaient pas à travers les jambes.) J'ai aussi dû agrandir les trous dans la palonniers pour que les vis fournies entrent.

 

Pour l'assemblage, c pas compliqué :

• J'ai placé les servos à 90° avant de placer les jambes dans leur axe.
• Ensuite fixer les palonniers sur les jambes avec la vis excentrée.
• Fixer les jambes sur les hanches puis sur les pieds.

 

 

 

 

Maintenant, trouver les limites mécaniques.

[Path]

 

 

Mouahaha, c'est l'éclate !!

 

[Guigz65]

Oh un robot cousin au mien ! 

 

C'est vrai qu'il y a un air de ressemblance avec les minions ! 

[Path]

Ha si j'avais eu du fil jaune ^^

[Path]

Bon voilà Bob !! Tadaa !!

 

 

Je lui ai ajouté un nez rouge témoin d'alimentation. Il n'est pas sur batterie mais sur secteur.

Il a aussi un interrupteur placé devant entre les jambes. Ça lui fait une tite stouquette.

 

 

Je lui ai agrandi le derrière pour accéder à la micro usb pour uploader de nouvelles versions du programme.

 

 

Voici les premiers pas de danse.

 

 

Il effectue un pas de danse aléatoirement quand on passe la main entre 10 cm et 1m. Sinon, il se remet en position de repos.

 

On va améliorer les pas de danse et fluidifier les mouvements par la suite. Le code source pour les amateurs.

 

Spoiler

#include <Servo.h>

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Pin definitions
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#define PIN_PIED_GAUCHE 11
#define PIN_PIED_DROIT 10
#define PIN_HANCHE_GAUCHE 9
#define PIN_HANCHE_DROITE 6

#define PIN_ECHO 2
#define PIN_TRIG 3

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Plage servo
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#define MAX_PIED_GAUCHE 168
#define MID_PIED_GAUCHE 99
#define MIN_PIED_GAUCHE 77

#define MAX_PIED_DROIT 110
#define MID_PIED_DROIT 82
#define MIN_PIED_DROIT 10

#define MAX_HANCHE_GAUCHE 120
#define MID_HANCHE_GAUCHE 85
#define MIN_HANCHE_GAUCHE 56

#define MAX_HANCHE_DROIT 113
#define MID_HANCHE_DROIT 87
#define MIN_HANCHE_DROIT 50


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Variables
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Servo servoPiedGauche;
Servo servoPiedDroit;
Servo servoHancheGauche;
Servo servoHancheDroite;

byte randNumber;
boolean hasMoved = true;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Fonctions
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

long lectureDistanceCm() {
  digitalWrite(PIN_TRIG, HIGH); 
  delayMicroseconds(10); 
  digitalWrite(PIN_TRIG, LOW);
  long lecture_echo = pulseIn(PIN_ECHO, HIGH, 60000); // 60ms
  return(lecture_echo / 58); 
}

void position0() {
  servoPiedGauche.write(MID_PIED_GAUCHE);
  servoPiedDroit.write(MID_PIED_DROIT);
  servoHancheGauche.write(MID_HANCHE_GAUCHE);
  servoHancheDroite.write(MID_HANCHE_DROIT);
}

void position1() {
  servoPiedGauche.write(MIN_PIED_GAUCHE);
  servoPiedDroit.write(MAX_PIED_DROIT);
  servoHancheGauche.write(MID_HANCHE_GAUCHE);
  servoHancheDroite.write(MID_HANCHE_DROIT);
}

void position2() {
  servoPiedGauche.write(MAX_PIED_GAUCHE);
  servoPiedDroit.write(MIN_PIED_DROIT);
  servoHancheGauche.write(MID_HANCHE_GAUCHE);
  servoHancheDroite.write(MID_HANCHE_DROIT);
}

void position3() {
  servoPiedGauche.write(MID_PIED_GAUCHE);
  servoPiedDroit.write(MID_PIED_DROIT);
  servoHancheGauche.write(MAX_HANCHE_GAUCHE);
  servoHancheDroite.write(MAX_HANCHE_DROIT);  
}

void position4() {
  servoPiedGauche.write(MID_PIED_GAUCHE);
  servoPiedDroit.write(MID_PIED_DROIT);
  servoHancheGauche.write(MIN_HANCHE_GAUCHE);
  servoHancheDroite.write(MIN_HANCHE_DROIT);  
}

void position5() {
  servoPiedGauche.write(MIN_PIED_GAUCHE);
  servoPiedDroit.write(MIN_PIED_DROIT);
  servoHancheGauche.write(MID_HANCHE_GAUCHE);
  servoHancheDroite.write(MID_HANCHE_DROIT);  
}

void position6() {
  servoPiedGauche.write(MAX_PIED_GAUCHE);
  servoPiedDroit.write(MAX_PIED_DROIT);
  servoHancheGauche.write(MID_HANCHE_GAUCHE);
  servoHancheDroite.write(MID_HANCHE_DROIT);  
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// SETUP
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void setup() {
  // Setup servos
  servoPiedGauche.attach(PIN_PIED_GAUCHE);
  servoPiedGauche.write(MID_PIED_GAUCHE);
  
  servoPiedDroit.attach(PIN_PIED_DROIT);
  servoPiedDroit.write(MID_PIED_DROIT);
  
  servoHancheGauche.attach(PIN_HANCHE_GAUCHE);
  servoHancheGauche.write(MID_HANCHE_GAUCHE);
  
  servoHancheDroite.attach(PIN_HANCHE_DROITE);
  servoHancheDroite.write(MID_HANCHE_DROIT);

  // Setup capteur US
  pinMode(PIN_TRIG, OUTPUT); 
  digitalWrite(PIN_TRIG, LOW); 
  pinMode(PIN_ECHO, INPUT);

  // Seed random
  randomSeed(analogRead(0));
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// LOOP
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void loop() {
  long distanceCm = lectureDistanceCm();
  if(distanceCm <= 10 || distanceCm >= 100) {
    position0();
    hasMoved = false;
  }
  else {
    if(!hasMoved) {
      
      randNumber = random(6);
      switch(randNumber) {
        case 0 :
          position1();
          break;
        case 1 :
          position2();
          break;
        case 2 :
          position3();
          break;
        case 3 :
          position4();
          break;
        case 4 :
          position5();
          break;
        case 5 :
          position6();
          break;
      }
      hasMoved = true;
    }
  }
  delay(500);
} 

[Bobox]

Impressionnant, Path, du beau boulot.

Il a une allure très sympatique, j'aime beaucoup.

 

Combien de temps as-tu passé dessus, si j'ai bien compris, tu profites de vacances ? Belle utilisation.

[Path]

Merci !! J'ai pas compté le temps. Comme tu dis, c'est les vacances. Je serai très approximatif. J'ai eu des pb de filament. L'impression a duré sur plusieurs jours. J'ai fini l'impression mercredi ou jeudi et je suis dessus depuis là. J'ai fait un voyage chez mon quincailler préféré et j'ai fait une pause d'une demi journée pour réfléchir au branchement et au placement interne des composants. Bref je dirais 2 à 3 jours de boulot pour assembler et écrire les quelques lignes que j'ai posté.

Je vais encore y passer quelques heures pour finir le code. Au programme : mouvements plus lents et simultanés. Si j'ai l'inspiration, il y aura du pid dedans.

[Mike118]

Un pid dedans ? Pour faire quoi ? =) 

[Path]

Je mets ça en option. Ce serait pour avoir des mouvements plus fluide. Non ?
Peut-être tu as un truc plus simple en alternative ?
L'idée pourrait être aussi de calculer les étapes intermediaires d'un mouvement avec une petite équation. Avec une pente droite, ça pourrait le faire ?

[Guigz65]

Bravo pour ces quelques pas de danse , à quand le moonwalk ???
Je bosse en ce moment sur le code pour faire marcher Mobbob plus rapidement avec des mouvements plus amples.
Je suis curieux c'est quoi cette histoire de pente droite ???

[Path]

L'idée est d'avoir des mouvements fluides. Sur un servo, quand tu lui donne un angle (avec servo.h) il y va aussi vite qu'il peut. Je voufrait lui donner des ordres intermédiaires sur sa course. Au mieux, pour accéler au début et ralentir à la fin. Au moins pour ralentir sur la fin de la course.

Intuitivement, je me dis que le pid peut gérer ce comportement. En alternative, je peux imposer des accélération et décélérations (pentes).

J'ai revu mon code pour le rendre asynchrone et permettre plusieurs passages dans loop() pour effectuer une course. L'aspect asynchrone me permet aussi de gérer plusieurs courses donc plusieurs servos en même temps. Je posterai tout ça.

[Oliver17]

Intéressant ton histoire d'accélération et de décélération, vais suivre ça

 

Sinon Bob à une bonne tête.

[Mike118]

en faite c'est pas vraiment un PID qu'il faut mettre en place mais plutôt un système de " rampe".

en gros tu as la position final pf que tu souhaite atteindre et ta position intermédiaires consigne pi. 

 tu definis "un pas max" qui peut être rendu variable si tu le souhaites  ( qui sera interprété comme une valeur d'accélération " ) et tous les x temps tu incrémentes (ou décrémente si pi> pf ) ta position pi de sorte a ce qu'au fur et à mesure pi se rapproche de pf. 

après c'est vrai que si tu veux " ralentir " quand le servo se rapproche de la position c'est vrai que tu peux au fur et à mesure que tu te rapproche reduire ton pas max. 

 

[Path]

Pas besoin de PID effectivement, je m'en sors avec des rampes en découpant les pas de danse.
 
J'ai presque fini le code. Et je but sur un pb de C.  J'ai besoin d'un tableau à plusieurs dimensions. 

 

J'ai un premier niveau dont le connais la taille. Pour le 2e niveau, j'ai des tailles différentes entre elles.

 

 

C'est possible dans le C/C++ d'arduino ?

 

[Oliver17]

Path sans pourrir ton post, c'est juste pour m'éclairer, le principe d'accélération et décélération ce joue sur la fréquence (Hz) ???

Je suis sur la même chose, déjà merci pour le code du map que tu m'a filé Path, j'en reparlerai sur mon post ^^

 

PS : virer mon message si il gène.