Projet distributeur de nourriture automatique mais le code ne fonctionne pas

Bonjour, je possède un programme Arduino mais.... il fonctionne pas . :thinking: :frowning:

Mon but est de créer un nourrisseur pour poissons automatique. Il dispose d’un moteur stepper 28BYJ-48, un module RTC et deux 3 boutons poussoir (voire le schéma d’assemblage).

Si j’appuie sur Bouton1, je règle mon programme pour qu’ils leurs donnent à manger 1x par jours à midi pile. De plus, tant que je n’appuie sur aucun autre bouton mon programme se fait en boucle.

Si j’appuie sur Bouton2, je règle mon programme pour qu’ils leurs donnent à manger 2x par jours. Une première fois à midi est une deuxième fois à 19h. De plus, tant que je n’appuie sur aucun autre bouton mon programme se fait en boucle.

Si j’appuie sur Bouton3, je règle mon programme pour qu’ils leurs donnent à manger maintenant. De plus, tant que je n’appuie sur aucun autre bouton mon programme se fait en boucle.

Part contre, si j’appuie pendant 3sc sur Bouton1 j’ai la possibilité de définir à quel jour et à quelle heure je leurs donne à manger.

Pour augmenter de +1 le jours de la semaine qui sera définit comme moment les poissons auront à manger je dois appuyer 1x sur Bouton1. Mais si j’appuie alors qu’il est dimanche, je reviens à lundi. Le système est exactement pareil pour les heures mais cette fois je dois appuyer sur le Bouton2.

Pour finir, je dois appuyer 1x sur le Bouton3pour initialiser cette « alarme », de telle sorte qu’a l’heure voulut mon programme se mette en route (exemple : Mardi ; 12h).

De plus, tant que je n’appuie sur aucun autre bouton mon programme se fait en boucle.

A mon avis, ce que je vous dit ce n’est pas très claire mais je vous joint ci-joint le code avec des annotations pour une meilleur compréhension :sweat_smile:

Programe_distributeur_automatique_de_nourriture_pour_poissons.ino (9,3 Ko)

Si ca marche pas, je vous l'envoie comme cela:

#include <Stepper.h>
#include <Wire.h>              /*Ici se sont les librairies que je souhaite utuliser, étant débutant il n'est pas 
                                improbable que je les aient mal installer*/
#include <DS3231.h>            

const int STEPPPER_PIN_1 = 2;
const int STEPPPER_PIN_2 = 3;
const int STEPPPER_PIN_3 = 4; // Ici, j'initialise les broches de mon moteur 28BYJ-48 aini que 3 Bouton poussoire
const int STEPPPER_PIN_4 = 5;
const int Bouton1 = 6;
const int Bouton2 = 7;
const int Bouton3 = 8;

int Bouton_presse= pulseIn(Bouton1, HIGH);  //cette variable ne sert a rien, juste a la lisibilité du programe
int Nombre_de_pas= 148; //cette variable me permet de definir le nombre de pas qu'il faut au moteur pour pouvoire "lacher" completement un compartiment de nouriture (2048 (nombre de pas pour un tour)/14 (nombre de compartiment))
int LdT_Allumage= 60000;
int LdT_Mise_en_veille= 60000;  //ici se sont des variables, LdT_Allumage et LdT_Mise_en_veille vont me servire a "mettre en veille" ou a "allumer mon moteur stepper". Je sais que cela n'est pas très utile, mais pour mon usage personnelle je souhaite garder ces deux variables
unsigned char Jour= 0;
unsigned char Heure= 0;  //ces deux variables me permettent d'initialiser une "alarme" sur un module RTC, ces valeurs sont changer sur l'appuie de Bouton1 (Jour) et Bouton2 (Heure)

Stepper Moteur_plateforme(2048, STEPPPER_PIN_2, STEPPPER_PIN_4, STEPPPER_PIN_3, STEPPPER_PIN_1);// Déclare un Stepper nommer Moteur_plateforme
DS3231 rtc(SDA, SCL); // Initialisation du module RTC---Repris d'un code fait par l'IA.

 void setup() {
  pinMode(STEPPPER_PIN_1, OUTPUT);
  pinMode(STEPPPER_PIN_2, OUTPUT);
  pinMode(STEPPPER_PIN_3, OUTPUT);
  pinMode(STEPPPER_PIN_4, OUTPUT);  //Ici je declare les broches ainsi que si ils sont en entrées ou sorties
  pinMode(Bouton1, INPUT);
  pinMode(Bouton2, INPUT);
  pinMode(Bouton3, INPUT);
  Moteur_plateforme.setSpeed(1); // Ici la vitesse de mon moteur (nommé: Moteur_plateforme)
  rtc.begin(); // Initialisation du module RTC---Repris d'un code fait par l'IA, je ne sais pas trop ce que cela signifie
  Jour= map (Jour, 0, 6, 1, 7);
  Heure= map  (Heure, 0, 23, 1, 24); // Grace a la fonction map, je vais pouvoire initialiser une "alarme" sur un module RTC (ligne 19) sans aucun dysfonctionnement et en evitant d'ecrire des valeurs= 0, ce qui m'empecherait d'attendre le 7eme jour de la semaine ou la 24ème h de la journée
 }
 
void Distribution(){
  digitalWrite(STEPPPER_PIN_1, HIGH);
  digitalWrite(STEPPPER_PIN_2, HIGH);  //mise en route du stepper (Moteur_plateforme)
  digitalWrite(STEPPPER_PIN_3, HIGH);
  digitalWrite(STEPPPER_PIN_4, HIGH);
  delay(LdT_Allumage);                      //les variables, LdT_Allumage et LdT_Mise_en_veille vont me servire a "mettre en veille" ou a "allumer mon moteur stepper". Je sais que cela n'est pas très utile, mais pour mon usage personnelle je souhaite garder ces deux variables
  Moteur_plateforme.step(Nombre_de_pas);    //Ici je met une fonction, cela me permet d'allegr mon programe. En gros, j'allume les broche de moon stepper (Moteur_plateforme) puis je lui demande de tourner de Nombre_de_pas (148), 148 est le nombre de pas qu'il faut au moteur pour pouvoire "lacher" completement un compartiment de nouriture
  delay(LdT_Mise_en_veille);                 //les variables, LdT_Allumage et LdT_Mise_en_veille vont me servire a "mettre en veille" ou a "allumer mon moteur stepper". Je sais que cela n'est pas très utile, mais pour mon usage personnelle je souhaite garder ces deux variables
  digitalWrite(STEPPPER_PIN_1, LOW);
  digitalWrite(STEPPPER_PIN_2, LOW);
  digitalWrite(STEPPPER_PIN_3, LOW);        // je met en veille mon stepper (Moteur_plateforme) pour eviter de trop consomer
  digitalWrite(STEPPPER_PIN_4, LOW);
    
}

void loop() {

if (Bouton_presse >= 30000){       //si j'appuie sur mon Bouton1 (bouton poussoir) pendant 3sc: 
  while (pulseIn(Bouton3, LOW)){   //je fais de telle sorte que tant que je n'appuie pas sur le Bouton3 (bouton poussoir), ce dernier me permet d'initialiser l'alarme que je suis entrain de creer pour telle jours et telle heure
    if (pulseIn(Bouton1, HIGH)){
      if (Jour <= 6){
        Jour= Jour + 1;
      }
      else{                      // En gros, si j'appuie sur le Bouton1, j'augmente ma variable jour de 1. Par exemple deux appuie= Jour=1, cela signifirera plus bas dans le code que je programe mon alarme a mardi
        Jour= 0;                // En revenche, si j'appuie dessus alors que jour=6 (ce qui represente dimanche), ma variable jour vaut 0 qui grace a ma fonction map (*****montrer plus bas dans le code*****) devient 1 (cela reprenste le 1er jour de la semaine, soit lundi)
      }
    }
  
    if (pulseIn(Bouton2, HIGH)){
      if (Heure <= 23){
        Heure= Heure + 1;
      }                            //Pareil que tout a l'heure, mais pour regler l'heure de mon alarme et non les jours
      else{
        Heure= 0;
      }
    }   
  }  //Petit rappel: je peux quitter ma boucle while en appyant sur Bouton3, cela ma permet alors d'initialiser mon alarme a l'heure choisit
  while (pulseIn(Bouton1, LOW) && pulseIn(Bouton2, LOW) && pulseIn(Bouton3, LOW)){   //maintenant, tant que j'appui nulle part, mon programe s'effectue en boucle qui est de: donner a manger aux poisson a l'heure définit (l'alarme en question). Cette boucle me permet de faire repeter ce programe en permananance, meme quand je suis pas present.
    Jour= map (Jour, 0, 6, 1, 7);
    Heure= map  (Heure, 0, 23, 1, 24);  // la fonction map me permet d'éviter que jour=0 ou heure=0 mais qu'ils soient minimum a 1. Cela devrait m'eviter des dysfonctionnement lors de mon initialisation de mon alarme (juste en dessous)
    DateTime now = rtc.now() // Récupération de l'heure actuelle---Repris d'un code fait par l'IA, je ne sais pas trop ce que cela signifie 
    if (now.hour() == Heure && now.minute() == 0 && now.second() == 0 && now.dayOfWeek() == Jour) {    //Ici, j'ai demandé a l'IA comment faire pour que je puisse verifier que mon temps actuel soit égale a mon alrme que j'avais programmé. Par la suite j'y ai rajouter les variables Jour et Heure.
      Distribution(); // je donne a manger au poisson grace a ma fonction Distribution() (et eux sont tout content ;) )
    }
  }
}
else{ // Par contre, si je n'appuie pas sur mon Bouton1 pendant 3sc mais que j'appuie dessus comme meme:
  while (pulseIn(Bouton2, LOW) && pulseIn(Bouton3, LOW)){  //Tant que je n'appuie sur aucun autre bouton mon programe passe en boucle. Cela me permet d'avoir la possibiliter d'appuyer sur Bouton2 ou Bouton3 et d'executer leurs programes respectifs tout en empechant celui de Bouton1 de fonctionner. Deplus, mon programme pourra tourner en boucle tant que je n'appuie pas sur les autres bouton poussoir. L'avantage et que si je pars pendant un certain temps, l'action pourra continuer de fonctionner
    Bouton1= HIGH;  //je ne sais plus a quoi ca sert, j'avais mis cela quand j'avait debuter mon programme. Je la laisse donc pour eviter des erreurs si elle est utile
    DateTime now = rtc.now() // Récupération de l'heure actuelle---Repris d'un code fait par l'IA, je ne sais pas trop ce que cela signifie 
    if (now.hour() == 11 && now.minute() == 59){ //Ici, j'ai demandé a l'IA comment faire pour que je puisse verifier que mon temps actuel soit égale a maintenant, un peut comme une alarme.
      Distribution(); // je donne a manger au poisson grace a ma fonction Distribution() (et eux sont tout content ;) )
    }  
  }
  Bouton1= LOW; //je ne sais plus a quoi ca sert, j'avais mis cela quand j'avait debuter mon programme. Je la laisse donc pour eviter des erreurs si elle est utile
}

if (pulseIn(Bouton1, HIGH)){ //si j'appuie sur le Bouton2:
  while (pulseIn(Bouton1, LOW) && pulseIn(Bouton3, LOW)){ //maintenant, tant que j'appui nulle part, mon programe s'effectue en boucle qui est de: donner a manger aux poisson a l'heure définit (l'alarme en question). Cette boucle me permet de faire repeter ce programe en permananance, meme quand je suis pas present.
    Bouton2= HIGH; //je ne sais plus a quoi ca sert, j'avais mis cela quand j'avait debuter mon programme. Je la laisse donc pour eviter des erreurs si elle est utile
    DateTime now = rtc.now() // Récupération de l'heure actuelle---Repris d'un code fait par l'IA, je ne sais pas trop ce que cela signifie
    if (now.hour() == 9 && now.minute() == 59 || now.hour() == 18 && now.minute() == 59) { //Ici, j'ai demandé a l'IA comment faire pour que je puisse verifier que mon temps actuel soit égale a maintenant, un peut comme une alarme.
      Distribution(); // je donne a manger au poisson grace a ma fonction Distribution() (et eux sont tout content ;) )
    }
  }
  Bouton2= LOW; //je ne sais plus a quoi ca sert, j'avais mis cela quand j'avait debuter mon programme. Je la laisse donc pour eviter des erreurs si elle est utile
}


if (pulseIn(Bouton3, HIGH)){ //si j'appuie sur le bouton3:
  LdT_Allumage= 3000;
  LdT_Mise_en_veille= 3000;  //cela me permet d'allumer ou d'etendre mon moteur le plus raidement possible (c'est surtout pour un interet personnel qu'il y ait un laps de temps)
  Distribution(); // je donne a manger au poisson grace a ma fonction Distribution() (et eux sont tout content ;) )
  LdT_Allumage= 60000;
  LdT_Mise_en_veille= 60000;  //cela me permet de reintialiser les variables precendentes a leurs valeurs par défaut
  }
}

Pour finir, si vous voulez je vous joint une photo de mon programme avec les erreurs:

sC:\Users\alexm\Documents\Arduino\Programe_distributeur_automatique_de_nourriture_pour_poissons\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino:22:20: error: no matching function for call to 'DS3231::DS3231(const uint8_t&, const uint8_t&)'
 DS3231 rtc(SDA, SCL); // Initialisation du module RTC---Repris d'un code fait par l'IA.
                    ^
In file included from C:\Users\alexm\Documents\Arduino\Programe_distributeur_automatique_de_nourriture_pour_poissons\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino:4:0:
C:\Users\alexm\Documents\Arduino\libraries\DS3231/DS3231.h:73:3: note: candidate: DS3231::DS3231(TwoWire&)
   DS3231(TwoWire & w);
   ^~~~~~
C:\Users\alexm\Documents\Arduino\libraries\DS3231/DS3231.h:73:3: note:   candidate expects 1 argument, 2 provided
C:\Users\alexm\Documents\Arduino\libraries\DS3231/DS3231.h:72:3: note: candidate: DS3231::DS3231()
   DS3231();
   ^~~~~~
C:\Users\alexm\Documents\Arduino\libraries\DS3231/DS3231.h:72:3: note:   candidate expects 0 arguments, 2 provided
C:\Users\alexm\Documents\Arduino\libraries\DS3231/DS3231.h:68:7: note: candidate: constexpr DS3231::DS3231(const DS3231&)
 class DS3231 {
       ^~~~~~
C:\Users\alexm\Documents\Arduino\libraries\DS3231/DS3231.h:68:7: note:   candidate expects 1 argument, 2 provided
C:\Users\alexm\Documents\Arduino\libraries\DS3231/DS3231.h:68:7: note: candidate: constexpr DS3231::DS3231(DS3231&&)
C:\Users\alexm\Documents\Arduino\libraries\DS3231/DS3231.h:68:7: note:   candidate expects 1 argument, 2 provided
C:\Users\alexm\Documents\Arduino\Programe_distributeur_automatique_de_nourriture_pour_poissons\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino: In function 'void setup()':
C:\Users\alexm\Documents\Arduino\Programe_distributeur_automatique_de_nourriture_pour_poissons\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino:33:7: error: 'class DS3231' has no member named 'begin'
   rtc.begin(); // Initialisation du module RTC---Repris d'un code fait par l'IA, je ne sais pas trop ce que cela signifie
       ^~~~~
C:\Users\alexm\Documents\Arduino\Programe_distributeur_automatique_de_nourriture_pour_poissons\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino: In function 'void loop()':
C:\Users\alexm\Documents\Arduino\Programe_distributeur_automatique_de_nourriture_pour_poissons\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino:78:24: error: 'class DS3231' has no member named 'now'
     DateTime now = rtc.now() // Récupération de l'heure actuelle---Repris d'un code fait par l'IA, je ne sais pas trop ce que cela signifie
                        ^~~
C:\Users\alexm\Documents\Arduino\Programe_distributeur_automatique_de_nourriture_pour_poissons\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino:82:3: error: expected ',' or ';' before '}' token
   }
   ^
In file included from C:\Users\alexm\AppData\Local\Temp\arduino\sketches\0B901E0DB9F963A5043E3657B961FDE5\sketch\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino.cpp:1:0:
C:\Users\alexm\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.8.6\cores\arduino/Arduino.h:40:14: error: assignment of read-only variable 'Bouton1'
 #define HIGH 0x1
              ^
C:\Users\alexm\Documents\Arduino\Programe_distributeur_automatique_de_nourriture_pour_poissons\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino:86:14: note: in expansion of macro 'HIGH'
     Bouton1= HIGH;  //je ne sais plus a quoi ca sert, j'avais mis cela quand j'avait debuter mon programme. Je la laisse donc pour eviter des erreurs si elle est utile
              ^~~~
C:\Users\alexm\Documents\Arduino\Programe_distributeur_automatique_de_nourriture_pour_poissons\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino:87:24: error: 'class DS3231' has no member named 'now'
     DateTime now = rtc.now() // Récupération de l'heure actuelle---Repris d'un code fait par l'IA, je ne sais pas trop ce que cela signifie
                        ^~~
C:\Users\alexm\Documents\Arduino\Programe_distributeur_automatique_de_nourriture_pour_poissons\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino:91:3: error: expected ',' or ';' before '}' token
   }
   ^
In file included from C:\Users\alexm\AppData\Local\Temp\arduino\sketches\0B901E0DB9F963A5043E3657B961FDE5\sketch\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino.cpp:1:0:
C:\Users\alexm\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.8.6\cores\arduino/Arduino.h:41:14: error: assignment of read-only variable 'Bouton1'
 #define LOW  0x0
              ^
C:\Users\alexm\Documents\Arduino\Programe_distributeur_automatique_de_nourriture_pour_poissons\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino:92:12: note: in expansion of macro 'LOW'
   Bouton1= LOW; //je ne sais plus a quoi ca sert, j'avais mis cela quand j'avait debuter mon programme. Je la laisse donc pour eviter des erreurs si elle est utile
            ^~~
C:\Users\alexm\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.8.6\cores\arduino/Arduino.h:40:14: error: assignment of read-only variable 'Bouton2'
 #define HIGH 0x1
              ^
C:\Users\alexm\Documents\Arduino\Programe_distributeur_automatique_de_nourriture_pour_poissons\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino:97:14: note: in expansion of macro 'HIGH'
     Bouton2= HIGH; //je ne sais plus a quoi ca sert, j'avais mis cela quand j'avait debuter mon programme. Je la laisse donc pour eviter des erreurs si elle est utile
              ^~~~
C:\Users\alexm\Documents\Arduino\Programe_distributeur_automatique_de_nourriture_pour_poissons\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino:98:24: error: 'class DS3231' has no member named 'now'
     DateTime now = rtc.now() // Récupération de l'heure actuelle---Repris d'un code fait par l'IA, je ne sais pas trop ce que cela signifie
                        ^~~
C:\Users\alexm\Documents\Arduino\Programe_distributeur_automatique_de_nourriture_pour_poissons\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino:102:3: error: expected ',' or ';' before '}' token
   }
   ^
In file included from C:\Users\alexm\AppData\Local\Temp\arduino\sketches\0B901E0DB9F963A5043E3657B961FDE5\sketch\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino.cpp:1:0:
C:\Users\alexm\AppData\Local\Arduino15\packages\arduino\hardware\avr\1.8.6\cores\arduino/Arduino.h:41:14: error: assignment of read-only variable 'Bouton2'
 #define LOW  0x0
              ^
C:\Users\alexm\Documents\Arduino\Programe_distributeur_automatique_de_nourriture_pour_poissons\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino:103:12: note: in expansion of macro 'LOW'
   Bouton2= LOW; //je ne sais plus a quoi ca sert, j'avais mis cela quand j'avait debuter mon programme. Je la laisse donc pour eviter des erreurs si elle est utile
            ^~~
Plusieurs bibliothèque trouvées pour "Stepper.h"
  Utilisé: C:\Users\alexm\Documents\Arduino\libraries\Stepper
  Non utilisé: C:\Users\alexm\AppData\Local\Arduino15\libraries\Stepper
exit status 1

Compilation error: no matching function for call to 'DS3231::DS3231(const uint8_t&, const uint8_t&)'
DS3231 rtc(SDA, SCL); // Initialisation du module RTC---Repris d'un code fait par l'IA.

C’est faux, ça devrait être

DS3231 rtc();

Merci, ca fait déjà une erreur de moins !! :face_holding_back_tears:

je ne sais plus a quoi ca sert,
Est-ce bien raisonnable, de conserver si tu ne sais pas ce que cela fait ??

C'est effectivement le problème lorsqu'on récupère du code n'importe où et qu'on ne lit pas la doc de la librairie que l'on utilise.

Voir la doc, je ne pense pas que c'est ce que tu veux faire.
https://www.arduino.cc/reference/en/language/functions/advanced-io/pulsein/

Pour conclure, les IA c'est peut-être bien mais je pense qu'il faut encore coder avec son cerveau plutôt que de déléguer pour ensuite mettre au point un code que l'on ne comprend pas.

c'est typiquement une définition de programme qui se prête bien à la programmation par machine à états (cf mon tuto éventuellement)

Et pour simplifier votre gestion des boutons, éventuellement utilisez la bibliothèque Button dans easyRun de @bricoleau ou OneButton de Matthias Hertel ou encore Toggle de @dlloyd.

Merci pour ta réponse, mais je tient a préciser que l'IA ma aider a faire que 1/12 -ème du code. En effet, je suis débutant et donc je ne connais pas Arduino parfaitement. Je l'utilise uniquement pour m'ouvrir des possibilité sur la manière de coder un élément et ainsi d'en apprendre d'avantage. Par exemple, grâce à elle j'ai découvert la fonction map() sur un autre projet puis j'ai par la suite approfondie mes connaissances de celle-ci sur ytb, et c'est ainsi que je me retrouve a l'utiliser pour ce nouveau projet.

Mais retournons a notre sujet, normalement si je remplace pulseIn par if (Bouton1=HIGH) {...} ca marche non?
Ducoup, tu pourrais m'expliquer pourquoi DateTime now = rtc.now() marche pas? En attendant je vais me renseigner sur cette librairie.

non

if (Bouton1==HIGH)

= permet de faire une affectation

toto = 5; // on met 5 dans la variable toto

== réalise un test et retourne une valeur vraie ou fausse

if ( toto == 5){ // le test sera vrai si toto contient la valeur 5 sinon il sera faux

merci pour votre réponse, effectivement après avoir lue votre tuto sur la programmation par machine à états cela ma donner quelque idées pour modifier le code. je vais donc aller creuser cette voie pour y simplifier certain élément.
En revanche, je ne pense pas utiliser une bibliothèque pour les boutons car cela signifierait changer une bonne partie de mon code ce qui me prendrait un peut de temps. Après, si j'aurais d'autre idées de projets avec des boutons j'inclurais cette bibliothèque.
Malheureusement, je ne pense pas que cela resolvera mes erreurs actuels. Comme me la fait prendre conscience @fdufnews la majorité semble provenir d'une mauvaise utulisation de libraire. Soit il s'agit <Wire.h> ou <DS3231.h>. Ou alors, il s'agit d'un autre librairie que je n'aurais pas marquer et je n'ai aucune idée de laquelle il s'agirait. Effectivement, j'ai constater que quasiment toute les erreurs avait un lien avec le module RTC

DateTime now = rtc.now() doit fonctionner si:

  • la librairie utilisée implémente une méthode now() qui retourne l'heure actuelle.
  • rtc est une instance de la classe DS3231

Or dans ton code la seconde condition n'était pas remplie car le compilateur t'avais retourné une erreur indiquant qu'il ne trouvait pas dans la librairie de méthode pouvant s'appliquer à DS3231 rtc(SDA, SCL);. Par conséquent rtc n'était pas créé, ce qui entraîne des erreurs en cascade.
La solution t'a été donnée par @MaximoEsfuerzo . En supprimant cette erreur tu devrais maintenant avoir une instance de DS3231 nommée rtc qui doit te permettre d'accéder aux autres méthodes de la librairie et tu devrais pouvoir récupérer l'heure.

Ne pas oublier qu'à la première mise sous-tension du module DS3231 il n'y a pas d'heure dedans. Il faut, au moins une fois, faire une mise à l'heure pour qu'il commence à fonctionner.

Il faut regarder les exemples qui sont installés en même temps que les librairies. Il y a assez souvent des librairies avec des noms identiques ou très proches qui ne fonctionnent pas de la meme manière ou ne proposent pas les mêmes méthodes ce qui peut entrainer des recherches fastidieuses.
La lecture des exemples peut faire gagner du temps.

Ah oui mince :roll_eyes:, je confond souvent avec le moment ou l'on assigne une valeurs a une variable du style Bouton1= HIGH;

Programe_distributeur_automatique_de_nourriture_pour_poissons.ino (8,5 Ko)

#include <Stepper.h>
#include <Wire.h>              /*Ici se sont les librairies que je souhaite utuliser, étant débutant il n'est pas 
                                improbable que je les aient mal installer*/
#include <DS3231.h>            

const int STEPPPER_PIN_1 = 2;
const int STEPPPER_PIN_2 = 3;
const int STEPPPER_PIN_3 = 4; // Ici, j'initialise les broches de mon moteur 28BYJ-48 aini que 3 Bouton poussoire
const int STEPPPER_PIN_4 = 5;
const int Bouton1 = 6;
const int Bouton2 = 7;
const int Bouton3 = 8;

int Bouton_presse= pulseIn(Bouton1, HIGH);  //cette variable ne sert a rien, juste a la lisibilité du programe
int Nombre_de_pas= 148; //cette variable me permet de definir le nombre de pas qu'il faut au moteur pour pouvoire "lacher" completement un compartiment de nouriture (2048 (nombre de pas pour un tour)/14 (nombre de compartiment))
int LdT_Allumage= 60000;
int LdT_Mise_en_veille= 60000;  //ici se sont des variables, LdT_Allumage et LdT_Mise_en_veille vont me servire a "mettre en veille" ou a "allumer mon moteur stepper". Je sais que cela n'est pas très utile, mais pour mon usage personnelle je souhaite garder ces deux variables
unsigned char Jour= 0;
unsigned char Heure= 0;  //ces deux variables me permettent d'initialiser une "alarme" sur un module RTC, ces valeurs sont changer sur l'appuie de Bouton1 (Jour) et Bouton2 (Heure)

Stepper Moteur_plateforme(2048, STEPPPER_PIN_2, STEPPPER_PIN_4, STEPPPER_PIN_3, STEPPPER_PIN_1);// Déclare un Stepper nommer Moteur_plateforme
DS3231 rtc(); // Initialisation du module RTC---Repris d'un code fait par l'IA.

 void setup() {
  pinMode(STEPPPER_PIN_1, OUTPUT);
  pinMode(STEPPPER_PIN_2, OUTPUT);
  pinMode(STEPPPER_PIN_3, OUTPUT);
  pinMode(STEPPPER_PIN_4, OUTPUT);  //Ici je declare les broches ainsi que si ils sont en entrées ou sorties
  pinMode(Bouton1, INPUT);
  pinMode(Bouton2, INPUT);
  pinMode(Bouton3, INPUT);
  Moteur_plateforme.setSpeed(1); // Ici la vitesse de mon moteur (nommé: Moteur_plateforme)
  rtc.begin(); // Initialisation du module RTC---Repris d'un code fait par l'IA, je ne sais pas trop ce que cela signifie
  Jour= map (Jour, 0, 6, 1, 7);
  Heure= map  (Heure, 0, 23, 1, 24); // Grace a la fonction map, je vais pouvoire initialiser une "alarme" sur un module RTC (ligne 19) sans aucun dysfonctionnement et en evitant d'ecrire des valeurs= 0, ce qui m'empecherait d'attendre le 7eme jour de la semaine ou la 24ème h de la journée
 }
 
void Distribution(){
  digitalWrite(STEPPPER_PIN_1, HIGH);
  digitalWrite(STEPPPER_PIN_2, HIGH);  //mise en route du stepper (Moteur_plateforme)
  digitalWrite(STEPPPER_PIN_3, HIGH);
  digitalWrite(STEPPPER_PIN_4, HIGH);
  delay(LdT_Allumage);                      //les variables, LdT_Allumage et LdT_Mise_en_veille vont me servire a "mettre en veille" ou a "allumer mon moteur stepper". Je sais que cela n'est pas très utile, mais pour mon usage personnelle je souhaite garder ces deux variables
  Moteur_plateforme.step(Nombre_de_pas);    //Ici je met une fonction, cela me permet d'allegr mon programe. En gros, j'allume les broche de moon stepper (Moteur_plateforme) puis je lui demande de tourner de Nombre_de_pas (148), 148 est le nombre de pas qu'il faut au moteur pour pouvoire "lacher" completement un compartiment de nouriture
  delay(LdT_Mise_en_veille);                 //les variables, LdT_Allumage et LdT_Mise_en_veille vont me servire a "mettre en veille" ou a "allumer mon moteur stepper". Je sais que cela n'est pas très utile, mais pour mon usage personnelle je souhaite garder ces deux variables
  digitalWrite(STEPPPER_PIN_1, LOW);
  digitalWrite(STEPPPER_PIN_2, LOW);
  digitalWrite(STEPPPER_PIN_3, LOW);        // je met en veille mon stepper (Moteur_plateforme) pour eviter de trop consomer
  digitalWrite(STEPPPER_PIN_4, LOW);
    
}

void loop() {

if (Bouton_presse >= 30000){       //si j'appuie sur mon Bouton1 (bouton poussoir) pendant 3sc: 
  while (Bouton3 == LOW){   //je fais de telle sorte que tant que je n'appuie pas sur le Bouton3 (bouton poussoir), ce dernier me permet d'initialiser l'alarme que je suis entrain de creer pour telle jours et telle heure
    if (Bouton1 == HIGH){
      if (Jour <= 6){
        Jour= Jour + 1;
      }
      else{                      // En gros, si j'appuie sur le Bouton1, j'augmente ma variable jour de 1. Par exemple deux appuie= Jour=1, cela signifirera plus bas dans le code que je programe mon alarme a mardi
        Jour= 0;                // En revenche, si j'appuie dessus alors que jour=6 (ce qui represente dimanche), ma variable jour vaut 0 qui grace a ma fonction map (*****montrer plus bas dans le code*****) devient 1 (cela reprenste le 1er jour de la semaine, soit lundi)
      }
    }
  
    if (Bouton2 == HIGH){
      if (Heure <= 23){
        Heure= Heure + 1;
      }                            //Pareil que tout a l'heure, mais pour regler l'heure de mon alarme et non les jours
      else{
        Heure= 0;
      }
    }   
  }  //Petit rappel: je peux quitter ma boucle while en appyant sur Bouton3, cela ma permet alors d'initialiser mon alarme a l'heure choisit
  while (Bouton1 == LOW && Bouton2 ==LOW && Bouton3 == LOW){   //maintenant, tant que j'appui nulle part, mon programe s'effectue en boucle qui est de: donner a manger aux poisson a l'heure définit (l'alarme en question). Cette boucle me permet de faire repeter ce programe en permananance, meme quand je suis pas present.
    Jour= map (Jour, 0, 6, 1, 7);
    Heure= map  (Heure, 0, 23, 1, 24);  // la fonction map me permet d'éviter que jour=0 ou heure=0 mais qu'ils soient minimum a 1. Cela devrait m'eviter des dysfonctionnement lors de mon initialisation de mon alarme (juste en dessous)
    DateTime now = rtc.now() // Récupération de l'heure actuelle---Repris d'un code fait par l'IA, je ne sais pas trop ce que cela signifie 
    if (now.hour() == Heure && now.minute() == 0 && now.second() == 0 && now.dayOfWeek() == Jour) {    //Ici, j'ai demandé a l'IA comment faire pour que je puisse verifier que mon temps actuel soit égale a mon alrme que j'avais programmé. Par la suite j'y ai rajouter les variables Jour et Heure.
      Distribution(); // je donne a manger au poisson grace a ma fonction Distribution() (et eux sont tout content ;) )
    }
  }
}
else{ // Par contre, si je n'appuie pas sur mon Bouton1 pendant 3sc mais que j'appuie dessus comme meme:
  while (Bouton2 == LOW && Bouton3 == LOW){  //Tant que je n'appuie sur aucun autre bouton mon programe passe en boucle. Cela me permet d'avoir la possibiliter d'appuyer sur Bouton2 ou Bouton3 et d'executer leurs programes respectifs tout en empechant celui de Bouton1 de fonctionner. Deplus, mon programme pourra tourner en boucle tant que je n'appuie pas sur les autres bouton poussoir. L'avantage et que si je pars pendant un certain temps, l'action pourra continuer de fonctionner
    DateTime now = rtc.now() // Récupération de l'heure actuelle---Repris d'un code fait par l'IA, je ne sais pas trop ce que cela signifie 
    if (now.hour() == 11 && now.minute() == 59){ //Ici, j'ai demandé a l'IA comment faire pour que je puisse verifier que mon temps actuel soit égale a maintenant, un peut comme une alarme.
      Distribution(); // je donne a manger au poisson grace a ma fonction Distribution() (et eux sont tout content ;) )
    }  
  }
}

if (Bouton1 == HIGH){ //si j'appuie sur le Bouton2:
  while (Bouton1 == LOW && Bouton3 == LOW){ //maintenant, tant que j'appui nulle part, mon programe s'effectue en boucle qui est de: donner a manger aux poisson a l'heure définit (l'alarme en question). Cette boucle me permet de faire repeter ce programe en permananance, meme quand je suis pas present.
    DateTime now = rtc.now() // Récupération de l'heure actuelle---Repris d'un code fait par l'IA, je ne sais pas trop ce que cela signifie
    if (now.hour() == 9 && now.minute() == 59 || now.hour() == 18 && now.minute() == 59) { //Ici, j'ai demandé a l'IA comment faire pour que je puisse verifier que mon temps actuel soit égale a maintenant, un peut comme une alarme.
      Distribution(); // je donne a manger au poisson grace a ma fonction Distribution() (et eux sont tout content ;) )
    }
  }
}


if (Bouton3 == HIGH){ //si j'appuie sur le bouton3:
  LdT_Allumage= 3000;
  LdT_Mise_en_veille= 3000;  //cela me permet d'allumer ou d'etendre mon moteur le plus raidement possible (c'est surtout pour un interet personnel qu'il y ait un laps de temps)
  Distribution(); // je donne a manger au poisson grace a ma fonction Distribution() (et eux sont tout content ;) )
  LdT_Allumage= 60000;
  LdT_Mise_en_veille= 60000;  //cela me permet de reintialiser les variables precendentes a leurs valeurs par défaut
  }
}

voila ce que ca donne avec les erreurs corriger, mais il reste encore les erreurs liés a rtc et a now:

C:\Users\alexm\Documents\Arduino\Programe_distributeur_automatique_de_nourriture_pour_poissons\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino: In function 'void setup()':
C:\Users\alexm\Documents\Arduino\Programe_distributeur_automatique_de_nourriture_pour_poissons\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino:33:7: error: request for member 'begin' in 'rtc', which is of non-class type 'DS3231()'
   rtc.begin(); // Initialisation du module RTC---Repris d'un code fait par l'IA, je ne sais pas trop ce que cela signifie
       ^~~~~
C:\Users\alexm\Documents\Arduino\Programe_distributeur_automatique_de_nourriture_pour_poissons\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino: In function 'void loop()':
C:\Users\alexm\Documents\Arduino\Programe_distributeur_automatique_de_nourriture_pour_poissons\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino:78:24: error: request for member 'now' in 'rtc', which is of non-class type 'DS3231()'
     DateTime now = rtc.now() // Récupération de l'heure actuelle---Repris d'un code fait par l'IA, je ne sais pas trop ce que cela signifie
                        ^~~
C:\Users\alexm\Documents\Arduino\Programe_distributeur_automatique_de_nourriture_pour_poissons\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino:82:3: error: expected ',' or ';' before '}' token
   }
   ^
C:\Users\alexm\Documents\Arduino\Programe_distributeur_automatique_de_nourriture_pour_poissons\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino:86:24: error: request for member 'now' in 'rtc', which is of non-class type 'DS3231()'
     DateTime now = rtc.now() // Récupération de l'heure actuelle---Repris d'un code fait par l'IA, je ne sais pas trop ce que cela signifie
                        ^~~
C:\Users\alexm\Documents\Arduino\Programe_distributeur_automatique_de_nourriture_pour_poissons\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino:90:3: error: expected ',' or ';' before '}' token
   }
   ^
C:\Users\alexm\Documents\Arduino\Programe_distributeur_automatique_de_nourriture_pour_poissons\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino:95:24: error: request for member 'now' in 'rtc', which is of non-class type 'DS3231()'
     DateTime now = rtc.now() // Récupération de l'heure actuelle---Repris d'un code fait par l'IA, je ne sais pas trop ce que cela signifie
                        ^~~
C:\Users\alexm\Documents\Arduino\Programe_distributeur_automatique_de_nourriture_pour_poissons\Programe_distributeur_automatique_de_nourriture_pour_poissons.ino:99:3: error: expected ',' or ';' before '}' token
   }
   ^
Plusieurs bibliothèque trouvées pour "Stepper.h"
  Utilisé: C:\Users\alexm\Documents\Arduino\libraries\Stepper
  Non utilisé: C:\Users\alexm\AppData\Local\Arduino15\libraries\Stepper
exit status 1

Compilation error: request for member 'begin' in 'rtc', which is of non-class type 'DS3231()'

Si je comprend bien ce que tu mas dit, cela pourrait donc être dut à cause d'une mauvaise librairie? Pour autant, j'ai l'impression que c'est la bonne (ci-joint la photo). De plus, comment regarder les exemples?

arrêtez de poster des photos d'un texte. Postez juste le texte.

récrire une nouvelle version de son code est une pratique courante...

c'est à dire que le mode du bouton 1 ou bouton 2 reste activé, c'est cela ?

donc c'est un mode 1x par semaine ?
comment visualisez vous le jour choisi et les heures ? il ne manque pas un afficheur à votre projet ?


sinon

attention sur un UNO les int sont sur 2 octets. la valeur max c'est 32767.. 60000 ça ne rentre pas
utilisez des unsigned long pour tout ce qui est lié au temps

ligne 78, 86 et 95 il manque le ; après la parenthèse fermante de now()

Dans le sous-menu qui s'ouvre il devrait y avoir une ligne DS3231

Oui, je comptais mettre un afficheur par la suite. Mais, j'en ait jamais utiliser ce qui risque de multiplier les chances que mon code ne fonctionne pas. Je préfère y aller petit à petit. En plus, je crois que je n'aurais pas assez d'intensité pour tout faire fonctionner. Il vas probablement falloir que je mette un module relais pour que cela puisse fonctionner. C'est pour cela que pour l'instant je me contente de faire fonctionner la "base" de mon programme. Mais sinon oui, c'est un mode 1x par semaine

Non justement, grâce a mes boucle while je fais de telle sorte que si j'appuie sur un bouton autre que celui que je viens d'appuyer je sors du programme actuel pour passer sur celui qui compose le bouton que j'ai appuyer.

exemple:

if (Bouton2 == HIGH){
   while (Bouton1 == LOW && Bouton3 == LOW) {
             le code qui vas avec Bouton1 s'exécute
    }
}

Par exemple si j'appuie su Bouton2 il devient HIGH et alors je valide ma condition "if (Bouton2 == HIGH)" et ainsi tant que je n'appui ni sur Bouton1 ni sur Bouton3 grâce à while (Bouton2 == LOW && Bouton3 == LOW) mon programme s'exécute en boucle (en l'occurrence c'est donner a manger aux poissons toutes les 12h). Par contre, si j'appuie sur Bouton1 ou Bouton3 je sors de cette boucle et ainsi j'annule le programme Bouton2 (il faut que je rappuie dessus pour l'enclencher à nouveau). De plus, en appuyant sur un autre bouton cela me permet tout aussi d'enclencher le programme qu'il contient. J'ai pour exemple Bouton2 mais c'est valable pour Bouton1 et Bouton3.
J'ai passer au moin 3h a imaginer comment faire ca :sweat_smile:

je voulais dire appuyer sur le bouton 3 déclenche le moteur pour quelques instants mais ne change pas le mode, 1 ou 2 fois jour ou 1 fois par semaine ? c'est ça ?

une bibliothèque de boutons simplifie la vie

Alors la mon programme ne met plus d'erreur. Voici ce que j'ai fait:
Ligne 5 : J'ai rajouter RTClib myRTC;// je l'ai rajouter car sur les exemples ou ils y avaient marquer MyRTC.now il y avait cette ligne et depuis que je l'ai mise je n'ai plus de problème.
Ligne 6: DS3231 Clock; // je l'ai rajouter car sur les exemple ou ils y avaient marquer MyRTC.now il y avait cette ligne et depuis que je l'ai mise je n'ai plus de problème.
Ligne 35: Wire.begin(); //avant il y avait rtc.begin(); mais arduino detecter une erreur, en regardant les exemples j'ai vues qu'il y avait systématiquement Wire.begin(). Depuis, je n'ai plus d'erreur afficher, par contre Wire.begin() signifie quoi?
Ligne 80, 88 et 97: DateTime now = myRTC.now();// avant il y avait DateTime now = rtc.now(), le fait que j'ai rajouter RTClib myRTC a la ligne 5 permet d'éviter les erreurs. Savez vous pourquoi?

Apres j'ai relue mon code est j'ai constater deux fautes de frappes que j'ai ensuite corriger, mais rien de grave.
Voila le code :
Programe_distributeur_automatique_de_nourriture_pour_poissons.ino (8,7 Ko)
Pour terminer ces questions: Je ne possède pas encore tout le matériel, mais selon vous ces petites modifications vont-elles changer la manière dont fonctionne le code (du style si ca a changer une variable ou si vue que j'ai rajouter ca il faut que je rajoute autre chose pour que ca fonctionne bien...)

Bon je voulais voir si c'était compliqué avec des bibliothèques boutons, voici un petit code d'exemple pour vous donner des idées

(j'ai caché les fils sur le dessin de configuration mais bien sûr les composants sont reliés)


#include <Wire.h>
#include <RTClib.h>
#include <Toggle.h>                         // https://github.com/Dlloydev/Toggle
#include <Stepper.h>
#include <hd44780.h>
#include <hd44780ioClass/hd44780_I2Cexp.h> // i2c expander i/o class header

// les constantes
const byte pinB1 = 2;
const byte pinB2 = 3;
const byte pinB3 = 4;
const byte pinModeConfiguration = 13;
const int pasParTour = 200;
const char * jours[] = {"Dimanche", "Lundi   ", "Mardi   ", "Mercredi", "Jeudi   ", "Vendredi", "Samedi  "};
const byte nbJours = sizeof jours / sizeof * jours;
const unsigned long periodUnPas = 5; // un pas toutes les 5ms quand le moteur est activé
const unsigned long dureeNourriture = 5000;
const int nbCols = 16;
const int nbLignes = 2;

// les variables
enum {uneFoisJour, deuxFoisJour, uneFoisSemaine, modeConfiguration } mode = uneFoisJour;
byte heureAlarme1 = 12; // 12h
byte heureAlarme2 = 19; // 12h
byte heureAlarme3 = 0;  // 0h
byte jourAlarme3 = 0;   // dimanche
bool moteurActif = false;
unsigned long chronoFeeder;
unsigned long chronoPaP;
long nbPas = 1; // influe sur la vitesse perçue

// les instances
hd44780_I2Cexp lcd;
Stepper moteur(pasParTour, 8, 9, 10, 11);
RTC_DS1307 rtc; // pins A4 et A5 pour SDA et SCL
Toggle b1(pinB1);
Toggle b2(pinB2);
Toggle b3(pinB3);


void debutDistribution() {
  Serial.println("activation moteur");
  moteurActif = true;
  chronoPaP = chronoFeeder = millis();
}

void finDistribution() {
  Serial.println("arrêt moteur");
  nbPas = -nbPas; // on tournera dans l'autre sens la prochain fois
  moteurActif = false;
}

void mode1x() {
  Serial.println("Mode une fois par jour");
  lcd.setCursor(0, 1);
  lcd.print("journalier x 1  ");
  mode = uneFoisJour;
}

void mode2x() {
  Serial.println("Mode deux fois par jour");
  lcd.setCursor(0, 1);
  lcd.print("journalier x 2  ");
  mode = deuxFoisJour;
}

void majAlarme3() {
  lcd.setCursor(0, 1);
  for (byte i = 0; i < nbCols; i++) lcd.write(' '); // efface la ligne
  lcd.setCursor(0, 1);
  lcd.print(jours[jourAlarme3]);
  lcd.setCursor(13, 1);
  if (heureAlarme3 < 10) lcd.print('0');
  lcd.print(heureAlarme3);
  lcd.print('h');
}

void finParametrage() {
  digitalWrite(pinModeConfiguration, LOW);
  Serial.print("Mode une fois par semaine, le ");
  lcd.setCursor(0, 1);
  lcd.print("hebdomadaire x 1");
  Serial.print(jours[jourAlarme3]);
  Serial.print(" à ");
  Serial.print(heureAlarme3);
  Serial.println(" h.");
  mode = uneFoisSemaine;
}


void debutParametrage() {
  Serial.println("Mode Configuration");
  majAlarme3();
  mode = modeConfiguration;
}

void majHeure() {
  static DateTime datePrecente(2000, 1, 1, 0, 0, 0);
  DateTime maintenant = rtc.now();

  if (maintenant.hour() != datePrecente.hour()) {
    lcd.setCursor(0, 0);
    if (maintenant.hour() < 10) lcd.print(' ');
    lcd.print(maintenant.hour());
    lcd.print(':');
  }

  if (maintenant.minute() != datePrecente.minute()) {
    lcd.setCursor(3, 0);
    if (maintenant.minute() < 10) lcd.print('0');
    lcd.print(maintenant.minute());
    lcd.print(':');
  }

  if (maintenant.second() != datePrecente.second()) {
    lcd.setCursor(6, 0);
    if (maintenant.second() < 10) lcd.print('0');
    lcd.print(maintenant.second());
  }

  if (maintenant.day() != datePrecente.day()) {
    lcd.setCursor(11, 0);
    if (maintenant.day() < 10) lcd.print(' ');
    lcd.print(maintenant.day());
    lcd.print('/');
  }

  if (maintenant.month() != datePrecente.month()) {
    lcd.setCursor(14, 0);
    if (maintenant.month() < 10) lcd.print('0');
    lcd.print(maintenant.month());
  }

  datePrecente = maintenant;
}

void setup() {

  pinMode(pinModeConfiguration, OUTPUT);

  b1.begin(pinB1);
  b2.begin(pinB2);
  b3.begin(pinB3);

  Serial.begin(115200);

  if (! rtc.begin()) {
    Serial.println("Couldn't find RTC");
    Serial.flush();
    abort();
  }
  if (! rtc.isrunning()) {
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }

  int lcdAbsent = lcd.begin(nbCols, nbLignes);
  if (lcdAbsent) {
    Serial.print(" initialisation LCD - erreur ");
    Serial.println(lcdAbsent);
    hd44780::fatalError(lcdAbsent);
  }

  mode1x();
}

void loop() {

  majHeure();

  // gestion du moteur
  if (moteurActif) {
    if (millis() - chronoFeeder >= dureeNourriture) finDistribution();
    else if (millis() - chronoPaP >= periodUnPas) {
      chronoPaP += periodUnPas;
      moteur.step(nbPas);
    }
  }

  // gestion des boutons
  b1.poll();
  b2.poll();
  b3.poll();

  if (mode != modeConfiguration) {
    static unsigned long debutChrono;
    if (b1.onPress()) debutChrono = millis();
    if (b1.isPressed() && (millis() - debutChrono >= 3000))   digitalWrite(pinModeConfiguration, HIGH);
    if (b1.onRelease()) {
      if (millis() - debutChrono >= 3000)
        debutParametrage();
      else
        mode1x();
    }
    if (b2.onRelease()) mode2x();
      if (b3.onRelease()) if (moteurActif) finDistribution(); else debutDistribution();
  } else {
    if (b1.onRelease()) {
      jourAlarme3 = (jourAlarme3 + 1) % nbJours;
      Serial.print("Jour Alarme hebdomadaire : "); Serial.println(jours[jourAlarme3]);
      majAlarme3();
    }
    if (b2.onRelease()) {
      heureAlarme3 = (heureAlarme3 + 1) % 24;
      Serial.print("Heure Alarme hebdomadaire : "); Serial.print(heureAlarme3); Serial.println(" h.");
      majAlarme3();
    }
    if (b3.onRelease()) finParametrage();
  }

  // gestion des alarmes
  DateTime maintenant = rtc.now();
  switch (mode) {
    case uneFoisJour:
      if (!moteurActif &&
          (maintenant.hour() == heureAlarme1) && (maintenant.minute() == 0) && (maintenant.second() == 0)) {
        debutDistribution();
      }
      break;

    case deuxFoisJour:
      if (!moteurActif &&
          (maintenant.hour() == heureAlarme1) && (maintenant.minute() == 0) && (maintenant.second() == 0)) {
        debutDistribution();
      }

      if (!moteurActif &&
          (maintenant.hour() == heureAlarme2) && (maintenant.minute() == 0) && (maintenant.second() == 0)) {
        debutDistribution();
      }
      break;

    case uneFoisSemaine:
      if (!moteurActif &&
          (maintenant.dayOfTheWeek() == jourAlarme3) &&
          (maintenant.hour() == heureAlarme3) && (maintenant.minute() == 0) && (maintenant.second() == 0)) {
        debutDistribution();
      }
      break;

    default: break;
  }

}

Ah ok, j'avait mal compris. Le bouton3 est un peut "particulier" car son but est différent comparer aux autres, ce qui fait aussi que son code est beaucoup plus simple. Si j'appuie sur bouton3 le moteurs vas tourner immédiatement, mais il est à "usage unique" car il n'est pas dans une boucle (sinon le moteurs tourne tout le temps et ... plus de poissons :sweat: ) . Mais son désavantage et que si j'appuie dessus j'annule le programme qui était exécuter auparavant par un des autres bouton. Par exemple si avant j'avais appuyer sur bouton1 le moteur tourner une fois par jour et cela tout le temps tant que je n'ai pas appuyer sur un autre bouton. En revanche, si j'appuie après sur bouton3 le moteur s'active une fois. A partir de ce moment, plus aucun code n'est exécuter. Il faut que j'appuie à nouveau sur bouton1 pour que le moteur tourne une fois par jour.
En contrepartie le bouton3 à une double fonction: celle d'initialiser l'alarme, soit le moment ou le moteur tournera durant la semaine (qui est de maximum 1x). Pour pouvoir initialiser ce moment il faut appuyer 3sc sur bouton1 et appuyer sur bouton1 ou bouton2 pour modifier le jour ou l'heure. En gros, dans ce cas bouton3 sert juste a valider le jours et l'heure auxquelles ils auront à manger. Si je veux changer ce mode, je dois appuyer sur un autre bouton (1, 2 ou 3).
Mais, il ne peut pas définir le moteur de telle sorte: tourne 3fois par semaine, une fois lundi, une fois mardi, une fois vendredi.
Mais bon, a mon avis c'est pas très compliquer à régler puisque c'est un peut comme le reste du programme. En tout cas, merci pour l'idée je pense que je vais tenter de la réaliser. Mais pour ca, il faut déjà que je termine la "base" du code :grin: .

OK je vous ai mis une version de ce que je pense correspond à votre description, si ça peut vous donner des pistes

j'ai rajouté une LED qui s'allume au bout de 3s d'appui sur le bouton 1 pour confirmer le passage en mode "configuration"

j'ai rajouté un écran LCD qui donne l'heure et le mode (et en mode configuration donne les infos avant qu'on appuie sur le bouton 3)

l'appui sur le bouton 3 hors mode config déclenche une distribution ou arrête la distribution si elle est en cours.