Code qui boucle en permanence

Bonjour

J'ai enfin eu mes petits jouets arduino.
J'ai tout câblé avec le code ci-dessous.
Pour raison pratique j'ai mis des leds à la place des moteurs.

le pb est que les leds s'allument en permanence alternativement et qu'il semble que ni les ultrasons ni les boutons ne fonctionnent ( ils sont bien alimentés électriquement).
Jen'ai même pas la première phqse sans aucune détection pour que les 2 moteurs ( ici les 2 leds) fonctionnent ensemble

 if (!(BtnContact1) && !(BtnContact2) && !(cm)) { // bateau en pleine eau , il va tout droit
    digitalWrite(moteur1, HIGH);
    digitalWrite(moteur2, HIGH);
  }

Code complet

/*
  levinegabriella.com/teaching
  It includes an parallax ultrasonic rangefinder : see data sheet
  http://www.arduino.cc/en/Tutorial/Ping

  created 2011 by gabriella levine
*/


// constants
// set pin numbers:

const int DetecteurPin1 = 2;  // the number of the pushbutton pin  le numero du pin du bouton  commande automatique(presse-bouton)
const int DetecteurPin2 = 4;
const int moteur1 =  3;      // the number of the motor pin    le numero du pin du moteur
const int moteur2 = 11;

// les 2 pin ultrason
#define echoPin 7 // broche Echo 
#define trigPin 8 // broche Trigger (declenchement)


// variables
int BtnContact1 = 0;    // variable pour lire le statut des boutons poussoirs
int BtnContact2 = 0;

void setup() {
  //begin serial
  Serial.begin(9600);

  // Activer les broches ultrason
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);

  // initialize the motors  as output:
  pinMode(moteur1, OUTPUT);
  pinMode(moteur2, OUTPUT);

  // initialize the pushbutton pins as  input:
  pinMode(DetecteurPin1, INPUT_PULLUP); // remplace INPUT permet de mettre un simple poussoir sans résistance
  pinMode(DetecteurPin2, INPUT_PULLUP); // remplace INPUT permet de mettre un simple poussoir sans résistance

}



void loop() {
  // establish variables for duration of the ping,
  // and the distance result in centimeters:

  long distance, duration, cm; // Durée utilisée pour calculer la distance

  // Envoi une impulsion de 10 micro secondes sur la broche "trigger"
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Attend que la broche Echo passe au niveau HAUT et retourne la durée
  duration = pulseIn(echoPin, HIGH);

  //Calculer la distance (en cm, basé sur la vitesse du son).
  distance = duration / 58.2;
  cm = distance;

  // read the state of the pushbutton value:
  BtnContact1 = digitalRead(DetecteurPin1);
  BtnContact2 = digitalRead(DetecteurPin2);

  // mouvement en pleine eau qui evite les bords si contact
  if (!(BtnContact1) && !(BtnContact2) && !(cm)) { // bateau en pleine eau , il va tout droit
    digitalWrite(moteur1, HIGH);
    digitalWrite(moteur2, HIGH);
  }

  else if (cm <= 15) { // si 1er contact ultrason, on tourne à droite
    digitalWrite(moteur1, LOW);
    digitalWrite(moteur2, HIGH);
  }

  if (BtnContact1 == HIGH) {
    digitalWrite(moteur1, LOW);
    digitalWrite(moteur2, HIGH);
    delay (5000);  //  tourne encore pendant 5ec pour s'axer vers le miieu de la piscine
    digitalWrite(moteur1, HIGH);// va tout droit
    digitalWrite(moteur2, HIGH);
  }

  if (cm <= 15) { // si 2er contact ultrason, on tourne à gauche
    digitalWrite(moteur1, HIGH);
    digitalWrite(moteur2, LOW);
  }

  if (BtnContact2 == HIGH) {
    digitalWrite(moteur1, HIGH);
    digitalWrite(moteur2, LOW);
    delay (5000);  //  tourne encore pendant 5ec pour s'axer vers le miieu de la piscine
    digitalWrite(moteur1, HIGH);
    digitalWrite(moteur2, HIGH);
  }

  /*Partie originale
    if (cm <= 15) {
      //digitalWrite(motor, LOW);
      digitalWrite(motor2, LOW);
    }
    else {
      //digitalWrite(motor, HIGH);
      digitalWrite(motor2, HIGH);
      button();
    }
  */
  delay(100);
}

void button() {
  // check if the pushbutton is pressed.
  // if it is, the buttonState is HIGH:

  if (BtnContact1 == HIGH) {
    digitalWrite(moteur1, LOW);
  }
  else {
    digitalWrite(moteur1, HIGH);
  }

  if (BtnContact2 == HIGH) {
    digitalWrite(moteur2, LOW);
  }
  else {
    digitalWrite(moteur2, HIGH);
  }
}



long microsecondsToCentimeters(long microseconds)

{
  return microseconds / 29 / 2;
}

Bienvenue dans la vraie vie !!! :slight_smile:

:confused: :confused: :confused: :confused: :confused:

Je me demande s'il ne faut pas une bibliothèque pour les ultrason ?!
J'ai pris la toute dernière ici

Tel que ton code est écrit, tu n'as pas besoin d'une bibli pour les ultrasons : ce qui est écrit fonctionne très bien. Il y a un fil de discussion près du tien qui fait un truc similaire : tu peux voir son code, il est pareil pour les ultrasons avec en plus la gestion de l'onde perdue.

Tu déclares cm comme un entier et tu fais ce test:

  if (!(BtnContact1) && !(BtnContact2) && !(cm)) {

(!cm) signifie 'cm == 0' :est-ce ce que tu veux tester ? Si la distance est nulle, tu n'es pas en pleine eau. Par contre, c'est le cas où l'onde est perdue (duration > 30000) qui indique que tu es en pleine eau. Une distance supérieure à un seuil aussi.

Pour savoir ce qui se passe dans l'exécution de ton code, il faut que tu mettes des Serial.print dans tes tests. Par exemple :

  if (BtnContact1 == HIGH) {
    Serial.println("BtnContact1 == HIGH");  // <---- pour débug (tu peux ajouter d'autres textes plus explicites
    digitalWrite(moteur1, LOW);
    digitalWrite(moteur2, HIGH);
    delay (5000);  //  tourne encore pendant 5ec pour s'axer vers le miieu de la piscine
    digitalWrite(moteur1, HIGH);// va tout droit
    digitalWrite(moteur2, HIGH);
  }

Ça te permettra de suivre l'exécution et de comprendre pourquoi tes LEDs s'allument.

Pour nous, ce n'est pas facile de t'aider car l'exécution dépend de l'état de tes boutons et de la mesure de distance, et ça il n'y a que toi qui puisse le voir. Dans un premier temps, tu devrais faire afficher la distance pour savoir si elle est correctement mesurée. Le reste de l'exécution en dépend.

Merci pour pleine eau. Du coup je dis que si rien à 20 cm, alors je suis en pleine eau.

J'ai mis le maxi de serial.print.
Je teste ce soir

question 1 : la dernière ligne ne me sert pas non ?

long microsecondsToCentimeters(long microseconds)
{
  return microseconds / 29 / 2;
}

Question 2 :
la formulation est bonne , pour afficher mon texte et la valeur 'cm' ?

Serial.println("1° Echo à 15cm,tourne à dte, moteur1droite 0 et moteur2gauche 1  " "  cm"  );
#include <Ultrasonic.h>

/*
  levinegabriella.com/teaching
  It includes an parallax ultrasonic rangefinder : see data sheet
  http://www.arduino.cc/en/Tutorial/Ping

  created 2011 by gabriella levine
*/


// constants
// set pin numbers:

const int DetecteurPin1 = 2;  // the number of the pushbutton pin  le numero du pin du bouton  commande automatique(presse-bouton)
const int DetecteurPin2 = 4;
const int moteur1 =  3;      // the number of the motor pin    le numero du pin du moteur
const int moteur2 = 11;

// les 2 pin ultrason
#define echoPin 7 // broche Echo                     ancien code
#define trigPin 8 // broche Trigger (declenchement)  ancien code

// variables
int BtnContact1 = 0;    // variable pour lire le statut des boutons poussoirs
int BtnContact2 = 0;

void setup() {
  //begin serial
  Serial.begin(9600);

  // Activer les broches ultrason
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);

  // initialize the motors  as output:
  pinMode(moteur1, OUTPUT);
  pinMode(moteur2, OUTPUT);

  // initialize the pushbutton pins as  input:
  pinMode(DetecteurPin1, INPUT_PULLUP); // remplace INPUT permet de mettre un simple poussoir sans résistance
  pinMode(DetecteurPin2, INPUT_PULLUP); // remplace INPUT permet de mettre un simple poussoir sans résistance

}



void loop() {
  // establish variables for duration of the ping,
  // and the distance result in centimeters:

  long distance, duration, cm; // Durée utilisée pour calculer la distance

  // Envoi une impulsion de 10 micro secondes sur la broche "trigger"
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Attend que la broche Echo passe au niveau HAUT et retourne la durée
  duration = pulseIn(echoPin, HIGH);

  //Calculer la distance (en cm, basé sur la vitesse du son).
  distance = duration / 58.2;
  cm = distance;

  // read the state of the pushbutton value:
  BtnContact1 = digitalRead(DetecteurPin1);
  BtnContact2 = digitalRead(DetecteurPin2);

  // mouvement en pleine eau (si rien devant à 20 cm)qui evite les bords si contact
  if (!(BtnContact1) && !(BtnContact2) && (cm >= 20)) { // bateau en pleine eau rien à l'avant sur 20 cm , il va tout droit
    Serial.println("rien à 20cm, 2 moteurs tournent" "  cm"  );  // <---- pour débug 
    digitalWrite(moteur1, HIGH);
    digitalWrite(moteur2, HIGH);
  }

  else if (cm <= 15) { // si 1er contact ultrason, on tourne à droite
    Serial.println("1° Echo à 15cm,tourne à dte, moteur1droite 0 et moteur2gauche 1  " "  cm"  );  // <---- pour débug 
    digitalWrite(moteur1, LOW);
    digitalWrite(moteur2, HIGH);
  }

    if (BtnContact1 == HIGH) {
    Serial.println("BtnContact1 à gauche est appuyé,  moteur droit arret, moteur gauche tourne ");  // <---- pour débug 
    digitalWrite(moteur1, LOW);
    digitalWrite(moteur2, HIGH);
    delay (5000);  //  tourne encore pendant 5ec pour s'axer vers le miieu de la piscine
    digitalWrite(moteur1, HIGH);// va tout droit
    digitalWrite(moteur2, HIGH);
  }

  if (cm <= 15) { // si 2er contact ultrason, on tourne à gauche
    Serial.println("2° Echo à 15cm,tourne à gche, moteur1droite 1 et moteur2gauche 0" "  cm" );  // <---- pour débug 
    digitalWrite(moteur1, HIGH);
    digitalWrite(moteur2, LOW);
  }

  if (BtnContact2 == HIGH) {
    Serial.println("BtnContact2 à droite est appuyé, moteur gauche arret, moteur droit tourne " "  cm" );  // <---- pour débug 
    digitalWrite(moteur1, HIGH);
    digitalWrite(moteur2, LOW);
    delay (5000);  //  tourne encore pendant 5ec pour s'axer vers le miieu de la piscine
    digitalWrite(moteur1, HIGH);
    digitalWrite(moteur2, HIGH);
  }

  /*Partie originale
    if (cm <= 15) {
      //digitalWrite(motor, LOW);
      digitalWrite(motor2, LOW);
    }
    else {
      //digitalWrite(motor, HIGH);
      digitalWrite(motor2, HIGH);
      button();
    }
  */
  delay(100);
}

void button() {
  // check if the pushbutton is pressed.
  // if it is, the buttonState is HIGH:

  if (BtnContact1 == HIGH) {
    digitalWrite(moteur1, LOW);
  }
  else {
    digitalWrite(moteur1, HIGH);
  }

  if (BtnContact2 == HIGH) {
    digitalWrite(moteur2, LOW);
  }
  else {
    digitalWrite(moteur2, HIGH);
  }
}



long microsecondsToCentimeters(long microseconds)

{
  return microseconds / 29 / 2;
}

Non, en effet ces lignes ne servent pas, tu peux les enlever. La bibli aussi.

Tes Serial.println m'inquiètent, mais il semble que ça compile, donc... on verra comment ça s'exécute...
    Serial.println("rien à 20cm, 2 moteurs tournent" "  cm"  );  // <---- pour débug Moi j'aurais écrit :

    Serial.print("rien à 20cm, 2 moteurs tournent - distance mesuree = ");
    Serial.println(cm);  // <---- pour débug

Tu devrais afficher la valeur de cm directement après son calcul :

  cm = distance;
  Serial.print("Distance mesuree = ");
  Serial.println(cm);  // <---- pour débug

C'est plus clair comme tu l'écrits.
J'ai donc modifié
Je teste en rentrant chez moi ce soir

Ps : ta signature me correspond tout à fait ;D

#include <Ultrasonic.h>

/*
  levinegabriella.com/teaching
  It includes an parallax ultrasonic rangefinder : see data sheet
  http://www.arduino.cc/en/Tutorial/Ping

  created 2011 by gabriella levine
*/


// constants
// set pin numbers:

const int DetecteurPin1 = 2;  // the number of the pushbutton pin  le numero du pin du bouton  commande automatique(presse-bouton)
const int DetecteurPin2 = 4;
const int moteur1 =  3;      // the number of the motor pin    le numero du pin du moteur
const int moteur2 = 11;

// les 2 pin ultrason
#define echoPin 7 // broche Echo                     ancien code
#define trigPin 8 // broche Trigger (declenchement)  ancien code

// variables
int BtnContact1 = 0;    // variable pour lire le statut des boutons poussoirs
int BtnContact2 = 0;

void setup() {
  //begin serial
  Serial.begin(9600);

  // Activer les broches ultrason
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);

  // initialize the motors  as output:
  pinMode(moteur1, OUTPUT);
  pinMode(moteur2, OUTPUT);

  // initialize the pushbutton pins as  input:
  pinMode(DetecteurPin1, INPUT_PULLUP); // remplace INPUT permet de mettre un simple poussoir sans résistance
  pinMode(DetecteurPin2, INPUT_PULLUP); // remplace INPUT permet de mettre un simple poussoir sans résistance

}



void loop() {
  // establish variables for duration of the ping,
  // and the distance result in centimeters:

  long distance, duration, cm; // Durée utilisée pour calculer la distance

  // Envoi une impulsion de 10 micro secondes sur la broche "trigger"
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Attend que la broche Echo passe au niveau HAUT et retourne la durée
  duration = pulseIn(echoPin, HIGH);

  //Calculer la distance (en cm, basé sur la vitesse du son).
  distance = duration / 58.2;
  cm = distance;

  // read the state of the pushbutton value:
  BtnContact1 = digitalRead(DetecteurPin1);
  BtnContact2 = digitalRead(DetecteurPin2);

  // mouvement en pleine eau (si rien devant à 20 cm)qui evite les bords si contact
  if (!(BtnContact1) && !(BtnContact2) && (cm >= 20)) { // bateau en pleine eau rien à l'avant sur 20 cm , il va tout droit
    Serial.print("rien à 20cm, 2 moteurs tournent - distance mesuree = ");  // <---- pour débug  
    Serial.println(cm);  // <---- pour débug  
    digitalWrite(moteur1, HIGH);
    digitalWrite(moteur2, HIGH);
  }

  else if (cm <= 15) { // si 1er contact ultrason, on tourne à droite
    Serial.println("1° Echo inféruer à 15cm,tourne à dte, moteur1droite 0 et moteur2gauche 1 - distance mesuree = "  );  // <---- pour débug 
    Serial.println(cm);  // <---- pour débug 
    digitalWrite(moteur1, LOW);
    digitalWrite(moteur2, HIGH);
  }

    if (BtnContact1 == HIGH) {
    Serial.println("BtnContact1 à gauche est appuyé,  moteur droit arret, moteur gauche tourne - distance mesuree = ");  // <---- pour débug 
    Serial.println(cm);  // <---- pour débug 
    digitalWrite(moteur1, LOW);
    digitalWrite(moteur2, HIGH);
    delay (5000);  //  tourne encore pendant 5ec pour s'axer vers le miieu de la piscine
    digitalWrite(moteur1, HIGH);// va tout droit
    digitalWrite(moteur2, HIGH);
  }

  if (cm <= 15) { // si 2er contact ultrason, on tourne à gauche
    Serial.println("2° Echo inféruer à 15cm,tourne à gche, moteur1droite 1 et moteur2gauche 0 - distance mesuree = " );  // <---- pour débug 
    Serial.println(cm);  // <---- pour débug 
    digitalWrite(moteur1, HIGH);
    digitalWrite(moteur2, LOW);
  }

  if (BtnContact2 == HIGH) {
    Serial.println("BtnContact2 à droite est appuyé, moteur gauche arret, moteur droit tourne - distance mesuree = " );  // <---- pour débug 
    Serial.println(cm);  // <---- pour débug 
    digitalWrite(moteur1, HIGH);
    digitalWrite(moteur2, LOW);
    delay (5000);  //  tourne encore pendant 5ec pour s'axer vers le miieu de la piscine
    digitalWrite(moteur1, HIGH);
    digitalWrite(moteur2, HIGH);
  }

  /*Partie originale
    if (cm <= 15) {
      //digitalWrite(motor, LOW);
      digitalWrite(motor2, LOW);
    }
    else {
      //digitalWrite(motor, HIGH);
      digitalWrite(motor2, HIGH);
      button();
    }
  */
  delay(100);
}

void button() {
  // check if the pushbutton is pressed.
  // if it is, the buttonState is HIGH:

  if (BtnContact1 == HIGH) {
    digitalWrite(moteur1, LOW);
  }
  else {
    digitalWrite(moteur1, HIGH);
  }

  if (BtnContact2 == HIGH) {
    digitalWrite(moteur2, LOW);
  }
  else {
    digitalWrite(moteur2, HIGH);
  }
}

Après une lecture en diagonale, l’enchevêtrement de if else me parait bien tordu.
Si j'étais toi, j'écrirais sur une feuille le comportement attendu et je comparerais avec le code que tu nous proposes je ne suis pas certain que tu retrouves tes petits là-dedans.

Je pense que ton calcul de distance peut être amélioré. Il y a un bon tuto ici.

PulseIn renvoie une durée en microsecondes. C'est le temps nécessaire a un aller-retour (A/R) du signal ultrason à la vitesse du son (340 m/s en première approximation). Si la "cible" se trouve à 1 mètre, le temps A/R vaut t = 2*d/v soit 5.88 ms ou 5882 microsecondes.

Lorsque tu calcules la distance, tu fais   distance = duration / 58.2;Il faudrait diviser par 58.82...

Le tuto utilise une option de pulseIn : le timeout, qui correspond au temps nécessaire avant de considérer qu'il n'y a pas d'obstacle, donc pas de mesure possible (1 seconde par défaut, ce qui est énorme). Tu devrais choisir une distance maximale au delà de laquelle il ne sert à rien de mesurer, afin de ne pas bloquer le code en attente du retour du signal. Si le capteur arrive au timeout, il pulseIn renvoie une durée nulle.
Connaissant ta distance max (en mètres), tu calcules le timeout avec:
TIMEOUT = distance_max / 2.0 / 340.0 * 1000000et tu le déclares dans l'entête comme c'est fait dans le tuto.

Me voilà avec les tests.
Je regarde le tuto ensuite.

Voici les retours

BtnContact2 à droite est appuyé, moteur gauche arret, moteur droit tourne - distance mesuree = 
2276
BtnContact1 à gauche est appuyé,  moteur droit arret, moteur gauche tourne - distance mesuree = 
2277
BtnContact2 à droite est appuyé, moteur gauche arret, moteur droit tourne - distance mesuree = 
2277
BtnContact1 à gauche est appuyé,  moteur droit arret, moteur gauche tourne - distance mesuree = 
2276

alors qu'aucun contact n'est appuyé

Et qu'y a-t-il à 22 mètres et 76 centimètres ? 2276 correspond à 132 463 microsecondes d'attente, soit 0.13 secondes. C'est long. Mets un timeout...

Tes deux boutons sont déclarés en INPUT_PULLUP, est-ce que tu les as bien connectés comme ceci :
GND -- Bouton -- Pin (2 et 4)

Si oui, alors bouton appuyé == LOW... Or tu testes HIGH :

if (BtnContact1 == HIGH)
if (BtnContact2 == HIGH)

et
if (!(BtnContact1) && !(BtnContact2) && (cm >= 20))équivaut à :
Bouton 1 appuyé ET bouton 2 appuyé ET distance inférieure à 20 (cm)

Conclusion : revoie tes tests...

alors , avant les 22m , j'ai mon plafond ;D ;D

J'ai modifié le code après le tuto et j'ai fait le graphe pleine eau

[/
0.00cm, 1° Echo inféruer à 15cm,tourne à dte, moteur1droite 0 et moteur2gauche 1 - distance mesuree = 
2
BtnContact1 à gauche est appuyé,  moteur droit arret, moteur gauche tourne - distance mesuree = 
2
2° Echo inféruer à 15cm,tourne à gche, moteur1droite 1 et moteur2gauche 0 - distance mesuree = 
2
BtnContact2 à droite est appuyé, moteur gauche arret, moteur droit tourne - distance mesuree = 
2
code]

[code]
/*
  levinegabriella.com/teaching
  It includes an parallax ultrasonic rangefinder : see data sheet
  http://www.arduino.cc/en/Tutorial/Ping

  created 2011 by gabriella levine
*/


// constants
// set pin numbers:

const int DetecteurPin1 = 2;  // the number of the pushbutton pin  le numero du pin du bouton  commande automatique(presse-bouton)
const int DetecteurPin2 = 4;
const int moteur1 =  3;      // the number of the motor pin    le numero du pin du moteur
const int moteur2 = 11;


/* Constantes pour les broches */
const byte TRIGGER_PIN = 2; // Broche TRIGGER
const byte ECHO_PIN = 3;    // Broche ECHO

/* Constantes pour le timeout */
const unsigned long MEASURE_TIMEOUT = 735UL; // 25 000 pour 25ms = ~8m à 340m/s
//calcul de TIMEOUT = distance_max / 2.0 / 340.0 * 1000000 pour 50 cm 735ms
// 0.50 m/2 = 0.25/340 = 0.000735 x 1 000 000 = 735 ms
/* Vitesse du son dans l'air en mm/us */
const float SOUND_SPEED = 340.0 / 1000;

//Calculer la distance (en cm, basé sur la vitesse du son).
long cm = 0;

// variables
int BtnContact1 = 0;    // variable pour lire le statut des boutons poussoirs
int BtnContact2 = 0;

void setup() {
  //begin serial
  Serial.begin(9600);

  //Initialise les broches
  pinMode(TRIGGER_PIN, OUTPUT);
  digitalWrite(TRIGGER_PIN, LOW); // La broche TRIGGER doit être à LOW au repos
  pinMode(ECHO_PIN, INPUT);


  // initialize the motors  as output:
  pinMode(moteur1, OUTPUT);
  pinMode(moteur2, OUTPUT);

  // initialize the pushbutton pins as  input:
  pinMode(DetecteurPin1, INPUT_PULLUP); // remplace INPUT permet de mettre un simple poussoir sans résistance
  pinMode(DetecteurPin2, INPUT_PULLUP); // remplace INPUT permet de mettre un simple poussoir sans résistance

}



void loop() {
  /* 1. Lance une mesure de distance en envoyant une impulsion HIGH de 10µs sur la broche TRIGGER */
  digitalWrite(TRIGGER_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIGGER_PIN, LOW);

  /* 2. Mesure le temps entre l'envoi de l'impulsion ultrasonique et son écho (si il existe) */
  long measure = pulseIn(ECHO_PIN, HIGH, MEASURE_TIMEOUT);

  /* 3. Calcul la distance à partir du temps mesuré */
  float distance_mm = measure / 2.0 * SOUND_SPEED;

  //Calculer la distance (en cm, basé sur la vitesse du son).
  cm = (distance_mm / 10.0, 2);

  // afficher en cm
  Serial.print(distance_mm / 10.0, 2);
  Serial.print(F("cm, "));

  /* Délai d'attente pour éviter d'afficher trop de résultats à la seconde */
  delay(500);


  // read the state of the pushbutton value:
  BtnContact1 = digitalRead(DetecteurPin1);
  BtnContact2 = digitalRead(DetecteurPin2);

  // mouvement en pleine eau (si rien devant à 20 cm)qui evite les bords si contact
  if (!(BtnContact1) && !(BtnContact2) && (cm >= 20)) { // bateau en pleine eau rien à l'avant sur 20 cm , il va tout droit
    Serial.print("rien à 20cm, 2 moteurs tournent - distance mesuree = ");  // <---- pour débug
    Serial.println(cm);  // <---- pour débug
    digitalWrite(moteur1, HIGH);
    digitalWrite(moteur2, HIGH);
  }

  else if (cm <= 15) { // si 1er contact ultrason, on tourne à droite
    Serial.println("1° Echo inféruer à 15cm,tourne à dte, moteur1droite 0 et moteur2gauche 1 - distance mesuree = "  );  // <---- pour débug
    Serial.println(cm);  // <---- pour débug
    digitalWrite(moteur1, LOW);
    digitalWrite(moteur2, HIGH);
  }

  if (BtnContact1 == HIGH) {
    Serial.println("BtnContact1 à gauche est appuyé,  moteur droit arret, moteur gauche tourne - distance mesuree = ");  // <---- pour débug
    Serial.println(cm);  // <---- pour débug
    digitalWrite(moteur1, LOW);
    digitalWrite(moteur2, HIGH);
    delay (5000);  //  tourne encore pendant 5ec pour s'axer vers le miieu de la piscine
    digitalWrite(moteur1, HIGH);// va tout droit
    digitalWrite(moteur2, HIGH);
  }

  if (cm <= 15) { // si 2er contact ultrason, on tourne à gauche
    Serial.println("2° Echo inféruer à 15cm,tourne à gche, moteur1droite 1 et moteur2gauche 0 - distance mesuree = " );  // <---- pour débug
    Serial.println(cm);  // <---- pour débug
    digitalWrite(moteur1, HIGH);
    digitalWrite(moteur2, LOW);
  }

  if (BtnContact2 == HIGH) {
    Serial.println("BtnContact2 à droite est appuyé, moteur gauche arret, moteur droit tourne - distance mesuree = " );  // <---- pour débug
    Serial.println(cm);  // <---- pour débug
    digitalWrite(moteur1, HIGH);
    digitalWrite(moteur2, LOW);
    delay (5000);  //  tourne encore pendant 5ec pour s'axer vers le miieu de la piscine
    digitalWrite(moteur1, HIGH);
    digitalWrite(moteur2, HIGH);
  }

  /*Partie originale
    if (cm <= 15) {
      //digitalWrite(motor, LOW);
      digitalWrite(motor2, LOW);
    }
    else {
      //digitalWrite(motor, HIGH);
      digitalWrite(motor2, HIGH);
      button();
    }
  */
  delay(100);
}

void button() {
  // check if the pushbutton is pressed.
  // if it is, the buttonState is HIGH:

  if (BtnContact1 == HIGH) {
    digitalWrite(moteur1, LOW);
  }
  else {
    digitalWrite(moteur1, HIGH);
  }

  if (BtnContact2 == HIGH) {
    digitalWrite(moteur2, LOW);
  }
  else {
    digitalWrite(moteur2, HIGH);
  }
}

lesept:
Tes deux boutons sont déclarés en INPUT_PULLUP, est-ce que tu les as bien connectés comme ceci :
GND -- Bouton -- Pin (2 et 4)

Si oui, alors bouton appuyé == LOW... Or tu testes HIGH :

if (BtnContact1 == HIGH)

if (BtnContact2 == HIGH)



et


if (!(BtnContact1) && !(BtnContact2) && (cm >= 20))



équivaut à :
Bouton 1 appuyé ET bouton 2 appuyé ET distance inférieure à 20 (cm)

Alors pour les boutons en INPUT_PULLUP, le branchement est bon et mon image vient du même site que toi.
Pour les contacts , effectivement si btn non appuyé le moteur doit tourner, c'était l'inverse

Pour le TIMEOUT, je m'y colle

Voici le retour
Il y a bien une phase ou les 2 leds s'allument mais cela doit durer 0.5 sec

0.00cm, 1° Echo inféruer à 15cm,tourne à dte, moteur1droite 0 et moteur2gauche 1 - distance mesuree = 
2
BtnContact1 à gauche est appuyé,  moteur droit arret, moteur gauche tourne - distance mesuree = 
2
2° Echo inféruer à 15cm,tourne à gche, moteur1droite 1 et moteur2gauche 0 - distance mesuree = 
2
BtnContact2 à droite est appuyé, moteur gauche arret, moteur droit tourne - distance mesuree = 
2

OK, tu reposteras la nouvelle version du code lorsque tu auras faits ces deux modifs (tests & timeout), je vais étudier le graphe...

Attention : si tu restes en cm, il te faut une constante en cm/µs :

/* Vitesse du son dans l'air en mm/us */
const float SOUND_SPEED = 340.0 / 1000;

OK tu divises par 10 ensuite, je n'avais pas vu. Par contre, ça :
cm = (distance_mm / 10.0, 2);ça m'étonnerait que ça compile. De toutes façons cm est un entier, donc tu n'as pas besoin de chiffres après la virgule, ni d'une précision au mm. tu peux garder :
cm = distance_mm / 10;et pareil dans le println.

Pour le timeout :

//calcul de TIMEOUT = distance_max / 2.0 / 340.0 * 1000000 pour 50 cm 735ms
// 0.50 m/2 = 0.25/340 = 0.000735 x 1 000 000 = 735 ms

Moi j'avais calculé 5.88ms pour 1 mètre, donc plus près de 3 ms pour 50 cm.

lesept:
Pour le timeout :

//calcul de TIMEOUT = distance_max / 2.0 / 340.0 * 1000000 pour 50 cm 735ms

// 0.50 m/2 = 0.25/340 = 0.000735 x 1 000 000 = 735 ms



Moi j'avais calculé 5.88ms pour 1 mètre, donc plus près de 3 ms pour 50 cm.

J'avais un doute sur mon calcul.
Peux tu me passer le tien pour voir stp ?

Pour le graphe, je veux simplement que le bateau se promène dans la piscine et dès qu'il s'approche d'un bord il s'en éloigne.
Je ne sais pas si mon graphe correspond à cela.

Je suis de retour vers 22h00

Il est dans la réponse #8

Donc pour le Timeout je mets

if (measure == 0) { faire tourner les deux moteurs a HIGH }

Desole pour les accents et ponctuations je reponds avec mon telephone

Pour changer le moins possible ton code, tu peux mettre juste après le calcul de cm :
if (measure ==0) cm = 1000;Comme ça tu es sûr qu'en cas de timeout, tu prendras la condition "pleine eau" (si c'est bien ce que tu veux...)

Pour le TimeOut, point pour toi.
J'avais divisé par 2 la distance maxi au lieu de multiplier et mis un 0 en trop après la virgule. :-[

le test

0.00cm, BtnContact1 à gauche est appuyé,  moteur droit arret, moteur gauche tourne - distance mesuree = 
1000
BtnContact2 à droite est appuyé, moteur gauche arret, moteur droit tourne - distance mesuree = 
1000
0.00cm, BtnContact1 à gauche est appuyé,  moteur droit arret, moteur gauche tourne - distance mesuree = 
1000
BtnContact2 à droite est appuyé, moteur gauche arret, moteur droit tourne - distance mesuree = 
1000

Aucun obstacle devant ultrason
Si on appuie sur les bouton cela donne ceci.

J'ai remarqué une certaine latence pour passer l'information du bouton appuyé.
J'appuie sur le btn1 la led1 s'allume, j'appuie sur le btn2 la led1 s'allume encore un peu puis la led2 s'allume.
J'ai aussi remarqué que, même si je reste appuyé sur un btn, pendant un très court instant ( 1/2 sec env) les 2 leds s'allument

0.00cm, BtnContact1 à gauche est appuyé,  moteur droit arret, moteur gauche tourne - distance mesuree = 
1000
BtnContact2 à droite est appuyé, moteur gauche arret, moteur droit tourne - distance mesuree = 
1000
0.00cm, BtnContact2 à droite est appuyé, moteur gauche arret, moteur droit tourne - distance mesuree = 
1000
0.00cm, BtnContact2 à droite est appuyé, moteur gauche arret, moteur droit tourne - distance mesuree = 
1000
0.00cm, BtnContact2 à droite est appuyé, moteur gauche arret, moteur droit tourne - distance mesuree = 
1000
0.00cm, BtnContact1 à gauche est appuyé,  moteur droit arret, moteur gauche tourne - distance mesuree = 
1000
0.00cm, BtnContact1 à gauche est appuyé,  moteur droit arret, moteur gauche tourne - distance mesuree = 
1000

le code complet

/*
  levinegabriella.com/teaching
  It includes an parallax ultrasonic rangefinder : see data sheet
  http://www.arduino.cc/en/Tutorial/Ping

  created 2011 by gabriella levine
*/


// constants
// set pin numbers:

const int DetecteurPin1 = 2;  // the number of the pushbutton pin  le numero du pin du bouton  commande automatique(presse-bouton)
const int DetecteurPin2 = 4;
const int moteur1 =  3;      // the number of the motor pin    le numero du pin du moteur
const int moteur2 = 11;


/* Constantes pour les broches */
const byte TRIGGER_PIN = 2; // Broche TRIGGER
const byte ECHO_PIN = 3;    // Broche ECHO

/* Constantes pour le timeout */
const unsigned long MEASURE_TIMEOUT = 2941UL; // exemple initial 25 000 pour 25ms = ~8m à 340m/s
//calcul de TIMEOUT = distance_max x 2 / 340.0 x 1000000 pour 50 cm 735ms
// 0.50 mx2 = 1/340 = 0.00294 x 1 000 000 = 2941 ms
// si à 0.50 m on n'a pas d'obstacle, on est en pleine eau
/* Vitesse du son dans l'air en mm/us */
const float SOUND_SPEED = 340.0 / 1000;

//Calculer la distance (en cm, basé sur la vitesse du son).
long cm = 0;

// variables
int BtnContact1 = 0;    // variable pour lire le statut des boutons poussoirs
int BtnContact2 = 0;

void setup() {
  //begin serial
  Serial.begin(9600);

  //Initialise les broches
  pinMode(TRIGGER_PIN, OUTPUT);
  digitalWrite(TRIGGER_PIN, LOW); // La broche TRIGGER doit être à LOW au repos
  pinMode(ECHO_PIN, INPUT);


  // initialize the motors  as output:
  pinMode(moteur1, OUTPUT);
  pinMode(moteur2, OUTPUT);

  // initialize the pushbutton pins as  input:
  pinMode(DetecteurPin1, INPUT_PULLUP); // remplace INPUT permet de mettre un simple poussoir sans résistance
  pinMode(DetecteurPin2, INPUT_PULLUP); // remplace INPUT permet de mettre un simple poussoir sans résistance

}



void loop() {
  /* 1. Lance une mesure de distance en envoyant une impulsion HIGH de 10µs sur la broche TRIGGER */
  digitalWrite(TRIGGER_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIGGER_PIN, LOW);

  /* 2. Mesure le temps entre l'envoi de l'impulsion ultrasonique et son écho (si il existe) */
  long measure = pulseIn(ECHO_PIN, HIGH, MEASURE_TIMEOUT);

  /* 3. Calcul la distance à partir du temps mesuré */
  float distance_mm = measure / 2.0 * SOUND_SPEED;

  //Calculer la distance (en cm, basé sur la vitesse du son).
  cm = distance_mm / 10;
  if (measure == 0) cm = 1000; // Measure TimeOut =  à 0, si à 0.50 m on n'a pas d'obstacle, on est en pleine eau

  // afficher en cm
  Serial.print(distance_mm / 10);
  Serial.print(F("cm, "));

  /* Délai d'attente pour éviter d'afficher trop de résultats à la seconde */
  delay(500);


  // read the state of the pushbutton value:
  BtnContact1 = digitalRead(DetecteurPin1);
  BtnContact2 = digitalRead(DetecteurPin2);

  // mouvement en pleine eau (si rien devant à 50 cm)qui evite les bords si contact
  if (!(BtnContact1) && !(BtnContact2) && (cm >= 50)) { // bateau en pleine eau rien à l'avant sur 20 cm , il va tout droit
    Serial.print("rien à 50cm, 2 moteurs tournent - distance mesuree = ");  // <---- pour débug
    Serial.println(cm);  // <---- pour débug
    digitalWrite(moteur1, HIGH);
    digitalWrite(moteur2, HIGH);
  }

  else if (cm <= 15) { // si 1er contact ultrason, on tourne à droite
    Serial.println("1° Echo inféruer à 15cm,tourne à dte, moteur1droite 0 et moteur2gauche 1 - distance mesuree = "  );  // <---- pour débug
    Serial.println(cm);  // <---- pour débug
    digitalWrite(moteur1, LOW);
    digitalWrite(moteur2, HIGH);
  }

  if (BtnContact1 == HIGH) {
    Serial.println("BtnContact1 à gauche est appuyé,  moteur droit arret, moteur gauche tourne - distance mesuree = ");  // <---- pour débug
    Serial.println(cm);  // <---- pour débug
    digitalWrite(moteur1, LOW);
    digitalWrite(moteur2, HIGH);
    delay (5000);  //  tourne encore pendant 5ec pour s'axer vers le miieu de la piscine
    digitalWrite(moteur1, HIGH);// va tout droit
    digitalWrite(moteur2, HIGH);
  }

  if (cm <= 15) { // si 2er contact ultrason, on tourne à gauche
    Serial.println("2° Echo inféruer à 15cm,tourne à gche, moteur1droite 1 et moteur2gauche 0 - distance mesuree = " );  // <---- pour débug
    Serial.println(cm);  // <---- pour débug
    digitalWrite(moteur1, HIGH);
    digitalWrite(moteur2, LOW);
  }

  if (BtnContact2 == HIGH) {
    Serial.println("BtnContact2 à droite est appuyé, moteur gauche arret, moteur droit tourne - distance mesuree = " );  // <---- pour débug
    Serial.println(cm);  // <---- pour débug
    digitalWrite(moteur1, HIGH);
    digitalWrite(moteur2, LOW);
    delay (5000);  //  tourne encore pendant 5ec pour s'axer vers le miieu de la piscine
    digitalWrite(moteur1, HIGH);
    digitalWrite(moteur2, HIGH);
  }

  /*Partie originale
    if (cm <= 15) {
      //digitalWrite(motor, LOW);
      digitalWrite(motor2, LOW);
    }
    else {
      //digitalWrite(motor, HIGH);
      digitalWrite(motor2, HIGH);
      button();
    }
  */
  delay(100);
}

void button() {
  // vérifie l'état des btn, si non appuyé LOW alors les moteur tourne par défaut

  if (BtnContact1 == LOW) {
    digitalWrite(moteur1, LOW);
  }
  else {
    digitalWrite(moteur2, HIGH);
  }

  if (BtnContact2 == LOW) {
    digitalWrite(moteur2, LOW);
  }
  else {
    digitalWrite(moteur2, HIGH);
  }
}

J'ai aussi remarqué que, même si je reste appuyé sur un btn, pendant un très court instant ( 1/2 sec env) les 2 leds s'allument

Ça rejoint la remarque de fdufnews : ta gestion des tests. Il faut bien identifier ce qui doit être fait et s'arranger pour que les tests soient exclusifs, c'est à dire que si tu appuies par exemple sur le bouton droit, il n'y ait qu'une seule condition qui soit vraie. Sinon, tu fais plus de choses que prévu, et on ne maîtrise pas ce qui peut se passer.

C'était le but du graphe : ce n'est pas forcément facile à faire, mais ça aide à mettre les choses au clair et à se poser les questions qui vont aider à s'assurer que tous les cas sont traités sans recouvrement... (je ne sais pas si c'est clair)

Si tu maintiens un bouton appuyé, il est possible que tu exécutes la loop plusieurs fois avec des conditions différentes : première fois une led s'allume, on ne l'éteint pas, deuxième fois l'autre led s'allume...

Je continuerai demain...