De l'Arduino

**Henrix** · 18/10/2026, 15h23

Bonjour,
Alors voila, j'ai décidé de remplacer la carte de commande de mon lave linge par de l'Arduino.
Si quelqu'un avait la bonté de corriger, et d'ajouter la boucle de 100 cycles, je pourrais continuer le code.
Je ne suis pas sûr que le remplissage doive être dans la première boucle.code]
A votre bon coeur
Merci
Le code:

Code:

[#define PIN_PRESS A1// Pressostat
#define PIN_POMP A2// Pompe
#define PIN_VID A3// Vidange
#define PIN_EV A4 // EV
#define PIN_MOT_A1 A5
#define PIN_MOT_A2 A6
#define PIN_MOT_B1 A7
#define PIN_MOT_B2 A8

void setup()
{
  pinMode(PIN_PRESS, INPUT);
  pinMode(PIN_POMP, OUTPUT);
  pinMode(PIN_VID, OUTPUT);
  pinMode(PIN_EV, OUTPUT);
  pinMode(PIN_MOT_A1, OUTPUT);
  pinMode(PIN_MOT_A2, OUTPUT);
  pinMode(PIN_MOT_B1, OUTPUT);
  pinMode(PIN_MOT_B2, OUTPUT);
  digitalWrite(PIN_POMP, LOW);
  digitalWrite(PIN_VID, LOW);
  digitalWrite(PIN_EV, LOW);
  digitalWrite(PIN_MOT_A1, LOW);
  digitalWrite(PIN_MOT_A2, LOW);
  digitalWrite(PIN_MOT_B1, LOW);
  digitalWrite(PIN_MOT_B2, LOW);
}

void loop()
{
  // 1 : Remplissage
   if (PIN_PRESS == LOW) {
    digitalWrite(PIN_EV, HIGH);
  }
   if (PIN_PRESS == HIGH) {
    digitalWrite(PIN_EV, LOW);
  }
  // Ici il faut démarrer une boucle de 100 cycles (lavage)
  // Sens horaire   
  }
  digitalWrite(MOT_MOT_A1, HIGH); //Sens horaire
  digitalWrite(MOT_MOT_A2, HIGH);
  delay( 25 ); // 1023*12 = environ 12.8s 

  // a : phase repos ...
    digitalWrite(MOT_MOT_A1, LOW);
    digitalWrite(MOT_MOT_A2, LOW);
    delay(25);  // 1023*12 = environ 12.8s
  }
  //Sens antihoraire
    digitalWrite(MOT_MOT_B1, HIGH); //Sens antihoraire
  digitalWrite(MOT_MOT_B2, HIGH);
  delay( 25 ); // 1023*12 = environ 12.8s 

    // b : phase repos ...
    digitalWrite(MOT_MOT_B1, LOW);
    digitalWrite(MOT_MOT_B2, LOW);
    delay(25);  // 1023*12 = environ 12.8s
  }

}

**umfred** · Hier, 11h58

0 sécurité (pas de vérification que la porte est bien fermée à moins que ce soit autrement), 1 seul type de cycle ... on branche ça démarre .....

Nota1:tes 2 conditions qui s'enchainent comme ça si pressostat est à l'état bas, on ouvre l'électrovanne, puis si le pressostat est à l'état bas, on coupe l'électrovanne (0 attente, ce qui fait que si le pressostat est à l'état bas on ouvre l'électrovanne et comme je doute que le pressostat passe immédiatement à 1, on ne ferme pas l'électrovanne et on lance les rotations directements, donc risque de débordement assuré)

Nota2: la fonction delay prend un valeur en millisecondes, donc 25 => 25ms si tu veux 12.8s, met 12800

Nota3: du fait de la présence (actuelle) d'une accolade fermante après tes tests, le code d'après n'est jamais exécuté (mais c'est peut-être voulu ici)

Nota4: tu fais fonctionner ton moteur plein pot et tu l'arrêtes d'un coup ? (alors que le tambour a une certaine charge à entrainer)

La structure setup() - loop() a la particularité que la partie loop se répète sans cesse (d'où son nom)
On peut utiliser la structure classique du main() sinon (le loop() remplace la boucle while(1) qui pourrait être utilisée dans le main)

Sinon pour faire des boucles, on peut utiliser le for() ou le while() selon le besoin, je ne vois pas a priori de difficulté à moins de ne pas connaitre le C (ou autre langage).

**Henrix** · Hier, 12h31

Le verrou de capot, je le vire et je shunte le contact (en espérant qu'il n'y a pas une "diablerie" avec).
Ok Pour une tempo après remplissage.
Je ne vois pas de démarrage particulier du moteur en l'état. (je revérifierai).
Quel risque y a t-il à démarrer plein pot (avec un tambour aux trois quart plein (moins de balourd)) ?
Le void setup (),(fermé par }), ne s'exécute qu'une fois, non ?
Je ne connais pas trop le C, mais je connais bien le Basic et ses boucles et tests
J'ai un peu de mal avec les accolades.
Merci pour les infos

**Henrix** · Hier, 12h47

Suite du #3:
Après modifs, ce code est-il cohérent ?

Code:

#define PIN_PRESS A1// Pressostat
#define PIN_POMP A2// Pompe
#define PIN_VID A3// Vidange
#define PIN_EV A4 // EV
#define PIN_MOT_A1 A5
#define PIN_MOT_A2 A6
#define PIN_MOT_B1 A7
#define PIN_MOT_B2 A8

void setup()
{
  pinMode(PIN_PRESS, INPUT);
  pinMode(PIN_POMP, OUTPUT);
  pinMode(PIN_VID, OUTPUT);
  pinMode(PIN_EV, OUTPUT);
  pinMode(PIN_MOT_A1, OUTPUT);
  pinMode(PIN_MOT_A2, OUTPUT);
  pinMode(PIN_MOT_B1, OUTPUT);
  pinMode(PIN_MOT_B2, OUTPUT);
  digitalWrite(PIN_POMP, LOW);
  digitalWrite(PIN_VID, LOW);
  digitalWrite(PIN_EV, LOW);
  digitalWrite(PIN_MOT_A1, LOW);
  digitalWrite(PIN_MOT_A2, LOW);
  digitalWrite(PIN_MOT_B1, LOW);
  digitalWrite(PIN_MOT_B2, LOW);

  // 1 : Remplissage
   if (PIN_PRESS == LOW) {
    digitalWrite(PIN_EV, HIGH);
  }
   if (PIN_PRESS == HIGH) {
    digitalWrite(PIN_EV, LOW);
  }
   delay( 25 ); // 1023*12 = environ 12.8s 

  // Lavage
      for (int i = 1; i <= 5; i++) { // 5 pour les tests

  // Sens horaire   
  digitalWrite(MOT_MOT_A1, HIGH); //Sens horaire
  digitalWrite(MOT_MOT_A2, HIGH);
  delay( 25 ); // 1023*12 = environ 12.8s 

  // a : phase repos ...
    digitalWrite(MOT_MOT_A1, LOW);
    digitalWrite(MOT_MOT_A2, LOW);
    delay(25);  // 1023*12 = environ 12.8s
 
  //Sens antihoraire
    digitalWrite(MOT_MOT_B1, HIGH); //Sens antihoraire
  digitalWrite(MOT_MOT_B2, HIGH);
  delay( 25 ); // 1023*12 = environ 12.8s 

    // b : phase repos ...
    digitalWrite(MOT_MOT_B1, LOW);
    digitalWrite(MOT_MOT_B2, LOW);
    delay(25);  // 1023*12 = environ 12.8s  
}

A voir en vidéo sur Futura · Aujourd'hui

**umfred** · Hier, 14h19

Code:

void loop()
{
  // 1 : Remplissage
   if (PIN_PRESS == LOW) {
    digitalWrite(PIN_EV, HIGH);
  }
   if (PIN_PRESS == HIGH) {
    digitalWrite(PIN_EV, LOW);
  }
  // Ici il faut démarrer une boucle de 100 cycles (lavage)
  // Sens horaire   
  }<--

je parlais de cette accolade (pointée par <--) qui fermait le loop; mais bref

Pour le remplissage, le but est d'attendre que le pressostat passe à 1 après avoir ouvert l'électrovanne, non? or toi tu n'attends pas

Code:

// 1 : Remplissage
   if (PIN_PRESS == LOW) {
    digitalWrite(PIN_EV, HIGH);
  }
  While(PIN_PRESS!=HIGH); //on attend tanque pressostat n'est pas à 1
   if (PIN_PRESS == HIGH) {
    digitalWrite(PIN_EV, LOW);
  }
   delay( 5000 ); // 5s

Pour le démarrage du moteur à plein régime, je crains (mais j'ai peut-être tort) que tu n'ai besoin d'un certain couple pour le mettre en mouvement et aussi que le plein régime corresponde plus à l'essorage qu'au lavage (il me semble que ça tourne plus vite dans la phase d'essorage que celle du lavage).

pour la boucle for, c'est le principe (je reviens sur la valeur passée à la fonction delay qui est une durée en millisecondes normalement)

**Henrix** · Hier, 15h17

Je vais corriger le delay.
Le moteur a deux branchements distincts pour le lavage et l'essorage (5 fils)
J'ai testé les fils du lavage pour les deux sens
Je vérifierai en tension pour voir ce qu se passe au démarrage
Je fais l'impasse sur l'essorage. (Il y a un bon moment que cette machine essore de force malgré mes demandes, ça m'a gonflé)
Et comme je ne maîtrise pas trop l'histoire, je coupe et alimente sur les deux fils (MOT_A1, MOT_A2)
C'est bon si il n'y a pas de "main" quelque part ?
Merci pour la correction du remplissage.

**Janpolanton** · Hier, 15h24

Bonjour,
Il serait peut-être temps de changer de machine à laver...

**Henrix** · Hier, 16h05

Si c'était aussi simple...
Toutes les machine modernes on un verrou de capot
Et une chierie d'électronique qui n'en fait qu'à sa tête
Cette machine a moins de un an
Et j'aime es choses simples. Pas de verrou (un poids de cinq kilos sur le capot), lavage à froid, pas d'essorage
Plus tard je mettrai des potards pour régler les nombres de cycles (lavage et rinçage
Le code complet:
Merci pour la vérification

Code:

e PIN_PRESS A1// Pressostat
#define PIN_POMP A2// Pompe
#define PIN_VID A3// Vidange
#define PIN_EV A4 // EV
#define PIN_MOT_A1 A5
#define PIN_MOT_A2 A6
#define PIN_MOT_B1 A7
#define PIN_MOT_B2 A8

void setup()
{
  pinMode(PIN_PRESS, INPUT);
  pinMode(PIN_POMP, OUTPUT); / Pompe de puit
  pinMode(PIN_VID, OUTPUT);
  pinMode(PIN_EV, OUTPUT);
  pinMode(PIN_MOT_A1, OUTPUT);
  pinMode(PIN_MOT_A2, OUTPUT);
  pinMode(PIN_MOT_B1, OUTPUT);
  pinMode(PIN_MOT_B2, OUTPUT);
  digitalWrite(PIN_VID, LOW);
  digitalWrite(PIN_EV, LOW);
  digitalWrite(PIN_MOT_A1, LOW);
  digitalWrite(PIN_MOT_A2, LOW);
  digitalWrite(PIN_MOT_B1, LOW);
  digitalWrite(PIN_MOT_B2, LOW);

// 1 : Remplissage
   if (PIN_PRESS == LOW) {
     digitalWrite(PIN_EV, HIGH);
     delay( 2000 );
     digitalWrite(POMP, HIGH);
  }
  While(PIN_PRESS!=HIGH); //on attend tanque pressostat n'est pas à 1
   if (PIN_PRESS == HIGH) {
     digitalWrite(POMP, LOW)
     delay( 10000 ); / On attend que la pression de la pompe retombe (eau de puit)
     digitalWrite(PIN_EV, LOW);
  }
   delay( 5000 ); // 5s

  // Lavage
     for (int i = 1; i <= 5; i++) { // 5 pour les tests

  // Sens horaire   
     digitalWrite(MOT_MOT_A1, HIGH); //Sens horaire
     digitalWrite(MOT_MOT_A2, HIGH);
     delay( 15000 );  

  // a : phase repos ...
     digitalWrite(MOT_MOT_A1, LOW);
     digitalWrite(MOT_MOT_A2, LOW);
     delay(15000);  
 
  // Sens antihoraire
     digitalWrite(MOT_MOT_B1, HIGH); //Sens antihoraire
     digitalWrite(MOT_MOT_B2, HIGH);
     delay( 15000 );

  // b : phase repos ...
     digitalWrite(MOT_MOT_B1, LOW);
     digitalWrite(MOT_MOT_B2, LOW);
     delay( 15000 );  
}
  // Rinçage
      for (int i = 1; i <= 7; i++) { 
  // Vidage
     digitalWrite(PIN_VID, HIGH);
     While(PIN_PRESS!=HIGH);
     delay( 50000 ); // Pour vidage maxi
     
  // re rempliss 
   if (PIN_PRESS == LOW) {
     digitalWrite(PIN_EV, HIGH);
     delay( 2000 );
     digitalWrite(POMP, HIGH);
  }
  While(PIN_PRESS!=HIGH); //on attend tanque pressostat n'est pas à 1
   if (PIN_PRESS == HIGH) {
     digitalWrite(POMP, LOW)
     delay( 10000 ); / On attend que la pression de la pompe retombe (eau de puit)
     digitalWrite(PIN_EV, LOW);
  }
}
  // FIN

**umfred** · Hier, 16h51

si tu n'utilises pas le main, il faut obligatoirement setup et loop (loop peut-être vide)

Code:

void setup(){
// tout le code
}
void loop(){
}

J'insiste encore une fois sur la sécurité, en particulier électrique quand tu fais tes mesures (je pense qu'il peut y avoir de fort pic de courant)

**Henrix** · Hier, 17h01

Ah bon, je pensais que le "setup" c'était pour initialiser .
Je préfère le "main", mais je le mets où ?
Et avec le "main" je garde le "setup" ?
Pas d'inquiétude pour la sécurité, si le multimètre brûle, j'ai de bons réflexes.

**umfred** · Hier, 17h01

pour le vidage il faut que tu attendes tant que la pression n'est pas basse au contraire du remplissage

Code:

// Vidage
     digitalWrite(PIN_VID, HIGH);
     While(PIN_PRESS!=LOW);
     delay( 50000 ); // Pour vidage maxi

A priori il manque l'accolade fermante du setup (et le loop vide)
Après, il faudrait factoriser certaines parties en en faisant de fonctions (histoire ne pas répéter du code)

**Henrix** · Hier, 17h42

Je préfère répéter du code, ça me paraît plus clair.
J'ai testé le code dans l'interface
Il me sort des: "expected primary-expression before "," token un peu partout
Je ne comprends pas pourquoi mettre tout le code dans le"setup"
Le code testé:

Code:

#define PIN_PRESS // Pressostat
#define PIN_POMP // Pompe
#define PIN_VID // Vidange
#define PIN_EV  // EV
#define PIN_MOT_A1
#define PIN_MOT_A2
#define PIN_MOT_B1
#define PIN_MOT_B2 
#define int i 

void setup()
{
  pinMode(PIN_PRESS, INPUT);
  pinMode(PIN_POMP, OUTPUT); // Pompe de puit
  pinMode(PIN_VID, OUTPUT);
  pinMode(PIN_EV, OUTPUT);
  pinMode(PIN_MOT_A1, OUTPUT);
  pinMode(PIN_MOT_A2, OUTPUT);
  pinMode(PIN_MOT_B1, OUTPUT);
  pinMode(PIN_MOT_B2, OUTPUT);
  digitalWrite(PIN_VID, LOW);
  digitalWrite(PIN_EV, LOW);
  digitalWrite(PIN_MOT_A1, LOW);
  digitalWrite(PIN_MOT_A2, LOW);
  digitalWrite(PIN_MOT_B1, LOW);
  digitalWrite(PIN_MOT_B2, LOW);
}
  void loop(){
}
// 1 : Remplissage
   if (PIN_PRESS == LOW) {
     digitalWrite(PIN_EV, HIGH);
     delay( 2000 );
     digitalWrite(PIN_POMP, HIGH);
  }
  While(PIN_PRESS!=HIGH); //on attend tant que pressostat n'est pas à 1
   if (PIN_PRESS == HIGH) {
     digitalWrite(PIN_POMP, LOW)
     delay( 10000 ); / On attend que la pression de la pompe retombe (eau de puit)
     digitalWrite(PIN_EV, LOW);
  }
   delay( 5000 ); // 5s

  // Lavage
     for (int i = 1; i <= 5; i++) { // 5 pour les tests

  // Sens horaire   
     digitalWrite(PIN_MOT_MOT_A1, HIGH); //Sens horaire
     digitalWrite(PIN_MOT_MOT_A2, HIGH);
     delay( 15000 );  

  // a : phase repos ...
     digitalWrite(PIN_MOT_MOT_A1, LOW);
     digitalWrite(PIN_MOT_MOT_A2, LOW);
     delay(15000);  
 
  // Sens antihoraire
     digitalWrite(PIN_MOT_MOT_B1, HIGH); //Sens antihoraire
     digitalWrite(PIN_MOT_MOT_B2, HIGH);
     delay( 15000 );

  // b : phase repos ...
     digitalWrite(PIN_MOT_MOT_B1, LOW);
     digitalWrite(PIN_MOT_MOT_B2, LOW);
     delay( 15000 );  
}
  // Rinçage
      for (int i = 1; i <= 7; i++) { 
  // Vidage
     digitalWrite(PIN_VID, HIGH);
     While(PIN_PRESS!=LOW);
     delay( 50000 ); // Pour vidage maxi
     
  // re rempliss 
   if (PIN_PRESS == LOW) {
     digitalWrite(PIN_EV, HIGH);
     delay( 2000 );
     digitalWrite(PIN_POMP, HIGH);
  }
  While(PIN_PRESS!=HIGH); //on attend tanque pressostat n'est pas à 1
   if (PIN_PRESS == HIGH) {
     digitalWrite(PIN_POMP, LOW);
     delay( 10000 ); / On attend que la pression de la pompe retombe (eau de puit)
     digitalWrite(PIN_EV, LOW);
  }
}
  // FIN

**umfred** · Hier, 18h21

retire la ligne [c]#define int i [/c] on ne déclare pas les variables ainsi
Ici, je pense que le faire dans les for est le mieux pour cette variable [c]for(int i = 1;...[/c] comme i n'est utiliser que dans les boucles (c'est d'ailleurs ce que tu as fait).
Et comme tu l'as écrit, tout le code qui se trouve après loop n'est jamais exécuté (et sans doute en grande partie la cause des erreurs)
Le setup n'est exécuté qu'une seule fois contrairement au loop; on définit les fonctions setup et loop utilisés dans un main "caché" (ou masqué) par l'ide Arduino
Le main caché ressemble à

Code:

int main(void) {
    init();
    initVariant();
    setup();
    for (;;) {
        loop();
        if (serialEventRun) serialEventRun();
    }
    return 0;
}

et utilise donc le code que tu écris dans les fonctions setup et loop.
Comme ton code ne tourne pas en boucle, tu dois tout écrire dans setup, le programme se terminera dans une boucle infi dans laquelle il ne se passe rien (à part une gestion du port série).
Ou alors tu utilises la fonction main et tu écris ton code dedans, comme un code standard en C/C++.
1.setup/loop

Code:

#define PIN_PRESS // Pressostat
#define PIN_POMP // Pompe
#define PIN_VID // Vidange
#define PIN_EV  // EV
#define PIN_MOT_A1
#define PIN_MOT_A2
#define PIN_MOT_B1
#define PIN_MOT_B2 

void setup()
{
  pinMode(PIN_PRESS, INPUT);
  pinMode(PIN_POMP, OUTPUT); // Pompe de puit
  pinMode(PIN_VID, OUTPUT);
  pinMode(PIN_EV, OUTPUT);
  pinMode(PIN_MOT_A1, OUTPUT);
  pinMode(PIN_MOT_A2, OUTPUT);
  pinMode(PIN_MOT_B1, OUTPUT);
  pinMode(PIN_MOT_B2, OUTPUT);
  digitalWrite(PIN_VID, LOW);
  digitalWrite(PIN_EV, LOW);
  digitalWrite(PIN_MOT_A1, LOW);
  digitalWrite(PIN_MOT_A2, LOW);
  digitalWrite(PIN_MOT_B1, LOW);
  digitalWrite(PIN_MOT_B2, LOW);

// 1 : Remplissage
   if (PIN_PRESS == LOW) {
     digitalWrite(PIN_EV, HIGH);
     delay( 2000 );
     digitalWrite(PIN_POMP, HIGH);
  }
  While(PIN_PRESS!=HIGH); //on attend tant que pressostat n'est pas à 1
   if (PIN_PRESS == HIGH) {
     digitalWrite(PIN_POMP, LOW)
     delay( 10000 ); / On attend que la pression de la pompe retombe (eau de puit)
     digitalWrite(PIN_EV, LOW);
  }
   delay( 5000 ); // 5s

  // Lavage
     for (int i = 1; i <= 5; i++) { // 5 pour les tests

  // Sens horaire   
     digitalWrite(PIN_MOT_MOT_A1, HIGH); //Sens horaire
     digitalWrite(PIN_MOT_MOT_A2, HIGH);
     delay( 15000 );  

  // a : phase repos ...
     digitalWrite(PIN_MOT_MOT_A1, LOW);
     digitalWrite(PIN_MOT_MOT_A2, LOW);
     delay(15000);  
 
  // Sens antihoraire
     digitalWrite(PIN_MOT_MOT_B1, HIGH); //Sens antihoraire
     digitalWrite(PIN_MOT_MOT_B2, HIGH);
     delay( 15000 );

  // b : phase repos ...
     digitalWrite(PIN_MOT_MOT_B1, LOW);
     digitalWrite(PIN_MOT_MOT_B2, LOW);
     delay( 15000 );  
  }
  // Rinçage
      for (int i = 1; i <= 7; i++) { 
  // Vidage
     digitalWrite(PIN_VID, HIGH);
     While(PIN_PRESS!=LOW);
     delay( 50000 ); // Pour vidage maxi
     
  // re rempliss 
   if (PIN_PRESS == LOW) {
     digitalWrite(PIN_EV, HIGH);
     delay( 2000 );
     digitalWrite(PIN_POMP, HIGH);
  }
  While(PIN_PRESS!=HIGH); //on attend tanque pressostat n'est pas à 1
   if (PIN_PRESS == HIGH) {
     digitalWrite(PIN_POMP, LOW);
     delay( 10000 ); / On attend que la pression de la pompe retombe (eau de puit)
     digitalWrite(PIN_EV, LOW);
  }
}
  // FIN
}
void loop(){}

2.main

Code:

#include <Arduino.h>
#define PIN_PRESS // Pressostat
#define PIN_POMP // Pompe
#define PIN_VID // Vidange
#define PIN_EV  // EV
#define PIN_MOT_A1
#define PIN_MOT_A2
#define PIN_MOT_B1
#define PIN_MOT_B2 

void main()
{
  pinMode(PIN_PRESS, INPUT);
  pinMode(PIN_POMP, OUTPUT); // Pompe de puit
  pinMode(PIN_VID, OUTPUT);
  pinMode(PIN_EV, OUTPUT);
  pinMode(PIN_MOT_A1, OUTPUT);
  pinMode(PIN_MOT_A2, OUTPUT);
  pinMode(PIN_MOT_B1, OUTPUT);
  pinMode(PIN_MOT_B2, OUTPUT);
  digitalWrite(PIN_VID, LOW);
  digitalWrite(PIN_EV, LOW);
  digitalWrite(PIN_MOT_A1, LOW);
  digitalWrite(PIN_MOT_A2, LOW);
  digitalWrite(PIN_MOT_B1, LOW);
  digitalWrite(PIN_MOT_B2, LOW);

// 1 : Remplissage
   if (PIN_PRESS == LOW) {
     digitalWrite(PIN_EV, HIGH);
     delay( 2000 );
     digitalWrite(PIN_POMP, HIGH);
  }
  While(PIN_PRESS!=HIGH); //on attend tant que pressostat n'est pas à 1
   if (PIN_PRESS == HIGH) {
     digitalWrite(PIN_POMP, LOW)
     delay( 10000 ); / On attend que la pression de la pompe retombe (eau de puit)
     digitalWrite(PIN_EV, LOW);
  }
   delay( 5000 ); // 5s

  // Lavage
     for (int i = 1; i <= 5; i++) { // 5 pour les tests

  // Sens horaire   
     digitalWrite(PIN_MOT_MOT_A1, HIGH); //Sens horaire
     digitalWrite(PIN_MOT_MOT_A2, HIGH);
     delay( 15000 );  

  // a : phase repos ...
     digitalWrite(PIN_MOT_MOT_A1, LOW);
     digitalWrite(PIN_MOT_MOT_A2, LOW);
     delay(15000);  
 
  // Sens antihoraire
     digitalWrite(PIN_MOT_MOT_B1, HIGH); //Sens antihoraire
     digitalWrite(PIN_MOT_MOT_B2, HIGH);
     delay( 15000 );

  // b : phase repos ...
     digitalWrite(PIN_MOT_MOT_B1, LOW);
     digitalWrite(PIN_MOT_MOT_B2, LOW);
     delay( 15000 );  
  }
  // Rinçage
      for (int i = 1; i <= 7; i++) { 
  // Vidage
     digitalWrite(PIN_VID, HIGH);
     While(PIN_PRESS!=LOW);
     delay( 50000 ); // Pour vidage maxi
     
  // re rempliss 
   if (PIN_PRESS == LOW) {
     digitalWrite(PIN_EV, HIGH);
     delay( 2000 );
     digitalWrite(PIN_POMP, HIGH);
  }
  While(PIN_PRESS!=HIGH); //on attend tanque pressostat n'est pas à 1
   if (PIN_PRESS == HIGH) {
     digitalWrite(PIN_POMP, LOW);
     delay( 10000 ); / On attend que la pression de la pompe retombe (eau de puit)
     digitalWrite(PIN_EV, LOW);
  }
}
  // FIN
}

Il doit manqué quelques #include aussi au début (lié à ta carte Arduino) (surtout avec main avec au minimum Ardhuino.h pour pouvoir utiliser les fonctions de base d'Arduino)

**umfred** · Hier, 18h27

Je rajoute qu'il manque aussi et surtout la fin de tes "define" à savoir le numéro de la pin correspondant au nom que tu définies , ce qui était présent dans tes codes initiaux (je ne réédite pas mon code ci-dessus, je te laisse les rajouter)

**Henrix** · Aujourd'hui, 10h31

Chat GPT m'a pondu ça
Je le soumets à votre sagacité
Et l'ausculte moi-même

Code:

// Affectation des broches numériques
#define PIN_PRESS  22
#define PIN_POMP   23
#define PIN_VID    24
#define PIN_EV     25
#define PIN_MOT_A1 26
#define PIN_MOT_A2 27
#define PIN_MOT_B1 28
#define PIN_MOT_B2 29

// Temporisations
const unsigned long DELAI_POMPE = 2000;
const unsigned long DELAI_REPOS_POMPE = 10000;
const unsigned long DELAI_REPOS = 15000;
const unsigned long DELAI_MOTEUR = 15000;
const unsigned long DELAI_VIDANGE = 50000;

// Délais maximaux de sécurité (à adapter)
const unsigned long MAX_REMPLISSAGE = 300000UL; // 5 minutes
const unsigned long MAX_VIDANGE = 180000UL;     // 3 minutes

// Nombre de cycles
const int NB_LAVAGES = 5;
const int NB_RINCAGES = 7;


// --------------------------------------------------
// Arrêt des actionneurs
// --------------------------------------------------
void arretGeneral()
{
  digitalWrite(PIN_POMP, LOW);
  digitalWrite(PIN_VID, LOW);
  digitalWrite(PIN_EV, LOW);

  digitalWrite(PIN_MOT_A1, LOW);
  digitalWrite(PIN_MOT_A2, LOW);
  digitalWrite(PIN_MOT_B1, LOW);
  digitalWrite(PIN_MOT_B2, LOW);
}


// --------------------------------------------------
// Arrêt du moteur
// --------------------------------------------------
void arretMoteur()
{
  digitalWrite(PIN_MOT_A1, LOW);
  digitalWrite(PIN_MOT_A2, LOW);
  digitalWrite(PIN_MOT_B1, LOW);
  digitalWrite(PIN_MOT_B2, LOW);
}


// --------------------------------------------------
// Mise en sécurité en cas de défaut
// --------------------------------------------------
void defaut(const char* message)
{
  arretGeneral();

  Serial.println(message);
  Serial.println("Cycle interrompu.");

  // Attente d'une remise sous tension
  while (true)
  {
    delay(1000);
  }
}


// --------------------------------------------------
// Remplissage
// Hypothese : LOW = niveau insuffisant
//             HIGH = niveau atteint
// --------------------------------------------------
void remplir()
{
  arretMoteur();
  digitalWrite(PIN_VID, LOW);

  // Ouverture de l'electrovanne
  digitalWrite(PIN_EV, HIGH);

  // Attente avant demarrage de la pompe
  delay(DELAI_POMPE);

  // Demarrage de la pompe
  digitalWrite(PIN_POMP, HIGH);

  unsigned long debut = millis();

  while (digitalRead(PIN_PRESS) == LOW)
  {
    if (millis() - debut >= MAX_REMPLISSAGE)
    {
      defaut("DEFAUT : temps maximal de remplissage depasse");
    }

    delay(10);
  }

  // Niveau atteint : arret de la pompe
  digitalWrite(PIN_POMP, LOW);

  // Attente de stabilisation de la pression
  delay(DELAI_REPOS_POMPE);

  // Fermeture de l'electrovanne
  digitalWrite(PIN_EV, LOW);

  Serial.println("Remplissage termine.");
}


// --------------------------------------------------
// Vidange
// Hypothese : LOW = cuve vide
//             HIGH = niveau d'eau present
// --------------------------------------------------
void vidanger()
{
  arretMoteur();

  digitalWrite(PIN_POMP, LOW);
  digitalWrite(PIN_EV, LOW);

  // Demarrage de la vidange
  digitalWrite(PIN_VID, HIGH);

  unsigned long debut = millis();

  while (digitalRead(PIN_PRESS) == HIGH)
  {
    if (millis() - debut >= MAX_VIDANGE)
    {
      defaut("DEFAUT : temps maximal de vidange depasse");
    }

    delay(10);
  }

  // Le pressostat indique que la cuve est vide
  delay(DELAI_VIDANGE);

  digitalWrite(PIN_VID, LOW);

  Serial.println("Vidange terminee.");
}


// --------------------------------------------------
// Moteur sens horaire
// --------------------------------------------------
void moteurHoraire()
{
  arretMoteur();
  delay(500); // Temps de transition

  digitalWrite(PIN_MOT_A1, HIGH);
  digitalWrite(PIN_MOT_A2, HIGH);

  delay(DELAI_MOTEUR);

  arretMoteur();
  delay(DELAI_REPOS);
}


// --------------------------------------------------
// Moteur sens antihoraire
// --------------------------------------------------
void moteurAntihoraire()
{
  arretMoteur();
  delay(500); // Temps de transition

  digitalWrite(PIN_MOT_B1, HIGH);
  digitalWrite(PIN_MOT_B2, HIGH);

  delay(DELAI_MOTEUR);

  arretMoteur();
  delay(DELAI_REPOS);
}


// --------------------------------------------------
// Initialisation
// --------------------------------------------------
void setup()
{
  Serial.begin(9600);

  // Pressostat
  pinMode(PIN_PRESS, INPUT);

  // Actionneurs
  pinMode(PIN_POMP, OUTPUT);
  pinMode(PIN_VID, OUTPUT);
  pinMode(PIN_EV, OUTPUT);

  pinMode(PIN_MOT_A1, OUTPUT);
  pinMode(PIN_MOT_A2, OUTPUT);
  pinMode(PIN_MOT_B1, OUTPUT);
  pinMode(PIN_MOT_B2, OUTPUT);

  arretGeneral();

  Serial.println("Demarrage du programme de lavage.");
}


// --------------------------------------------------
// Cycle de lavage
// --------------------------------------------------
void loop()
{
  // 1. Remplissage initial
  remplir();

  delay(5000);

  // 2. Lavage : 5 alternances
  for (int i = 0; i < NB_LAVAGES; i++)
  {
    Serial.print("Lavage : alternance ");
    Serial.println(i + 1);

    moteurHoraire();
    moteurAntihoraire();
  }

  // 3. Rinçage : 7 cycles
  for (int i = 0; i < NB_RINCAGES; i++)
  {
    Serial.print("Rincage : cycle ");
    Serial.println(i + 1);

    vidanger();
    remplir();
  }

  // 4. Fin du programme
  arretGeneral();

  Serial.println("CYCLE TERMINE.");

  // Ne pas recommencer automatiquement
  while (true)
  {
    delay(1000);
  }
}

**Henrix** · Aujourd'hui, 10h44

Suite du #15
Et le plus dingue,c'est que ça compile direct
Il est vraiment fort le bestiau.
Reste à savoir pourquoi il vide après avoir rempli
Et qu'ensuite il démarre le moteur
Lavage à sec ???

**Henrix** · Aujourd'hui, 10h50

Suite du : #16
Oh purée,il a tout mis en fonctions
Et il exécute les fonctions
Alors là,je suis scié, baba, espanté, médusé, le cul par terre.

**umfred** · Aujourd'hui, 11h33

perso, je sortirai les arrêts moteur des fonctions remplir et vidanger
dans ton #16

Reste à savoir pourquoi il vide après avoir rempli
Et qu'ensuite il démarre le moteur

c'est résolu ?
l'algo est relativement simple, donc GPT n'est pas trop perdu, surtout si tu lui as bien expliqué

**Henrix** · Aujourd'hui, 12h41

Cite: " sortirai les arrêts moteur des fonctions remplir et vidanger"
Ok mais j'en fais quoi ?
Je lui ai donné le dernier code d'ici
Il a compris direct de quoi il s'agissait (les commentaires ont dû aider, ça aide toujours).
Résolu, je ne sais pas, pour l'instant ça compile
Je verrai avec les tests de fonctionnement.
Mais la mise en fonction, ça n'aide pas à la compréhension pour le néophyte
J'attends les composants de "Farnell".

**Henrix** · Aujourd'hui, 12h51

Suite du #19:
Dans "void remplir()
Je ne comprends pas: "unsigned long debut = millis()"

**Henrix** · Aujourd'hui, 13h11

Suite du #20:
Pour la fonction: "void arretMoteur() "
Je supprime les: "arretMoteur();"
Et je garde les instructions: "digitalWrite(PIN_VID, LOW); // Et consort...

Toujours la question quézaquo -->: "unsigned long debut = millis()"

**Henrix** · Aujourd'hui, 13h23

Suite du #21:
Je crois que j'ai compris
"debut" stocke la valeur de: "milli()"
Puis "milli() " continue de compter les ms
On teste la valeur actuelle de "milli()" on soustrait debut et on a le temps écoulé
Qu'on compare à: "MAX_REMPLISSAGE"
LE C, c'est génial !!
J'ai bon ?

**Janpolanton** · Aujourd'hui, 13h26

Bonjour,
Un peu de lecture ICI

**umfred** · Aujourd'hui, 13h52

l'utilisation de fonction rend au contraire normalement plus lisible le code (surtout si le nom de la fonction est parlante)
la fonction remplir() a pour but de remplir quelque chose, arretMoteur() a pour but l'arrêt du moteur, etc et donc faire succéder les fonctions remplir puis moteurhoraire puis arretmoteur puis vidange, c'est beaucoup plus lisible et parlant qu'une succession d'instructions.
D'où (entre autre) le fait de retirer les appels à arretMoteur dans les fonctions remplir et vidanger (on n'a pas à s'occuper du moteurs dans ces 2 fonctions)

Je pense avoir compris ta remarque du #16:
les void arretMoteur(){....} etc définissent les fonctions, ce qu'elles doivent faire (elles ne sont pas executées)
elles sont ensuite exécutées quand elles sont appelées dans les autres fonctions par arretMoteur(); etc

**Henrix** · Aujourd'hui, 13h59

Merci pour le lien
Après toutes les modifs suggérées
ça compile toujours.
Et je commence à comprendre les fonctions.
Leur inconvénient, c'est que quand on veut connaître une valeur
Il faut remonter voir dans la fonction.
Perso je préfère avoir les valeurs là où elles sont utilisées

**Henrix** · Aujourd'hui, 14h07

Suite du #25:
J'ai deux questions:
1):"const unsigned long DELAI_MOTEUR = 15000;" suspend t-il le programme comme "delay" ?
2): Dans: "const unsigned long MAX_VIDANGE = 180000UL;
C'est quoi: "180000UL" ?

**umfred** · Aujourd'hui, 14h10

de quelles valeurs tu parles?
l'avantage en revanche c'est que si tu veux modifier une valeur ou une instruction, tu ne le fais qu'une seule fois dans la fonction, pas besoin de répéter la modification au risque d'en oublier une (si la valeur peut être amener à changer selon les cas, alors, il faut envisager de la passer en paramètre de la fonction)

**Henrix** · Aujourd'hui, 14h30

Suite du: #26:
"const unsigned long MAX_VIDANGE = 180000UL;"
C'est une "déclaration" comme les: "#define" ?
@ "UNFRED": vu comme ça, ça se tient.

**umfred** · Aujourd'hui, 15h11

les define c'est un code "macro". ça va dire au compilateur "quand tu vois cette chaine de caractères, remplace la par cette valeur" (c'est en quelque sorte demander au compilateur de faire un "cherche et remplace") (et c'est aussi pour ça que la ligne ne se termine pas par un point virgule, puisque celui-ci est dans le code)
"const unsigned long MAX_VIDANGE = 180000UL;" c'est une déclaration de variable de type entier long non signé, à considérer comme une constante (non modifiable dans le programme) et affecte lui la valeur 180000 (le L est pour forcer la prise en compte en entier long); ça réserve donc une adresse mémoire pour stocker un entier long non signé (je crois que c'est 32 bits ou 4 octets) pour y stocker une valeur.

**Ikhar84** · Aujourd'hui, 15h12

#define s'adresse au prépocesseur.
Chaque occurrence de ce qui est "définie" sera remplacée par la valeur spécifiée avant la compilation.

const permet de définir des constantes. Des "variables" dont la veleur est fixée à la définition et qui ne pourra plus être modifiée, une forme de sécurité.
Si on oublie et tente de modifier la valeur d'une constante, cela provoque une erreur...
On défini une constante en début de code pour une valeur fixe lors de l'execution du code, réutilisée plusieurs fois dans le code.
Lorsque le besoin de faire évoluer cette valeur (avant recompilation), cette définition est centralisée et évite de parcourir tout le code pour la changer...
Sans compter le fait que le nom de la constante donne une indication claire sur l'utilité de la valeur...
Par convention les constantes sont en majuscule et les variables en minuscules...

unsigned est un "modificateur" qui indique que seul les valeurs "positives" seront possible. Comme les valeurs possibles d'un type particulier vont d'un minimum négatif, à un maximum positif, cela permet de stocker une valeur plus grande puisque on "commence" à 0 et non à moins Y...
Exemple trivial sur un seul octet (8 bits, 256 valeurs) :
signed (par défaut) : de -128 à 127 (le 0 compte pour un positif, 256 combinaisons)
unsigned : de 0 à 255 (256 combinaisons avec le 0)

long permet d'utiliser plus de bits pour stocker un nombre plus grand (en théorie). Se renseigner sur la plateforme pour le connaitre. 32 à 64 bits en général.
Sur une plateforme moderne, souvent int et long sont équivalents (32 ou 64 bits), sur une platforme plus ancienne ou plus "légère", les int peuvent faire 8 bits et les longs 32, par exemple...

180000UL une valeur suivie d'un suffixe UL (Unsigned Long), pas du C "classique", je penses que ça vient d'Arduino pour "forcer" le type et assurer une meilleure portabilité...

Je ne sais pas si j'ai fait assez clair, j'ai fait au mieux

Edit:
Grillé par umfred (salut !)...
À ma décharge c'était plus long à taper !

De l'Arduino

De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Re : De l'Arduino

Discussions similaires

[Programmation] arduino programme (projet SI) arduino+shield et relais grove branchement

(Arduino) problème de téléversement de programme Arduino

Carte Arduino UNO R3 ou Arduino Mega 2560 R3 ?

Communication arduino-arduino avec module Xbee