Bateau autonome Coller aux parois d'une piscine 1/2

je fais une fonction TourneGauche et TourneDroite

Quand loop lance bordures () , cela lance en premier TourneGauche.
ensuite avec millis > 10 mn, cela lance aléatoire (),
ensuite avec millis > 10 mn, cela lance TourneDroite (),
Puis c'est loop qui reprend la main.

L'idée est de forcer le bateau à ce coller sur la bordure (de son coté) gauche TourneAGauche ().
puis la fonction de déplacement aléatoire () est activée
Puis la fonction bordures () est activée MAIS cette fois le bateau est de forcer le bateau à ce coller sur la bordure (de son coté) droit TourneADroite ().

Aléatoire , TourneAGauche vrai , Aléatoire
Si TourneAGauche vrai , Aléatoire, TourneADroite, Aléatoire

Si Si TourneAGauche faux , TourneAGauche

TourneADroite () stoppe le moteur droit et active le gauche et la pompe
TourneAGauche () stoppe le moteur gauche et active le droit et la pompe

Maintenant tu sais faire : des fonctions simples et un cadencement dans la loop
A+

Trop tard ce soir.
Je vois ça demain

1 Dans la fonction aléatoire (), je ne vois pas le fait si pas de contact ni à droite ni à gauche,
alors les 2 moteurs fonctionnent ensembles

2 Vu sur le net, un montage pour afficher la temperature.
Comment ajouter le systéme car cet ajout utilise des pins déjà pris par le programme du bateau ?
On est bloqué par le nombre de pins non ?

3 sur ARDUINO, il y a des pins type chiffe simple 4 et des pins avec symbole environ + chifre.
Quelle est la différence entre les 2 types ?

void aleatoire() {

  if (cm <= 15) {
    //digitalWrite(moteur, LOW);
    digitalWrite(moteur2, LOW);
    //
    //**************************************************************************************************
    // à moins de 15 cm la pompe fonctionne ************************************************************
    digitalWrite(pompe, HIGH);
    //**************************************************************************************************
  }
  else {
    //digitalWrite(moteur, HIGH);
    digitalWrite(moteur2, HIGH);
    //
    //**************************************************************************************************
    // sinon à plus de 15 cm la pompe stoppe ***********************************************************
    digitalWrite(pompe, LOW);
    //**************************************************************************************************
    button();
  }
}
  • Il faudrait que tu postes ton code complet, qu'on voie où on en est
  • Je ne sais pas, indique tes branchements et ton type d'Arduino
  • Ce sont des broches PWM

1 pour le code et je ne vois pas le lien entre
const int DetecteurPin1 = 2;
const int DetecteurPin2 = 4;
et
BtnContact1
BtnContact2

Je dois renommer BtnContact* en DetecteurPin* non ?

// constants
// set pin numbers:
const int pingPin = 7;
const int DetecteurPin1 = 2; // the number of the pushbutton pin  Le numéro de l'épingle à commande automatique(presse-bouton)
const int DetecteurPin2 = 4;
const int moteur1 = 3; // the number of the motor pin    le (numéro l'épingle du moteur
const int moteur2 = 11;
//

const int pompe = 10; // declaration pompe au pin 10 ********************************************


// variables
int BtnContact1 = 0; // variable for reading the pushbutton status     variable pour lire le statut du 1er bouton de contact
int BtnContact2 = 0; //

// Variable globale pour faire le décompte du temps
unsigned long startMillis; // à 0 par défaut
long cm = 0;


//variable pour lire le statut du 2 ieme bouton de contact
void setup() {
  //begin serial
  Serial.begin(9600);
  // initialise  les pin moteurs à OUTPUT, soit éteint
  pinMode(moteur1, OUTPUT);
  pinMode(moteur2, OUTPUT);
  // initialise les boutons contact pins à INPUT, soit actif:
  pinMode(DetecteurPin1, INPUT);
  pinMode(DetecteurPin2, INPUT);

  //**************************************************************************************************
  // initialize the pump pins as output:   au démarrage la pompe ne marche pas ***********************
  pinMode(pompe, OUTPUT);
  // *************************************************************************************************
  //
}
void loop() {
  // dès le départ le bateau bouge aléatoirement et la fonction ultrasons est lancée
  ultrasons ();
  long tempsEcoule = millis() - startMillis;
  long tempsEcouleAvantPause = millis() - startMillis;
  if (tempsEcoule < 10000) aleatoire();
  else if (tempsEcoule < 20000) bordures();
  else if (tempsEcouleAvantPause < 60000) pause(); // après 60 mn de fonctionnement mise en pause
  else startMillis = millis();

  delay (100);
}





//******
//******
//******

void button() {
  // moteur et Btncontact sont opposes
  // vérifie si les boutoncontact sont actifs(HIGH), si oui le moteur passe à actif(HIGH) ou éteint(LOW) selon le programme
  if (BtnContact1 == HIGH) {
    // turn LED on:
    digitalWrite(moteur1, LOW);
    //
    //**************************************************************************************************
    // si le bouton touche le bord la pompe fonctionne *************************************************
    digitalWrite(pompe, HIGH);
    //**************************************************************************************************
  }
  else {
    // turn LED off:
    digitalWrite(moteur1, HIGH);
    //
    //**************************************************************************************************
    // sinon pas de contact la pompe stoppe ************************************************************
    digitalWrite(pompe, LOW);
    //**************************************************************************************************
  }
  if (BtnContact2 == HIGH) {
    // turn LED on:
    digitalWrite(moteur2, LOW);
    //
    //**************************************************************************************************
    // si le bouton touche le bord la pompe fonctionne *************************************************
    digitalWrite(pompe, HIGH);
    //**************************************************************************************************
  }
  else {
    // turn LED off:
    digitalWrite(moteur2, HIGH);
    //
    //**************************************************************************************************
    // sinon pas de contact la pompe stoppe ************************************************************
    digitalWrite(pompe, LOW);
    //**************************************************************************************************
  }
}


void ultrasons() {

  // establish variables for duration of the ping,
  // and the distance result in inches and centimeters:
  long duration, inches, cm;
  // The PING))) is triggered by a HIGH pulse of 2 or more microseconds.
  // Give a short LOW pulse beforehand to ensure a clean HIGH pulse.
  //Le PING))) est déclenché par un contact de 2 ou plusieurs micro-secondes.
  //Donnez une impulsion ETEINT courte à l'avance pour assurer une impulsion MARCHE propre
  pinMode(pingPin, OUTPUT);
  digitalWrite(pingPin, LOW);
  delayMicroseconds(2);
  digitalWrite(pingPin, HIGH);
  delayMicroseconds(5);
  digitalWrite(pingPin, LOW);
  /*
    le même pin est utilisé pour lire le signal du PING))) : impulsion
    dont la durée est le temps (en micro-secondes) de l'émission
    du Ping à la réception de son écho sur un objet.
  */
  pinMode(pingPin, INPUT);
  duration = pulseIn(pingPin, HIGH);
  cm = microsecondsToCentimeters(duration);

}

void aleatoire() {

  if (cm <= 15) {
    //digitalWrite(moteur, LOW);
    digitalWrite(moteur2, LOW);
    //
    //**************************************************************************************************
    // à moins de 15 cm la pompe fonctionne ************************************************************
    digitalWrite(pompe, HIGH);
    //**************************************************************************************************
  }
  else {
    //digitalWrite(moteur, HIGH);
    digitalWrite(moteur2, HIGH);
    //
    //**************************************************************************************************
    // sinon à plus de 15 cm la pompe stoppe ***********************************************************
    digitalWrite(pompe, LOW);
    //**************************************************************************************************
    button();
  }
}


void pause () {
  delay (900000);  //    15 mn soit  15 *60*1000(milli secondes)
  startMillis = millis();
}


void bordures() {
  /*
    En C/C++ un ET logique se note &&. Un OU logique se note ||. La négation se note !. Donc cela ressemblera à :
    if( (buttonState==HIGH) && (cm<=5) ) ... // contact ET ultrason
    if( (buttonState==HIGH) && !(cm<=5) ) ... // contact sans ultrason
    Remarque : pour le dernier cas on peut écrire if( (buttonState==HIGHT) && (cm>5) ) ... // contact sans ultrason
  */

  if ( (BtnContact1) && (cm <= 5)) { // contact ET ultrason : le bateau est dans un angle ou arrondi détecté par ultrasons
    digitalWrite(moteur2, HIGH);
    digitalWrite(moteur1, LOW);
    //  la pompe fonctionne ************************************************************
    digitalWrite(pompe, HIGH);
  }

  if ( (BtnContact2) && (cm <= 5)) { //contact ET ultrason : le bateau est dans un angle ou arrondi détecté par ultrasons
  digitalWrite(moteur2, LOW);
    digitalWrite(moteur1, HIGH);
    //  la pompe fonctionne ************************************************************
    digitalWrite(pompe, HIGH);
  }

  if ( (BtnContact1) && !(cm <= 5)) { //contact SANS ultrason : le bateau est collé à un bord et le suit
  digitalWrite(moteur2, LOW);
    digitalWrite(moteur1, HIGH);
    //  la pompe fonctionne ************************************************************
    digitalWrite(pompe, HIGH);
  }

  if ( (BtnContact2) && !(cm <= 5)) { //contact SANS ultrason : le bateau est collé à un bord et le suit
  digitalWrite(moteur1, LOW);
    digitalWrite(moteur2, HIGH);
    //  la pompe fonctionne ************************************************************
    digitalWrite(pompe, HIGH);
  }
  button();
}




//******
//******
//******

long microsecondsToCentimeters(long microseconds)
{
  /*
    La vitesse du son est 340 m/s ou 29 micro-secondes par centimètre.
    Le tintement voyage d'et en arrière, ainsi trouver la distance de le
    L'objet nous prenons la moitié de la distance a voyagé.
  */
  return microseconds / 29 / 2;
}

2 pour le type ARDUINO , j'ai commandé ça
https://www.aliexpress.com/item/New-Avoidance-tracking-Motor-Smart-Robot-Car-Chassis-Kit-Speed-Encoder-Battery-Box-2WD-Ultrasonic-module/32541422454.html?spm=a2g0s.9042311.0.0.Hkcd7G
pour les pin utilisés

// set pin numbers:
const int pingPin = 7;
const int DetecteurPin1 = 2; // the number of the pushbutton pin  Le numéro de l'épingle à commande automatique(presse-bouton)
const int DetecteurPin2 = 4;
const int moteur1 = 3; // the number of the motor pin    le (numéro l'épingle du moteur
const int moteur2 = 11;

const int pompe = 10; // declaration pompe au pin 10

3 C'es tquoi PWN ?

PWM signifie Pulse Width Modulation, c'est utilisé pour faire varier la vitesse de rotation d'un moteur.

Pour le bouton : au début de la fonction button(), tu dois en effet lire l'état des boutons :

void button() {
  BtnContact1 = digitalRead(DetecteurPin1);
  BtnContact2 = digitalRead(DetecteurPin2);

1 Dans la fonction aléatoire (), je ne vois pas le fait si pas de contact ni à droite ni à gauche, alors les 2 moteurs fonctionnent ensembles

Tu as fait un logigramme d'exécution de tes fonctions. Maintenant, il faudrait définir précisément ce que doivent faire ces fonctions. En l'état actuel, la fonction aléatoire fait juste ceci :

  • Si distance inférieure à 15 cm : on coupe le moteur 2, sans toucher au moteur 1 (qu'il soit on ou off) et on active la pompe
  • Sinon on allume le moteur 2 sans toucher au moteur 1 (qu'il soit on ou off), on coupe la pompe et on lit les boutons

Ça parait bizarre : tu ne t'occupes que d'un seul moteur et je pense qu'il faudrait lire les boutons tout le temps ou bien au moins lorsque la distance est faible. Par ailleurs, je ne sais pas exactement à quoi correspond cette distance : comment ton capteur est-il orienté : vers l'avant du bateau, d'un côté ...?

Donc, tu dois bien réfléchir à ce que les fonctions doivent faire afin d'assurer la cohérence du programme.

Je joint un croquis plus explicatif pour les mouvements :slight_smile:

edit

J'ai publié avant de te lire.
Je reviens vers toi

donc pour l'assignation ( BtnContact1 = digitalRead(DetecteurPin1);), je suis content d'avoir trouvé :slight_smile:
(Je commence ARDUINO à peine)

Comme je ne connais rien avec ARDUINO j'avais récupéré un script d'un montage tout fait.
Donc le code est celui de base. Je (on plutôt) le modife au fur et à mesure.
J'avais bien vu ce pb d'un seul moteur :slight_smile:

donc voici le graphe pour la fonction aleatoire.
J'espère ne rien avoir oublié .

je démarre tout droit, 1e radar, il tourne à droite
si contact coté gauche (btn1), il tourne encore pour être axer vers le centre de la piscine
puis tout droit
2 eme radar, il tourne à gauche
si contact coté droit (btn2), il tourne encore pour être axer vers le centre de la piscine
et boucle

Edit : petite modif aux lignes de Btncontact1 et2

voici le code modifié de aleatoire.
Je devrais trouver un autre nom car en fait je lui dis de tourner comme je veux

Je redonne le graphe de la fonction, j'avais fais un oubli d'attente de 5 sec sur la fin

void aleatoire() { // pas de pompe au milieu de l eau!
  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);
  }
  button();
}

Ton code commence à être un peu complexe ! :slight_smile:

J'ai relevé une petite erreur dans ultrasons : pas besoin de déclarer inches (tu ne t'en sers plus) ni cm (qui est une variable globale)

Autre chose, dans ta loop : tu as deux temporisations distinctes, je pense qu'il te faut deux chronos différents :

void loop() {
  // dès le départ le bateau bouge aléatoirement et la fonction ultrasons est lancée
  ultrasons ();
  long tempsEcoule = millis() - startMillis;
  long tempsEcouleAvantPause = millis() - startMillisPause;  //  <-- second chrono ici
  if (tempsEcoule < 10000) aleatoire();
  else if (tempsEcoule < 20000) bordures();
  else if (tempsEcouleAvantPause < 60000) pause(); // après 60 mn de fonctionnement mise en pause
  else startMillis = millis();

  delay (100);
}

et dans la fonction pause

void pause () {
  delay (900000);  //    15 mn soit  15 *60*1000(milli secondes)
  startMillisPause = millis();  // <-- second chrono ici
}

et déclarer au début du code :

unsigned long startMillisPause; // à 0 par défaut

Enfin, il faut initialiser les états des boutons : passe l'appel de button() au début de aleatoire.

Le reste me semble bon, sauf la fonction aleatoire() : il faut bien la décortiquer pour voir si elle fait bien ce que tu veux. C'est un peu compliqué avec tous ces tests successifs : demande-toi bien dans quel état tu es à la sortie de chaque test pour savoir si les suivants sont corrects. De même demande-toi dans quel ordre les faire, ça peut changer des choses.

Plus c'est complexe , plus s'est réaliste :slight_smile:

J'ai modifié Bordure en bordureGauche et BordureDroit
Un pb détecté dans bordure*; Avec un angle saillant, on perd le contact avec le bord et du coup plus d'info . J'ai pensé à forcer pendant 3 sec ( à voir le temps avec vitesse bateau) la rotatio pourrecoller au bord

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

  created 2011 by gabriella levine
*/


/*
  En C/C++ un ET logique se note &&. Un OU logique se note ||. La négation se note !. Donc cela ressemblera à :
  if( (buttonState==HIGH) && (cm<=15) ) ... // contact ET ultrason
  if( (buttonState==HIGH) && !(cm<=15) ) ... // contact sans ultrason
  Remarque : pour le dernier cas on peut écrire if( (buttonState==HIGHT) && (cm>15) ) ... // contact sans ultrason
*/

// constants
// set pin numbers:
const int pingPin = 7;
const int DetecteurPin1 = 2; // the number of the pushbutton pin  Le numéro de l'épingle à commande automatique(presse-bouton)
const int DetecteurPin2 = 4;
const int moteur1 = 3; // the number of the motor pin    le (numéro l'épingle du moteur
const int moteur2 = 11;
const int pompe = 10; // declaration pompe au pin 10 

// variables
int BtnContact1 = 0; // variable for reading the pushbutton status     variable pour lire le statut du 1er bouton de contact
int BtnContact2 = 0; //

// Variable globale pour faire le décompte du temps
unsigned long startMillis; // à 0 par défaut pour le chrono de MouvementPleineEaux() suivi de bordureGauche/BordureDroite
long cm = 0;
unsigned long startMillisPause; // à 0 par défaut  pour le chrono des 60 mn


//variable pour lire le statut du 2 ieme bouton de contact
void setup() {
  //begin serial
  Serial.begin(9600);
  // initialise  les pin moteurs à OUTPUT, soit éteint
  pinMode(moteur1, OUTPUT);
  pinMode(moteur2, OUTPUT);
  // initialise les boutons contact pins à INPUT, soit actif:
  pinMode(DetecteurPin1, INPUT);
  pinMode(DetecteurPin2, INPUT);
  // initialize the pump pins as output:   au démarrage la pompe ne marche pas ***********************
  pinMode(pompe, OUTPUT);
  }
void loop() { //deux temporisations distinctes, donc deux chronos différents :
 
    long tempsEcoule = millis() - startMillis;
    long tempsEcouleAvantPause = millis() - startMillis;
    if (tempsEcoule < 10000) MouvementPleineEaux();
    else if (tempsEcoule < 20000) bordureGauche();
     else if (tempsEcoule < 30000) MouvementPleineEaux();
     else if (tempsEcoule < 40000) bordureDroite();
    else if (tempsEcouleAvantPause < 60000) pause(); // après 60 mn de fonctionnement mise en pause
    else startMillis = millis();
  
  delay (100);
}


//******
//Les fonctions appelées
//******

void button() {
  // moteur et Btncontact sont opposes
  // vérifie si les boutoncontact sont actifs(HIGH), si oui le moteur passe à actif(HIGH) ou éteint(LOW) selon le programme
  // Assignation des pin es détecteur à leur contact
  BtnContact1 = digitalRead(DetecteurPin1); // bouton contact à gauche
  BtnContact2 = digitalRead(DetecteurPin2); // bouton contact à droite

  if (BtnContact1 == HIGH) {
    // turn LED on:
    digitalWrite(moteur1, LOW);
    // si le bouton touche le bord la pompe fonctionne
    digitalWrite(pompe, HIGH);
    
  }
  else {
    // turn LED off:
    digitalWrite(moteur1, HIGH);
    // sinon pas de contact la pompe stoppe 
    digitalWrite(pompe, LOW);
    
  }
  if (BtnContact2 == HIGH) {
    // turn LED on:
    digitalWrite(moteur2, LOW);
    // si le bouton touche le bord la pompe fonctionne
    digitalWrite(pompe, HIGH);
   
  }
  else {
    // turn LED off:
    digitalWrite(moteur2, HIGH);
    // sinon pas de contact la pompe stoppe 
    digitalWrite(pompe, LOW);
    
  }
}


void ultrasons() {

  // establish variables for duration of the ping,
  // and the distance result in inches and centimeters:
  long duration;
  // The PING))) is triggered by a HIGH pulse of 2 or more microseconds.
  // Give a short LOW pulse beforehand to ensure a clean HIGH pulse.
  //Le PING))) est déclenché par un contact de 2 ou plusieurs micro-secondes.
  //Donnez une impulsion ETEINT courte à l'avance pour assurer une impulsion MARCHE propre
  pinMode(pingPin, OUTPUT);
  digitalWrite(pingPin, LOW);
  delayMicroseconds(2);
  digitalWrite(pingPin, HIGH);
  delayMicroseconds(5);
  digitalWrite(pingPin, LOW);
  /*
    le même pin est utilisé pour lire le signal du PING))) : impulsion
    dont la durée est le temps (en micro-secondes) de l'émission
    du Ping à la réception de son écho sur un objet.
  */
  pinMode(pingPin, INPUT);
  duration = pulseIn(pingPin, HIGH);
  cm = microsecondsToCentimeters(duration);

}

void MouvementPleineEaux() { // pas de pompe au milieu de l eau!
  
  button(); // initialise les états des contacts
 
  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);
  }

}



void pause () { // utilisation du second chrono pour arrété au bout de 60 mn
  delay (900000);  //    15 mn soit  15 *60*1000(milli secondes)
  startMillisPause = millis();  // <-- second chrono ici
}





  void bordureGauche() { // BtnContact1

  // le bateau se dirige vers une parois.
    digitalWrite(moteur2, HIGH);
    digitalWrite(moteur1, HIGH);


  if (cm <= 5){ // parois détectée par ultrason, le bateau pivote à droite pour coller sur la parois gauche
    digitalWrite(moteur2, HIGH);
    digitalWrite(moteur1, LOW);
    //  la pompe fonctionne
    digitalWrite(pompe, HIGH);
  }

  if ( (BtnContact1) && (cm <= 5)) { // contact ET ultrason : le bateau est dans un angle ou arrondi détecté par ultrasons
    digitalWrite(moteur2, LOW);
    digitalWrite(moteur1, HIGH);
    //  la pompe fonctionne
    digitalWrite(pompe, HIGH);
  }

    if ( (BtnContact1) && !(cm <= 5)) { //contact SANS ultrason : le bateau est collé à un bord et le suit
  digitalWrite(moteur2, LOW);
    digitalWrite(moteur1, HIGH);
    //  la pompe fonctionne
    digitalWrite(pompe, HIGH);
        delay (3000);  //  le bateau va dépasser l'angle saillant de la piscine
                   //  on le force à continuer à tourner encore pendant 3 sec
                   //  pour le recoller au bord
  }
  button();
  }


  void bordureDroite() { // BtnContact2


  // le bateau se dirige vers une parois.
    digitalWrite(moteur2, HIGH);
    digitalWrite(moteur1, HIGH);


  if (cm <= 5){ // parois détectée par ultrason, le bateau pivote à gauche pour coller sur la parois droite
    digitalWrite(moteur2, LOW);
    digitalWrite(moteur1, HIGH);
    //  la pompe fonctionne
    digitalWrite(pompe, HIGH);
  }

  if ( (BtnContact2) && (cm <= 5)) { // contact ET ultrason : le bateau est dans un angle ou arrondi détecté par ultrasons
    digitalWrite(moteur2, HIGH);
    digitalWrite(moteur1, LOW);
    //  la pompe fonctionne
    digitalWrite(pompe, HIGH);
  }

  if ( (BtnContact2) && !(cm <= 5)) { //contact SANS ultrason : le bateau est collé à un bord et le suit
    digitalWrite(moteur2, HIGH);
    digitalWrite(moteur1, LOW);
    //  la pompe fonctionne
    digitalWrite(pompe, HIGH);
    delay (3000);  //  le bateau va dépasser l'angle saillant de la piscine
                   //  on le force à continuer à tourner encore pendant 3 sec
                   //  pour le recoller au bord
  }
  button();
  }




long microsecondsToCentimeters(long microseconds)
{
  /*
    La vitesse du son est 340 m/s ou 29 micro-secondes par centimètre.
    Le tintement voyage d'et en arrière, ainsi trouver la distance de le
    L'objet nous prenons la moitié de la distance a voyagé.
  */
  return microseconds / 29 / 2;
}

Ok, encore un bintz dans la loop : il faut comprendre que tu enchaines les 'else' donc la condition numéro n nest testée que si toutes les précédentes sont fausses.

void loop() { //deux temporisations distinctes, donc deux chronos différents :
 
    long tempsEcoule = millis() - startMillis;
    long tempsEcouleAvantPause = millis() - startMillis;
    if (tempsEcoule < 10000) MouvementPleineEaux();
    else if (tempsEcoule < 20000) bordureGauche();
     else if (tempsEcoule < 30000) MouvementPleineEaux();
     else if (tempsEcoule < 40000) bordureDroite();
    else if (tempsEcouleAvantPause < 60000) pause(); // après 60 mn de fonctionnement mise en pause
    else startMillis = millis();
  
  delay (100);
}

Là, avec les chiffres ci-dessus, ke bateau fait :

  • De 0 à 10s : pleine eau
  • De 10 à 20s : bordure gauche
  • De 20 à 30s : pleine eau
  • De 30 à 40s : bordure droite
  • Au delà de 40s, il test s'il s'est passé moins d'une minute depuis la pause précédente et si oui ; il fait une pause et remet le chrono de la pause à 0 --> la pause se fait toutes les 40s. Mais comme elle dure 15 minutes...

Du coup, je pense que le else qui suit n'est jamais exécuté, puisque le précédent est vrai au bout de 40s. Donc, il ne remet jamais le premier chrono à 0 et le chrono continue à tourner : il reste sur les réglages de la pause. indéfiniment.

Donc, je pense qu'il faut modifier la pause et enlever le dernier else :

void pause () { // utilisation du second chrono pour arrété au bout de 60 mn
  delay (900000);  //    15 mn soit  15 *60*1000(milli secondes)
  startMillisPause = millis();  // <-- second chrono ici
  startMillis = millis(); // <-- remise à 0 du premier chrono
}

Comme ça devient compliqué, il devient de plus en plus difficile de prévoir précisément le comportement : tu devrais passer à la réalisation et aux tests en vraie grandeur (ou peut-être faire des simulations, il existe des simulateurs comme electronics labs et un autre dont j'ai oublié le nom --> kammo le connait).

Tu as reçu ton kit ?

pas gaffe aux temps du loop >:(
Je modifie tout en minute , et donc x 60

toujours rien reçu, pas avant fin de semaine prochaine
Je vais voir les simulateurs.

" De 0 à 10s : pleine eau
De 10 à 20s : bordure gauche
De 20 à 30s : pleine eau
De 30 à 40s : bordure droite
Au delà de 40s, il test s'il s'est passé moins d'une minute depuis la pause précédente et si oui ; il fait une pause et remet le chrono de la pause à 0 --> la pause se fait toutes les 40s. Mais comme elle dure 15 minutes..."

En fait je doit plutôot mettre si lle temps passè ets > à 60 mn , soit 3600000

void loop() { //deux temporisations distinctes, donc deux chronos différents :
 
    long tempsEcoule = millis() - startMillis;
    long tempsEcouleAvantPause = millis() - startMillis;
    if (tempsEcoule < 600000) MouvementPleineEaux();      // 10 mn * 60 * 1 000
    else if (tempsEcoule < 1200000) bordureGauche();      // 20 mn * 60 * 1 000
    else if (tempsEcoule < 1800000) MouvementPleineEaux();// 30 mn * 60 * 1 000
    else if (tempsEcoule < 2400000) bordureDroite();      // 40 mn * 60 * 1 000
    else if (tempsEcouleAvantPause > 3600000) pause();    // 60 mn * 60 * 1 000après 60 mn de fonctionnement mise en pause
    else startMillis = millis();
  
  delay (100);
}

Oui, je pense que ça fonctionnera comme ça.

sur Arduino et les pin

sur une image d'un Arduino, j'ai 14 entrées sorties dont 6 PWN. Elles sont réservées qu'aux moteurs ?

avec mon bateau j'utilise les pin 2 , ~3 ,4,7,~10 ,~11 ,

J'ai vu un montage pour lire la température sur un écran
http://www.circuitbasics.com/arduino-thermistor-temperature-sensor-tutorial/

ce montage utilise des pins utilisés par bateau

Comme je pense 1 pin = 1 élément, si je veux le bateau ET l'écran avec température
il me faut 2 Arduino ?

J'ai aussi vu un petit montage à led pour afficher le niveau de batterie
Lui aussi utilise des pins pris par le bateau ( pin 1 à 6)

et du coup 3 Arduino ?

Sur un Uno, tu disposes de 6 pins analogiques et 14 digitales. Les pins digitales 0 et 1 sont à réserver pour la liaison série (en particulier celle avec le PC pour télécharger les programmes). Celles qui ont le PWM peuvent être utilisées comme les pins digitales standard.

C'est vrai qu'un écran LCD utilise beaucoup de broches, oriente toi vers les écran OLED I2C qui n'ont besoin que de 2 connexions (+ VCC & GND)

De même, il te faut une broche par LED si tu veux utiliser des LEDs une par une. Mais si tu utilises une barrette de LEDs adressables (WS2812), il te faut juste un broche supplémentaire (en plus du VCC & GND)

Merci

Juste pour ma compréhension

4 choix sinon action par défaut recule Si tout est négatif alors fonction par défaut recule
if A (avance +1) ou if A (avance +1 ) Ok alors on avance SINON on passe à
If B (avance +2) ou if B (avance +2) Ok alors on avance SINON on passe à
if C (avance +3) ou if C (avance +1) Ok alors on avance SINON on passe à
if D (avance +4 ) if D avance +1) Ok alors on avance SINON on passe à
else E (recule) Aucun des 4 alors recule else E (recule) Tout est NON donc action par défaut

C'est bon ?

Comprends pas !

j'ai essayé de résumer les conditions if et else