74 réponses à ce sujet

[GD ONE]

 

Malheureusement le test proposé par oracid ( qui est un très bon test pour éliminer les problèmes qui viendraient du code ) n'aidera sans doutes pas ici si c'est bien un problème " électrique " comme je le dis ... 
 

 

 

C'est bien un problème électrique. Merci Mike..

 

La batterie que j'utilisais était une batterie 24V   2000 mAh  que je réduisais à 5V.  Ampérage pas assez puissant, apparemment.

J'ai donc utiliser des batteries 3,7V 2500 mAh et là plus de problème, ça marche. 

 

Je vais passer à la programmation vocal et télécommande du bras dans le même principe que ma Base.

 

A+

[GD ONE]

Re,

 

Petite question. Est-ce qu'un servo à un cerveau.

Je m'explique. J'ai vidé la mémoire de ma MEGA avec un programme RESET. (Setup vide et Loop vide)

Mon bras se met en position relaché.

 

je charge ce programme

[code]

#include <HCSR04.h>
#include <Servo.h>
#include <NewPing.h>           // bibliothèque de gestion des delays
#include <SoftwareSerial.h>

/*#define NO_OF_FIELDS 6*/

Servo base, shoulder, foreArm, wristFlex, wristRotate, claw;

SoftwareSerial hc06(0, 1);   // RX,TX
//DEFINITION CAPTEUR BLUETOOTH
unsigned char Bluetooth_val;        //définition de la valeur val
String messageRecu = ""; // stockage du message venant du bluetooth

int ledPin = 13;

void setup()
{
  Serial.begin(38400);

  base.attach(2);
  shoulder.attach(3);
  foreArm.attach(4);
  wristFlex.attach(5);
  wristRotate.attach(6);
  claw.attach(7);
/*
  //initialise all arms

  base.write(0);              //  90      0 = Bras horizontal
  shoulder.write(0);          // 150      0 = Bras pendant
  foreArm.write(180);         //  40      40 = Coude fermé
  wristFlex.write(0);         //  90      0 = Poignet ouvert limite fermé 175
  wristRotate.write(0);       //  90    180 = Paume au dessus
  claw.write(175);            //  0       0 = Pince ouverte
*/
  pinMode(ledPin, OUTPUT);
}

void loop()
{

  while (Serial.available())
  {
    delay (3); // lecture car par car
    char c = Serial.read();
    messageRecu += c;
  }

  if (messageRecu.length() > 0)
  {

    if ((messageRecu.indexOf("recule") != -1)) { // marche arrière
      Serial.println ("recule");
  //initialise all arms

    }
    else if ((messageRecu.indexOf("gauche") != -1)) { // tourne à gauche brièvement
      Serial.println ("a gauche");

    }
    else if ((messageRecu.indexOf("droite") != -1)) { //tourne à droite brièvement
      Serial.println ("a droite");

      /*     avance();*/
    }
    else if ((messageRecu.indexOf("sto") != -1)) { // moteur stop
      Serial.println ("stop");
 
    }
    else if ((messageRecu.indexOf("demi-tour") != -1)) { // moteur stop
      Serial.println ("demi-tour");
  
    }
    else if ((messageRecu.indexOf("quart-de-tour") != -1)) { // moteur stop
      Serial.println ("quart-de-tour à gauche");
 
    }
    else if ((messageRecu.indexOf("retourne") != -1)) { // marche avant
      Serial.println ("Retourne");
 

      Serial.println (messageRecu);
    }

    else if ((messageRecu.indexOf("avance") != -1)) { // marche avant
      Serial.println (messageRecu);
 

      Serial.println (messageRecu);
    }
    else if ((messageRecu.indexOf("viens ici") != -1)) { // marche avant
      Serial.println (messageRecu);


      Serial.println (messageRecu);

    }
  }
}
[/code]

Le bras n'est pas censé bougé puisque je ne lui donne pas d'instruction. Pourtant dès que j'alimente en courant, le bras se met dans une position assez agressive d'ailleurs.  Pourquoi ?

 

Cordialement

[Mike118]

J'ai pas bien compris ta question... Mais il y a bien des puces plus ou moins intelligente dans les servomoteurs ... 

[Sandro]

J'ai une idée du sens de la question:

Si j'ai bien compris, quand GD ONE mets un programme vide sur l'arduino, les servos se mettent dans une position par défaut, qu'il appelle "relaché".

Quand il charge ensuite le programme ci-dessus, qui a priori ne fait rien avec les servos sauf de les "attacher", les servos changent de position.

 

Je pense que GD ONE soupsonne le "cerveau" des servos de lui jouer ce tour.

 

 

En regardant le code source de la librairie Servo, j'ai l'impression que quand on crée un objet de type Servo, le constructeur lui donne une consigne de position par défaut, qui correspond à une impulsion de DEFAULT_PULSE_WIDTH=1500µs, ce qui correspond à la position "milieu" sur la plupart des servos.

Servo::Servo()
{
  if( ServoCount < MAX_SERVOS) {
    this->servoIndex = ServoCount++;                    // assign a servo index to this instance
	servos[this->servoIndex].ticks = usToTicks(DEFAULT_PULSE_WIDTH);   // store default values  - 12 Aug 2009
  }
  else
    this->servoIndex = INVALID_SERVO ;  // too many servos
}

En revanche, quand on charge un code vide, les pins sont en mode "entrée".

Si on suppose qu'on interne le servo a une pull up ou une pull down, alors il interprétera probablement l'absence de signal comme une longueur d'impulsion de 0 ou infinie, ce qui est hors de la gamme attendue (1000 à 2000µs). Sauf erreur de ma part, le servo l'interprétera donc comme si c'était la valeur min ou max qu'il supporte, et se mettra donc en butée/bout de course d'un coté ou de l'autre.

 

 

Si mon hypothèse est correcte, alors quand tu mets le programme vide, les servos sont en bout de course, et quand tu charges le programme ci-dessus, ils sont à mi-parcourt (environ 90° si tu as des servos 180°, ou 135° si tu asdes servos 270°).

Est-ce que ça te semble cohérent avec tes observations?

 

Si oui, alors il suffit que quand tu fais servo.attach, juste après tu fasses un servo.write(0) pour aller à la position en butée d'un coté, ou servo.write(255) pour aller en butée de l'autre coté. NB : je crois que ça marche aussi si tu mets ce code avant servo.attach, dans quel cas ça éviterait un petit début de déplacement, mais à tester

[GD ONE]

Pour MIKE, merci pour le mail. J'ai rien compris, car j’étais sur le forum.

 

Pour Sandro

 

Merci pour cette excellente réponse, clair et explicite. En effet cela me parait cohérent. J'ai monté  mon bras sur un support  et il pend comme pend le bras d'une personne, flasque.
 Dès le chargement du programme le bras se met en position de défense comme un boxeur qui correspondrait au 90° que tu dit.

 

J'ai testé ton avis et c'est effectivement ça. J'ai aussi testé la commande vocale. Marche pas. J'ai pourtant utilisé le même programme que pour la base.

En y réfléchissant bien je me demande si je vais continuer sur cette voie là. Cà fait plus d'un mois que je galère avec ce bras.

 Merci, cordialement et a+

[Mike118]

Pour la commande vocale quel code as tu fais / qu'est ce qui ne marche pas ... 

Il faut toujours décomposer un programme en plusieurs sous étapes .


Exemple : 

A )Comprendre  la commande vocal " Avance " 
B ) Savoir faire avancer le robot 
C ) Une fois que A ) et B ) ça marche les combiner pour que le robot avance lorsque l'on dit la commande vocale Avance. 

Dans le cadre de ton bras où en es tu ? Est ce que tu arrive à faire fonctionner ton bras comme tu veux ? 
Est ce que ton code de commande vocale marche bien tout seul ?  
Si oui et oui poste les deux code séparé qui marchent bien, et poste ton code " assemblé" qui marche pas =)

[GD ONE]

Re-salut à tous,

 

On était bien quand même confiné, on pouvait bosser sur nos projets. Bref....

 

Voici le code test que j'utilise pour le bras. ATTENTION !!! Les commentaires ne sont pas les bons et la programmation est les ordres sont des ordres tests.  

 

Le code fonctionne avec le scope, c'est à dire lorsque je lui donne un ordre il l’exécute. Mais avec l'application que j'utilise sur mon mobile ou la tablette. RIEN...

Alors que la même application que j'utilise pour ma base, ça marche.

 

J'ai aussi inversé les modules HC-06 de ma base vers le bras pour tester, il ne veut rien savoir.

 

Il y aussi un second truc qui me préoccupe, c'est la rapidité des mouvements. C'est trop sec. Les servos vont pas tenir longtemps comme ça et je vous dis le nombre de fois ou je dois resserrer les boulons.

[code]

#include <HCSR04.h>
#include <Servo.h>
#include <NewPing.h>           // bibliothèque de gestion des delays
#include <SoftwareSerial.h>

/*#define NO_OF_FIELDS 6*/

Servo base, shoulder, foreArm, wristFlex, wristRotate, claw;

SoftwareSerial hc06(A0, A1);   // RX,TX
//DEFINITION CAPTEUR BLUETOOTH
unsigned char Bluetooth_val;        //définition de la valeur val
int val;
int ledpin = 1;
String messageRecu = ""; // stockage du message venant du bluetooth

void setup()
{
  Serial.begin(38400);

  base.attach(2);
  shoulder.attach(3);
  foreArm.attach(4);
  wristFlex.attach(5);
  wristRotate.attach(6);
  claw.attach(7);

  //initialise all arms

  base.write(0);               //  90      0 = Bras vertical,  Haut les mains = limite 170
  shoulder.write(0);           // 150      0 = Bras pendant
  foreArm.write(179);          //  40      40 = Coude fermé,   Coude ouvert = 179
  wristFlex.write(0);          //  90      0 = Poignet ouvert, limite fermé = 175
  wristRotate.write(0);        //  90      0 = Paume en dessous, Paume audessus limite = 175
  claw.write(0);               //   0      0 = Pince ouverte, Pince fermé = 179

  pinMode(ledpin, OUTPUT);
}

void loop()
{

  while (Serial.available())
  {
    delay (3); // lecture car par car
    char c = Serial.read();
    messageRecu += c;
  }

  if (messageRecu.length() > 0)
  {

    if ((messageRecu.indexOf("monte") != -1)) { // marche arrière
      Serial.println ("monte");
      base.write(90);
      messageRecu = "";
    }
    else if ((messageRecu.indexOf("descend") != -1)) { // tourne à gauche brièvement
      Serial.println ("descend");
      base.write(0);
      messageRecu = "";
    }
    else if ((messageRecu.indexOf("recule") != -1)) { //tourne à droite brièvement
      Serial.println ("recule");
      shoulder.write(0);
      messageRecu = "";

    }
    else if ((messageRecu.indexOf("sto") != -1)) { // moteur stop
      Serial.println ("stop");

      messageRecu = "";
    }
    else if ((messageRecu.indexOf("salut") != -1)) { // moteur stop
      Serial.println ("demi-tour");

      messageRecu = "";
    }
    else if ((messageRecu.indexOf("avance") != -1)) { // moteur stop
      Serial.println ("avance");
      shoulder.write(90);
      messageRecu = "";
    }
    else if ((messageRecu.indexOf("ouvre") != -1)) { // marche avant
      Serial.println ("ouvre");
      claw.write(175);
      messageRecu = "";

    }

    else if ((messageRecu.indexOf("ferme") != -1)) { // marche avant
      Serial.println ("ferme");
      messageRecu = "";
      claw.write(10);
    }
    else if ((messageRecu.indexOf("defense") != -1)) { // marche avant
      Serial.println ("defense");
      base.write(90);              //  90      0 = Bras vertical,  Haut les mains = limite 170
      shoulder.write(150);         // 150      0 = Bras pendant
      foreArm.write(45);          //  40      40 = Coude fermé,   Coude ouvert = 179
      wristFlex.write(90);          //  90      0 = Poignet ouvert, limite fermé = 175
      wristRotate.write(90);       //  90      0 = Paume en dessous, Paume audessus limite = 175
      claw.write(0);               //   0      0 = Pince ouverte, Pince fermé = 179
      messageRecu = "";
    }
  }
}
[/code]

Cordialement

[Mike118]

Alors tu évoques deux problèmes complètement différent... 

La façon la plus facile pour resoudre tes problèmes c'est de diviser pour mieux régner et de chercher à en résoudre 1 à la fois . 

A) Les mouvements brusques => Apprendre à utiliser complètement ton bras avant d'aller plus loin, faire des déplacement souple etc ... 
Tu peux regarder ce que j'ai fais dans le blog pour Briel par exemple, ça montre comment utiliser des servomoteurs en douceur, mais il y a aussi les codes proposés par Oracid et jean brunet dans les quadrupèdes ... 


B ) tester ton code de communication tout simple et qui fonctionne sans le bras. ( Pas de code de servomoteur ou autre dedans => On peut un code le plus simple possible )

Repars du code qui marche pour la base par exemple et enlève ce qui est pour la base dans ce code de sorte à n'extraire que la partie communication et qui marche toujours ... 


Une fois que A et B seront validé, tu pourras passer à C ) le mélange des deux. 

Du coup tu veux commencer par quoi ? A ou B ? Moi je veux bien t'aider mais une seul problème à la fois

[GD ONE]

Ok Mike,

 

On va commencer par A. Je vais aller visiter tout ça et tenter de modifier mes codes, que je te soumettrais plus tard.

 

Merci à vous tous.

[GD ONE]

Salut à tous,

 

Voilà mon dernier code avec des déplacements un peu plus cool. J'ai l'impression que mes servos ne sont pas assez puissant, car lorsque le bras est tendu un des servos lâche et remonte ensuite.

[code]

#include <HCSR04.h>
#include <Servo.h>
#include <NewPing.h>           // bibliothèque de gestion des delays
#include <SoftwareSerial.h>

/*#define NO_OF_FIELDS 6*/

Servo base, shoulder, foreArm, wristFlex, wristRotate, claw;

SoftwareSerial hc06(0, 1);   // RX,TX
//DEFINITION CAPTEUR BLUETOOTH
unsigned char Bluetooth_val;        //définition de la valeur val
int val;
int ledpin = 1;

// variable contenant la position des servomoteurs

int pos_base = 0;
int pos_shoulder = 0;
int pos_foreArm = 0;
int pos_wristFlex = 0;
int pos_wristRotate = 0;
int pos_claw = 0;

//Déclaration des constantes
#define UPDATE_TIME 15

int Max_pos_base = 170;
int Max_pos_shoulder = 175;
int Max_pos_foreArm = 45;
int Max_pos_wristFlex = 175;
int Max_pos_wristRotate = 175;
int Max_pos_claw = 160;

int Min_pos_base = 0;
int Min_pos_shoulder = 20;
int Min_pos_foreArm = 175;
int Min_pos_wristFlex = 0;
int Min_pos_wristRotate = 0;
int Min_pos_claw = 20;


String messageRecu = ""; // stockage du message venant du bluetooth

void setup()
{
  Serial.begin(38400);

  base.attach(2);
  shoulder.attach(3);
  foreArm.attach(4);
  wristFlex.attach(5);
  wristRotate.attach(6);
  claw.attach(7);

  //initialise all arms

  base.write(Min_pos_base);                 //  90      0 = Bras vertical,  Haut les mains = limite 170
  shoulder.write(Min_pos_shoulder);         // 150      0 = Bras pendant
  foreArm.write(Min_pos_foreArm);           //  40      40 = Coude fermé,   Coude ouvert = 179
  wristFlex.write(Min_pos_wristFlex);       //  90      0 = Poignet ouvert, limite fermé = 175
  wristRotate.write(Min_pos_wristRotate);   //  90      0 = Paume en dessous, Paume audessus limite = 175
  claw.write(Min_pos_claw);                 //   0      0 = Pince ouverte, Pince fermé = 179

  pinMode(ledpin, OUTPUT);
}

void loop()
{

  while (Serial.available())
  {
    delay (3); // lecture car par car
    char c = Serial.read();
    messageRecu += c;
  }

  if (messageRecu.length() > 0)
  {
    //************************ MAITRISE BRAS I ***************************//

    if ((messageRecu.indexOf("monte bras") != -1)) { // Bras monte
      Serial.println ("monte bras");
      for (pos_base = Min_pos_base; pos_base <= Max_pos_base; pos_base += 1) {
        base.write(pos_base);
        Serial.print ("Min : "); Serial.print (Min_pos_base); Serial.print (" Max : "); Serial.print (Max_pos_base); Serial.print (" increment : "); Serial.println(pos_base);
        delay(UPDATE_TIME);
      }
      messageRecu = "";

    }
    else if ((messageRecu.indexOf("baisse bras") != -1)) { // Bras descend
      Serial.println ("baisse bras");
      for (pos_base = Max_pos_base; pos_base >= Min_pos_base; pos_base -= 1) {
        base.write(pos_base);
        Serial.print ("Min : "); Serial.print (Min_pos_base); Serial.print (" Max : "); Serial.print (Max_pos_base); Serial.print (" increment : "); Serial.println(pos_base);
        delay(UPDATE_TIME);
      }
      messageRecu = "";
    }
    //************************ MAITRISE BRAS II ***************************//

    else if ((messageRecu.indexOf("ouvre bras") != -1)) { // ouvre bras
      Serial.println ("ouvre bras");
      for (pos_shoulder = Min_pos_shoulder; pos_shoulder <= Max_pos_shoulder; pos_shoulder += 1) {
        shoulder.write(pos_shoulder);
        Serial.print ("Min : "); Serial.print (Min_pos_shoulder); Serial.print (" Max : "); Serial.print (Max_pos_shoulder); Serial.print (" increment : "); Serial.println(pos_shoulder);
        delay(UPDATE_TIME);
      }
      messageRecu = "";

    }
    else if ((messageRecu.indexOf("ferme bras") != -1)) { // ferme bras
      Serial.println ("ferme bras");
      for (pos_shoulder = Max_pos_shoulder; pos_shoulder >= Min_pos_shoulder; pos_shoulder -= 1) {
        shoulder.write(pos_shoulder);
        Serial.print ("Min : "); Serial.print (Min_pos_shoulder); Serial.print (" Max : "); Serial.print (Max_pos_shoulder); Serial.print (" increment : "); Serial.println(pos_shoulder);
        delay(UPDATE_TIME);
      }
      messageRecu = "";

    }

    //************************ MAITRISE COUDE  ***************************//

    else if ((messageRecu.indexOf("ferme coude") != -1)) { // ouvre coude
      Serial.println ("ferme coude");
      for (pos_foreArm = Min_pos_foreArm; pos_foreArm >= Max_pos_foreArm; pos_foreArm -= 1) {
        foreArm.write(pos_foreArm);
        Serial.print ("Min : "); Serial.print (Min_pos_foreArm); Serial.print (" Max : "); Serial.print (Max_pos_foreArm); Serial.print (" increment : "); Serial.println(pos_foreArm);
        delay(UPDATE_TIME);
      }
      messageRecu = "";

    }
    else if ((messageRecu.indexOf("ouvre coude") != -1)) { // ferme coude
      Serial.println ("ouvre coude");
      
      for (pos_foreArm = Max_pos_foreArm; pos_foreArm <= Min_pos_foreArm; pos_foreArm += 1) {
        foreArm.write(pos_foreArm);
        Serial.print ("Min : "); Serial.print (Min_pos_foreArm); Serial.print (" Max : "); Serial.print (Max_pos_foreArm); Serial.print (" increment : "); Serial.println(pos_foreArm);
        delay(UPDATE_TIME);
      }
      messageRecu = "";

    }

    //************************ MAITRISE POIGNET I  ***************************//

    else if ((messageRecu.indexOf("ferme poignet") != -1)) { // ferme poignet
      Serial.println ("ferme poignet");
      for (pos_wristFlex = Min_pos_wristFlex; pos_wristFlex <= Max_pos_wristFlex; pos_wristFlex += 1) {
        wristFlex.write(pos_wristFlex);
        Serial.print ("Min : "); Serial.print (Min_pos_wristFlex); Serial.print (" Max : "); Serial.print (Max_pos_wristFlex); Serial.print (" increment : "); Serial.println(pos_wristFlex);
        delay(UPDATE_TIME);
      }
      messageRecu = "";

    }
    else if ((messageRecu.indexOf("ouvre poignet") != -1)) { // ouvre poignet
      Serial.println ("ouvre poignet");
      for (pos_wristFlex = Max_pos_wristFlex; pos_wristFlex >= Min_pos_wristFlex; pos_wristFlex -= 1) {
        wristFlex.write(pos_wristFlex);
        Serial.print ("Min : "); Serial.print (Min_pos_wristFlex); Serial.print (" Max : "); Serial.print (Max_pos_wristFlex); Serial.print (" increment : "); Serial.println(pos_wristFlex);
        delay(UPDATE_TIME);
      }
      messageRecu = "";
    }

    //************************ MAITRISE PAUME ROTATION  ***************************//

    else if ((messageRecu.indexOf("paume dessus") != -1)) { // paume dessus
      Serial.println ("paume dessus");
      for (pos_wristRotate = Min_pos_wristRotate; pos_wristRotate <= Max_pos_wristRotate; pos_wristRotate += 1) {
        wristRotate.write(pos_wristRotate);
        Serial.print ("Min : "); Serial.print (Min_pos_wristRotate); Serial.print (" Max : "); Serial.print (Max_pos_wristRotate); Serial.print (" increment : "); Serial.println(pos_wristRotate);
        delay(UPDATE_TIME);
      }
      messageRecu = "";

    }
    else if ((messageRecu.indexOf("paume dessous") != -1)) { // paume dessous
      Serial.println ("paume dessous");
      for (pos_wristRotate = Max_pos_wristRotate; pos_wristRotate >= Min_pos_wristRotate; pos_wristRotate -= 1) {
        wristRotate.write(pos_wristRotate);
        Serial.print ("Min : "); Serial.print (Min_pos_wristRotate); Serial.print (" Max : "); Serial.print (Max_pos_wristRotate); Serial.print (" increment : "); Serial.println(pos_wristRotate);
        delay(UPDATE_TIME);
      }
      messageRecu = "";

    }
    //************************ MAITRISE PINCE  ***************************//

    else if ((messageRecu.indexOf("ferme pince") != -1)) { // ferme pince
      Serial.println ("ferme pince");
      for (pos_claw = Min_pos_claw; pos_claw <= Max_pos_claw; pos_claw += 1) {
        claw.write(pos_claw);
        Serial.print ("Min : "); Serial.print (Min_pos_claw); Serial.print (" Max : "); Serial.print (Max_pos_claw); Serial.print (" increment : "); Serial.println(pos_claw);
        delay(UPDATE_TIME);
      }
      messageRecu = "";

    }
    else if ((messageRecu.indexOf("ouvre pince") != -1)) { // ouvre pince
      Serial.println ("ouvre pince");
      for (pos_claw = Max_pos_claw; pos_claw <= Min_pos_claw; pos_claw -= 1) {
        claw.write(pos_claw);
        Serial.print ("Min : "); Serial.print (Min_pos_claw); Serial.print (" Max : "); Serial.print (Max_pos_claw); Serial.print (" increment : "); Serial.println(pos_claw);
        delay(UPDATE_TIME);
      }
      messageRecu = "";

    }
    //************************ POSITION DEFENSE  ***************************//

    else if ((messageRecu.indexOf("defense") != -1)) { // position defense
      Serial.println ("defense");
      base.write(90);              //  90      0 = Bras vertical,  Haut les mains = limite 170
      shoulder.write(150);         // 150      0 = Bras pendant
      foreArm.write(90);           //  40      40 = Coude fermé,   Coude ouvert = 179
      wristFlex.write(90);         //  90      0 = Poignet ouvert, limite fermé = 175
      wristRotate.write(90);       //  90      0 = Paume en dessous, Paume audessus limite = 175
      claw.write(160);               //   0      0 = Pince ouverte, Pince fermé = 179
    }
    messageRecu = "";
  }
}
[/code]

Je n'ai pas de boucle FOR dans la position DEFENSE car je souhaite un effet agressif pour ce code.

Bien sûr la commande vocale ne fonctionne toujours pas.

 

A+

[Mike118]

Alors, pour faire un code plus propre, normalement tu fais des fonctions du genre : 

 

 void modeDefense() {

 }

de manière à pouvoir facilement tester chacune des fonctions ... 

J'ai peut être pas été assez claire mais lors de l'étape A, normalement on ne teste que les servomoteurs du bras => Pas de code autre ... 


Par contre il y a un truc qui me paraît anormal, tu fais un softserial sur les pin 0 et 1 avec ton module bluetooth ... et après tu fais un Serial qui utilise aussi les pins 0 et 1 ... J'ai comme l'impression que j'ai mis le doigt sur ton problème... 

 

 

[GD ONE]

Bonjour à tous,

 

Cela fait un bail que je n'ai pas posté. Mon robot à bien avancé et fonctionne pas trop mal.

 

Je souhaiterais le sonoriser. J'ai trouvé sur la toile un code sonore D2R2 qui fonctionne une fois chargé sur ma MEGA

 

J'ai donc rajouté a mon code robot (qui fonctionne)  les informations du code D2R2

 

Et là j'ai les messages d'erreur ci-dessous

 

Tone.cpp.o (symbol from plugin): In function `timer0_pin_port':

(.text+0x0): multiple definition of `__vector_13'

libraries\NewPing\NewPing.cpp.o (symbol from plugin).text+0x0): first defined here

collect2.exe: error: ld returned 1 exit status

exit status 1

Erreur de compilation pour la carte Arduino Mega or Mega 2560

 

 

Avec ça pouvez m'aider s.v.p.

 

Cordialement

[GD ONE]

MIRACLE !!! Ca fait huit jours que je cherche.

 

Il faut modifier dans NEWPING.H  #define TIMER_ENABLED true  et le Définir sur "false" pour désactiver.

[GD ONE]

Bonjour à tous,

 

Mon robot est actuellement pilotable par l'intermédiaire d'un smartphone.

Je souhaite utiliser une télécommande de casque VR tel que ci-dessous

 

Cette télécommande peut télécommander un smartphone, une tablette (le volume, changement de page, avance recule d'une vidéo, etc...)

 

Ma question est :

Comment coupler cette télécommande avec le HC-06 arduino, afin que je puisse télécommander le robot.

 

J'ai aussi envisager une télécommande radio.

 

Qu'en pensez vous ?

 

Merci

[Mike118]

Je ne sais pas si tu peux coupler ta télécommande avec un module HC06 ... Il est généralement plus facile de connecter un smartphone à une arduino en bluetooth et de faire une application " télécommande " ... 

Sinon une télécommande radio ça marche bien et ça a une meilleure portée que le bluetooth =)