Passer de delay à Millis

Bonjour à tous.

J'ai écris un petit programme pour gérer un bac récifal, le but est de pouvoir couper et remettre en fonction les différents éléments pompes, écumeur, éclairage etc...

Par contre je souhaiterais remplacer le delay que j'ai mis lors du nourrissage des mes hôtes aquatique pour que les pompes se coupent pendant 3 minutes, cela fonctionne mais bloque les autres fonctions, or je suis sur le problème depuis 2 bonnes semaines et je m'arrache les cheveux.

Si un(e) de vous pourrais m'expliquer ce qui bloque je lui serais bien remerciant.

Pascal.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
//*********************************
// PROGRAMME GESTION BAC RECIFAL 
//*********************************
 
#include <UTFT.h>
#include <RTClib.h>
#include <DS3231.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <Wire.h>
#include <URTouch.h>
#include <SPI.h>
#include <SdFat.h>
#include <UTFT_SdRaw.h>
#include <avr/pgmspace.h>
 
#define ONE_WIRE_BUS 10
#define TEMPERATURE_PRECISION 9 
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
 
unsigned long previousMillis = 0;
const long miam = 30000;
 
DS3231  rtc(20, 21);
 
float tempB;
float phBac;
float temperature;
 
float Tmax_Bac = 0.0;
float Tmin_Bac = 100.0;
 
char TmaxBac[20];
char TminBac[20];
 
UTFT myGLCD(ITDB50, 38, 39, 40, 41);
URTouch  myTouch( 6, 5, 4, 3, 2);
#define SD_CHIP_SELECT  53  // SD chip select pin
 
// file system object
SdFat SD;
UTFT_SdRaw myFiles(&myGLCD);
File myFile;
 
//extern uint8_t SmallFont[];
extern uint8_t BigFont[];
extern uint8_t SevenSegNumFont[];
extern uint8_t GroteskBold16x32[6084];
 
int x, y; // Variables for the coordinates where the display has been pressed
 
// Définition des consignes Ventilation-Eclairage-Chauffage-Ecumeur-Brassage.
const int Eclairage = 14; // Eclairage.
const int relai_ventil = 15; // Ventilateur.
const int Brassage = 16; // Brassage Jebao.
const int Pompe1 = 17; // Pompe à eau 1.
const int Pompe2 = 18; // Pompe à eau 2
const int Ecumeur = 19; // Ecumeur
int cons_temp = 22; // Consigne température pour déclenchement ventilo.
const int PhBac = 8; // entree sonde PH BAC
const int buzzer = 12; // sortie buzzer
 
//boolean etatFonction;
boolean etatPompe1 = false;
boolean etatPompe2 = false;
boolean etatEcumeur = false;
boolean etatBrassage = false;
boolean etatEclairage = false;
 
 
// ************************** horloge
RTC_DS3231 RTC;
 
int hour;
int minute;
int second;
int day;
int month;
int year;
 
// debut programmation
 
void setup() 
{
 
  Serial.begin(115200);
  Serial.println(F("Initialising LCD ..."));
  myGLCD.InitLCD();
  myGLCD.clrScr();
  myTouch.InitTouch();
  myTouch.setPrecision(PREC_MEDIUM);
 
  Serial.println(F("Initialising SD card..."));
  bool mysd = 0;
  // see if the card is present and can be initialized:
  while (!mysd)
  {
    if (!SD.begin(SD_CHIP_SELECT, SPI_FULL_SPEED)) {
      Serial.println(F("Card failed, or not present"));
      Serial.println(F("Retrying...."));
    }
    else
    {
      mysd = 1;
      Serial.println(F("Card initialised."));
    }
  }
 
  myGLCD.setColor(255, 255, 255);
  myGLCD.fillScr(10, 30, 30); 
  myGLCD.setBackColor(10, 30, 30); 
  myGLCD.drawRect(2,2,798,478); 
 
  Wire.begin();
  rtc.begin();
  //if (! RTC.isrunning()) 
  {
    //Serial.println("RTC is NOT running!");
    // following line sets the RTC to the date & time this sketch was compiled
    RTC.adjust(DateTime(__DATE__, __TIME__));
  }
  sensors.begin();
  temperature = rtc.getTemp();
 
  // Consignes sortie Relais.
 
  pinMode (Pompe1,OUTPUT); // Relais Pompe1.
  digitalWrite(Pompe1, HIGH);
  pinMode (Pompe2,OUTPUT); // Relais Pompe2.
  digitalWrite(Pompe2, HIGH);
  pinMode (Ecumeur,OUTPUT); // Relais ecumeur.
  digitalWrite(Ecumeur,HIGH);
  pinMode (Brassage,OUTPUT); // Relais brassage.
  digitalWrite(Brassage,HIGH);
  pinMode (Eclairage,OUTPUT);// Relais Eclairage.
  digitalWrite(Eclairage,HIGH);
  pinMode (relai_ventil,OUTPUT); // Relais Ventilateur.
 
}
 
 
void loop() 
{
 
  // **********Horloge*********
 
  RTC_DS3231 rtc;
 
  DateTime now = rtc.now();
 
  myFiles.load(260, 70, 250, 240, "Bocal1.RAW");
 
  // Affichage Heure et Date. 
 
  myGLCD.setFont(SevenSegNumFont);
  myGLCD.setColor(255,255,255);
  myGLCD.printNumI(now.hour(), 400, 5, 2, '0');
  myGLCD.setFont(GroteskBold16x32);
  myGLCD.print("H", 480, 10);
  myGLCD.setFont(SevenSegNumFont);
  myGLCD.printNumI(now.minute(), 515, 5, 2, '0');
  myGLCD.setFont(GroteskBold16x32);
  myGLCD.print("M", 595, 10);
  //myGLCD.printNumI(now.second(), 280, 30, 2, '0');
 
 
  myGLCD.setFont(SevenSegNumFont);
  myGLCD.setColor(255,255,255);
  myGLCD.printNumI(now.day(), 10, 5, 2,'0');
  myGLCD.printNumI(now.month(), 100, 5, 2,'0');
  myGLCD.printNumI(now.year(), 190, 5, 2);
 
  delay(150);
 
  // Fin Programme Horloge.
 
  //*****************************************************
 
  // Projet Récupération Sonde PH et affichage.
 
  myFiles.load(340, 350, 50, 70, "PH.RAW");
 
  phBac = (1023 - analogRead(PhBac)) / 73.07;
 
  myGLCD.setFont(GroteskBold16x32);
  myGLCD.setColor(0,255,255);
  myGLCD.printNumI(phBac, 415, 390);
 
  // Fin programme PH.
 
  //***************************************************
 
  //***********Température Maison**********
 
  myFiles.load(680, 10, 40, 40, "home.RAW");
  myGLCD.setColor(0,140,255);
  myGLCD.setFont(BigFont);
  myGLCD.printNumF(temperature,0, 730, 20);
 
  // Fin Programme T.Home
 
  //***************************************************
 
  // Recuperation Temperature Sonde Bac et Affichage.
 
  hour = now.hour();
  minute = now.minute();
  second = now.second();
 
  sensors.requestTemperatures();
  tempB=(sensors.getTempCByIndex(0));
  Serial.print("tempB :");
  Serial.println(tempB);
  myGLCD.setFont(BigFont);
  myGLCD.setColor(255, 255, 0);
  myGLCD.print("Temp Bac", 10, 250);
  myGLCD.print("C",100 , 285);
  myGLCD.setFont(GroteskBold16x32);
  myGLCD.printNumF(tempB,1, 20, 285);
 
  if (now.hour()==00 && now.minute()==00)
  {
    Tmax_Bac=0;
    Tmin_Bac=100;
  }
  if (Tmax_Bac<tempB)  
  {
    Tmax_Bac=tempB;
    sprintf(TmaxBac,"a %uh%u  ",hour,minute); 
  }
  if (tempB<Tmin_Bac)
  {
    Tmin_Bac=tempB;
    sprintf(TminBac,"a %uh%u  ",hour,minute);
  }
  myGLCD.setFont(BigFont);
  myGLCD.setColor(255, 255, 255);
  myGLCD.print("Temp_M:", 50, 450);
  myGLCD.printNumF(Tmax_Bac,1, 160, 450);
  myGLCD.print(TmaxBac, 230, 450);
  myGLCD.print("Temp_m:", 380, 450);
  myGLCD.printNumF(Tmin_Bac,1, 490, 450);
  myGLCD.print(TminBac, 560, 450);
 
  if ((tempB >= 10) && (tempB <= 22 )) // Si la mesure t est < à 22.
  {
    myFiles.load(175, 227, 25, 100, "thermo_B.RAW");
  }
  if ((tempB >= 22.1 ) && (tempB <= 24.9)) // Si la mesure t est entre 22 et 25.
  {
    myFiles.load(175, 227, 25, 100, "thermo_V.RAW");
  }
  if (tempB >= 25 ) // Si la mesure t est > 26.
  {
    myFiles.load(175, 227, 25, 100, "thermo_R.RAW");
  }
 
  // Ventilation suivant la température du bac : mise en marche/arrêt du Ventilateur.
  myFiles.load(165, 350, 70, 70, "Ventil.RAW");
 
  if (tempB > (cons_temp + 3)) // Si la mesure t est > ou = à la consigne +1.00 : fonction ventille
  {
    digitalWrite (relai_ventil,HIGH);
  }
  if (tempB < (cons_temp + 2)) // Si la mesure t est < à la consigne -1.00 : arrêt ventille
  {
    digitalWrite (relai_ventil,LOW);
  }
 
  // *****Affichage ventilation On/Off.
 
  if (digitalRead(relai_ventil) == HIGH)
  {
    myFiles.load(10, 360, 120, 52, "ON_V.RAW");    
  }
  else
  {  
    myFiles.load(10, 360, 120, 52, "OFF_R.RAW");
  }
 
  // Fin Programme Température du Bac et Ventilation.
 
  //***************************************************************************
 
  // Etat Programme Eclairage On/Off.
 
  if (myTouch.dataAvailable()) 
  {
    myTouch.read();
    x = myTouch.getX(); // X coordonnée de pression.
    y = myTouch.getY(); // Y coordonnée de pression.
 
    if ((x >= 170) && (x <= 224) && (y >= 75) && (y <= 129)) 
    {
      etatEclairage = !etatEclairage;
      digitalWrite(Eclairage, etatEclairage); //on met en fonction l'éclairage.
    }
    delay(100);
  }
 
  // *****Affichage éclairage Jour On/Off. 
  if (digitalRead(Eclairage) == HIGH)
  {
    myFiles.load(170, 75, 54, 54, "Soleil.RAW");
    myFiles.load(10, 77, 120, 52, "ON_V.RAW");    
  }
  else
  {
    myFiles.load(170, 75, 54, 54, "Lune.RAW");
    myFiles.load(10, 77, 120, 52, "OFF_R.RAW"); 
  }
 
  //Fin programmen éclairage.
 
  //****************************************************************************
 
  //Etat Programme Pompe1 On/Off.
 
  myFiles.load(685, 75, 84, 60, "Pompe3.RAW");
 
  if (myTouch.dataAvailable()) 
  {
    myTouch.read();
    x = myTouch.getX(); // X coordonnée de pression.
    y = myTouch.getY(); // Y coordonnée de pression.
    // Si icone On/Off pressé.
 
    if ((x >= 685) && (x <= 769) && (y >= 75) && (y <= 135)) 
    {
      etatPompe1 = !etatPompe1;
      digitalWrite(Pompe1, etatPompe1);//on met en fonction la Pompe.
    }
    delay(100);
  }
 
  // *****Affichage Pompe a eau N°1 On/Off. 
  if (digitalRead(Pompe1) == HIGH)
  {
    myFiles.load(540, 80, 120, 52, "ON_V.RAW");
  }
  else
  {
    myFiles.load(540, 80, 120, 52, "OFF_R.RAW");
  }
 
  //****************************************************************
 
  // Etat Programme Pompe2 On/Off.
 
  myFiles.load(685, 145, 84, 60, "Pompe3.RAW");
 
  if (myTouch.dataAvailable()) 
  {
    myTouch.read();
    x = myTouch.getX(); // X coordonnée de pression.
    y = myTouch.getY(); // Y coordonnée de pression.
    // Si icone On/Off pressé.
 
    if ((x >= 685) && (x <= 775) && (y >= 145) && (y <= 205))
    {
      etatPompe2 = !etatPompe2;
      digitalWrite(Pompe2, etatPompe2);//on met en fonction la Pompe.
    }
    delay(100);
  }
  //delay(200);
 
  // *****Affichage Pompe a eau N°2 On/Off. 
  if (digitalRead(Pompe2) == HIGH)
  {
    myFiles.load(540, 152, 120, 52, "ON_V.RAW");    
  }
  else
  {
    myFiles.load(540, 152, 120, 52, "OFF_R.RAW"); 
  }
 
  //Fin programme Pompe1/2.
 
  //**********************************************
 
  //******Programme nourissage *******************
  //***Arret Pompe1/2 pendant 3 minutes*********
 
  myFiles.load(555, 340, 90, 77, "Distrib.RAW");
 
  unsigned long currentMillis = millis();
 
  if (myTouch.dataAvailable()) 
  {
    myTouch.read();
    x = myTouch.getX(); // X coordonnée de pression.
    y = myTouch.getY(); // Y coordonnée de pression.
 
    if ((x >= 555) && (x <= 645) && (y >= 340) && (y <= 417))
    {      
      digitalWrite(Pompe1, LOW);//Pompe1 off.
      digitalWrite(Pompe2, LOW);// Pompe2 off
      myFiles.load(540, 80, 120, 52, "OFF_R.RAW");
      myFiles.load(540, 80, 120, 52, "OFF_R.RAW");
      myGLCD.setFont(GroteskBold16x32);
      myGLCD.setColor(255,140,0);
      myGLCD.print("MIAM",660, 360);
    }
    if (currentMillis - previousMillis >= miam)
    { 
      digitalWrite(Pompe1, HIGH);// Pompe1 on
      digitalWrite(Pompe2, HIGH);// Pompe2 on
      myFiles.load(540, 80, 120, 52, "ON_V.RAW");
      myFiles.load(540, 80, 120, 52, "ON_V.RAW");
      myGLCD.setFont(GroteskBold16x32);
      myGLCD.print("    ",660, 360);
 
      tone(buzzer, 2637, 200);
      delay(400);
      tone(buzzer, 1975, 200);
      delay(200);
      tone(buzzer, 2093, 200);
      delay(200);
      tone(buzzer, 2349, 200);
      delay(400);
      tone(buzzer, 2093, 200);
      delay(200);
      tone(buzzer, 1975, 200);
      delay(200);
      tone(buzzer, 1760, 200);
      delay(400);
      tone(buzzer, 1760, 200);
      delay(200);
      tone(buzzer, 2093, 200);
      delay(200);
      tone(buzzer, 2637, 200);
      delay(400);
      tone(buzzer, 2349, 200);
      delay(200);
      tone(buzzer, 2093, 200);
      delay(200);
      tone(buzzer, 1975, 200);
      delay(400);
      tone(buzzer, 1975, 200);
      delay(200);
      tone(buzzer, 2093, 200);
      delay(200);
      tone(buzzer, 2349, 200);
      delay(400);
      tone(buzzer, 2637, 200);
      delay(400);
      tone(buzzer, 2093, 200);
      delay(400);
      tone(buzzer, 1760, 200);
      delay(400);
      tone(buzzer, 1760, 200);
      delay(800);
      tone(buzzer, 1760, 200);
      delay(400);
      tone(buzzer, 2349, 200);
      delay(200);
      tone(buzzer, 2794, 200);
      delay(200);
      tone(buzzer, 3520, 200);
      delay(400);
      tone(buzzer, 3136, 200);
      delay(200);
      tone(buzzer, 2794, 200);
      delay(200);
      tone(buzzer, 2637, 200);
      delay(600);
      tone(buzzer, 2093, 200);
      delay(200);
      tone(buzzer, 2637, 200);
      delay(400);
      tone(buzzer, 2349, 200);
      delay(200);
      tone(buzzer, 2093, 200);
      delay(200);
      tone(buzzer, 1975, 200);
      delay(400);
      tone(buzzer, 1975, 200);
      delay(200);
      tone(buzzer, 2093, 200);
      delay(200);
      tone(buzzer, 2349, 200);
      delay(400);
      tone(buzzer, 2637, 200);
      delay(400);
      tone(buzzer, 2093, 200);
      delay(400);
      tone(buzzer, 1760, 200);
      delay(400);
      tone(buzzer, 1760, 200);
      delay(800);
 
      previousMillis = currentMillis;
 
    }
  }
  //Fin Programme nourrisage.
 
  //*****************************************************************
 
  // Etat Programme Brassage On/Off.
 
  myFiles.load(685, 235, 90, 77, "Brassage.RAW"); 
 
  if (myTouch.dataAvailable()) 
  {
    myTouch.read();
    x = myTouch.getX(); // X coordonnée de pression.
    y = myTouch.getY(); // Y coordonnée de pression.
    // Si icone On/Off pressé.
 
    if ((x >= 685) && (x <= 775) && (y >= 235) && (y <= 312)) 
    {
      etatBrassage = !etatBrassage;
      digitalWrite(Brassage, etatBrassage);//on met en fonction la Pompe.
    }
    delay(100);
  }
 
  // *****Affichage Pompe de Brassage On/Off. 
  if (digitalRead(Brassage) == HIGH)
  {
    myFiles.load(565, 240, 70, 70, "On.RAW");    
  }
  else
  {
    myFiles.load(565, 240, 70, 70, "Off.RAW"); 
  }
 
  //Fin programme Brassage.
 
  //***************************************************************************
 
  // Etat Programme Ecumeur On/Off.
 
  myFiles.load(170, 150, 54, 60, "Ecumeur.RAW"); 
 
  if (myTouch.dataAvailable()) 
  {
    myTouch.read();
    x = myTouch.getX(); // X coordonnée de pression.
    y = myTouch.getY(); // Y coordonnée de pression.
    // Si icone On/Off pressé.
 
    if ((x >= 170) && (x <= 224) && (y >= 150) && (y <= 210))
    {
      etatEcumeur = !etatEcumeur; 
      digitalWrite(Ecumeur, etatEcumeur);//on met en fonction l'écumeur.
    }
    delay(100);
  }
 
  // *****Affichage Ecumeur On/Off. 
  if (digitalRead(Ecumeur) == HIGH)
  {
    myFiles.load(10, 156, 120, 52, "ON_V.RAW");
  }
  else
  {
    myFiles.load(10, 156, 120, 52, "OFF_R.RAW");
  }
 
  //Fin programme Ecumeur.
 
  //*********************************************************************************
 
}

Bonjour,

s'il s'agit de réaliser une action à intervalles réguliers, je te conseille d'utiliser la bibliothèque Arduino ElapsedMillis.

un exemple si tu as 2 actions à réaliser à intervalles réguliers. Pour les intervalles il faut penser aux durées des actions.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
#include <elapsedMillis.h>
 
 
elapsedMillis timeElapsed_1;
elapsedMillis timeElapsed_2;
 
unsigned int interval_1 = 1000;
unsigned int interval_2 = 2000;
 
void setup() 
{
  // initialisation
}
 
void loop() 
{
  if (timeElapsed_1 > interval_1)
  {
    // action 1 à réaliser
    // .........
    timeElapsed_1 = 0; // ne pas oublier de réinitialiser le compteur (à placer à la fin de l'action)
  }
 
 
  if (timeElapsed_2 > interval_2)
  {
    // .....
    // action 2 à réaliser
    // .....
    timeElapsed_2 = 0; // ne pas oublier de réinitialiser le compteur
  }  
 
}

Re

Auteur bonjour.

Non ce n'est qu'une action lors de l'appuie sur la zone Nourriture de l'écran, cela devrais couper les pompes pour 3 minutes une fois par jour.

Mais je retiens ton exemple et explication.

En vous remerciant.

Pascal

Bonsoir,

Pourquoi des delay() ou millis() alors que tu disposes d'une horloge RTC (DS3231) ??

f-leb bonjour.

Je ne crois pas tout comprendre à votre réponse, me suggérer vous d'utiliser un compte à rebours à chaque appuie tactile sur l'image du 'Nourrissage' ????

En vous remerciant d' alimenter ma petite flamme de compréhension.

Bonsoir,

Juste relever l'heure à l'horloge au moment d'arrêter les pompes, puis faire un test à chaque passage dans la boucle loop() pour voir si 3 minutes se sont écoulées depuis. Je suppose que tu peux aussi régler l'heure du nourrissage.

Bonjour f-leb.

Ce n'est pas un automatisme que je cherche, mais juste une action ponctuelle journalière manuel de ma part pour le nourrissage des mes hôtes. Il n'y as pas d'heure fixe.

Il y a plusieurs points que je voudrais éclaircir : lorsque tu appuies une première fois sur le bouton, tu souhaites arrêter tes pompes pendant 3 minutes sans pour autant bloquer les autres fonctions ? Si au cours de la journée tu rappuies sur le bouton faut-il couper les pompes ?
Puis remettre cette horloge à zéro passée minuit ?
Si au cours d'une journée tu n'appuies pas sur le bouton, faut-il quand même couper les pompes ?

Bref, quel est ton cahier des charges ?

Auteur bonjour,

Non je n' appuie sur l'image Nourrissage ( et donc nourris mes bestioles) que le soir donc une fois par jour, et cela 7j sur 7. Si pas appuyer sur une journée sans conséquence ( mais c'est rare) et je n'appuie pas deux fois dans la journée.

en vous remerciant.

Ok, je reviens donc avec la bibliothèque elapsedMillis :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 #include <elapsedMillis.h> elapsedMillis timeElapsed; unsigned int interval = 3*60*1000; // 3 min en ms //..... autres déclaration de variables void setup() { // initialisation.... } void loop() { // si on a appuyé sur le bouton if (btnNourrissage) { delay(100); // gestion du rebond, pour un bouton mécanique timeElapsed = 0; // initialisation du chrono digitalWrite(Pompe1, LOW); // arrêt des pompes digitalWrite(Pompe2, LOW); // arrêt des pompes etatPompe1 = false; etatPompe2 = false; nourrissage(); } if (timeElapsed > interval && !etatPompe1 && !etatPompe2) { digitalWrite(Pompe1, HIGH); // arrêt des pompes digitalWrite(Pompe2, HIGH); // arrêt des pompes etatPompe1 = true; etatPompe2 = true; } // autres actions.... }
Tu appuies sur le bouton, (adapte la condition à ton matériel), tu provoques l'arrêt des pompes avec digitalWrite(pompe, LOW). N'oublie pas de basculer tes variables etatPompe à false. Puis 3 minutes plus tard (environ) et si tes pompes sont arrêtées, donc etatPompe à false, tu redémarres tes pompes.

Dans ton code, j'ai vu que tes variables etatPompe n'étaient pas toujours associées aux commandes d'arrêt et de fonctionnement de tes pompes, elles ne reflètent donc pas l'état réel (on/off) de tes pompes.