Besoin d´aide par rapport a un program de robot

Bonjours j´aurais besoin d´aide pour terminer a programmer un robot automatiser le probleme est que je n´arrive pas a faire fonctionner 2 des 3 capteurs utilisées mais j´arrive aucun d´eux ont un soucis j´ai fait des test induviduel (ref capteur: Sharp IR GP2Y0A21YK0F mesure en CM )
puis je n´arrive pas a faire en sorte que mon moteur fassent un demi tour ou esquive l´obstacle que le capteur rencontre l´obstacle les mouvements du robot seront aléatoire (toujours tout droit jusqu´à rencontrer un obstacle)

Pièce utilisé:

  • Arduino UNO Board
  • Velleman motor shield
  • Sharp sensor GP2Y0A21YK0F 3x (2 a l´avant puis 1 derrière)
  • 2 Moteur DC biDirectionnel
  • alim 24v 4Ah

Program que j´ai déjà reussi a sortir :

#include <SharpIR.h>

#define ir A0
#define ir A1
#define ir A2
#define model 1080
int pwm_a = 3;
int pwm_b = 9;
int dir_a = 2;
int dir_b = 8;

SharpIR SharpIR(ir, model);

void setup() {
  pinMode(pwm_a, OUTPUT); 
  pinMode(pwm_b, OUTPUT);
  pinMode(dir_a, OUTPUT);
  pinMode(dir_b, OUTPUT);
  analogWrite(pwm_a, 255); 
  analogWrite(pwm_b, 255);
  Serial.begin(9600);
}

void loop() {

  delay(2000);   

  unsigned long pepe1=millis();

  int dis=SharpIR.getDistance(0); 

  Serial.print("Mean distance: ");
  Serial.println(dis);
 
  unsigned long pepe2=millis()-pepe1;
  Serial.print("Time taken (ms): ");
  Serial.println(pepe2); 

}

Merci de bien vouloir m´aider car je bloque depuis un petit moment maintenant…

Bonjour,
Cela n'est pas possible :

#define ir A0
#define ir A1
#define ir A2

Dans la vie, il faut choisir ir = A0 ou A1 ou A1 mais pas les trois en même temps.
@+

icare:
Bonjour,
Cela n'est pas possible :

#define ir A0

#define ir A1
#define ir A2



Dans la vie, il faut choisir ir = A0 ou A1 ou A1 mais pas les trois en même temps.
@+

Merci je pensais qu´il faillait les mettres car j´ai 3 capteur ^^

Re,
Tu peux faire :

#define ir0 A0
#define ir1 A1
#define ir2 A2

et dans ton programme en fonction de ton capteur:

SharpIR SharpIR(ir?, model);

icare:
Re,
Tu peux faire :

#define ir0 A0

#define ir1 A1
#define ir2 A2



et dans ton programme en fonction de ton capteur:


SharpIR SharpIR(ir?, model);




je vien d´essayer:



#define ir0 A0
#define ir1 A1
#define ir2 A2




mais du coup je ne peut pas ajouter plusieurs 


SharpIR SharpIR(ir?, model);

le logiciel me dit SharpIr does not name a type

Hello

SharpIR SharpIR_AVG(ir0, model);

SharpIR SharpIR_AVD(ir1, model);

SharpIR SharpIR_RECUL(ir2, model);

puis dans le prg

int dis_AVANT_GAUCHE= SharpIR_AVG.getDistance(0);
int dis_AVANT_DROITE = SharpIR_AVD.getDistance(0);
int dis_ARRIERE = SharpIR_RECUL.getDistance(0);

dfgh:
Hello

SharpIR SharpIR_AVG(ir0, model);

SharpIR SharpIR_AVD(ir1, model);

SharpIR SharpIR_RECUL(ir2, model);

puis dans le prg

int dis_AVANT_GAUCHE= SharpIR_AVG.getDistance(0);
int dis_AVANT_DROITE = SharpIR_AVD.getDistance(0);
int dis_ARRIERE = SharpIR_RECUL.getDistance(0);

je vais tester sur le champs

Update :
ok nice ca a regler un soucis manque plus que la partie pour faire tourner robot pour eviter un obstacle

pas de nouvelle erreur mais les capteur ignore toujours les obstacles et les moteurs continuent d´avancer tout droit

La derniere version du code:

#include <SharpIR.h>

#define ir0 A0
#define ir1 A1
#define ir2 A2
#define model 1080
int pwm_a = 3;
int pwm_b = 9;
int dir_a = 2;
int dir_b = 8;

SharpIR SharpIR_AVG(ir0, model);

SharpIR SharpIR_AVD(ir1, model);

SharpIR SharpIR_RECUL(ir2, model);

void setup() {
  Serial.begin(9600);
  pinMode(pwm_a, OUTPUT);
  pinMode(pwm_b, OUTPUT);
  pinMode(dir_a, OUTPUT);
  pinMode(dir_b, OUTPUT);
  
  analogWrite(pwm_a, 255);
  analogWrite(pwm_b, 255);
  
  int dis_AVANT_GAUCHE = SharpIR_AVG.getDistance(0);
  int dis_AVANT_DROITE = SharpIR_AVD.getDistance(0);
  int dis_ARRIERE      = SharpIR_RECUL.getDistance(0);
}

void loop() {

  delay(2000);   

  unsigned long pepe1=millis();

  int dis_AVANT_GAUCHE = SharpIR_AVG.getDistance(0);

  Serial.print("Mean distance: ");
  Serial.println(dis_AVANT_GAUCHE);
 
  unsigned long pepe2=millis()-pepe1;
  Serial.print("Time taken (ms): ");
  Serial.println(pepe2);

}

c’est un truc scolaire?

testes çe code que je viens de taper.

et verifies que ton cablage correspond bien au code
et pendant tes essais penses que ton mobile peut tourner à droite au lieu de gauche
et qu’il te faudra inverser les commandes dans le code

#include <SharpIR.h>

#define AVG A0
#define AVD A1
#define REC A2
#define model 1080
const byte pwm_moteur_gauche = 3;
const byte pwm_moteur_droite = 9;
const byte dir_moteur_gauche = 2;
const byte dir_moteur_droite = 8;

SharpIR SharpIR_AVG(AVG, model);
SharpIR SharpIR_AVD(AVD, model);
SharpIR SharpIR_RECUL(REC, model);

void setup() {
  Serial.begin(115200);
  pinMode(pwm_moteur_gauche, OUTPUT);
  analogWrite(pwm_moteur_gauche, 0);
  pinMode(pwm_moteur_droite, OUTPUT);
  analogWrite(pwm_moteur_gauche, 0);
  pinMode(dir_moteur_gauche, OUTPUT);
  pinMode(dir_moteur_droite, OUTPUT);

  int dis_AVANT_GAUCHE = SharpIR_AVG.getDistance(0);
  int dis_AVANT_DROITE = SharpIR_AVD.getDistance(0);
  int dis_ARRIERE      = SharpIR_RECUL.getDistance(0);
}

void loop() {
  if ((SharpIR_AVG.getDistance(0) > 10) && (SharpIR_AVG.getDistance(0) > 10))
  {
    marche_avant(100);
  }
  else
  {
    if (SharpIR_AVG.getDistance(0) < 10)
    {
      //stop(); delay(200);
      tourne_droite_avant(100, 50);
    }
    else
    {
      if (SharpIR_AVD.getDistance(0) < 10)
      {
        //stop(); delay(200);
        tourne_gauche_avant(50, 100);
      }
      else
      {
        if ((SharpIR_AVG.getDistance(0) < 10) && (SharpIR_AVD.getDistance(0) < 10))
      {
        stop(); delay(200); recul(100);
        }
        else
        {
          if (SharpIR_RECUL.getDistance(0) < 10)
        {
          stop(); delay(200); marche_avant(100);
          }
        }
      }
    }
  }
}
void tourne_droite_avant(byte vitesse_G, byte vitesse_D)
{
  digitalWrite(dir_moteur_gauche, HIGH);
  digitalWrite(dir_moteur_droite, HIGH);
  analogWrite(pwm_moteur_gauche, vitesse_G);
  analogWrite(pwm_moteur_droite, vitesse_D);
}
void tourne_gauche_avant(byte vitesse_G, byte vitesse_D)
{
  digitalWrite(dir_moteur_gauche, HIGH);
  digitalWrite(dir_moteur_droite, HIGH);
  analogWrite(pwm_moteur_gauche, vitesse_G);
  analogWrite(pwm_moteur_droite, vitesse_D);
}
void marche_avant(byte vitesse)
{
  digitalWrite(dir_moteur_gauche, HIGH);
  digitalWrite(dir_moteur_droite, HIGH);
  analogWrite(pwm_moteur_gauche, vitesse);
  analogWrite(pwm_moteur_droite, vitesse);
}
void recul(byte vitesse)
{
  digitalWrite(dir_moteur_gauche, LOW);
  digitalWrite(dir_moteur_droite, LOW);
  analogWrite(pwm_moteur_gauche, vitesse);
  analogWrite(pwm_moteur_droite, vitesse);
}
void demi_tour_gauche(byte vitesse)
{
  digitalWrite(dir_moteur_gauche, HIGH);
  digitalWrite(dir_moteur_droite, LOW);
  analogWrite(pwm_moteur_gauche, vitesse);
  analogWrite(pwm_moteur_droite, vitesse);
}
void demi_tour_droite(byte vitesse)
{
  digitalWrite(dir_moteur_gauche, LOW);
  digitalWrite(dir_moteur_droite, HIGH);
  analogWrite(pwm_moteur_gauche, vitesse);
  analogWrite(pwm_moteur_droite, vitesse);
}
void stop()
{
  digitalWrite(dir_moteur_gauche, LOW);
  digitalWrite(dir_moteur_droite, LOW);
  analogWrite(pwm_moteur_gauche, 0);
  analogWrite(pwm_moteur_droite, 0);
}

dfgh:
c’est un truc scolaire?

testes çe code que je viens de taper.

et verifies que ton cablage correspond bien au code
et pendant tes essais penses que ton mobile peut tourner à droite au lieu de gauche
et qu’il te faudra inverser les commandes dans le code

#include <SharpIR.h>

#define AVG A0
#define AVD A1
#define REC A2
#define model 1080
const byte pwm_moteur_gauche = 3;
const byte pwm_moteur_droite = 9;
const byte dir_moteur_gauche = 2;
const byte dir_moteur_droite = 8;

SharpIR SharpIR_AVG(AVG, model);
SharpIR SharpIR_AVD(AVD, model);
SharpIR SharpIR_RECUL(REC, model);

void setup() {
  Serial.begin(115200);
  pinMode(pwm_moteur_gauche, OUTPUT);
  analogWrite(pwm_moteur_gauche, 0);
  pinMode(pwm_moteur_droite, OUTPUT);
  analogWrite(pwm_moteur_gauche, 0);
  pinMode(dir_moteur_gauche, OUTPUT);
  pinMode(dir_moteur_droite, OUTPUT);

int dis_AVANT_GAUCHE = SharpIR_AVG.getDistance(0);
  int dis_AVANT_DROITE = SharpIR_AVD.getDistance(0);
  int dis_ARRIERE      = SharpIR_RECUL.getDistance(0);
}

void loop() {
  if ((SharpIR_AVG.getDistance(0) > 10) && (SharpIR_AVG.getDistance(0) > 10))
  {
    marche_avant(100);
  }
  else
  {
    if (SharpIR_AVG.getDistance(0) < 10)
    {
      //stop(); delay(200);
      tourne_droite_avant(100, 50);
    }
    else
    {
      if (SharpIR_AVD.getDistance(0) < 10)
      {
        //stop(); delay(200);
        tourne_gauche_avant(50, 100);
      }
      else
      {
        if ((SharpIR_AVG.getDistance(0) < 10) && (SharpIR_AVD.getDistance(0) < 10))
      {
        stop(); delay(200); recul(100);
        }
        else
        {
          if (SharpIR_RECUL.getDistance(0) < 10)
        {
          stop(); delay(200); marche_avant(100);
          }
        }
      }
    }
  }
}
void tourne_droite_avant(byte vitesse_G, byte vitesse_D)
{
  digitalWrite(dir_moteur_gauche, HIGH);
  digitalWrite(dir_moteur_droite, HIGH);
  analogWrite(pwm_moteur_gauche, vitesse_G);
  analogWrite(pwm_moteur_droite, vitesse_D);
}
void tourne_gauche_avant(byte vitesse_G, byte vitesse_D)
{
  digitalWrite(dir_moteur_gauche, HIGH);
  digitalWrite(dir_moteur_droite, HIGH);
  analogWrite(pwm_moteur_gauche, vitesse_G);
  analogWrite(pwm_moteur_droite, vitesse_D);
}
void marche_avant(byte vitesse)
{
  digitalWrite(dir_moteur_gauche, HIGH);
  digitalWrite(dir_moteur_droite, HIGH);
  analogWrite(pwm_moteur_gauche, vitesse);
  analogWrite(pwm_moteur_droite, vitesse);
}
void recul(byte vitesse)
{
  digitalWrite(dir_moteur_gauche, LOW);
  digitalWrite(dir_moteur_droite, LOW);
  analogWrite(pwm_moteur_gauche, vitesse);
  analogWrite(pwm_moteur_droite, vitesse);
}
void demi_tour_gauche(byte vitesse)
{
  digitalWrite(dir_moteur_gauche, HIGH);
  digitalWrite(dir_moteur_droite, LOW);
  analogWrite(pwm_moteur_gauche, vitesse);
  analogWrite(pwm_moteur_droite, vitesse);
}
void demi_tour_droite(byte vitesse)
{
  digitalWrite(dir_moteur_gauche, LOW);
  digitalWrite(dir_moteur_droite, HIGH);
  analogWrite(pwm_moteur_gauche, vitesse);
  analogWrite(pwm_moteur_droite, vitesse);
}
void stop()
{
  digitalWrite(dir_moteur_gauche, LOW);
  digitalWrite(dir_moteur_droite, LOW);
  analogWrite(pwm_moteur_gauche, 0);
  analogWrite(pwm_moteur_droite, 0);
}

oui c´est scolaire du coup j´ai essayer ton programme malheureusement il me fait tourner une seule roue et le capteur inactif MAIS j´ai trouver une autre solution pour faire reagir les capteurs

int pwm_a = 3;  //PWM control for motor outputs 1 and 2 
int dir_a = 2;  //direction control for motor outputs 1 and 2 
int dir_b = 8;
int pwm_b = 9;
int irSenRead1 =1;
int irSenRead2 =6;
int irSenRead3 =7;
int LED1=1;
int LED2=5;
int LED3=6;
int isObstacle1 = HIGH;
int isObstacle2 = HIGH;
int isObstacle3 = HIGH;
int delayRead =100;
void setup() {
  
  pinMode(irSenRead3 ,INPUT);
   pinMode(LED3 ,OUTPUT);
      pinMode(LED2 ,OUTPUT);
         pinMode(LED1 ,OUTPUT);
    pinMode(pwm_a, OUTPUT);  //Set control pins to be outputs
      pinMode(pwm_b, OUTPUT);
    pinMode(dir_a, OUTPUT);
        pinMode(dir_b, OUTPUT);
   Serial.begin(9600);
   analogWrite(pwm_a, 255);
     analogWrite(pwm_b, 255);

}

void loop() {

  isObstacle1 = digitalRead(irSenRead3);
   Serial.println(digitalRead(irSenRead3));

   // isObstacle ==low there is obstacle infront of sensor
  if (isObstacle1 == LOW) {
    digitalWrite(LED3, HIGH);
  }
  else
  {
 digitalWrite(dir_a, HIGH );
  }
     // isObstacle ==low there is obstacle infront of sensor
  if (isObstacle1 == HIGH) {
    digitalWrite(LED3, HIGH);
  }
  else
  {
 digitalWrite(dir_a, LOW );
  }
    isObstacle2 = digitalRead(irSenRead2);
   Serial.println(digitalRead(irSenRead2));

   // isObstacle ==low there is obstacle infront of sensor
  if (isObstacle2 == LOW) {
    digitalWrite(LED2, HIGH);
  }
  else
  {
 digitalWrite(dir_b, LOW );
  }
     // isObstacle ==low there is obstacle infront of sensor
  if (isObstacle2 == HIGH) {
    digitalWrite(LED2, LOW);
  }
  else
  {
 digitalWrite(dir_b, HIGH );
  }

  delay(delayRead);

}

Probleme avec celui ci je n´arrive que a commander avec 1 capteur les autres ne s´ajoute pas
Bref merci beaucoup pour l´aide precieuse apporter jusque là

bon..., je préfère laisser tomber.
bon courage

:o pourquoi j'ai le sentiment de m’être fait prendre pour un lapin de 3 semaines ??????????????? :o

après avoir découvert ce post chez nos amis brexiteurs

deux posts en même temps, ici et outre Manche

:confused: c'est la nouvelle méthode :confused:

je comprends mieux que tes propositions partent dans tous les sens.
visiblement tu n'es pas opérationnel en C,................ et tu pars de loin.................................

je te laisse avec les english.

Merci pour votre cooperation j´ai reussi a resoudre du coup

int pwm_a = 3;  //PWM control for motor outputs 1 and 2 
int dir_a = 2;  //direction control for motor outputs 1 and 2 
int dir_b = 8;
int pwm_b = 9;
int irSenRead1 =13;
int irSenRead2 =10;
int irSenRead3 =7;
int LED1=12;
int LED2=9;
int LED3=6;
int isObstacle1 = HIGH;
int isObstacle2 = HIGH;
int isObstacle3 = HIGH;
int delayRead =100;

void setup() {
  
  pinMode(irSenRead3 ,INPUT);
   pinMode(LED3 ,OUTPUT);
      pinMode(LED2 ,OUTPUT);
         pinMode(LED1 ,OUTPUT);
    pinMode(pwm_a, OUTPUT);  //Set control pins to be outputs
      pinMode(pwm_b, OUTPUT);
    pinMode(dir_a, OUTPUT);
        pinMode(dir_b, OUTPUT);
   Serial.begin(9600);
   analogWrite(pwm_a, 255);
     analogWrite(pwm_b, 255);

}

void GAUCHE() {

  isObstacle1 = digitalRead(irSenRead3);
   Serial.println(digitalRead(irSenRead3));

   // isObstacle ==low there is obstacle infront of sensor
  if (isObstacle1 == LOW) {
    digitalWrite(LED3, HIGH);
  }
  else
  {
 digitalWrite(dir_a, HIGH );
 digitalWrite(dir_b, LOW);
  }
     // isObstacle ==low there is obstacle infront of sensor
  if (isObstacle1 == HIGH) {
    digitalWrite(LED3, HIGH);
  }
  else
  {
 digitalWrite(dir_a, LOW );
 digitalWrite(dir_b, LOW );
  }
}
  // test capteur centre

void droite() {

  isObstacle2= digitalRead(irSenRead2);
    Serial.println(digitalRead(irSenRead2));
    if(isObstacle2 == LOW) {
      digitalWrite(LED2, HIGH);
    }
    else
    {
      digitalWrite(dir_a, LOW);
      digitalWrite(dir_b, HIGH);
    }
    if(isObstacle2 == HIGH) {
      digitalWrite(LED2, HIGH);
    }
    else
    {
      digitalWrite(dir_a, LOW);
      digitalWrite(dir_b, LOW);
    }
}
void Arriere() {

  isObstacle1= digitalRead(irSenRead1);
    Serial.println(digitalRead(irSenRead1));
    if(isObstacle1 == LOW) {
      digitalWrite(LED1, HIGH);
    }
    else
    {
      digitalWrite(dir_a, HIGH);
      digitalWrite(dir_b, HIGH);
    }
    if(isObstacle1 == HIGH) {
      digitalWrite(LED1, HIGH);
    }
    else
    {
      digitalWrite(dir_a, HIGH);
      digitalWrite(dir_b, HIGH);
    }

void loop() {
  
}
  delay(delayRead);
}