calcul consommation/récupération eau

salut a tous

alors voila j’ai fait un système de pour visualisé le niveau d’eau d’une cuve a eau de 10KL
avec un capteur a ultra son (jusqu’ici rien de bien exceptionnel vue le nombre de sujet la dessus)

maintenant je me heurte a mon manque de connaissance

je voudrais réalisé un échantillonnage tout les N min pendant 1 mois si possible (utilisant un arduino Nano je sais que la mémoire est pas énorme) si impossible pendant 1 mois au moins durant 1 semaine
et que lorsque le niveau augmente on sache combien de litres sont récupéré et quand le niveau descend combien de litres sont consommé tout cela visible a n’importe quel moment lors de l’appuis sur un bouton poussoir

actuellement il y a un lcd 2X16 qui sera remplacer par un 4X20 et les valeurs (hauteur eau, Litres, M3) sont afficher simultanément lors de l’appuis sur le bouton poussoir

est-ce que quelqu’un aurais un code qui me permettrai de réalisé cela car je n’ai jamais utilisé la mémoire, les tableau etc… je ne sais pas vraiment comment m’y prendre :frowning:

merci a tous pour votre futur aide

je vous met mon code qui fonctionne actuellement au cas ou :slight_smile:

/* 
 * Code pour la cuve a eau de pluie
 */
// inclure la librairie écran:
#include <LiquidCrystal.h>

// initialize the library by associating any needed LCD interface pin
// with the arduino pin number it is connected to
const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

/* pour la Température de la cuve

int ThermistorPin = 0;
int Vo;
float R1 = 10000;
float logR2, R2, T, Tc;
float c1 = 1.009249522e-03, c2 = 2.378405444e-04, c3 = 2.019202697e-07;
*/

//pour le bouton

const byte bouton = 7;
boolean bp;
char pb;
char compteur;
const byte eclair = 10;

//pour le volume:

float volume = 0; //volume de la cuve
int volume_L = 0; //volume en Litre de la cuve
float hauteur_cm ; //en cm
int hauteur_cuve = 280 ; //en cm
int largeur_cuve = 220; //en cm
int longueur_cuve = 200 ; //en cm

/* Constantes pour les broches a capteur ultrason */
const byte TRIGGER_PIN = 8; // Broche TRIGGER
const byte ECHO_PIN = 9;    // Broche ECHO
 
/* Constantes pour le timeout */
const unsigned long MEASURE_TIMEOUT = 25000UL; // 25ms = ~8m à 340m/s

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

/** Fonction setup() */

void setup() {

  pb = 0;
  bp = 0;
  compteur = 0;
  pinMode(eclair, OUTPUT);
  pinMode(bouton, INPUT);
   
  /* Initialise le port série */
//  Serial.begin(9600);
   
  /* Initialise les broches */
  pinMode(TRIGGER_PIN, OUTPUT);
  digitalWrite(TRIGGER_PIN, LOW); // La broche TRIGGER doit être à LOW au repos
  pinMode(ECHO_PIN, INPUT);

// affichage écran
  
  digitalWrite(eclair, HIGH);
  lcd.begin(16, 2);
  // Print a message to the LCD.
  lcd.print("visualisation");
  lcd.setCursor(0, 1);
  lcd.print("niveau de cuve");
  delay(2000);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("dimension cuve");
  delay(1500);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(" H     l     L");
  lcd.setCursor(0, 1);
  lcd.print(hauteur_cuve);
  lcd.setCursor(6, 1);
  lcd.print(largeur_cuve);
  lcd.setCursor(12, 1);
  lcd.print(longueur_cuve);
  delay(2000);
  lcd.clear();
  digitalWrite(eclair, LOW);

}

void loop() {
//bouton
bp = digitalRead(bouton);
if (bp == 1){
  pb = 1;
}
 
int compteur = 0;
while ((compteur != 4) && (pb == 1)){
  affichage();
  compteur ++;
}
pb = 0;
digitalWrite(eclair, LOW);
lcd.clear();
}

void affichage(){
lcd.clear();
   affichage_1();
delay(5000);
  affichage_2();
delay(5000); 
}

void capteur() {
  /* 1. Lance une mesure de distance en envoyant une impulsion HIGH de 10µs sur la broche TRIGGER */
  digitalWrite(TRIGGER_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIGGER_PIN, LOW);
  
  /* 2. Mesure le temps entre l'envoi de l'impulsion ultrasonique et son écho (si il existe) */
  long measure = pulseIn(ECHO_PIN, HIGH, MEASURE_TIMEOUT);
   
  /* 3. Calcul la distance à partir du temps mesuré */
  float distance_mm = measure / 2.0 * SOUND_SPEED;

// calcule de la quantité d'eau
  
  hauteur_cm = (hauteur_cuve - (distance_mm / 10.0)); // calcule de la hauteur en centimetre
  volume =( hauteur_cm * largeur_cuve * longueur_cuve * 0.000001);// volume en m3, rentré dimension en mètre de la cuve (M=Hauteur * largeur * longeur)
  volume_L =(volume * 1000); //volume en litre 
}

// Affiche les résultats
// Affiche par l'écran LCD
int affichage_1() {
capteur();
digitalWrite(eclair, HIGH);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(volume);
lcd.setCursor(6, 0);
lcd.print("Metre cube");
lcd.setCursor(0, 1);
lcd.print(volume_L);
lcd.setCursor(6, 1);
lcd.print("Litres");
}

int affichage_2() {
capteur();
lcd.clear();
lcd.setCursor(0, 1);
lcd.print(hauteur_cm);
lcd.setCursor(7, 1);
lcd.print("cm");
lcd.setCursor(0, 0);
lcd.print("Hauteur de l'eau"); 
}

Je dirais que ce type de montage serait plus facile à réaliser sur Raspberry Pie. Sinon, c'est compliqué pour rien.

TTTTT: Je dirais que ce type de montage serait plus facile à réaliser sur Raspberry Pie. Sinon, c'est compliqué pour rien.

pourquoi? faudrait documenter un peu.... et pas besoin d'un raspberry forcément... on peut faire sous Arduino

le Nano a 2K de SRAM (et 1K d'EEPROM)

à la louche votre code doit utiliser peu de mémoire (200 octets?) pour le moment, donc au moins 1.5k de RAM libre pour du stockage et le reste pour la partie dynamique

si vous voulez faire des mesures sur un mois il va falloir conserver la mesure elle même - sur 4 octets - et éventuellement le moment de la mesure - millis() tient sur 4 octets aussi -> 8 octets pour 1 mesure donc à la louche pour 1600 octets dispos vous allez pouvoir conserver environ 200 mesures. 4 semaines pour 200 mesures => en gros une mesure tous les 3h20 - disons pour simplifier 6 mesures par jour.

On est loin de vos mesures en minutes.

Si on veut stocker plus on peut mémoriser le top départ 4 octets et ensuite si on sait que les mesures sont régulières, pas la peine d'enregistrer millis(). Donc que 4 octets par mesure --> on double notre capacité à 400 enregistrements soit 1h40 entre chaque échantillon (~100 minutes)

Pour descendre sous le niveau de l'heure, il faudrait encore diviser par deux le besoin de stockage, soit conserver la mesure sur 2 octets et pour descendre à ~25 minutes sur 1 octet.

--> quelle précision souhaitez vous avoir ? si la distance est rapportée entre 0 et 255 (si vous avez une idée du min et max de la mesure) est-ce suffisant ? dans ce cas vous avez 1600 mesures échantillonnées enregistrées - en gros toutes les 25 minutes.

si vous le faites sur une semaine et qu'un octet est acceptable alors on divise par 4 le besoin et on peut stocker toutes les 6/7 minutes environ.

--

Une autre stratégie - si le niveau ne varie pas souvent - c'est de mesurer toutes les minutes par exemple et de stocker millis() comme dans la première idée, mais uniquement si la mesure a varié significativement (à vous de définir ce qui est significatif). de cette façon vous avez 200 mesures sur un certain temps avec pleine résolution et si vous ne conservez la mesure que sur 1 octet (échelle de 0 à 255) alors 5 octets sont nécessaires au lieu de 8 soit plus de 300 mesures pertinentes. vous avez mémorisé alors que les événements essentiels.

On peut gratter un peu sur la mesure du temps - le jour entre 0 et 27 (4 semaines) et si on ne mémorise que la minute de la journée (1440 dans un jour) on a besoin de moins de bits: 5 bits pour le jour (donc ferait 32 jours) et 11 bits pour la minute ==> 16 bits = 2 octets --> on peut doubler

donc si mesure échantillonnée sur 1 octet (échelle à 255 niveau entre min et max de la cuve) si timing stocké à la minute près sur 2 octets --> 3 octets par mesure. si 1600 octets dispo --> ~530 mesures pertinentes

si vous passez sur une MEGA, 8K de SRAM soit 4,75 fois plus de mesures si vous passez sur MKR1000, 32 KB de SRAM soit 20 fois plus de mesures si vous passez sur un ESP-8266EX genre Wemos D1 mini vous avez 4M de flash dont une partie utilisable en stockage - par exemple 3Megs pour vos data et là vous êtes tranquille

bref - sans aller chercher l'artillerie lourde et un RPI - c'est jouable en fonction des choix que vous voulez faire (et je n'ai pas utilisé l'EEPROM qui pourrait aussi servir)

utilise une carte sd pour stocker les données

merci pour cette explication :slight_smile: J-M-L

lorsque je disais tout les N min cela pouvais dire toute les 120 min c’était seulement une échelle de temps

donc si j’ai bien compris

si je stock la valeur en M3 cela me permet de stocker sur 1 octet mais je perd énormément en précision

j’ai 1800 octets de libres

si je stock la valeur en Litres qui sera dans ce cas un INT et donc stocker sur 2 octets se qui fait 900 valeurs

donc si j’enregistre toute les 2H je pourrai donc avoir 7J d’enregistré ?
(ce qui me suffira)

maintenant il faut que je m’attelle a la tache d’enregistré cela dans un tableau qui pour moi est une nouveauté :sweat_smile:

a combien de cycle d’écriture/effacement chaque byte peux subir ?

puisque tu stockes ta valeur dans un entier - donc tu perds en précision - tu peux choisir de stocker la valeur - soit en litres - soit en dizaines de litres - soit en centaines de litres - soit en milliers de litres (c-a-d en m3) A toi de choisir le meilleur compromis place/précision

Alors après un peut de réflexion j’en suis arrivé a se code donc qui devrais réalisé après l’appel de cette fonction l’enregistrement dans le tableau de la valeur là n’est pas l’importance je vois comment l’intégré dans mon code :slight_smile:

la partie ou je voudrai confirmation et correction si besoin est pour la deuxième boucle FOR,

celle qui contiens les IF qui sert donc a comparé la valeur présente a celle précédente pour savoir si on a consommé de l’eau ou si on en a récupéré en comptabilisant seulement les cases du tableau non vides

merci

int tab [800];
int compteur_1 = 0;
int compteur_2 = 0;
char gain = 0;
char consommation = 0;

char pb = 0;
int volume_L;

void capteur(){
  //realiser la lecture et la transformation en litre
}

void setup() {
  // put your setup code here, to run once:

}

void loop() {
  // put your main code here, to run repeatedly:
while (pb = 0){

  for (compteur_1 = 0; compteur_1 < 800; compteur_1++){
    capteur();
    tab[compteur_1] = volume_L;
  }
  for (compteur_2 = 1; compteur_2 > compteur_1; compteur_2++){
    
    if (tab[compteur_2] < tab[compteur_2 - 1]){
      
      consommation = consommation + (tab[compteur_2 - 1] - tab[compteur_2]);
    }

    if (tab[compteur_2] > tab[compteur_2 - 1]){
      
      gain = gain + (tab[compteur_2] - tab[compteur_2 - 1]);
    }  
  
  }
}
}

while (pb [color=red]=[/color] 0){.... ooops

(tab[compteur_2] - 1) ou ne serait-ce pas plutôt (tab[compteur_2 - 1]) ?? ;)

pb est la "position du bouton" au départ a 0 mais dans le programme que j'ai posté en premier on viens régulièrement vérifier son état 0 ou 1

lorsqu'il est a 1 je m'occupe de la partie affichage des valeurs et a 0 je m'occupe de calculé la consommation car j'ai peur que cela rende la réponse au bouton trop lente

je crois que je m'embrouille (dure journée je m’emmêle les pinceaux)

oui je me suis rendu compte de mon erreur, j'ai édité le poste et corriger juste après avoir posté celui-ci

Euh, rappelez moi comment on vérifie (compare) une valeur? ;)

devrai-je utilisé un IF et non un while ?

ps: ce nombre de poste par 5min est très gênant

If ou while, le problème est en rouge :slight_smile:

haaaa je viens de comprendre effectivement c'est le double égale

while (pb == 0){ ...

mais avec une boucle while vais-je toujours vérifier l'état de PB a n'importe quel moment ?

:)

Ca ne sert pas à grand chose ce while dans la loop puisque la loop boucle déjà pour vous

Ensuite il faudra tester le bouton etc

bon j’ai un nouveau problème je ne sais pas comment faire pour réalisé un compteur qui tourne dans le LOOP et qui vas lancer l’enregistrement d’une valeur tout les 6 heures en gardant un bouton poussoir réactif si je viens a appuyé sur celui-ci n’importe quand pour visualisé mes valeurs

sachant que je peux enregistré 800 valeurs
j’ai pensé a 4 valeurs par jours soit tout les 6H
soit 200Jours si mon calcul est bon ?

mon code actuel combiné avec le tableau etc

merci pour votre aide :slight_smile:

// inclure la librairie écran:
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

//SDA--> A4
//SCL--> A5

//----- Adressage matériel -----

//LiquidCrystal_I2C lcd(0x27, 20, 4); 
LiquidCrystal_I2C lcd(0x3F,20,4);
//-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
//pour la consommation
int tab [800];
int compteur_1 = 0;
int compteur_2 = 0;
int gain = 0;
int consommation = 0;
//-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
// pour le bouton
const byte bouton = 7;
boolean bp;
char pb;
char compteur;
//-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
// pour le volume:
float volume = 0; //volume de la cuve
int volume_L = 0; //volume en Litre de la cuve
float hauteur_cm = 0.0; //en cm
int hauteur_cuve = 280 ; //en cm
unsigned char largeur_cuve = 220; //en cm
unsigned char longueur_cuve = 200 ; //en cm
//-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
/* Constantes pour les broches a capteur ultrason */
const byte TRIGGER_PIN = 8; // Broche TRIGGER
const byte ECHO_PIN = 9;    // Broche ECHO
 
/* Constantes pour le timeout */
const unsigned long MEASURE_TIMEOUT = 25000UL; // 25ms = ~8m à 340m/s

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

/** Fonction setup() */
//-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
void setup() {
  lcd.init();
  pb = 0;
  bp = 0;
  compteur = 0;
  pinMode(bouton, INPUT);
   
  /* Initialise le port série */
//  Serial.begin(9600);
   
  /* Initialise les broches */
  pinMode(TRIGGER_PIN, OUTPUT);
  digitalWrite(TRIGGER_PIN, LOW); // La broche TRIGGER doit être à LOW au repos
  pinMode(ECHO_PIN, INPUT);

// affichage écran
  
  lcd.backlight();
  lcd.print("visualisation");
  lcd.setCursor(0, 1);
  lcd.print("niveau de la cuve");
  lcd.setCursor(0, 2);
  lcd.print("2.0 By Pierre o.o");
  lcd.setCursor(14, 3);
  lcd.print("-_-");
  delay(2000);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("dimension cuve");
  lcd.setCursor(0, 2);
  lcd.print(" H     l     L");
  lcd.setCursor(0, 3);
  lcd.print(hauteur_cuve);
  lcd.setCursor(6, 3);
  lcd.print(largeur_cuve);
  lcd.setCursor(12, 3);
  lcd.print(longueur_cuve);
  delay(2000);
  lcd.clear();
  lcd.noBacklight();

}
//-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
void loop() {
//bouton
bp = digitalRead(bouton);
if (bp == 1){
  pb = 1;
}delay(250);
if (bp == 1) && (pb == 1){
  pb = 2;
}
 
int compteur = 0;
//si appuie sur le bouton 1X affichage des quantité

if ((compteur != 20) && (pb == 1)){
  capteur();
   lcd.backlight();
   affichage_1();
  delay(1000);
  compteur ++;
}
//si appuie sur le bouton une deuxieme fois affichage des consommation

if ((compteur != 20) && (pb == 2)){
  capteur();
   lcd.backlight();
   affichage_2();
  delay(1000);
  compteur ++;
}
pb = 0;
lcd.noBacklight();
lcd.clear();

// ordre d'enregistrement de la hauteur tout les 6H par appel de la fonction "conso();"
int compteur_conso = 0;



}
//-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
void capteur() {
  /* 1. Lance une mesure de distance en envoyant une impulsion HIGH de 10µs sur la broche TRIGGER */
  digitalWrite(TRIGGER_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIGGER_PIN, LOW);
  
  /* 2. Mesure le temps entre l'envoi de l'impulsion ultrasonique et son écho (si il existe) */
  long measure = pulseIn(ECHO_PIN, HIGH, MEASURE_TIMEOUT);
   
  /* 3. Calcul la distance à partir du temps mesuré */
  float distance_mm = measure / 2.0 * SOUND_SPEED;

// calcule de la quantité d'eau

  // calcule de la hauteur en centimetre
  hauteur_cm = (hauteur_cuve - (distance_mm / 10.0));
  
  // volume en m3, rentré dimension en mètre de la cuve ligne 27,28,29 (M=Hauteur * largeur * longeur)
  volume =( hauteur_cm * largeur_cuve * longueur_cuve * 0.000001);
  
  //volume en litre
  volume_L =(volume * 1000); 
}
//-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
// Affiche les résultats par l'écran LCD
int affichage_1() {
lcd.setCursor(0, 0);
lcd.print(volume);
lcd.setCursor(6, 0);
lcd.print("Metre cube");
lcd.setCursor(0, 1);
lcd.print(volume_L);
lcd.setCursor(6, 1);
lcd.print("Litres");
lcd.setCursor(0, 3);
lcd.print(hauteur_cm);
lcd.setCursor(7, 3);
lcd.print("cm");
lcd.setCursor(0, 2);
lcd.print("Hauteur de l'eau"); 
}
//-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
//enregistrement des quantité en Litres tout les 6H
void conso(){
 for (compteur_1 = 0; compteur_1 < 800; compteur_1++){
   capteur();
   tab[compteur_1] = volume_L;
 }
    if (compteur_1 == 799){
      compteur_1 = 0;
    }}
//-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
//calcul de la consommation avant affichage sur le LCD
void affichage_conso(){
 for (compteur_2 = 1; compteur_2 > compteur_1; compteur_2++){
    
   if (tab[compteur_2] < tab[compteur_2 - 1]){
      
      consommation = consommation + (tab[compteur_2 - 1] - tab[compteur_2]);
      }

   if (tab[compteur_2] > tab[compteur_2 - 1]){
      
      gain = gain + (tab[compteur_2] - tab[compteur_2 - 1]);
}}}
//-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
//affichage de la consommation sur le LCD
int affichage_2() {
  affichage_conso();
lcd.setCursor(0, 0);
lcd.print(consommation);
lcd.setCursor(6, 0);
lcd.print("conso en L");
lcd.setCursor(0, 1);
lcd.print(gain);
lcd.setCursor(6, 1);
lcd.print("Litres récup");
}

Sur ce genre de durée il vaut mieux acheter une RTC (Real Time Clock) genre DS3231 car votre arduino et sa fonction millis() va dériver significativement sur 200 jours

Pour faire un compteur dans la boucle on déclare une variable globale par exemple (ou en static dans la loop) et on l’augmente à chaque fois que c’est pertinent

unsigned int compteur = 0; // attention valeur max (sur 2 octets) donc 65 535, Si besoin de plus utiliser un unsigned long (sur 4 octets) qui a un Max à 4 294 967 295
void setup()
{
   ...
}

void loop()
{
   ...

   if (c’est le bon moment) {
      // faire les actions
      ...
      // augmenter le compteur
      compteur++; // même effet que compteur = compteur+1;
   }
   ...
}

voila ce que j'ai pondu rien de bien compliqué j'ai une question lors de l'appel de CONSO() je vais entré dans ma boucle for mais je veux qu'il fasse qu'une seul fois l'enregistrement or pour le moment il vas réalisé celui ci jusqu'à 800 comment faire pour l'interrompre après une boucle réalisé dans CONSO(); ?

void loop() {
//bouton
bp = digitalRead(bouton);
if (bp == 1){
  pb = 1;
}delay(250);
if ((bp == 1) && (pb == 1)){
  pb = 2;
}

int compteur = 0;
//si appuie sur le bouton 1X affichage des quantité

if ((compteur != 20) && (pb == 1)){
  capteur();
   lcd.backlight();
   affichage_1();
  delay(1000);
  compteur ++;
}
//si appuie sur le bouton une deuxieme fois affichage des consommation

if ((compteur != 20) && (pb == 2)){
  compteur = 0;
  capteur();
   lcd.backlight();
   affichage_2();
  delay(1000);
  compteur ++;
}
pb = 0;
lcd.noBacklight();
lcd.clear();
// ordre d'enregistrement de la hauteur tout les 6H par appel de la fonction "conso();"
long compteur_conso = 0;
compteur_conso++;
// 21600 seconde == 6H, ici 4 tour par seconde (250ms) soit 86400 pour 6H
if (compteur_conso == 86400){ 
  conso();
  compteur_conso = 0;
}

utilisez au minimum millis() pour calculer les 6h… essayer de bâtir l’attente sur le blocage d’exécution de votre code est assez arbitraire et le jour ou vous rajoutez des lignes ou des traitements au lieu d’attendre ça ne va plus marcher (car du temps sera consommé ailleurs)

vaut mieux compter le temps toujours avec des unsigned long

voici un exemple avec millis()

const byte capteur = A0;

unsigned long chrono;

const unsigned int maxData = 400;
unsigned int data[maxData];
unsigned int index;

const unsigned long sixHeures = 6 * 3600ul * 1000ul; // mettre au moins 1 ul à la fin des constantes pour forcer le calcul en unsigned long

void setup() {
  Serial.begin(115200);
  pinMode(capteur, INPUT); // pas nécessaire mais pour la forme
  chrono = millis();
  index = 0;
}


void loop() {

  if (millis() - chrono >= sixHeures) {
    Serial.println(F("Six heures sont passees"));
    if (index < maxData) { // si on a encore de la place dans le tableau
      data[index++] = analogRead(capteur);
    } else Serial.println(F("Tableau plein"));
    chrono += sixHeures; // on redéclenchera dans 6h
  }

  // ici on peut faire autre chose
}

(tapé ici donc pas sûr que ça fonctionne, relisez et testez)

merci je vais essayer

mais je ne cherche pas a être extrêmement précis sur la prise de valeurs je pense que un simple compteur suffira?

c'est seulement pour avoir un ordre d'idée sur les quantité d'eau mises en jeux millis() permet seulement de resté précis car il compte le temps a tout moment c'est bien ça ?

Oui millis avance de 1 toutes les millisecondes - c’est fait pour vous :)

Mais les 16MHz de votre arduino sont assez approximatifs et donc dans la durée (plusieurs jours) vous ne serez pas super précis; si vous avez besoin de plus de précision / stabilité alors une RTC genre DS3231 sera mieux que d’utiliser millis()