Tuto : abreuvoir à niveau constant électronique

#include <EEPROM.h>
#include <LiquidCrystal.h>

/*
Abreuvoir

*/

// select the pins used on the LCD panel
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

// Déclaration des entrées/sorties
#define ledPin LED_BUILTIN // onboard LED port D13
#define Backlit 10 // retroeclairage LCD
#define EV1 2 // Electrovanne abreuvoir #1 sur port D2
#define Niveau1 A1 // Capteur niveau abreuvoir #1 sur port A1
#define EV2 3 // Electrovanne abreuvoir #2 sur port D3
#define Niveau2 A2 // Capteur niveau abreuvoir #2 sur port A2
#define EV3 11 // Electrovanne abreuvoir #3 sur port D11
#define Niveau3 A3 // Capteur niveau abreuvoir #3 sur port A3
#define EV4 12 // Electrovanne abreuvoir #4 sur port D12
#define Niveau4 A4 // Capteur niveau abreuvoir #4 sur port A4
// Déclaration des variables

int adc_key_in = 0;
int last_lcd_key = 0;
int fr_lcd_key = 0;
int page_menu = 0;
int secondes = 0;
int minutes = 0;
int heures = 0;
int cal[4] = {0,0,0,0}; //Valeur de calibration des abreuvoir

unsigned long previousMillis = 0; //Tempo clignotement LED
unsigned long refreshLCD = 0; //Tempo rafraichissement afficheur LCD
unsigned long debButtons = 0; //Tempo anti-rebond boutons interface
unsigned long debTempsLvl[4] = {0,0,0,0}; //Tempo anti-rebond capteur niveau
unsigned long timeoutLvl[4] = {0,0,0,0}; //Tempo time-out remplissage abreuvoir
unsigned long tempobacklit = 0; //Tempo pour extinction automatique retroeclairage

unsigned long debut[4] = {0,0,0,0}; //valeur timer début remplissage
unsigned long fin[4] = {0,0,0,0}; //valeur timer fin remplissage
unsigned long total[4] = {0,0,0,0}; //temps total remplissage journée en cours
unsigned long totalJMN[4] = {0,0,0,0}; //temps total remplissage de la veille

bool ledState = LOW;
bool backlitState = true;
bool inpNiveau[4];
bool LastinpNiveau[4];
bool EVState[4] = {LOW,LOW,LOW,LOW};
bool ErrorLvl[4] = {false,false,false,false};
bool frupEV[4] = {false,false,false,false};
bool frdownEV[4] = {false,false,false,false};
bool forcageEV[4] = {false,false,false,false};
bool stopEV[4] = {false,false,false,false};


// Déclaration des constantes d'ajustement
const long interval = 1000;
const int DebTimeLvl = 2500; //durée anti-rebond capteur abreuvoir
const long ToutTimeLvl = 60000; //durée time-out remplissage abreuvoir
const long tempsbacklit = 45000; //Durée d'allumage retroeclaire après dernière action sur le clavier

// Déclaration des autres constantes
#define btnRIGHT 1
#define btnUP 2
#define btnDOWN 3
#define btnLEFT 4
#define btnSELECT 5
#define btnNONE 0



//-------------------------------------
// Routines et fonctions annexes
//-------------------------------------

// Lecture du clavier associé à l'afficheur LCD
int read_LCD_buttons()
{
int lcd_key = 0;
adc_key_in = analogRead(0); // Lecture entrée analogique clavier
// Sur mon shield les differents boutons correspondent à ces valeurs: 0, 99, 256, 410, 641
// on ajoute une fourchette de +/- 50 environs pour tester les valeurs
if (adc_key_in > 1000) lcd_key = btnNONE;
if (adc_key_in < 700) lcd_key = btnSELECT;
if (adc_key_in < 600) lcd_key = btnLEFT;
if (adc_key_in < 300) lcd_key = btnDOWN;
if (adc_key_in < 200) lcd_key = btnUP;
if (adc_key_in < 50) lcd_key = btnRIGHT;

unsigned long currentTimer = millis(); // Rafraichissement timer

if (lcd_key != last_lcd_key){ //Tant que 2 lectures d'affilée ne donnent pas la même valeur
debButtons = currentTimer; //la tempo anti-rebond est mise à zero
}
last_lcd_key = lcd_key;

if (currentTimer - debButtons >= 20){ //Si la lecture est identique pendant au moins 20ms
//création de front pour ne retourner la touche appuyée qu'une seule fois à l'enfoncement.
if (lcd_key != fr_lcd_key){
fr_lcd_key = lcd_key;
return lcd_key;
}
}

return btnNONE; // Si tout les autres cas ont échoués !
}

//Routine d'affichage du nombre de litres équivalent en fonction du temps et de la valeur de calibration
//L'affichage se fait là où se trouve le curseur du LCD
void LCD_litres(long Tempsms, int ValeurCalibration){

long volcalcul = Tempsms / ValeurCalibration; // La calibration est une valeur en milisecondes par decilitre (ms/dl)
int a = volcalcul / 10;
int b = volcalcul % 10;
lcd.print(a); //affichage de la partie entière
lcd.print("."); //affichage du separateur decimal
lcd.print(b); //affichage de la partie décimale

}


//Routine de remise à zero compteurs journaliers et horloge
//S'efectue automatiquement toutes les 24h
//ou manuellement depuis le menu LCD

void RAZ_count(){
secondes = 0;
minutes = 0;
heures = 0;
for (int i=0 ; i < 4; i++){
totalJMN[i] = total[i]; //transfert du total de la journée dans l'indicateur du total de la veille
total[i] = 0; //mise à zero compteur journalier.
}
}


//Routine de sauvegarde de l'arrêt des abreuvoirs en EEPROM
//Evite une remise en route non voulu d'un abreuvoir arrêté en
//cas de coupure secteur et/ou reset intenpestif

void SaveStop(){
int vts = 0;
int oldvts =0;
for (int i = 0; i < 4; i++){
if (stopEV[i]) bitSet(vts,i);
}
oldvts = EEPROM.read(0); //lecture de l'ancienne valeur des blocages abreuvoirs
if (vts != oldvts)EEPROM.write(0,vts); //ecriture seulement si la valeur à changé (limite cycle d'écriture en EEPROM)
}

//Routine de recuperation de l'arrêt des abreuvoirs en EEPROM
//et ecriture dans les variables correspondantes
// inverse de la fonction SaveStop()
void RestStop(){
int vtr = 0;
vtr = EEPROM.read(0);
for (int i = 0 ; i < 4 ; i++){
stopEV[i]=bitRead(vtr,i);
}
}

//Routine de sauvegarde des valeurs de calibrations en EEPROM
//Appelée uniquement à l'issue d'une routine de calibration
void SaveCal(){
int offset = 0;
int vtrh = 0;
int vtrl = 0;
for (int i = 0; i < 4; i++){
vtrh = cal[i]/256; //calcul de l'octet de poids fort
vtrl = cal[i] % 256; //calcul de l'octet de poids faible
offset = i * 2 + 2; //calcul de l'adresse du byte de poids fort
EEPROM.write(offset, vtrh);
EEPROM.write(offset + 1, vtrl);

}
}

//Routine de recuperation des valeurs de calibration enregistrées en EEPROM
//et écriture dans les variables correspondantes
void RestCal(){
int offset = 0;
int vtrh = 0;
int vtrl = 0;
for (int i = 0; i < 4; i++){
offset = i * 2 + 2; //calcul de l'adresse du byte de poids fort
vtrh = EEPROM.read(offset);
vtrl = EEPROM.read(offset + 1);
cal[i] = vtrh * 256; //octet de poids fort
cal[i] += vtrl; //octet de poids faible
}
}
//*************************************************************************************************
// Routine de calibration des abreuvoirs
// permet de mesurer le débit spécifique de chacune des installations d'abreuvoirs
// afin d'obtenir une valeur en millisecondes par décilitre (ms/dc) qui servira à l'affichage des
// compteurs journaliers
//*************************************************************************************************

void Calibrate(){
int index = 0; //variable pour traiter les 4 abreuvoirs
int page_calib = 0; //variable pour progression dans étapes calibrations
int decilitres = 0; //variable pour entrer volume par utilisateur
int litres = 0; //variable pour entrer volume par utilisateur
int volcal = 0; //variable temporaire pour calcul valeur calibration
unsigned long tempscal; //variable temporaire pour calcul valeur calibration
unsigned long timecursor; //pour tempo clignotement curseur
bool fincal = false; //pour sortir de la boucle sans fin de rafraichissement du menu
bool etape = true; //pour valider les étapes du menu de calibration
bool redo = false; //pour recommencer une étape
bool blinkcursor = false; //pour le activer clignotement du curseur dans les phases de saisie
bool cursorstatus; //pour le clignotement du curseur

do { // la routine tourne en boucle à partir d'ici tant que les 4 abreuvois ne sont pas calibrés correctement.
// Lecture des boutons pour navigation dans les menus
int touche = read_LCD_buttons();
unsigned long currentMillis = millis(); //rafraichissement variable timer
if (touche > btnNONE){
switch (touche){
case btnSELECT: //Bouton "Défilement"
{
if (etape){
etape = false; //on bloque le passage à la prochaine étape du menu, c'est les pages qui autorisent le passage ou non
page_calib++;
if (page_calib == 5){ // Si on arrive à la dernière page du menu
index++; //on passe à l'EV suivante...
if (index < 4){
page_calib = 1; //et tant qu'on à pas fait les 4 EV, on revient au début du menu.
litres = 0; //remise à zero des variables pour la calibration à venir
decilitres = 0;
}
}
}

break;
}
case btnUP: //Bouton "Séléction"
{

if (page_calib == 1){
if (EVState[index] == true) {
EVState[index] = false;
page_calib = 2;
} else {
EVState[index] = true;
}
break;
}

if (page_calib == 2){
if (redo){
page_calib = 1;
EVState[index] = false;
} else {
decilitres++;
if (decilitres > 9) decilitres = 0;
}
break;
}
if (page_calib == 3){
litres++;
if (litres > 29) litres = 0;
break;
}

if (page_calib == 4){
if (redo){
redo = false;
page_calib = 1;
}
}

if (page_calib == 5) fincal = true;
break;
}
}
}
// Fin des boutons


//Enregistrement temps début et fin remplissage

currentMillis = millis(); // Rafraichissement timer
// Detection front montant sortie EV
if( EVState[index] == HIGH && EVState[index] != frupEV[index]){
debut[index] = currentMillis; //enregistrement timming début du remplissage
}
frupEV[index] = EVState[index];

//Detection front déscendant sortie EV1
if (EVState[index] == LOW && EVState[index] != frdownEV[index]){
fin[index] = currentMillis; //enregistrement timming fin du remplissage
tempscal = fin[index] - debut[index]; //calcul durée du remplissage
}
frdownEV[index] = EVState[index];


//Application des états logiques aux sorties correspondantes
digitalWrite(EV1, EVState[0]);
digitalWrite(EV2, EVState[1]);
digitalWrite(EV3, EVState[2]);
digitalWrite(EV4, EVState[3]);

//---------------------------------------------------------------------------
// Rafraichissement afficheur
//---------------------------------------------------------------------------


//Tempo pour rafraichissement LCD

if (currentMillis - refreshLCD >= 100){ // Rafraichissement toutes les 100ms
refreshLCD = currentMillis;
lcd.clear();
if (page_calib == 0){ //Page de confirmation d'entrée du menu calibration
lcd.print("Menu calibration");
lcd.setCursor(0,1);
lcd.print("appuyez DEFIL");
}
if (page_calib == 1){ //premiere étape du menu de calibration
lcd.print("Calibration EV");
lcd.print(index + 1);
lcd.setCursor(0,1);
if (EVState[index] == false){
lcd.print("SEL = Ouvrir");
} else {
lcd.print("SEL = Fermer");
}
}
if (page_calib == 2){
if (tempscal < 5000){
redo = true;
lcd.print("Temps trop court");
lcd.setCursor(0,1);
lcd.print("Reprendre : SEL");
} else {
redo = false;
etape = true; //on autorise à passer à l'étape suivante avec le bouton défilement
lcd.print("Entrez volume ");
lcd.print(index + 1);
lcd.setCursor(1,1);
lcd.print("0.");
lcd.print(decilitres);
lcd.print(" litres");
lcd.setCursor(3,1);
blinkcursor = true;
}
}
if (page_calib == 3){ //troisième étape du menu calibration
etape = true; //on autorise à passer à l'étape suivante avec le bouton défilement
lcd.print("Entrez volume ");
lcd.print(index + 1);
lcd.setCursor(1,1);
if (litres > 9) lcd.setCursor(0,1); //si on depasse 9 litres il faut decaler le debut de l'affichage pour les dizaines
lcd.print(litres);
lcd.print(".");
lcd.print(decilitres);
lcd.print(" litres");
lcd.setCursor(1,1);
blinkcursor = true;
}
if (page_calib == 4){ //quatrième étape du menu calibration
blinkcursor = false;
volcal = litres * 10 + decilitres;
if (volcal > 0) {
cal[index] = tempscal / volcal;
etape = true; //on autorise à passer à l'étape suivante avec le bouton défilement
lcd.print("cal ");
lcd.print(index + 1);
lcd.print("=");
lcd.print(cal[index]);
lcd.setCursor(0,1);
lcd.print("Suite : DEFIL");

} else {
redo = true;
lcd.print("Volume nul !");
lcd.setCursor(0,1);
lcd.print("Reprendre : SEL");
}
}
if (page_calib == 5){ //cinquième étape du menu calibration
lcd.print("Calibrations OK");
lcd.setCursor(0,1);
lcd.print("SEL pour sortir");
}
}

//Clignotement du curseur si besoin
if (blinkcursor){
if (currentMillis - timecursor >= 500){
timecursor = currentMillis;
if (cursorstatus){
cursorstatus = false;
lcd.noCursor();
} else {
cursorstatus = true;
lcd.cursor();
}
}
} else {
lcd.noCursor();
}


} while (!fincal);
for (int j = 0 ; j < 4 ; j++){
debut[j] = 0; //remise à zero des variables de compteur
fin[j] = 0; //... pour eviter des faux comptes en sortie de calibration
EVState[j] = false;
frdownEV[j] = false;
}
SaveCal(); //Appel de routine de sauvegarde des calibrations en EEPROM

} //Fin routine calibration

// ----------------------------------------------------------------------------
// |-------------------------------------------------------------------------| |
// | Fonction d'initialisation au demarrage | |
// |-------------------------------------------------------------------------| |
// ----------------------------------------------------------------------------
void setup() {
// Initialisation des entrées/sorties
pinMode(ledPin, OUTPUT);
pinMode(Backlit, OUTPUT);
pinMode(EV1, OUTPUT);
pinMode(EV2, OUTPUT);
pinMode(EV3, OUTPUT);
pinMode(EV4, OUTPUT);
pinMode(Niveau1, INPUT);
pinMode(Niveau2, INPUT);
pinMode(Niveau3, INPUT);
pinMode(Niveau4, INPUT);
digitalWrite(Backlit, HIGH);
lcd.begin(16, 2); // start the library
lcd.setCursor(0,0);
lcd.print("Abreuvoir v1.0");
delay(3000); // Temporisation pour laisser le temps d'appeler le menu de calibration
int emc = analogRead(0);
if (emc < 200){ //Si on appuie sur le bouton SEL pendant le demarrage
delay(20); //antirebond
emc = analogRead(0);
if (emc < 200){
Calibrate();
}
}

RestStop(); //Appel de fonction de recuperation des blocages abreuvoirs
RestCal(); //Appel de fonction de recuperation des calibrations
if (cal[0] == -1){ //Si la memoire EEPROM est vierge (0xff) alors le système n'a jamais été calibré
Calibrate(); //Appel de la routine de calibration à la première mise en service.
}
tempobacklit = millis(); //remise à zero tempo retroeclairage (utile surtout en sortie de menu calibration)
}

// Boucle principale du programme
void loop() {
//Faire clignoter la led et compter le temps qui passe
unsigned long currentMillis = millis();
if (currentMillis - previousMillis >= interval) { //Base de temps de l'horloge programme
previousMillis = currentMillis;
secondes++;
if (secondes >= 60){
minutes++;
secondes = 0;
}
if (minutes >= 60){
heures++;
minutes = 0;
}
if (heures >= 24){
RAZ_count(); //appel de la routine de remise à zéro des compteurs journaliers
}

// Changement d'état pour faire clignoter la LED onboard (temoin deroulement programme OK)
if (ledState == LOW) {
ledState = HIGH;
} else {
ledState = LOW;
}
digitalWrite(ledPin, ledState);
}


// ---------------------------------------------------------------------
// Gestion des E/S et tempos Abreuvoirs
//----------------------------------------------------------------------

// Lecture des entrées
inpNiveau[0] = digitalRead(Niveau1);
inpNiveau[1] = digitalRead(Niveau2);
inpNiveau[2] = digitalRead(Niveau3);
inpNiveau[3] = digitalRead(Niveau4);

inpNiveau[0] = !inpNiveau[0]; //Commenter cette ligne ou non en fonction du sens de montage de l'inter de niveau (flotteur en haut ou flotteur en bas)
inpNiveau[1] = !inpNiveau[1]; //Commenter cette ligne ou non en fonction du sens de montage de l'inter de niveau (flotteur en haut ou flotteur en bas)
inpNiveau[2] = !inpNiveau[2]; //Commenter cette ligne ou non en fonction du sens de montage de l'inter de niveau (flotteur en haut ou flotteur en bas)
inpNiveau[3] = !inpNiveau[3]; //Commenter cette ligne ou non en fonction du sens de montage de l'inter de niveau (flotteur en haut ou flotteur en bas)

for (int i = 0 ; i <4 ; i++){ //boucle pour traiter les 4 abreuvoirs à la suite

// Prise en compte de la configuration arrêt de l'abreuvoir pour eviter de faux time-out remplissage
if (stopEV[i] == true){
inpNiveau[i] = false;
}

// Anti-rebond Entrée Abreuvoir
//reset du timer à chaque fois que l'entrée change d'état
if (inpNiveau[i] != LastinpNiveau[i]){
debTempsLvl[i] = currentMillis;
if (inpNiveau[i] == LOW){
ErrorLvl[i] = false; //au front descendant de l'entrée, l'enventuel drapeau d'erreur est effacé
}
}
LastinpNiveau[i] = inpNiveau[i];

// Si l'état est stable pendant la durée determinée
if (currentMillis - debTempsLvl[i] >= DebTimeLvl){
if (inpNiveau[i] == HIGH){ // ... alors on applique la commande correspondante à l'EV
EVState[i] = true;
} else {
EVState[i] = false;
}
}

// Time-out remplissage abreuvoir
if (EVState[i] == false) { // Dès que la commande d'EV passe à vraie...
timeoutLvl[i] = currentMillis; // ...la valeur reste figée
}

if (currentMillis - timeoutLvl[i] >= ToutTimeLvl){ // Si temps depassé
EVState[i] = LOW; //Forçage de la commane d'EV à zero
ErrorLvl[i] = true; //Drapeau erreur abreuvoir
}


//Enregistrement temps début et fin remplissage
currentMillis = millis(); // Rafraichissement timer
// Detection front montant sortie EV1
if( EVState[i] == HIGH && EVState[i] != frupEV[i]){
debut[i] = currentMillis; //enregistrement timming début du remplissage
}
frupEV[i] = EVState[i];

//Detection front déscendant sortie EV1
if (EVState[i] == LOW && EVState[i] != frdownEV[i]){
fin[i] = currentMillis; //enregistrement timming fin du remplissage
unsigned long resultat = fin[i] - debut[i]; //calcul durée du remplissage
total[i] += resultat; //ajout du temps du dernier remplissage au total journalier
}
frdownEV[i] = EVState[i];


if (forcageEV[i] == true){ //prise en compte du forçage du menu diagnostique
EVState[i] = true;
}

if (stopEV[i] == true){ //prise en compte de l'arrêt du menu diag
EVState[i] = false;
}
}
//Application des états logiques aux sorties correspondantes
digitalWrite(EV1, EVState[0]);
digitalWrite(EV2, EVState[1]);
digitalWrite(EV3, EVState[2]);
digitalWrite(EV4, EVState[3]);

//--------------------------------------------------------------------------------------
// Navigation dans les pages de menu et activation des fonctions IHM
//--------------------------------------------------------------------------------------
int touche = read_LCD_buttons();
if (touche > btnNONE){
if (backlitState == false) goto endtouches; //Si l'écran est eteind on ne fait rien sauf l'allumer
switch (touche)
{
case btnSELECT: //Bouton "Défilement"
{
page_menu++;
if (page_menu == 7){ //Fin du menu principal
page_menu = 0;
}
if (page_menu == 15){ //fin du menu diagnostique
page_menu = 8;
}
break;
}
case btnUP: //Bouton "Séléction"
{
if (page_menu == 3 && heures > 1){ //Si menu sur la page correspondante et que la dernière RAZ à plus d'une heure
// Tranfert des valeurs en memoire, et remise à zero horloge
RAZ_count();
}

if (page_menu == 6){
page_menu = 8; //Entrée dans le menu diagnostique
}

if (page_menu == 9){

if (forcageEV[0] == true && stopEV[0] == false){ //Forcage sortie EV1
forcageEV[0] = false;
stopEV[0] = true;
} else if (stopEV[0] == true){
stopEV[0] = false;
} else {
forcageEV[0] = true;
}

}

if (page_menu == 10){
if (forcageEV[1] == true && stopEV[1] == false){ //Forcage sortie EV1
forcageEV[1] = false;
stopEV[1] = true;
} else if (stopEV[1] == true){
stopEV[1] = false;
} else {
forcageEV[1] = true;
}
}

if (page_menu == 11){
if (forcageEV[2] == true && stopEV[2] == false){ //Forcage sortie EV1
forcageEV[2] = false;
stopEV[2] = true;
} else if (stopEV[2] == true){
stopEV[2] = false;
} else {
forcageEV[2] = true;
}
}

if (page_menu == 12){
if (forcageEV[3] == true && stopEV[3] == false){ //Forcage sortie EV1
forcageEV[3] = false;
stopEV[3] = true;
} else if (stopEV[3] == true){
stopEV[3] = false;
} else {
forcageEV[3] = true;
}
}

if (page_menu == 14){
for (int i = 0 ; i < 4; i++){ //Suppression des forçages en sortant du menu diag
forcageEV[i] = false;
}
SaveStop(); //Sauvegarde des forçages d'arrêt
page_menu = 0; //Retour au menu principal depuis le menu diagnostique
}
break;
}
default:
{
break;
}
}
endtouches:
tempobacklit = currentMillis; // raz tempo retroeclairage
digitalWrite(Backlit, HIGH); //Allumage retroeclairage
backlitState = true;
}
//Extinction retroeclairage
if (currentMillis - tempobacklit >= tempsbacklit){
digitalWrite(Backlit,LOW);
backlitState = false;
}

//Si un abreuvoir est en erreur, faire clignoter l'écran
bool gerr = ErrorLvl[0] | ErrorLvl[1] | ErrorLvl[2] | ErrorLvl[3];
if (gerr){
digitalWrite(Backlit,ledState);
}

//---------------------------------------------------------------------------
// Rafraichissement afficheur
//---------------------------------------------------------------------------
if (currentMillis - refreshLCD >= 100){ // Rafraichissement toutes les 100ms
refreshLCD = currentMillis;
lcd.clear();

if (page_menu ==0){ //Menu prinipal - vue globale compteurs abreuvoirs
//lcd.setCursor(0,0);
lcd.print("1");
lcd.write(0x7E);
if (stopEV[0] == true){
lcd.write("STOP");
}else if (ErrorLvl[0]){
lcd.write("Err");
} else {
LCD_litres(total[0],cal[0]); //Affichage Total Abreuvoir #1 journée en cours
}
lcd.setCursor(8,0);
lcd.print("2");
lcd.write(0x7E);
if (stopEV[1] == true){
lcd.write("STOP");
}else if (ErrorLvl[1] == true){
lcd.write("Err");
} else {
LCD_litres(total[1],cal[0]); //Affichage Total Abreuvoir #2 journée en cours
}
lcd.setCursor(0,1);
lcd.print("3");
lcd.write(0x7E);
if (stopEV[2] == true){
lcd.write("STOP");
}else if (ErrorLvl[2] == true){
lcd.write("Err");
} else {
LCD_litres(total[2],cal[0]); //Affichage Total Abreuvoir #3 journée en cours
}
lcd.setCursor(8,1);
lcd.print("4");
lcd.write(0x7E);
if (stopEV[3] == true){
lcd.write("STOP");
}else if (ErrorLvl[3] == true){
lcd.write("Err");
} else {
LCD_litres(total[3],cal[0]); //Affichage Total Abreuvoir #4 journée en cours
}
}
if (page_menu == 1){ //Menu prinipal - Vue compteurs Abreuvoir 1
lcd.print(" Abreuvoir 1");
lcd.setCursor(0,1);
lcd.print("J=");
LCD_litres(total[0],cal[0]); //Affichage Total Abreuvoir #1 journée en cours
lcd.setCursor(8,1);
lcd.print("J-1=");
LCD_litres(totalJMN[0],cal[0]); //Affichage total Abreuvoir#1 de la veille
}

if (page_menu == 2){ //Menu prinipal - Vue compteurs Abreuvoir 2
lcd.print(" Abreuvoir 2");
lcd.setCursor(0,1);
lcd.print("J=");
LCD_litres(total[1],cal[0]); //Affichage Total Abreuvoir #2 journée en cours
lcd.setCursor(8,1);
lcd.print("J-1=");
LCD_litres(totalJMN[1],cal[0]); //Affichage total Abreuvoir#2 de la veille
}

if (page_menu == 3){ //Menu prinipal - Vue compteurs Abreuvoir 3
lcd.print(" Abreuvoir 3");
lcd.setCursor(0,1);
lcd.print("J=");
LCD_litres(total[2],cal[0]); //Affichage Total Abreuvoir #3 journée en cours
lcd.setCursor(8,1);
lcd.print("J-1=");
LCD_litres(totalJMN[2],cal[0]); //Affichage total Abreuvoir#3 de la veille
}

if (page_menu == 4){ //Menu prinipal - Vue compteurs Abreuvoir 4
lcd.print(" Abreuvoir 4");
lcd.setCursor(0,1);
lcd.print("J=");
LCD_litres(total[3],cal[0]); //Affichage Total Abreuvoir #4 journée en cours
lcd.setCursor(8,1);
lcd.print("J-1=");
LCD_litres(totalJMN[3],cal[0]); //Affichage total Abreuvoir#4 de la veille
}

if (page_menu == 5){ //Menu prinipal - Page de remise à zero des compteurs
lcd.print("Reset compteurs?");
if (heures > 1){
lcd.setCursor(0,1);
lcd.print("appuyez SEL");
} else {
lcd.setCursor(6,1);
lcd.print("FAIT");
}

}

if (page_menu == 6){ //Menu prinipal - Selection entrée menu Diagnostique
lcd.print("Diagnostique ?");
lcd.setCursor(0,1);
lcd.print("appuyez SEL");
}

if (page_menu == 8){ //Menu diagnostique - Lecture des entrées
lcd.print("INPUT:");
lcd.setCursor(0,1);
lcd.print("1=");
if (digitalRead(Niveau1) == HIGH){
lcd.print("H");
} else {
lcd.print("L");
}
lcd.setCursor(4,1);
lcd.print("2=");
if (digitalRead(Niveau2) == HIGH){
lcd.print("H");
} else {
lcd.print("L");
}
lcd.setCursor(8,1);
lcd.print("3=");
if (digitalRead(Niveau3) == HIGH){
lcd.print("H");
} else {
lcd.print("L");
}
lcd.setCursor(12,1);
lcd.print("4=");
if (digitalRead(Niveau4) == HIGH){
lcd.print("H");
} else {
lcd.print("L");
}
}

if (page_menu == 9){ //Menu diagnostique - Forçage EV1
lcd.print("Forcage EV1=");
if (forcageEV[0] == true){
lcd.print("OUI");
} else if (stopEV[0] == true){
lcd.print("STOP");
} else {
lcd.print("NON");
}
lcd.setCursor(0,1);
lcd.print("SEL pour forcer");
}

if (page_menu == 10){ //Menu diagnostique - Forcage EV2
lcd.print("Forcage EV2=");
if (forcageEV[1] == true){
lcd.print("OUI");
} else if (stopEV[1] == true){
lcd.print("STOP");
} else {
lcd.print("NON");
}
lcd.setCursor(0,1);
lcd.print("SEL pour forcer");
}

if (page_menu == 11){ //Menu diagnostique - Forcage EV3
lcd.print("Forcage EV3=");
if (forcageEV[2] == true){
lcd.print("OUI");
} else if (stopEV[2] == true){
lcd.print("STOP");
} else {
lcd.print("NON");
}
lcd.setCursor(0,1);
lcd.print("SEL pour forcer");
}

if (page_menu == 12){ //Menu diagnostique - Forcage EV4
lcd.print("Forcage EV4=");
if (forcageEV[3] == true){
lcd.print("OUI");
} else if (stopEV[3] == true){
lcd.print("STOP");
} else {
lcd.print("NON");
}
lcd.setCursor(0,1);
lcd.print("SEL pour forcer");
}
if (page_menu == 13){ //Menu diagnostique - Affichage horloge interne
lcd.print("Horloge interne");
lcd.setCursor(5,1);
lcd.print(heures);
lcd.print(":");
lcd.print(minutes);
lcd.print(":");
lcd.print(secondes);
}
if (page_menu == 14){ //Menu diagnostique - Sortir du menu diagnostique
lcd.print("Sortir Diag ?");
lcd.setCursor(0,1);
lcd.print("appuyez SEL");
}
}



}//fin loop

inpNiveau[x] = !inpNiveau[x];

//inpNiveau[0] = !inpNiveau[0];

const int DebTimeLvl = 2500; //durée anti-rebond capteur abreuvoir

Abreuvoir v1.0

Menu calibration
appuyez DEFIL

Calibration EV1
SEL = Ouvrir

Calibration EV1
SEL = Fermer

Entrez volume 1
0.0 litres

Entrez volume 1
0.x litres

cal 1=x
Suite : DEFIL

Volume nul !
Reprendre : SEL

Temps trop court
Reprendre : SEL

Calibrations OK
SEL pour sortir

1->0.0 2->0.0
3->0.0 4->0.0

Abreuvoir x
J=0.0 J-1=0.0

Reset compteurs?
appuyez SEL

Reset compteurs?
FAIT

Diagnostique ?
appuyez SEL

INPUT:
1=H 2=H 3=H 4=H

Forcage EVx=NON
SEL pour forcer

Horloge interne
23:59:59

Sortir Diag ?
appuyez SEL

@equinoxe88
Une question: est-ce que tu penses qu'on peut avoir une estimation de la quantité d'eau fournie par jour pour chaque abreuvoir avec ton système?
Merci!