salut a tous,

petit mise a jour du boitier pour pouvoir ajuster le dosage sans tout reprogrammer.
J'ai déjà réaliser la partie hardware (ajout d'un Ecran 4 lignes et de 3 bouton)


j'ai communiquer avec un aquariophile d'eau douce qui connait bien l'arduino. (bricoleau)
Il m'as mis au point un code pour gérer les pompe mais aussi de pouvoir les étalonner.

Des que j'aurais tester celui ci et qu'il seras opérationnel, je partagerais.

a+

super bricolage, bravo.

Si j'avais eu cette solution il y a deux ans, je n'aurais sans doute pas acheter les boîtiers GROTECH.

bjr

ca pour 51 euros je reve ????????????????

http://www.reefshops.com/marine-color-d ... clone.html

oui, pourquoi se faire c..r avec du DIY ????

point important or mis la précision.
que la programmation et l'horloge reste en mémoire en cas de coupure edf.
si une coupure passe inaperçue, ou qu'on oublie de la remettre l'heure ,plus de dosage .

rayan42 a écrit:bjr

ca pour 51 euros je reve ????????????????

http://www.reefshops.com/marine-color-d ... clone.html

pompes dosseuses mcd-03-M (principal) et mcd-03-S (extension X3)

dream501 a écrit:

rayan42 a écrit:bjr

ca pour 51 euros je reve ????????????????

http://www.reefshops.com/marine-color-d ... clone.html

pompes dosseuses mcd-03-M (principal) et mcd-03-S (extension X3)

le boîtier principal ne coûte que 103,02 €. Cela me parait pas trop cher. Par contre voir les frais de port, il y a peut être une surprise.
http://www.reefshops.com/product-687.html

tinmihad a écrit:

dream501 a écrit:

rayan42 a écrit:bjr

ca pour 51 euros je reve ????????????????

http://www.reefshops.com/marine-color-d ... clone.html

pompes dosseuses mcd-03-M (principal) et mcd-03-S (extension X3)

le boîtier principal ne coûte que 103,02 €. Cela me parait pas trop cher. Par contre voir les frais de port, il y a peut être une surprise.
http://www.reefshops.com/product-687.html

22 euros de frais de port je viens de les commander

amitie

zebulon01 a écrit:oui, pourquoi se faire c..r avec du DIY ????

point important or mis la précision.
que la programmation et l'horloge reste en mémoire en cas de coupure edf.
si une coupure passe inaperçue, ou qu'on oublie de la remettre l'heure ,plus de dosage .

surtout avec de l'arduino

je trouve pas sa très cool de mettre ce genre de discutions sur se poste ...

personne n'oblige personne a faire quoi que se soit ni a acheter quoi que se soit ...


Je ne suis pas sur que si je vais sur le poste a tito, fabrication d'un durso ou refroidir son bac pour pas cher, et écrit pourquoi se faire chier c'est moins chère au magasin ... que le "posteur" apprécie ...

Nous somme la pour partager et j'ai apprécier le faire, merci donc de respecter le travaille de l'artiste

tu as fait un tres bon travail mais moi en bricolo je suis zero alors j achete tout fait

coucou

après longue période de test,
voici le nouveau code utilisé pour mes pompes
il permet d'effectuer l'etalonage de chaque pompe
bien sur régler le volume de distribution de chaque pompe sauf sel sans chlorure qui est calculer automatiquement par rapport au ca/kh.

//******************************************************************************************
//Programme de gestion des pompes doseuses pour l'automate de djbouns
//Bricoleau 2013
//******************************************************************************************
#include <EEPROM.h>
#include "AFMotor.h"
#include <LiquidCrystal.h>

//******************************************************************************************
//Branchements
//******************************************************************************************

//PIN de chaque bouton poussoir
#define BOUTON_PLUS 52 //PIN---BP---0V
#define BOUTON_MOINS 50 //PIN---BP---0V
#define BOUTON_VALID 23 //PIN---BP---0V

//PIN de chaque LED Verte (facultative)
//mettre la ligne en commentaire si la LED n'est pas install�e
/*
#define LED_VERTE_CA 22 //PIN---LED---R---5V
#define LED_VERTE_KH 25 //PIN---LED---R---5V
#define LED_VERTE_SL 26 //PIN---LED---R---5V
#define LED_VERTE_MG 29 //PIN---LED---R---5V
*/
//PIN de chaque LED Rouge (facultative)
//mettre la ligne en commentaire si la LED n'est pas install�e
//pour une seule LED rouge globale : laisser les 4 #define avec la m�me valeur
/*
#define LED_ROUGE_CA 30 //PIN---LED---R---5V
#define LED_ROUGE_KH 33 //PIN---LED---R---5V
#define LED_ROUGE_SL 34 //PIN---LED---R---5V
#define LED_ROUGE_MG 37 //PIN---LED---R---5V
*/
//PIN de l'�cran LCD
#define LCD_RS 43 //PIN---RS
#define LCD_EN 45 //PIN---EN
#define LCD_D4 47 //PIN---D4
#define LCD_D5 49 //PIN---D5
#define LCD_D6 51 //PIN---D6
#define LCD_D7 53 //PIN---D7


//******************************************************************************************
//Param�tres constants. Modif = recompil
//******************************************************************************************

//Identifiant des pompes sur le shield motor
const uint8_t pompe_CA = 4;
const uint8_t pompe_KH = 3;
const uint8_t pompe_SL = 2;
const uint8_t pompe_MG = 1;

//Libell�s � afficher sur l'�cran LCD : 6 caract�res maximum (+ 1 pour le \0)
char nom_CA[7] = "Ca ";
char nom_KH[7] = "KH ";
char nom_SL[7] = "S NaCl";
char nom_MG[7] = "Mg ";

//Dosage maximum autoris�, en ml par jour
//s�curit� contre les surdosages accidentels
//valeur maximum possible : 999 ml (� 4 chiffres l'affichage LCD d�borde)
const uint16_t max_dosage_CA = 50;
const uint16_t max_dosage_KH = 50;
const uint16_t max_dosage_SL = 50;
const uint16_t max_dosage_MG = 50;

//D�bit minimum des pompes pris en compte dans les calculs,
//en dixi�me de ml par minute : 198 = 19,8 ml par minute
//s�curit� contre les surdosages accidentels
//(debit erron� trop faible => allongement anormal dur�e de fonctionnement => surdosage)
//valeur 0 interdite ! minimum 1
const uint16_t min_debit_pompe_CA = 100;
const uint16_t min_debit_pompe_KH = 100;
const uint16_t min_debit_pompe_SL = 100;
const uint16_t min_debit_pompe_MG = 100;

//Vitesse de rotation des pompes 0=arr�t � 255=vitesse max
const uint8_t vitesse_moteur_CA = 200;
const uint8_t vitesse_moteur_KH = 200;
const uint8_t vitesse_moteur_SL = 200;
const uint8_t vitesse_moteur_MG = 200;

//Nombre de d�clenchements de chaque pompe par 24 heures
//valeur 0 interdite ! autant �teindre l'automate
const uint8_t nb_declenchements = 6; // x 4 pompes

//D�lai de d�sactivation des boutons poussoirs apr�s rel�chement, en guise de dispositif anti-rebond
const uint32_t delai_anti_rebond = 20; //en millisecondes
//si trop petit, les parasites � la commutation risquent d'entra�ner des doubles prises en compte
//si trop grand, les appuis trop brefs ne seront pas d�tect�s
//=> le mettre � la plus petite valeur possible sans effets parasites constat�s
//NB : 20 ms semble bien en premi�re approche


//******************************************************************************************
//Param�tres dynamiques, modifiables � chaud et sauvegard�s dans l'eeprom
//******************************************************************************************
//Les valeurs indiqu�es ci-dessous ne servent qu'au tout premier t�l�versement du programme

//Dosages en ml par 24 heures
uint16_t dosage_CA = 20;
uint16_t dosage_KH = 20;
uint16_t dosage_SL = 20;
uint16_t dosage_MG = 5;

//Debit des pompes en ml par minute de fonctionnement
uint16_t debit_pompe_CA = 42;
uint16_t debit_pompe_KH = 40;
uint16_t debit_pompe_SL = 32;
uint16_t debit_pompe_MG = 41;


//******************************************************************************************
//******************************************************************************************
//******************************************************************************************
//******************************************************************************************
//******************************************************************************************
//******************************************************************************************
//******************************************************************************************
//******************************************************************************************
//******************************************************************************************
//******************************************************************************************

// A partir de l� le code ne doit pas �tre modifi� sauf correction de bug


//******************************************************************************************
//Variables globales = �tats du syst�me
//******************************************************************************************

//Permet de d�sactiver le d�clenchement des pompes doseuses si une manip est en cours
uint8_t reglage_en_cours = 0;

//R�f�rence horaire pour les d�clenchements des pompes doseuses, exprim�e en millisecondes
uint32_t chrono_pompes = 0;

//D�lai entre deux d�clenchements de pompes doseuses, exprim� en millisecondes
const uint32_t intervalle = ((uint32_t) 24*60*60*1000)/((uint32_t) 4*nb_declenchements);

//Un commentaire est-il vraiment n�cessaire ici?
uint8_t prochaine_pompe_a_declencher = pompe_CA;

//Gestion des �crans
#define ECRAN_STANDARD 0
#define ECRAN_MENU_PMP 1
#define ECRAN_DOSAGE 2
#define ECRAN_ETALONNAGE 3
#define ECRAN_DEBIT 4
#define ECRAN_MENU 5
#define ECRAN_SYSTEME 6
#define ECRAN_LOG 7
uint8_t ecran_affiche = ECRAN_STANDARD;
uint8_t ecran_selectionne;
uint8_t pompe_selectionnee = 0;// = 0 ou pompe_CA ou pompe_KH ou pompe_SL ou pompe_MG
uint8_t curseur_log = 0;

//Etats des LED : un bit pour chaque
uint8_t etats_LED;


//******************************************************************************************
//Primitives de gestion de l'�cran LCD 4 lignes x 20 caract�res
//******************************************************************************************

LiquidCrystal lcd(LCD_RS, LCD_EN, LCD_D4, LCD_D5, LCD_D6, LCD_D7);

void initialiserLCD()
{
lcd.begin(20,4);
}

void fixerCurseurLCD(uint8_t ligne, uint8_t colonne)
{
//ligne de 0 � 3
//colonne de 0 � 19
lcd.setCursor(colonne, ligne);
}

void afficherCaractereLCD(char c)
{
lcd.write((uint8_t) c);
}


//******************************************************************************************
//Gestion des LEDs
//******************************************************************************************

void initialiserLEDs()
{
#ifdef LED_VERTE_CA
pinMode(LED_VERTE_CA, OUTPUT);
digitalWrite(LED_VERTE_CA, HIGH);
#endif
#ifdef LED_VERTE_KH
pinMode(LED_VERTE_KH, OUTPUT);
digitalWrite(LED_VERTE_KH, HIGH);
#endif
#ifdef LED_VERTE_SL
pinMode(LED_VERTE_SL, OUTPUT);
digitalWrite(LED_VERTE_SL, HIGH);
#endif
#ifdef LED_VERTE_MG
pinMode(LED_VERTE_MG, OUTPUT);
digitalWrite(LED_VERTE_MG, HIGH);
#endif
#ifdef LED_ROUGE_CA
pinMode(LED_ROUGE_CA, OUTPUT);
digitalWrite(LED_ROUGE_CA, HIGH);
#endif
#ifdef LED_ROUGE_KH
pinMode(LED_ROUGE_KH, OUTPUT);
digitalWrite(LED_ROUGE_KH, HIGH);
#endif
#ifdef LED_ROUGE_SL
pinMode(LED_ROUGE_SL, OUTPUT);
digitalWrite(LED_ROUGE_SL, HIGH);
#endif
#ifdef LED_ROUGE_MG
pinMode(LED_ROUGE_MG, OUTPUT);
digitalWrite(LED_ROUGE_MG, HIGH);
#endif
etats_LED = 0b11111111;
}

void allumerLEDVerte(uint8_t pompe)
{
switch (pompe)
{
case pompe_CA :
#ifdef LED_VERTE_CA
if (etats_LED & 0b10000000)
{
digitalWrite(LED_VERTE_CA, LOW);
etats_LED &= 0b01111111;
}
#endif
break;
case pompe_KH :
#ifdef LED_VERTE_KH
if (etats_LED & 0b01000000)
{
digitalWrite(LED_VERTE_KH, LOW);
etats_LED &= 0b10111111;
}
#endif
break;
case pompe_SL :
#ifdef LED_VERTE_SL
if (etats_LED & 0b00100000)
{
digitalWrite(LED_VERTE_SL, LOW);
etats_LED &= 0b11011111;
}
#endif
break;
case pompe_MG :
#ifdef LED_VERTE_MG
if (etats_LED & 0b00010000)
{
digitalWrite(LED_VERTE_MG, LOW);
etats_LED &= 0b11101111;
}
#endif
break;
}
}

void eteindreLEDVerte(uint8_t pompe)
{
switch (pompe)
{
case pompe_CA :
#ifdef LED_VERTE_CA
if ((~etats_LED) & 0b10000000)
{
digitalWrite(LED_VERTE_CA, HIGH);
etats_LED |= 0b10000000;
}
#endif
break;
case pompe_KH :
#ifdef LED_VERTE_KH
if ((~etats_LED) & 0b01000000)
{
digitalWrite(LED_VERTE_KH, HIGH);
etats_LED |= 0b01000000;
}
#endif
break;
case pompe_SL :
#ifdef LED_VERTE_SL
if ((~etats_LED) & 0b00100000)
{
digitalWrite(LED_VERTE_SL, HIGH);
etats_LED |= 0b00100000;
}
#endif
break;
case pompe_MG :
#ifdef LED_VERTE_MG
if ((~etats_LED) & 0b00010000)
{
digitalWrite(LED_VERTE_MG, HIGH);
etats_LED |= 0b00010000;
}
#endif
break;
}
}

void basculerLEDVerte(uint8_t pompe)
{
if (pompe != pompe_CA) eteindreLEDVerte(pompe_CA);
if (pompe != pompe_KH) eteindreLEDVerte(pompe_KH);
if (pompe != pompe_SL) eteindreLEDVerte(pompe_SL);
if (pompe != pompe_MG) eteindreLEDVerte(pompe_MG);
allumerLEDVerte(pompe);
}

void eteindreLEDsVertes()
{
eteindreLEDVerte(pompe_CA);
eteindreLEDVerte(pompe_KH);
eteindreLEDVerte(pompe_SL);
eteindreLEDVerte(pompe_MG);
}

void allumerLEDRouge(uint8_t pompe)
{
switch (pompe)
{
case pompe_CA :
#ifdef LED_ROUGE_CA
if (etats_LED & 0b00001000)
{
digitalWrite(LED_ROUGE_CA, LOW);
etats_LED &= 0b11110111;
}
#endif
break;
case pompe_KH :
#ifdef LED_ROUGE_KH
if (etats_LED & 0b00000100)
{
digitalWrite(LED_ROUGE_KH, LOW);
etats_LED &= 0b11111011;
}
#endif
break;
case pompe_SL :
#ifdef LED_ROUGE_SL
if (etats_LED & 0b00000010)
{
digitalWrite(LED_ROUGE_SL, LOW);
etats_LED &= 0b11111101;
}
#endif
break;
case pompe_MG :
#ifdef LED_ROUGE_MG
if (etats_LED & 0b00000001)
{
digitalWrite(LED_ROUGE_MG, LOW);
etats_LED &= 0b11111110;
}
#endif
break;
}
}

void eteindreLEDRouge(uint8_t pompe)
{
switch (pompe)
{
case pompe_CA :
#ifdef LED_ROUGE_CA
if ((~etats_LED) & 0b00001000)
{
digitalWrite(LED_ROUGE_CA, HIGH);
etats_LED |= 0b00001000;
}
#endif
break;
case pompe_KH :
#ifdef LED_ROUGE_KH
if ((~etats_LED) & 0b00000100)
{
digitalWrite(LED_ROUGE_KH, HIGH);
etats_LED |= 0b00000100;
}
#endif
break;
case pompe_SL :
#ifdef LED_ROUGE_SL
if ((~etats_LED) & 0b00000010)
{
digitalWrite(LED_ROUGE_SL, HIGH);
etats_LED |= 0b00000010;
}
#endif
break;
case pompe_MG :
#ifdef LED_ROUGE_MG
if ((~etats_LED) & 0b00000001)
{
digitalWrite(LED_ROUGE_MG, HIGH);
etats_LED |= 0b00000001;
}
#endif
break;
}
}


//******************************************************************************************
//LOG = m�morisation des d�clenchements effectu�s
//******************************************************************************************

const uint8_t maxi_log = 100;

uint8_t index_log = 0;

uint32_t chrono_deb_log[maxi_log];
uint32_t chrono_fin_log[maxi_log];
uint8_t pompe_log[maxi_log];

void ecrireLog(uint32_t deb, uint32_t fin, uint8_t pompe)
{
uint8_t i;

if (index_log < maxi_log) index_log++;

//On pousse vers le haut
for (i=index_log - 1; i>0; i--)
{
chrono_deb_log[i] = chrono_deb_log[i-1];
chrono_fin_log[i] = chrono_fin_log[i-1];
pompe_log[i] = pompe_log[i-1];
}

chrono_deb_log[0] = deb;
chrono_fin_log[0] = fin;
pompe_log[0] = pompe;
}

void lireLog(uint8_t rang, uint32_t *deb, uint32_t *fin, uint8_t *pompe)
{
if (rang < index_log)
{
*deb = chrono_deb_log[rang];
*fin = chrono_fin_log[rang];
*pompe = pompe_log[rang];
}
else
{
*deb = 0;
*fin = 0;
*pompe = 0;
}
}

char* formaterLog(uint8_t rang, char ligne[])
{
uint32_t deb, fin, heures, minutes, secondes, centiemes;
uint8_t pompe;
char nom_pompe[7];

lireLog(rang, &deb, &fin, &pompe);

switch (pompe)
{
case pompe_CA : sprintf(nom_pompe, "%s", nom_CA);break;
case pompe_KH : sprintf(nom_pompe, "%s", nom_KH);break;
case pompe_SL : sprintf(nom_pompe, "%s", nom_SL);break;
case pompe_MG : sprintf(nom_pompe, "%s", nom_MG);break;
default : nom_pompe[0] = 0;
}

fin = fin - deb;
deb = millis() - deb;
heures = deb / 3600000;
minutes = (deb % 3600000) / 60000;
secondes = fin / 1000;
centiemes = (fin % 1000) / 10;

if (heures > 99) // anti d�bordement affichage
{
heures = 99;
minutes = 59;
}

if (secondes > 9999)
{
sprintf(ligne,"-%02luH%02lu %s %lus", heures, minutes, nom_pompe, secondes);
}
else
{
if (secondes > 999)
{
sprintf(ligne,"-%02luH%02lu %s %04lus%lu", heures, minutes, nom_pompe, secondes, centiemes / 10);
}
else
{
sprintf(ligne,"-%02luH%02lu %s %03lus%02lu", heures, minutes, nom_pompe, secondes, centiemes);
if (ligne[14]=='0')
{
ligne[14] = ' ';
if (ligne[15]=='0') ligne[15]=' ';
}
}
}

return ligne;
}


//******************************************************************************************
//horloge = delai ecoule depuis le boot
//******************************************************************************************

uint32_t nb_jours = 0;
uint8_t nb_heures = 0;
uint8_t nb_minutes = 0;
uint8_t nb_secondes = 0;

void actualiserHorloge()
{
// nombre de cycles complets effectues par la fonction millis()
// un cycle = 49 jours, 17 heures, 2 minutes, 47 secondes et 296 ms
static uint32_t nb_roll_over = 0;
static uint32_t dernier_chrono = 0;
uint32_t chrono, jours, heures, minutes, secondes, millisecondes;

chrono = millis();

if ((chrono - dernier_chrono) > 1000) //seulement une fois par seconde
{
if (chrono < dernier_chrono) nb_roll_over++;
dernier_chrono = chrono;

millisecondes = chrono % 1000;
chrono = chrono / 1000;
secondes = chrono % 60;
chrono = chrono / 60;
minutes = chrono % 60;
chrono = chrono / 60;
heures = chrono % 24;
jours = chrono / 24;

millisecondes += 296 * nb_roll_over;
secondes += 47 * nb_roll_over;
minutes += 2 * nb_roll_over;
heures += 17 * nb_roll_over;
jours += 49 * nb_roll_over;

secondes += millisecondes / 1000;
minutes += secondes / 60;
heures += minutes / 60;
jours += heures / 24;

// millisecondes = millisecondes % 1000;
secondes = secondes % 60;
minutes = minutes % 60;
heures = heures % 24;

nb_jours = jours;
nb_heures = heures;
nb_minutes = minutes;
nb_secondes = secondes;
}
}


//******************************************************************************************
//Gestion des pompes doseuses
//******************************************************************************************

AF_DCMotor motorMG(pompe_MG, MOTOR12_64KHZ);
AF_DCMotor motorSL(pompe_SL, MOTOR12_64KHZ);
AF_DCMotor motorKH(pompe_KH, MOTOR12_64KHZ);
AF_DCMotor motorCA(pompe_CA, MOTOR12_64KHZ);

void initialiserPompes()
{
motorCA.setSpeed(vitesse_moteur_CA);
motorKH.setSpeed(vitesse_moteur_KH);
motorSL.setSpeed(vitesse_moteur_SL);
motorMG.setSpeed(vitesse_moteur_MG);
motorCA.run(RELEASE);
motorKH.run(RELEASE);
motorSL.run(RELEASE);
motorMG.run(RELEASE);
}

void declencherPompeCA(uint32_t duree_en_ms)
{
uint32_t chrono_start, chrono_stop;
if (duree_en_ms > 0)
{
allumerLEDRouge(pompe_CA);
chrono_start = millis();
motorCA.run(FORWARD);
delay(duree_en_ms);
motorCA.run(RELEASE);
chrono_stop = millis();
ecrireLog(chrono_start, chrono_stop, pompe_CA);
eteindreLEDRouge(pompe_CA);
}
}

void declencherPompeKH(uint32_t duree_en_ms)
{
uint32_t chrono_start, chrono_stop;
if (duree_en_ms > 0)
{
allumerLEDRouge(pompe_KH);
chrono_start = millis();
motorKH.run(FORWARD);
delay(duree_en_ms);
motorKH.run(RELEASE);
chrono_stop = millis();
ecrireLog(chrono_start, chrono_stop, pompe_KH);
eteindreLEDRouge(pompe_KH);
}
}

void declencherPompeSL(uint32_t duree_en_ms)
{
uint32_t chrono_start, chrono_stop;
if (duree_en_ms > 0)
{
allumerLEDRouge(pompe_SL);
chrono_start = millis();
motorSL.run(FORWARD);
delay(duree_en_ms);
motorSL.run(RELEASE);
chrono_stop = millis();
ecrireLog(chrono_start, chrono_stop, pompe_SL);
eteindreLEDRouge(pompe_SL);
}
}

void declencherPompeMG(uint32_t duree_en_ms)
{
uint32_t chrono_start, chrono_stop;
if (duree_en_ms > 0)
{
allumerLEDRouge(pompe_MG);
chrono_start = millis();
motorMG.run(FORWARD);
delay(duree_en_ms);
motorMG.run(RELEASE);
chrono_stop = millis();
ecrireLog(chrono_start, chrono_stop, pompe_MG);
eteindreLEDRouge(pompe_MG);
}
}

void declencherPompe()
{
//D�clenche une des 4 pompes,
//pour la dur�e correspondant � son dosage
//de mani�re cyclique CA -> KH -> SL -> MG -> CA -> KH -> etc.
uint32_t duree;

switch (prochaine_pompe_a_declencher)
{
case pompe_CA :
duree = (uint32_t) nb_declenchements * debit_pompe_CA / 10;
if (duree > 0) duree = ((uint32_t) dosage_CA * 60000) / duree;
declencherPompeCA(duree);
prochaine_pompe_a_declencher = pompe_KH;
break;
case pompe_KH :
duree = (uint32_t) nb_declenchements * debit_pompe_KH / 10;
if (duree > 0) duree = ((uint32_t) dosage_KH * 60000) / duree;
declencherPompeKH(duree);
prochaine_pompe_a_declencher = pompe_SL;
break;
case pompe_SL :
duree = (uint32_t) nb_declenchements * debit_pompe_SL / 10;
if (duree > 0) duree = ((uint32_t) dosage_SL * 60000) / duree;
declencherPompeSL(duree);
prochaine_pompe_a_declencher = pompe_MG;
break;
case pompe_MG :
duree = (uint32_t) nb_declenchements * debit_pompe_MG / 10;
if (duree > 0) duree = ((uint32_t) dosage_MG * 60000) / duree;
declencherPompeMG(duree);
prochaine_pompe_a_declencher = pompe_CA;
break;
}
}

void gererPompes()
{
uint32_t chrono;
//Ne rien faire si un reglage est en cours
if (reglage_en_cours == 0)
{
chrono = millis() - chrono_pompes;
//V�rifier si le d�lai de d�clenchement est atteint
if (chrono > intervalle)
{
basculerLEDVerte(prochaine_pompe_a_declencher);
declencherPompe();
eteindreLEDsVertes();
chrono_pompes += intervalle;
//On repart de la r�f�rence initiale, pour que les p�riodes de r�glage
//n'entrainent pas une d�rive dans la programmation horaire.
//Si l'automate �tait en cours de r�glage � l'horaire th�orique de
//d�clenchement d'une pompe, le retard sera ainsi rattrap�
}
else
{
//si moins de 31 secondes restantes, allumage de la led verte
if ((intervalle - chrono) < 31000)
{
basculerLEDVerte(prochaine_pompe_a_declencher);
}
}
}
}


//******************************************************************************************
//Lecture / sauvegarde des param�tres en eeprom
//******************************************************************************************

uint8_t lireEEprom(uint16_t adresse)
{
return EEPROM.read(adresse);
}

void ecrireEEprom(uint16_t adresse, uint8_t valeur)
{
//Dans le doute, au cas o� cela ne soit pas g�r� � plus bas niveau, �vite les �critures inutiles
if (lireEEprom(adresse) != valeur)
{
EEPROM.write(adresse, valeur);
}
}

//La signature �vite de r�cup�rer n'importe quoi au premier t�l�versement du programme
const uint8_t signature_EEprom = 154; //au pif, valeur al�atoire

void lireParametres()
{
uint16_t adresse = 0;

if (lireEEprom(0) == 153) //migration ancien parametrage. Bloc temporaire � supprimer
{
adresse = 1;
dosage_CA = lireEEprom(adresse++);
dosage_CA = (dosage_CA << 8) | lireEEprom(adresse++);
dosage_KH = lireEEprom(adresse++);
dosage_KH = (dosage_KH << 8) | lireEEprom(adresse++);
dosage_SL = lireEEprom(adresse++);
dosage_SL = (dosage_SL << 8) | lireEEprom(adresse++);
dosage_MG = lireEEprom(adresse++);
dosage_MG = (dosage_MG << 8) | lireEEprom(adresse++);
debit_pompe_CA = lireEEprom(adresse++);
debit_pompe_CA = (debit_pompe_CA << 8) | lireEEprom(adresse++);
debit_pompe_KH = lireEEprom(adresse++);
debit_pompe_KH = (debit_pompe_KH << 8) | lireEEprom(adresse++);
debit_pompe_SL = lireEEprom(adresse++);
debit_pompe_SL = (debit_pompe_SL << 8) | lireEEprom(adresse++);
debit_pompe_MG = lireEEprom(adresse++);
debit_pompe_MG = (debit_pompe_MG << 8) | lireEEprom(adresse++);
debit_pompe_CA = debit_pompe_CA * 10;
debit_pompe_KH = debit_pompe_KH * 10;
debit_pompe_SL = debit_pompe_SL * 10;
debit_pompe_MG = debit_pompe_MG * 10;
adresse = 0;
}

if (lireEEprom(adresse++) == signature_EEprom)
{
dosage_CA = lireEEprom(adresse++);
dosage_CA = (dosage_CA << 8) | lireEEprom(adresse++);
dosage_KH = lireEEprom(adresse++);
dosage_KH = (dosage_KH << 8) | lireEEprom(adresse++);
dosage_SL = lireEEprom(adresse++);
dosage_SL = (dosage_SL << 8) | lireEEprom(adresse++);
dosage_MG = lireEEprom(adresse++);
dosage_MG = (dosage_MG << 8) | lireEEprom(adresse++);
debit_pompe_CA = lireEEprom(adresse++);
debit_pompe_CA = (debit_pompe_CA << 8) | lireEEprom(adresse++);
debit_pompe_KH = lireEEprom(adresse++);
debit_pompe_KH = (debit_pompe_KH << 8) | lireEEprom(adresse++);
debit_pompe_SL = lireEEprom(adresse++);
debit_pompe_SL = (debit_pompe_SL << 8) | lireEEprom(adresse++);
debit_pompe_MG = lireEEprom(adresse++);
debit_pompe_MG = (debit_pompe_MG << 8) | lireEEprom(adresse++);
}

//Pour le cas o� on trouve des cochonneries dans l'eeprom
if (dosage_CA > max_dosage_CA) dosage_CA = max_dosage_CA;
if (dosage_KH > max_dosage_KH) dosage_KH = max_dosage_KH;
if (dosage_SL > max_dosage_SL) dosage_SL = max_dosage_SL;
if (dosage_MG > max_dosage_MG) dosage_MG = max_dosage_MG;
if (debit_pompe_CA < min_debit_pompe_CA) debit_pompe_CA = min_debit_pompe_CA;
if (debit_pompe_KH < min_debit_pompe_KH) debit_pompe_KH = min_debit_pompe_KH;
if (debit_pompe_SL < min_debit_pompe_SL) debit_pompe_SL = min_debit_pompe_SL;
if (debit_pompe_MG < min_debit_pompe_MG) debit_pompe_MG = min_debit_pompe_MG;
}

void enregistrerParametres()
{
uint16_t adresse = 0;

ecrireEEprom(adresse++, signature_EEprom);
ecrireEEprom(adresse++, dosage_CA >> 8);
ecrireEEprom(adresse++, dosage_CA & 255);
ecrireEEprom(adresse++, dosage_KH >> 8);
ecrireEEprom(adresse++, dosage_KH & 255);
ecrireEEprom(adresse++, dosage_SL >> 8);
ecrireEEprom(adresse++, dosage_SL & 255);
ecrireEEprom(adresse++, dosage_MG >> 8);
ecrireEEprom(adresse++, dosage_MG & 255);
ecrireEEprom(adresse++, debit_pompe_CA >> 8);
ecrireEEprom(adresse++, debit_pompe_CA & 255);
ecrireEEprom(adresse++, debit_pompe_KH >> 8);
ecrireEEprom(adresse++, debit_pompe_KH & 255);
ecrireEEprom(adresse++, debit_pompe_SL >> 8);
ecrireEEprom(adresse++, debit_pompe_SL & 255);
ecrireEEprom(adresse++, debit_pompe_MG >> 8);
ecrireEEprom(adresse++, debit_pompe_MG & 255);
}


//******************************************************************************************
//Gestion des boutons
//******************************************************************************************

void initialiserBoutons()
{
//d�finir les entr�es
pinMode(BOUTON_PLUS, INPUT);
pinMode(BOUTON_MOINS, INPUT);
pinMode(BOUTON_VALID, INPUT);
//activer le pullup
digitalWrite(BOUTON_PLUS, HIGH);
digitalWrite(BOUTON_MOINS, HIGH);
digitalWrite(BOUTON_VALID, HIGH);
}

void recalculerDosageSL()
{
dosage_SL = (dosage_CA + dosage_KH) >> 1;
if (dosage_SL > max_dosage_SL) dosage_SL = max_dosage_SL;
}

void terminerReglage()
{
reglage_en_cours = 0;
pompe_selectionnee = 0;
ecran_affiche = ECRAN_STANDARD;
enregistrerParametres();
eteindreLEDsVertes();
}

void gererBoutonsEcranStandard(uint8_t boutonAppuye)
{
switch (boutonAppuye)
{
case BOUTON_MOINS :
switch (pompe_selectionnee)
{
case pompe_CA :
pompe_selectionnee = pompe_KH;
break;
case pompe_KH :
pompe_selectionnee = pompe_SL;
break;
case pompe_SL :
pompe_selectionnee = pompe_MG;
break;
default :
pompe_selectionnee = pompe_CA;
break;
}
break;
case BOUTON_PLUS :
switch (pompe_selectionnee)
{
case pompe_MG :
pompe_selectionnee = pompe_SL;
break;
case pompe_SL :
pompe_selectionnee = pompe_KH;
break;
case pompe_KH :
pompe_selectionnee = pompe_CA;
break;
default :
pompe_selectionnee = pompe_MG;
break;
}
break;
case BOUTON_VALID :
switch (pompe_selectionnee)
{
case pompe_CA :
case pompe_KH :
case pompe_MG :
ecran_affiche = ECRAN_MENU_PMP;
ecran_selectionne = ECRAN_DOSAGE;
break;
case pompe_SL :
ecran_affiche = ECRAN_ETALONNAGE;
break;
default :
ecran_affiche = ECRAN_MENU;
ecran_selectionne = ECRAN_SYSTEME;
break;
}
break;
}
basculerLEDVerte(pompe_selectionnee);
}

void gererBoutonsEcranMenuPMP(uint8_t boutonAppuye)
{
if (boutonAppuye == BOUTON_VALID)
{
ecran_affiche = ecran_selectionne;
}
else
{
if (ecran_selectionne == ECRAN_ETALONNAGE)
{
ecran_selectionne = ECRAN_DOSAGE;
}
else
{
ecran_selectionne = ECRAN_ETALONNAGE;
}
}
}

void gererBoutonsEcranDosage(uint8_t boutonAppuye)
{
switch (boutonAppuye)
{
case BOUTON_MOINS :
switch (pompe_selectionnee)
{
case pompe_CA :
if (dosage_CA > 0)
{
dosage_CA--;
recalculerDosageSL();
}
break;
case pompe_KH :
if (dosage_KH > 0)
{
dosage_KH--;
recalculerDosageSL();
}
break;
case pompe_MG :
if (dosage_MG > 0) dosage_MG--;
break;
}
break;
case BOUTON_PLUS :
switch (pompe_selectionnee)
{
case pompe_CA :
if (dosage_CA < max_dosage_CA)
{
dosage_CA++;
recalculerDosageSL();
}
break;
case pompe_KH :
if (dosage_KH < max_dosage_KH)
{
dosage_KH++;
recalculerDosageSL();
}
break;
case pompe_MG :
if (dosage_MG < max_dosage_MG) dosage_MG++;
break;
}
break;
case BOUTON_VALID :
terminerReglage();
break;
}
}

void gererBoutonsEcranEtalonnage(uint8_t boutonAppuye)
{
if (boutonAppuye == BOUTON_PLUS)
{
switch (pompe_selectionnee)
{
case pompe_CA :
declencherPompeCA(60000);
ecran_affiche = ECRAN_DEBIT;
break;
case pompe_KH :
declencherPompeKH(60000);
ecran_affiche = ECRAN_DEBIT;
break;
case pompe_SL :
declencherPompeSL(60000);
ecran_affiche = ECRAN_DEBIT;
break;
case pompe_MG :
declencherPompeMG(60000);
ecran_affiche = ECRAN_DEBIT;
break;
}
}
if (boutonAppuye == BOUTON_MOINS)
{
terminerReglage();
}
if (boutonAppuye == BOUTON_VALID)
{
ecran_affiche = ECRAN_DEBIT;
}
}

void gererBoutonsEcranDebit(uint8_t boutonAppuye)
{
switch (boutonAppuye)
{
case BOUTON_MOINS :
switch (pompe_selectionnee)
{
case pompe_CA :
if (debit_pompe_CA > min_debit_pompe_CA) debit_pompe_CA--;
break;
case pompe_KH :
if (debit_pompe_KH > min_debit_pompe_KH) debit_pompe_KH--;
break;
case pompe_SL :
if (debit_pompe_SL > min_debit_pompe_SL) debit_pompe_SL--;
break;
case pompe_MG :
if (debit_pompe_MG > min_debit_pompe_MG) debit_pompe_MG--;
break;
}
break;
case BOUTON_PLUS :
switch (pompe_selectionnee)
{
case pompe_CA :
if (debit_pompe_CA < 65535) debit_pompe_CA++;
break;
case pompe_KH :
if (debit_pompe_KH < 65535) debit_pompe_KH++;
break;
case pompe_SL :
if (debit_pompe_KH < 65535) debit_pompe_SL++;
break;
case pompe_MG :
if (debit_pompe_KH < 65535) debit_pompe_MG++;
break;
}
break;
case BOUTON_VALID :
terminerReglage();
break;
}
}

void gererBoutonsEcranMenu(uint8_t boutonAppuye)
{
if (boutonAppuye == BOUTON_VALID)
{
ecran_affiche = ecran_selectionne;
curseur_log = 0;
}
else
{
if (ecran_selectionne == ECRAN_SYSTEME)
{
ecran_selectionne = ECRAN_LOG;
}
else
{
ecran_selectionne = ECRAN_SYSTEME;
}
}
}

void gererBoutonsEcranSysteme(uint8_t boutonAppuye)
{
if (boutonAppuye == BOUTON_VALID)
{
terminerReglage();
}
}

void gererBoutonsEcranLog(uint8_t boutonAppuye)
{
if (boutonAppuye == BOUTON_VALID)
{
terminerReglage();
}
if ((boutonAppuye == BOUTON_PLUS) && (curseur_log > 0))
{
curseur_log--;
}
if ((boutonAppuye == BOUTON_MOINS) && ((curseur_log+3) < index_log))
{
curseur_log++;
}
}

void gererBoutons()
{
static uint32_t chrono;
static uint8_t repetition = 0;
static uint8_t bouton_repete = 0;
uint8_t boutonAppuye, boutonPlus, boutonMoins, boutonValid;
uint32_t delai_repetition;

boutonPlus = (digitalRead(BOUTON_PLUS) == LOW);
boutonMoins = (digitalRead(BOUTON_MOINS) == LOW);
boutonValid = (digitalRead(BOUTON_VALID) == LOW);

if (boutonPlus || boutonMoins || boutonValid)
{
reglage_en_cours = 1;
if (boutonMoins) boutonAppuye = BOUTON_MOINS;
if (boutonPlus) boutonAppuye = BOUTON_PLUS;
if (boutonValid) boutonAppuye = BOUTON_VALID;

switch (ecran_affiche)
{
//Eclatement en sous-fonctions pour all�ger le code
case ECRAN_STANDARD :
gererBoutonsEcranStandard(boutonAppuye);
break;
case ECRAN_MENU_PMP :
gererBoutonsEcranMenuPMP(boutonAppuye);
break;
case ECRAN_DOSAGE :
gererBoutonsEcranDosage(boutonAppuye);
break;
case ECRAN_ETALONNAGE :
gererBoutonsEcranEtalonnage(boutonAppuye);
break;
case ECRAN_DEBIT :
gererBoutonsEcranDebit(boutonAppuye);
break;
case ECRAN_MENU :
gererBoutonsEcranMenu(boutonAppuye);
break;
case ECRAN_SYSTEME :
gererBoutonsEcranSysteme(boutonAppuye);
break;
case ECRAN_LOG :
gererBoutonsEcranLog(boutonAppuye);
break;
}

chrono = millis();

//Gestion des r�p�titions (bouton PLUS ou MOINS maintenu enfonc�)
if ((boutonAppuye != BOUTON_VALID) && (ecran_affiche != ECRAN_ETALONNAGE))
{
//comptage du nombre de r�p�titions
if (boutonAppuye == bouton_repete)
{
if (repetition < 255) repetition++;
}
else
{
repetition = 0;
bouton_repete = boutonAppuye;
}
//Calcul du d�lai entre r�p�titions
//Cadence progressive
delai_repetition = 1000;
if (repetition > 1) delai_repetition = 500;
if (repetition > 9) delai_repetition = 250;
if (repetition > 25) delai_repetition = 100;
//Attendre que le bouton soit rel�ch� ou que le d�lai soit expir�
while ((digitalRead(boutonAppuye)==LOW) && ((millis() - chrono) < delai_repetition))
{
delay(1);
}
//Si bouton rel�ch� : raz r�p�tition + anti-rebond
if (digitalRead(boutonAppuye)==HIGH)
{
bouton_repete = 0;
delay(delai_anti_rebond);
}
}
else
{
//Attendre le rel�chement complet des boutons poussoirs
while ((digitalRead(BOUTON_PLUS)==LOW) || (digitalRead(BOUTON_MOINS)==LOW) || (digitalRead(BOUTON_VALID)==LOW))
{
delay(1);
}
bouton_repete = 0;
delay(delai_anti_rebond);
}
}
else
{
repetition = 0;
bouton_repete = 0;
if (reglage_en_cours && ((millis() - chrono) > 120000))
{
//au bout de deux minutes � attendre l'appui sur un bouton
//sortie automatique de la proc�dure de r�glage
//pour reprise du fonctionnement normal des pompes doseuses
terminerReglage();
}
}
}


//******************************************************************************************
//Gestion des affichages sur �cran LCD
//******************************************************************************************

#define TAILLE_LIGNE 20

void completerLigneBlancs(char ligne[])
{
uint8_t i;

i=0;
while ((i<TAILLE_LIGNE) && ligne[i])
{
i++;
}
while (i<TAILLE_LIGNE)
{
ligne[i++] = ' ';
}
ligne[TAILLE_LIGNE] = '\0';
}

void afficherLigneStandard(uint8_t numligne, char ancienne_ligne[], char nouvelle_ligne[])
{
uint8_t i;
fixerCurseurLCD(numligne, 0);
completerLigneBlancs(nouvelle_ligne);
for (i=0;i<TAILLE_LIGNE;i++)
{
afficherCaractereLCD(nouvelle_ligne[i]);
ancienne_ligne[i] = nouvelle_ligne[i];
}
ancienne_ligne[TAILLE_LIGNE] = '\0';
}

void afficherLigneRapide(uint8_t numligne, char ancienne_ligne[], char nouvelle_ligne[])
{
uint8_t debut, fin, i;
completerLigneBlancs(nouvelle_ligne);
debut = 0;
while ((debut<TAILLE_LIGNE) && (ancienne_ligne[debut] == nouvelle_ligne[debut]))
{
debut++;
}
if (debut<TAILLE_LIGNE)
{
fixerCurseurLCD(numligne, debut);
for (i=debut; i<TAILLE_LIGNE; i++)
{
if (ancienne_ligne[i] != nouvelle_ligne[i]) fin=i;
}
for (i=debut; i<=fin; i++)
{
afficherCaractereLCD(nouvelle_ligne[i]);
ancienne_ligne[i] = nouvelle_ligne[i];
}
ancienne_ligne[TAILLE_LIGNE] = '\0';
}
}

char memorisation_ligne1[TAILLE_LIGNE+1];
char memorisation_ligne2[TAILLE_LIGNE+1];
char memorisation_ligne3[TAILLE_LIGNE+1];
char memorisation_ligne4[TAILLE_LIGNE+1];

void initialiserAffichage()
{
initialiserLCD();
memorisation_ligne1[0] = '\0';
memorisation_ligne2[0] = '\0';
memorisation_ligne3[0] = '\0';
memorisation_ligne4[0] = '\0';
completerLigneBlancs(memorisation_ligne1);
completerLigneBlancs(memorisation_ligne2);
completerLigneBlancs(memorisation_ligne3);
completerLigneBlancs(memorisation_ligne4);
}

void afficherLignes(char ligne1[], char ligne2[], char ligne3[], char ligne4[])
{
if (reglage_en_cours)
//En mode rapide, on n'envoie au LCD que les caract�res ayant chang� depuis le dernier affichage
{
afficherLigneRapide(0, memorisation_ligne1, ligne1);
afficherLigneRapide(1, memorisation_ligne2, ligne2);
afficherLigneRapide(2, memorisation_ligne3, ligne3);
afficherLigneRapide(3, memorisation_ligne4, ligne4);
}
else
//Le mode standard est plus robuste face aux �ventuels parasites �lectriques
{
afficherLigneStandard(0, memorisation_ligne1, ligne1);
afficherLigneStandard(1, memorisation_ligne2, ligne2);
afficherLigneStandard(2, memorisation_ligne3, ligne3);
afficherLigneStandard(3, memorisation_ligne4, ligne4);
}
}

void formaterLigneStandard(char ligne[], char nom[], uint16_t dosage)
{//un peu lourdlingue, mais pas trouv� mieux et aussi robuste
uint8_t i;
char c;

sprintf(ligne, " %03d ml ", dosage);

//insertion du nom
c = ' ';
for (i=0;i<6;i++)
{
if (c)
{
c = nom[i];
}
if (c)
{
ligne[i+1] = c;
}
else
{
ligne[i+1] = ' ';
}
}

//suppression des 0 disgracieux
for (i=7;i<9;i++)
{
if ((ligne[i] == ' ') && (ligne[i+1] == '0'))
{
ligne[i+1] = ' ';
}
}
}

void afficherEcranStandard()
{
char ligne1[21];
char ligne2[21];
char ligne3[21];
char ligne4[21];
uint32_t chrono, delai;

//Affichage de base
formaterLigneStandard(ligne1, nom_CA, dosage_CA);
formaterLigneStandard(ligne2, nom_KH, dosage_KH);
formaterLigneStandard(ligne3, nom_SL, dosage_SL);
formaterLigneStandard(ligne4, nom_MG, dosage_MG);

//Ajout indication ligne s�lectionn�e
switch (pompe_selectionnee)
{
case pompe_CA :
ligne1[0] = '>';
break;
case pompe_KH :
ligne2[0] = '>';
break;
case pompe_SL :
ligne3[0] = '>';
break;
case pompe_MG :
ligne4[0] = '>';
break;
}

//Ajout prochain d�clenchement si dans moins d'une heure
if (reglage_en_cours == 0)
{
chrono = millis() - chrono_pompes;
if (chrono < intervalle)
{
delai = intervalle - chrono;
if (delai < 3600000)
{
if (delai < 60000)
{
delai /= 1000;
switch (prochaine_pompe_a_declencher)
{
case pompe_CA :
sprintf(&ligne1[15],"%02dsec",delai);
break;
case pompe_KH :
sprintf(&ligne2[15],"%02dsec",delai);
break;
case pompe_SL :
sprintf(&ligne3[15],"%02dsec",delai);
break;
case pompe_MG :
sprintf(&ligne4[15],"%02dsec",delai);
break;
}
}
else
{
delai /= 60000;
switch (prochaine_pompe_a_declencher)
{
case pompe_CA :
sprintf(&ligne1[15],"%02dmin",delai);
break;
case pompe_KH :
sprintf(&ligne2[15],"%02dmin",delai);
break;
case pompe_SL :
sprintf(&ligne3[15],"%02dmin",delai);
break;
case pompe_MG :
sprintf(&ligne4[15],"%02dmin",delai);
break;
}
}
}
}
}

afficherLignes(ligne1, ligne2, ligne3, ligne4);
}

void afficherEcranMenuPMP()
{
char ligne1[21];
char ligne2[21];
char ligne3[21];
char ligne4[21];

//Affichage de base
switch (pompe_selectionnee)
{
case pompe_CA :
sprintf(ligne1, " Pompe %s", nom_CA);
break;
case pompe_KH :
sprintf(ligne1, " Pompe %s", nom_KH);
break;
case pompe_SL :
sprintf(ligne1, " Pompe %s", nom_SL);
break;
case pompe_MG :
sprintf(ligne1, " Pompe %s", nom_MG);
break;
}
sprintf(ligne2, " ");
sprintf(ligne3, " Modifier dosage ");
sprintf(ligne4, " Etalonnage debit");

//Ajout indication ligne s�lectionn�e
if (ecran_selectionne == ECRAN_DOSAGE)
{
ligne3[0] = '>';
}
else
{
ligne4[0] = '>';
}

afficherLignes(ligne1, ligne2, ligne3, ligne4);
}

void afficherEcranMenu()
{
char ligne1[21];
char ligne2[21];
char ligne3[21];
char ligne4[21];

sprintf(ligne1," Menu");
ligne2[0] = 0;
sprintf(ligne3," Systeme");
sprintf(ligne4," Log");

if (ecran_selectionne == ECRAN_SYSTEME) ligne3[0] = '>';
if (ecran_selectionne == ECRAN_LOG) ligne4[0] = '>';

afficherLignes(ligne1, ligne2, ligne3, ligne4);
}

int freeRam()
{
extern int __heap_start, *__brkval;
int v;
return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
}

void afficherEcranSysteme()
{
char ligne1[21];
char ligne2[21];
char ligne3[21];
char ligne4[21];

sprintf(ligne1, "En marche depuis");
sprintf(ligne2, "%luj %02dh %02dm %02ds", nb_jours, nb_heures, nb_minutes, nb_secondes);
sprintf(ligne3, "Memoire disponible");
sprintf(ligne4, "%d octets",freeRam());

afficherLignes(ligne1, ligne2, ligne3, ligne4);
}

void afficherEcranLog()
{
char ligne1[21];
char ligne2[21];
char ligne3[21];
char ligne4[21];

ligne1[0] = 0;
ligne2[0] = 0;
ligne3[0] = 0;
ligne4[0] = 0;

if (curseur_log < index_log) formaterLog(curseur_log, ligne1);
if ((curseur_log+1) < index_log) formaterLog(curseur_log+1, ligne2);
if ((curseur_log+2) < index_log) formaterLog(curseur_log+2, ligne3);
if ((curseur_log+3) < index_log) formaterLog(curseur_log+3, ligne4);

if (index_log == 0) sprintf(ligne2, "Log vide");

afficherLignes(ligne1, ligne2, ligne3, ligne4);
}

void afficherEcranDosage()
{
char ligne1[21];
char ligne2[21];
char ligne3[21];
char ligne4[21];

//Affichage de base
switch (pompe_selectionnee)
{
case pompe_CA :
sprintf(ligne1, "Dosage pompe %s", nom_CA);
sprintf(ligne2, "%d ml par jour", dosage_CA);
break;
case pompe_KH :
sprintf(ligne1, "Dosage pompe %s", nom_KH);
sprintf(ligne2, "%d ml par jour", dosage_KH);
break;
case pompe_SL :
sprintf(ligne1, "Dosage pompe %s", nom_SL);
sprintf(ligne2, "%d ml par jour", dosage_SL);
break;
case pompe_MG :
sprintf(ligne1, "Dosage pompe %s", nom_MG);
sprintf(ligne2, "%d ml par jour", dosage_MG);
break;
}
sprintf(ligne3, " ");
sprintf(ligne4, "Modif : bouton + - V");

afficherLignes(ligne1, ligne2, ligne3, ligne4);
}

void afficherEcranEtalonnage()
{
char ligne1[21];
char ligne2[21];
char ligne3[21];
char ligne4[21];

//Affichage de base
switch (pompe_selectionnee)
{
case pompe_CA :
sprintf(ligne1, " Pompe %s", nom_CA);
break;
case pompe_KH :
sprintf(ligne1, " Pompe %s", nom_KH);
break;
case pompe_SL :
sprintf(ligne1, " Pompe %s", nom_SL);
break;
case pompe_MG :
sprintf(ligne1, " Pompe %s", nom_MG);
break;
}
sprintf(ligne2, "Etalonnage sur 1 min");
sprintf(ligne3, "Bouton + : demarrer ");
sprintf(ligne4, "Bouton - : retour ");

afficherLignes(ligne1, ligne2, ligne3, ligne4);
}

void afficherEcranDebit()
{
char ligne1[21];
char ligne2[21];
char ligne3[21];
char ligne4[21];

//Affichage de base
switch (pompe_selectionnee)
{
case pompe_CA :
sprintf(ligne1, "Debit pompe %s", nom_CA);
sprintf(ligne2, "%d,%d ml / minute", debit_pompe_CA / 10, debit_pompe_CA % 10);
break;
case pompe_KH :
sprintf(ligne1, "Debit pompe %s", nom_KH);
sprintf(ligne2, "%d,%d ml / minute", debit_pompe_KH / 10, debit_pompe_KH % 10);
break;
case pompe_SL :
sprintf(ligne1, "Debit pompe %s", nom_SL);
sprintf(ligne2, "%d,%d ml / minute", debit_pompe_SL / 10, debit_pompe_SL % 10);
break;
case pompe_MG :
sprintf(ligne1, "Debit pompe %s", nom_MG);
sprintf(ligne2, "%d,%d ml / minute", debit_pompe_MG / 10, debit_pompe_MG % 10);
break;
}
sprintf(ligne3, " ");
sprintf(ligne4, "Modif : bouton + - V");

afficherLignes(ligne1, ligne2, ligne3, ligne4);
}

uint8_t evolutionContenuEcran()
{
//Retourne 1 si le contenu de l'�cran doit �tre actualis�
//Retourne 0 sinon
static uint8_t premier = 0;
static uint16_t sdosage_CA, sdosage_KH, sdosage_SL, sdosage_MG;
static uint16_t sdebit_pompe_CA, sdebit_pompe_KH, sdebit_pompe_SL, sdebit_pompe_MG;
static uint8_t spompe_selectionnee, sreglage_en_cours, sprochaine_pompe_a_declencher, secran_affiche, secran_selectionne;
static uint8_t schronomin, schronosec, snb_secondes, sindex_log, scurseur_log;
uint8_t pas_de_difference, chronomin, chronosec;
uint32_t chrono;

//test sur les variables d'etat
pas_de_difference = premier;
pas_de_difference = (pas_de_difference && (sdosage_CA == dosage_CA));
pas_de_difference = (pas_de_difference && (sdosage_KH == dosage_KH));
pas_de_difference = (pas_de_difference && (sdosage_SL == dosage_SL));
pas_de_difference = (pas_de_difference && (sdosage_MG == dosage_MG));
pas_de_difference = (pas_de_difference && (sdebit_pompe_CA == debit_pompe_CA));
pas_de_difference = (pas_de_difference && (sdebit_pompe_KH == debit_pompe_KH));
pas_de_difference = (pas_de_difference && (sdebit_pompe_SL == debit_pompe_SL));
pas_de_difference = (pas_de_difference && (sdebit_pompe_MG == debit_pompe_MG));
pas_de_difference = (pas_de_difference && (spompe_selectionnee == pompe_selectionnee));
pas_de_difference = (pas_de_difference && (sreglage_en_cours == reglage_en_cours));
pas_de_difference = (pas_de_difference && (sprochaine_pompe_a_declencher == prochaine_pompe_a_declencher));
pas_de_difference = (pas_de_difference && (secran_affiche == ecran_affiche));
pas_de_difference = (pas_de_difference && (secran_selectionne == ecran_selectionne));

chrono = millis() - chrono_pompes;
if (chrono > intervalle)
{
chronomin = 0;
chronosec = 0;
}
else
{
chrono = intervalle - chrono;
if (chrono >= 3600000)
{
chronomin = 0;
chronosec = 0;
}
else
{
if (chrono >= 60000)
{
chronomin = chrono / 60000;
chronosec = 0;
}
else
{
chronomin = 0;
chronosec = chrono / 1000;
}
}
}
pas_de_difference = (pas_de_difference && (schronomin == chronomin));
pas_de_difference = (pas_de_difference && (schronosec == chronosec));
pas_de_difference = (pas_de_difference && (snb_secondes == nb_secondes));
pas_de_difference = (pas_de_difference && (sindex_log == index_log));
pas_de_difference = (pas_de_difference && (scurseur_log == curseur_log));

//memorisation pour la prochaine fois
premier = 1;
sdosage_CA = dosage_CA;
sdosage_KH = dosage_KH;
sdosage_SL = dosage_SL;
sdosage_MG = dosage_MG;
sdebit_pompe_CA = debit_pompe_CA;
sdebit_pompe_KH = debit_pompe_KH;
sdebit_pompe_SL = debit_pompe_SL;
sdebit_pompe_MG = debit_pompe_MG;
spompe_selectionnee = pompe_selectionnee;
sreglage_en_cours = reglage_en_cours;
sprochaine_pompe_a_declencher = prochaine_pompe_a_declencher;
secran_affiche = ecran_affiche;
secran_selectionne = ecran_selectionne;
schronomin = chronomin;
schronosec = chronosec;
snb_secondes = nb_secondes;
sindex_log = index_log;
scurseur_log = curseur_log;

//retour
if (pas_de_difference)
{
return 0;
}
else
{
return 1;
}
}

void gererAffichage()
{
if (evolutionContenuEcran())
{
switch (ecran_affiche)
{
case ECRAN_STANDARD :
afficherEcranStandard();
break;
case ECRAN_MENU_PMP :
afficherEcranMenuPMP();
break;
case ECRAN_DOSAGE :
afficherEcranDosage();
break;
case ECRAN_ETALONNAGE :
afficherEcranEtalonnage();
break;
case ECRAN_DEBIT :
afficherEcranDebit();
break;
case ECRAN_MENU :
afficherEcranMenu();
break;
case ECRAN_SYSTEME :
afficherEcranSysteme();
break;
case ECRAN_LOG :
afficherEcranLog();
break;
}
}
}


//******************************************************************************************
//Fonctions principales d'une complexit� folle
//******************************************************************************************

void setup()
{
lireParametres();
initialiserLEDs();
initialiserBoutons();
initialiserPompes();
initialiserAffichage();
}

void loop()
{
actualiserHorloge();
gererAffichage();
gererPompes();
gererBoutons();
delay(1);
}

zebulon01 a écrit:oui, pourquoi se faire c..r avec du DIY ????

point important or mis la précision.
que la programmation et l'horloge reste en mémoire en cas de coupure edf.
si une coupure passe inaperçue, ou qu'on oublie de la remettre l'heure ,plus de dosage .

ta l'air de connaitre en programmation pour écrire ce genre de commentaire...
j'ai pas le temps de regarder le programme a djbouns
moi ma gestion pompe doseuse sur 10 test et sur 200ml ne donne pas plus de 2ml de plus ou moins et ça sur les 6 pompes
et puis quel mec oserait faire un programme sans l'heure garder en mémoire et donc plus de dosage??
si coupure edf tous simplement ta louper un dosage et le cycle revient a la normale quand il y aura de nouveau de l’électricité
le même principe que les grotech - buble magus etc...
et pourquoi tu tes fait c..r avec du DIY pour l'avertisseur de coupure ???je te renvoie la question

j'ai dut mal m'exprimer

je voulait dire qu'une personne qui veut une pompe doseuse et qui regarde que le prix, les marine magic lui conviendont, d'autant plus si il est pas bricoleur.
apres sur ce matos, pour pas etre em..er, il faut aussi voir d'autres points , comme la précision de chaques dosages.

et puis quel mec oserait faire un programme sans l'heure garder en mémoire et donc plus de dosage??
si coupure edf tous simplement ta louper un dosage et le cycle revient a la normale quand il y aura de nouveau de l’électricité

a ma connaissance , pratiquement toutes les pompes doseuse conservent les paramétres.
sauf l'horloge, ce qui fait qu'"au retour du courant , plus rien se passe ou tout est décaler tant que la remise a l'heure n'as pas étée faite.
a l'exception de certaines grotech, ghl et une autre marque , qui elles conservent l horloge.
c'est ce qu'ont m'as répondu quand j'avait poser la question ici.

le diy est trés bien ( trés content du transmetteur)
mais si la personne veut pas bricoler, pas programmer,que ca la dérange pas de remettre l'heure, donc elle vas prendre une pompe bon marché toute montée.

a ces plus clair
de toute manière pour faire un montage a base arduino pour pompe doseuse avec horloge temps réel qui possède ça propre pile ta pas de soucis vu quelle et autonome

je relance le post car je serai intéressé. au niveau hardware, tes modifs au niveau écran et boutons,, tjrs avec le uno??

J'ai mis une mega au lieu de la uno
j'ai mis un ecran 20*4
et j'ai ajouter 3 bouton poussoir (relier a la mase / pin)
et c'est tout

salut,

Petite maj du code avec ajout d'une commande "stop" car après certain redémarrage les pompe ce lançais.

Code: Tout sélectionner

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

//******************************************************************************************
//Branchements
//******************************************************************************************

//PIN de chaque bouton poussoir
#define BOUTON_PLUS  52  //PIN---BP---0V
#define BOUTON_MOINS 50  //PIN---BP---0V
#define BOUTON_VALID 23  //PIN---BP---0V

//PIN de chaque LED Verte (facultative)
//mettre la ligne en commentaire si la LED n'est pas install�e
/*
#define LED_VERTE_CA 22  //PIN---LED---R---5V
#define LED_VERTE_KH 25  //PIN---LED---R---5V
#define LED_VERTE_SL 26  //PIN---LED---R---5V
#define LED_VERTE_MG 29  //PIN---LED---R---5V
*/
//PIN de chaque LED Rouge (facultative)
//mettre la ligne en commentaire si la LED n'est pas install�e
//pour une seule LED rouge globale : laisser les 4 #define avec la m�me valeur
/*
#define LED_ROUGE_CA 30  //PIN---LED---R---5V
#define LED_ROUGE_KH 33  //PIN---LED---R---5V
#define LED_ROUGE_SL 34  //PIN---LED---R---5V
#define LED_ROUGE_MG 37  //PIN---LED---R---5V
*/
//PIN de l'�cran LCD
#define LCD_RS 43  //PIN---RS
#define LCD_EN 45  //PIN---EN
#define LCD_D4 47  //PIN---D4
#define LCD_D5 49  //PIN---D5
#define LCD_D6 51  //PIN---D6
#define LCD_D7 53  //PIN---D7


//******************************************************************************************
//Param�tres constants. Modif = recompil
//******************************************************************************************

//Identifiant des pompes sur le shield motor
const uint8_t pompe_CA = 4;
const uint8_t pompe_KH = 3;
const uint8_t pompe_SL = 2;
const uint8_t pompe_MG = 1;

//Libell�s � afficher sur l'�cran LCD : 6 caract�res maximum (+ 1 pour le \0)
char nom_CA[7] = "Ca    ";
char nom_KH[7] = "KH    ";
char nom_SL[7] = "S NaCl";
char nom_MG[7] = "Mg    ";

//Dosage maximum autoris�, en ml par jour
//s�curit� contre les surdosages accidentels
//valeur maximum possible : 999 ml (� 4 chiffres l'affichage LCD d�borde)
const uint16_t max_dosage_CA = 50;
const uint16_t max_dosage_KH = 50;
const uint16_t max_dosage_SL = 50;
const uint16_t max_dosage_MG = 50;

//D�bit minimum des pompes pris en compte dans les calculs,
//en dixi�me de ml par minute : 198 = 19,8 ml par minute
//s�curit� contre les surdosages accidentels
//(debit erron� trop faible => allongement anormal dur�e de fonctionnement => surdosage)
//valeur 0 interdite ! minimum 1
const uint16_t min_debit_pompe_CA = 100;
const uint16_t min_debit_pompe_KH = 100;
const uint16_t min_debit_pompe_SL = 100;
const uint16_t min_debit_pompe_MG = 100;

//Vitesse de rotation des pompes 0=arr�t � 255=vitesse max
const uint8_t vitesse_moteur_CA = 200;
const uint8_t vitesse_moteur_KH = 200;
const uint8_t vitesse_moteur_SL = 200;
const uint8_t vitesse_moteur_MG = 200;

//Nombre de d�clenchements de chaque pompe par 24 heures
//valeur 0 interdite ! autant �teindre l'automate
const uint8_t nb_declenchements = 6; // x 4 pompes

//D�lai de d�sactivation des boutons poussoirs apr�s rel�chement, en guise de dispositif anti-rebond
const uint32_t delai_anti_rebond = 25; //en millisecondes
//si trop petit, les parasites � la commutation risquent d'entra�ner des doubles prises en compte
//si trop grand, les appuis trop brefs ne seront pas d�tect�s
//=> le mettre � la plus petite valeur possible sans effets parasites constat�s
//NB : 20 ms semble bien en premi�re approche


//******************************************************************************************
//Param�tres dynamiques, modifiables � chaud et sauvegard�s dans l'eeprom
//******************************************************************************************
//Les valeurs indiqu�es ci-dessous ne servent qu'au tout premier t�l�versement du programme

//Dosages en ml par 24 heures
uint16_t dosage_CA  = 20;
uint16_t dosage_KH  = 16;
uint16_t dosage_SL  = 18;
uint16_t dosage_MG  = 35;

//Debit des pompes en ml par minute de fonctionnement
uint16_t debit_pompe_CA = 42;
uint16_t debit_pompe_KH = 40;
uint16_t debit_pompe_SL = 32;
uint16_t debit_pompe_MG = 41;


//******************************************************************************************
//******************************************************************************************
//******************************************************************************************
//******************************************************************************************
//******************************************************************************************
//******************************************************************************************
//******************************************************************************************
//******************************************************************************************
//******************************************************************************************
//******************************************************************************************

//  A partir de l� le code ne doit pas �tre modifi� sauf correction de bug


//******************************************************************************************
//Variables globales = �tats du syst�me
//******************************************************************************************

//Permet de d�sactiver le d�clenchement des pompes doseuses si une manip est en cours
uint8_t reglage_en_cours = 0;

//R�f�rence horaire pour les d�clenchements des pompes doseuses, exprim�e en millisecondes
uint32_t chrono_pompes = 0;

//D�lai entre deux d�clenchements de pompes doseuses, exprim� en millisecondes
const uint32_t intervalle = ((uint32_t) 24*60*60*1000)/((uint32_t) 4*nb_declenchements);

//Un commentaire est-il vraiment n�cessaire ici?
uint8_t prochaine_pompe_a_declencher = pompe_CA;

//Gestion des �crans
#define ECRAN_STANDARD   0
#define ECRAN_MENU_PMP   1
#define ECRAN_DOSAGE     2
#define ECRAN_ETALONNAGE 3
#define ECRAN_DEBIT      4
#define ECRAN_MENU       5
#define ECRAN_SYSTEME    6
#define ECRAN_LOG        7
uint8_t ecran_affiche = ECRAN_STANDARD;
uint8_t ecran_selectionne;
uint8_t pompe_selectionnee = 0;// = 0 ou pompe_CA ou pompe_KH ou pompe_SL ou pompe_MG
uint8_t curseur_log = 0;

//Etats des LED : un bit pour chaque
uint8_t etats_LED;


//******************************************************************************************
//Primitives de gestion de l'�cran LCD 4 lignes x 20 caract�res
//******************************************************************************************

LiquidCrystal lcd(LCD_RS, LCD_EN, LCD_D4, LCD_D5, LCD_D6, LCD_D7);

void initialiserLCD()
{
  lcd.begin(20,4);
}

void fixerCurseurLCD(uint8_t ligne, uint8_t colonne)
{
  //ligne de 0 � 3
  //colonne de 0 � 19
  lcd.setCursor(colonne, ligne);
}

void afficherCaractereLCD(char c)
{
  lcd.write((uint8_t) c);
}


//******************************************************************************************
//Gestion des LEDs
//******************************************************************************************

void initialiserLEDs()
{
  #ifdef LED_VERTE_CA
    pinMode(LED_VERTE_CA, OUTPUT);
    digitalWrite(LED_VERTE_CA, HIGH);
  #endif
  #ifdef LED_VERTE_KH
    pinMode(LED_VERTE_KH, OUTPUT);
    digitalWrite(LED_VERTE_KH, HIGH);
  #endif
  #ifdef LED_VERTE_SL
    pinMode(LED_VERTE_SL, OUTPUT);
    digitalWrite(LED_VERTE_SL, HIGH);
  #endif
  #ifdef LED_VERTE_MG
    pinMode(LED_VERTE_MG, OUTPUT);
    digitalWrite(LED_VERTE_MG, HIGH);
  #endif
  #ifdef LED_ROUGE_CA
    pinMode(LED_ROUGE_CA, OUTPUT);
    digitalWrite(LED_ROUGE_CA, HIGH);
  #endif
  #ifdef LED_ROUGE_KH
    pinMode(LED_ROUGE_KH, OUTPUT);
    digitalWrite(LED_ROUGE_KH, HIGH);
  #endif
  #ifdef LED_ROUGE_SL
    pinMode(LED_ROUGE_SL, OUTPUT);
    digitalWrite(LED_ROUGE_SL, HIGH);
  #endif
  #ifdef LED_ROUGE_MG
    pinMode(LED_ROUGE_MG, OUTPUT);
    digitalWrite(LED_ROUGE_MG, HIGH);
  #endif
  etats_LED = 0b11111111;
}

void allumerLEDVerte(uint8_t pompe)
{
  switch (pompe)
  {
    case pompe_CA :
      #ifdef LED_VERTE_CA
        if (etats_LED & 0b10000000)
        {
          digitalWrite(LED_VERTE_CA, LOW);
          etats_LED &= 0b01111111;
        }
      #endif
      break;
    case pompe_KH :
      #ifdef LED_VERTE_KH
        if (etats_LED & 0b01000000)
        {
          digitalWrite(LED_VERTE_KH, LOW);
          etats_LED &= 0b10111111;
        }
      #endif
      break;
    case pompe_SL :
      #ifdef LED_VERTE_SL
        if (etats_LED & 0b00100000)
        {
          digitalWrite(LED_VERTE_SL, LOW);
          etats_LED &= 0b11011111;
        }
      #endif
      break;
    case pompe_MG :
      #ifdef LED_VERTE_MG
        if (etats_LED & 0b00010000)
        {
          digitalWrite(LED_VERTE_MG, LOW);
          etats_LED &= 0b11101111;
        }
      #endif
      break;
  }
}

void eteindreLEDVerte(uint8_t pompe)
{
  switch (pompe)
  {
    case pompe_CA :
      #ifdef LED_VERTE_CA
        if ((~etats_LED) & 0b10000000)
        {
          digitalWrite(LED_VERTE_CA, HIGH);
          etats_LED |= 0b10000000;
        }
      #endif
      break;
    case pompe_KH :
      #ifdef LED_VERTE_KH
        if ((~etats_LED) & 0b01000000)
        {
          digitalWrite(LED_VERTE_KH, HIGH);
          etats_LED |= 0b01000000;
        }
      #endif
      break;
    case pompe_SL :
      #ifdef LED_VERTE_SL
        if ((~etats_LED) & 0b00100000)
        {
          digitalWrite(LED_VERTE_SL, HIGH);
          etats_LED |= 0b00100000;
        }
      #endif
      break;
    case pompe_MG :
      #ifdef LED_VERTE_MG
        if ((~etats_LED) & 0b00010000)
        {
          digitalWrite(LED_VERTE_MG, HIGH);
          etats_LED |= 0b00010000;
        }
      #endif
      break;
  }
}

void basculerLEDVerte(uint8_t pompe)
{
  if (pompe != pompe_CA) eteindreLEDVerte(pompe_CA);
  if (pompe != pompe_KH) eteindreLEDVerte(pompe_KH);
  if (pompe != pompe_SL) eteindreLEDVerte(pompe_SL);
  if (pompe != pompe_MG) eteindreLEDVerte(pompe_MG);
  allumerLEDVerte(pompe);
}

void eteindreLEDsVertes()
{
  eteindreLEDVerte(pompe_CA);
  eteindreLEDVerte(pompe_KH);
  eteindreLEDVerte(pompe_SL);
  eteindreLEDVerte(pompe_MG);
}

void allumerLEDRouge(uint8_t pompe)
{
  switch (pompe)
  {
    case pompe_CA :
      #ifdef LED_ROUGE_CA
        if (etats_LED & 0b00001000)
        {
          digitalWrite(LED_ROUGE_CA, LOW);
          etats_LED &= 0b11110111;
        }
      #endif
      break;
    case pompe_KH :
      #ifdef LED_ROUGE_KH
        if (etats_LED & 0b00000100)
        {
          digitalWrite(LED_ROUGE_KH, LOW);
          etats_LED &= 0b11111011;
        }
      #endif
      break;
    case pompe_SL :
      #ifdef LED_ROUGE_SL
        if (etats_LED & 0b00000010)
        {
          digitalWrite(LED_ROUGE_SL, LOW);
          etats_LED &= 0b11111101;
        }
      #endif
      break;
    case pompe_MG :
      #ifdef LED_ROUGE_MG
        if (etats_LED & 0b00000001)
        {
          digitalWrite(LED_ROUGE_MG, LOW);
          etats_LED &= 0b11111110;
        }
      #endif
      break;
  }
}

void eteindreLEDRouge(uint8_t pompe)
{
  switch (pompe)
  {
    case pompe_CA :
      #ifdef LED_ROUGE_CA
        if ((~etats_LED) & 0b00001000)
        {
          digitalWrite(LED_ROUGE_CA, HIGH);
          etats_LED |= 0b00001000;
        }
      #endif
      break;
    case pompe_KH :
      #ifdef LED_ROUGE_KH
        if ((~etats_LED) & 0b00000100)
        {
          digitalWrite(LED_ROUGE_KH, HIGH);
          etats_LED |= 0b00000100;
        }
      #endif
      break;
    case pompe_SL :
      #ifdef LED_ROUGE_SL
        if ((~etats_LED) & 0b00000010)
        {
          digitalWrite(LED_ROUGE_SL, HIGH);
          etats_LED |= 0b00000010;
        }
      #endif
      break;
    case pompe_MG :
      #ifdef LED_ROUGE_MG
        if ((~etats_LED) & 0b00000001)
        {
          digitalWrite(LED_ROUGE_MG, HIGH);
          etats_LED |= 0b00000001;
        }
      #endif
      break;
  }
}


//******************************************************************************************
//LOG = m�morisation des d�clenchements effectu�s
//******************************************************************************************

const uint8_t maxi_log = 100;

uint8_t index_log = 0;

uint32_t chrono_deb_log[maxi_log];
uint32_t chrono_fin_log[maxi_log];
uint8_t  pompe_log[maxi_log];

void ecrireLog(uint32_t deb, uint32_t fin, uint8_t pompe)
{
  uint8_t i;

  if (index_log < maxi_log) index_log++;

  //On pousse vers le haut
  for (i=index_log - 1; i>0; i--)
  {
    chrono_deb_log[i] = chrono_deb_log[i-1];
    chrono_fin_log[i] = chrono_fin_log[i-1];
    pompe_log[i] = pompe_log[i-1];
  }

  chrono_deb_log[0] = deb;
  chrono_fin_log[0] = fin;
  pompe_log[0] = pompe;
}

void lireLog(uint8_t rang, uint32_t *deb, uint32_t *fin, uint8_t *pompe)
{
  if (rang < index_log)
  {
    *deb = chrono_deb_log[rang];
    *fin = chrono_fin_log[rang];
    *pompe = pompe_log[rang];
  }
  else
  {
    *deb = 0;
    *fin = 0;
    *pompe = 0;
  }
}

char* formaterLog(uint8_t rang, char ligne[])
{
  uint32_t deb, fin, heures, minutes, secondes, centiemes;
  uint8_t pompe;
  char nom_pompe[7];

  lireLog(rang, &deb, &fin, &pompe);

  switch (pompe)
  {
    case pompe_CA : sprintf(nom_pompe, "%s", nom_CA);break;
    case pompe_KH : sprintf(nom_pompe, "%s", nom_KH);break;
    case pompe_SL : sprintf(nom_pompe, "%s", nom_SL);break;
    case pompe_MG : sprintf(nom_pompe, "%s", nom_MG);break;
    default       : nom_pompe[0] = 0;
  }

  fin = fin - deb;
  deb = millis() - deb;
  heures  = deb / 3600000;
  minutes = (deb % 3600000) / 60000;
  secondes = fin / 1000;
  centiemes = (fin % 1000) / 10;

  if (heures > 99) // anti d�bordement affichage
  {
    heures  = 99;
    minutes = 59;
  }

  if (secondes > 9999)
  {
    sprintf(ligne,"-%02luH%02lu %s %lus", heures, minutes, nom_pompe, secondes);
  }
  else
  {
    if (secondes > 999)
    {
      sprintf(ligne,"-%02luH%02lu %s %04lus%lu", heures, minutes, nom_pompe, secondes, centiemes / 10);
    }
    else
    {
      sprintf(ligne,"-%02luH%02lu %s %03lus%02lu", heures, minutes, nom_pompe, secondes, centiemes);
      if (ligne[14]=='0')
      {
        ligne[14] = ' ';
        if (ligne[15]=='0') ligne[15]=' ';
      }
    }
  }

  return ligne;
}


//******************************************************************************************
//horloge = delai ecoule depuis le boot
//******************************************************************************************

uint32_t nb_jours = 0;
uint8_t  nb_heures = 0;
uint8_t  nb_minutes = 0;
uint8_t  nb_secondes = 0;

void actualiserHorloge()
{
// nombre de cycles complets effectues par la fonction millis()
// un cycle = 49 jours, 17 heures, 2 minutes, 47 secondes et 296 ms
  static uint32_t nb_roll_over = 0;
  static uint32_t dernier_chrono = 0;
  uint32_t chrono, jours, heures, minutes, secondes, millisecondes;

  chrono = millis();

  if ((chrono - dernier_chrono) > 1000) //seulement une fois par seconde
  {
    if (chrono < dernier_chrono) nb_roll_over++;
    dernier_chrono = chrono;

    millisecondes = chrono % 1000;
    chrono = chrono / 1000;
    secondes = chrono % 60;
    chrono = chrono / 60;
    minutes = chrono % 60;
    chrono = chrono / 60;
    heures = chrono % 24;
    jours = chrono / 24;

    millisecondes += 296 * nb_roll_over;
    secondes += 47 * nb_roll_over;
    minutes += 2 * nb_roll_over;
    heures += 17 * nb_roll_over;
    jours += 49 * nb_roll_over;

    secondes += millisecondes / 1000;
    minutes += secondes / 60;
    heures += minutes / 60;
    jours += heures / 24;

//  millisecondes = millisecondes % 1000;
    secondes = secondes % 60;
    minutes = minutes % 60;
    heures = heures % 24;

    nb_jours = jours;
    nb_heures = heures;
    nb_minutes = minutes;
    nb_secondes = secondes;
  }
}


//******************************************************************************************
//Gestion des pompes doseuses
//******************************************************************************************

AF_DCMotor motorMG(pompe_MG, MOTOR12_64KHZ);
AF_DCMotor motorSL(pompe_SL, MOTOR12_64KHZ);
AF_DCMotor motorKH(pompe_KH, MOTOR12_64KHZ);
AF_DCMotor motorCA(pompe_CA, MOTOR12_64KHZ);

void initialiserPompes()
{
  motorCA.setSpeed(vitesse_moteur_CA);
  motorKH.setSpeed(vitesse_moteur_KH);
  motorSL.setSpeed(vitesse_moteur_SL);
  motorMG.setSpeed(vitesse_moteur_MG);
  motorCA.run(RELEASE);
  motorKH.run(RELEASE);
  motorSL.run(RELEASE);
  motorMG.run(RELEASE);
}

void declencherPompeCA(uint32_t duree_en_ms)
{
  uint32_t chrono_start, chrono_stop;
  if (duree_en_ms > 0)
  {
    allumerLEDRouge(pompe_CA);
    chrono_start = millis();
    motorCA.run(FORWARD);
    delay(duree_en_ms);
    motorCA.run(RELEASE);
    chrono_stop = millis();
    ecrireLog(chrono_start, chrono_stop, pompe_CA);
    eteindreLEDRouge(pompe_CA);
  }
}

void declencherPompeKH(uint32_t duree_en_ms)
{
  uint32_t chrono_start, chrono_stop;
  if (duree_en_ms > 0)
  {
    allumerLEDRouge(pompe_KH);
    chrono_start = millis();
    motorKH.run(FORWARD);
    delay(duree_en_ms);
    motorKH.run(RELEASE);
    chrono_stop = millis();
    ecrireLog(chrono_start, chrono_stop, pompe_KH);
    eteindreLEDRouge(pompe_KH);
  }
}

void declencherPompeSL(uint32_t duree_en_ms)
{
  uint32_t chrono_start, chrono_stop;
  if (duree_en_ms > 0)
  {
    allumerLEDRouge(pompe_SL);
    chrono_start = millis();
    motorSL.run(FORWARD);
    delay(duree_en_ms);
    motorSL.run(RELEASE);
    chrono_stop = millis();
    ecrireLog(chrono_start, chrono_stop, pompe_SL);
    eteindreLEDRouge(pompe_SL);
  }
}

void declencherPompeMG(uint32_t duree_en_ms)
{
  uint32_t chrono_start, chrono_stop;
  if (duree_en_ms > 0)
  {
    allumerLEDRouge(pompe_MG);
    chrono_start = millis();
    motorMG.run(FORWARD);
    delay(duree_en_ms);
    motorMG.run(RELEASE);
    chrono_stop = millis();
    ecrireLog(chrono_start, chrono_stop, pompe_MG);
    eteindreLEDRouge(pompe_MG);
  }
}

void declencherPompe()
{
//D�clenche une des 4 pompes,
//pour la dur�e correspondant � son dosage
//de mani�re cyclique CA -> KH -> SL -> MG -> CA -> KH -> etc.
  uint32_t duree;

  switch (prochaine_pompe_a_declencher)
  {
    case pompe_CA :
      duree = (uint32_t) nb_declenchements * debit_pompe_CA / 10;
      if (duree > 0) duree = ((uint32_t) dosage_CA * 60000) / duree;
      declencherPompeCA(duree);
      prochaine_pompe_a_declencher = pompe_KH;
      break;
    case pompe_KH :
      duree = (uint32_t) nb_declenchements * debit_pompe_KH / 10;
      if (duree > 0) duree = ((uint32_t) dosage_KH * 60000) / duree;
      declencherPompeKH(duree);
      prochaine_pompe_a_declencher = pompe_SL;
      break;
    case pompe_SL :
      duree = (uint32_t) nb_declenchements * debit_pompe_SL / 10;
      if (duree > 0) duree = ((uint32_t) dosage_SL * 60000) / duree;
      declencherPompeSL(duree);
      prochaine_pompe_a_declencher = pompe_MG;
      break;
    case pompe_MG :
      duree = (uint32_t) nb_declenchements * debit_pompe_MG / 10;
      if (duree > 0) duree = ((uint32_t) dosage_MG * 60000) / duree;
      declencherPompeMG(duree);
      prochaine_pompe_a_declencher = pompe_CA;
      break;
  }
}

void gererPompes()
{
  uint32_t chrono;
//Ne rien faire si un reglage est en cours
  if (reglage_en_cours == 0)
  {
    chrono = millis() - chrono_pompes;
    //V�rifier si le d�lai de d�clenchement est atteint
    if (chrono > intervalle)
    {
      basculerLEDVerte(prochaine_pompe_a_declencher);
      declencherPompe();
      eteindreLEDsVertes();
      chrono_pompes += intervalle;
      //On repart de la r�f�rence initiale, pour que les p�riodes de r�glage
      //n'entrainent pas une d�rive dans la programmation horaire.
      //Si l'automate �tait en cours de r�glage � l'horaire th�orique de
      //d�clenchement d'une pompe, le retard sera ainsi rattrap�
    }
    else
    {
      //si moins de 31 secondes restantes, allumage de la led verte
      if ((intervalle - chrono) < 31000)
      {
        basculerLEDVerte(prochaine_pompe_a_declencher);
      }
    }
  }
}


//******************************************************************************************
//Lecture / sauvegarde des param�tres en eeprom
//******************************************************************************************

uint8_t lireEEprom(uint16_t adresse)
{
  return EEPROM.read(adresse);
}

void ecrireEEprom(uint16_t adresse, uint8_t valeur)
{
//Dans le doute, au cas o� cela ne soit pas g�r� � plus bas niveau, �vite les �critures inutiles
  if (lireEEprom(adresse) != valeur)
  {
    EEPROM.write(adresse, valeur);
  }
}

//La signature �vite de r�cup�rer n'importe quoi au premier t�l�versement du programme
const uint8_t signature_EEprom = 154; //au pif, valeur al�atoire

void lireParametres()
{
  uint16_t adresse = 0;

  if (lireEEprom(0) == 153) //migration ancien parametrage. Bloc temporaire � supprimer
  {
    adresse = 1;
    dosage_CA = lireEEprom(adresse++);
    dosage_CA = (dosage_CA << 8) | lireEEprom(adresse++);
    dosage_KH = lireEEprom(adresse++);
    dosage_KH = (dosage_KH << 8) | lireEEprom(adresse++);
    dosage_SL = lireEEprom(adresse++);
    dosage_SL = (dosage_SL << 8) | lireEEprom(adresse++);
    dosage_MG = lireEEprom(adresse++);
    dosage_MG = (dosage_MG << 8) | lireEEprom(adresse++);
    debit_pompe_CA = lireEEprom(adresse++);
    debit_pompe_CA = (debit_pompe_CA << 8) | lireEEprom(adresse++);
    debit_pompe_KH = lireEEprom(adresse++);
    debit_pompe_KH = (debit_pompe_KH << 8) | lireEEprom(adresse++);
    debit_pompe_SL = lireEEprom(adresse++);
    debit_pompe_SL = (debit_pompe_SL << 8) | lireEEprom(adresse++);
    debit_pompe_MG = lireEEprom(adresse++);
    debit_pompe_MG = (debit_pompe_MG << 8) | lireEEprom(adresse++);
    debit_pompe_CA = debit_pompe_CA * 10;
    debit_pompe_KH = debit_pompe_KH * 10;
    debit_pompe_SL = debit_pompe_SL * 10;
    debit_pompe_MG = debit_pompe_MG * 10;
    adresse = 0;
  }

  if (lireEEprom(adresse++) == signature_EEprom)
  {
    dosage_CA = lireEEprom(adresse++);
    dosage_CA = (dosage_CA << 8) | lireEEprom(adresse++);
    dosage_KH = lireEEprom(adresse++);
    dosage_KH = (dosage_KH << 8) | lireEEprom(adresse++);
    dosage_SL = lireEEprom(adresse++);
    dosage_SL = (dosage_SL << 8) | lireEEprom(adresse++);
    dosage_MG = lireEEprom(adresse++);
    dosage_MG = (dosage_MG << 8) | lireEEprom(adresse++);
    debit_pompe_CA = lireEEprom(adresse++);
    debit_pompe_CA = (debit_pompe_CA << 8) | lireEEprom(adresse++);
    debit_pompe_KH = lireEEprom(adresse++);
    debit_pompe_KH = (debit_pompe_KH << 8) | lireEEprom(adresse++);
    debit_pompe_SL = lireEEprom(adresse++);
    debit_pompe_SL = (debit_pompe_SL << 8) | lireEEprom(adresse++);
    debit_pompe_MG = lireEEprom(adresse++);
    debit_pompe_MG = (debit_pompe_MG << 8) | lireEEprom(adresse++);
  }

  //Pour le cas o� on trouve des cochonneries dans l'eeprom
  if (dosage_CA > max_dosage_CA) dosage_CA = max_dosage_CA;
  if (dosage_KH > max_dosage_KH) dosage_KH = max_dosage_KH;
  if (dosage_SL > max_dosage_SL) dosage_SL = max_dosage_SL;
  if (dosage_MG > max_dosage_MG) dosage_MG = max_dosage_MG;
  if (debit_pompe_CA < min_debit_pompe_CA) debit_pompe_CA = min_debit_pompe_CA;
  if (debit_pompe_KH < min_debit_pompe_KH) debit_pompe_KH = min_debit_pompe_KH;
  if (debit_pompe_SL < min_debit_pompe_SL) debit_pompe_SL = min_debit_pompe_SL;
  if (debit_pompe_MG < min_debit_pompe_MG) debit_pompe_MG = min_debit_pompe_MG;
}

void enregistrerParametres()
{
  uint16_t adresse = 0;

  ecrireEEprom(adresse++, signature_EEprom);
  ecrireEEprom(adresse++, dosage_CA >> 8);
  ecrireEEprom(adresse++, dosage_CA & 255);
  ecrireEEprom(adresse++, dosage_KH >> 8);
  ecrireEEprom(adresse++, dosage_KH & 255);
  ecrireEEprom(adresse++, dosage_SL >> 8);
  ecrireEEprom(adresse++, dosage_SL & 255);
  ecrireEEprom(adresse++, dosage_MG >> 8);
  ecrireEEprom(adresse++, dosage_MG & 255);
  ecrireEEprom(adresse++, debit_pompe_CA >> 8);
  ecrireEEprom(adresse++, debit_pompe_CA & 255);
  ecrireEEprom(adresse++, debit_pompe_KH >> 8);
  ecrireEEprom(adresse++, debit_pompe_KH & 255);
  ecrireEEprom(adresse++, debit_pompe_SL >> 8);
  ecrireEEprom(adresse++, debit_pompe_SL & 255);
  ecrireEEprom(adresse++, debit_pompe_MG >> 8);
  ecrireEEprom(adresse++, debit_pompe_MG & 255);
}


//******************************************************************************************
//Gestion des boutons
//******************************************************************************************

void initialiserBoutons()
{
//d�finir les entr�es
  pinMode(BOUTON_PLUS,  INPUT);
  pinMode(BOUTON_MOINS, INPUT);
  pinMode(BOUTON_VALID, INPUT);
//activer le pullup
  digitalWrite(BOUTON_PLUS,  HIGH);
  digitalWrite(BOUTON_MOINS, HIGH);
  digitalWrite(BOUTON_VALID, HIGH);
}

void recalculerDosageSL()
{
  dosage_SL = (dosage_CA + dosage_KH) >> 1;
  if (dosage_SL > max_dosage_SL) dosage_SL = max_dosage_SL;
}

void terminerReglage()
{
  reglage_en_cours = 0;
  pompe_selectionnee = 0;
  ecran_affiche = ECRAN_STANDARD;
  enregistrerParametres();
  eteindreLEDsVertes();
}

void gererBoutonsEcranStandard(uint8_t boutonAppuye)
{
  switch (boutonAppuye)
  {
    case BOUTON_MOINS :
      switch (pompe_selectionnee)
      {
        case pompe_CA :
          pompe_selectionnee = pompe_KH;
          break;
        case pompe_KH :
          pompe_selectionnee = pompe_SL;
          break;
        case pompe_SL :
          pompe_selectionnee = pompe_MG;
          break;
        default :
          pompe_selectionnee = pompe_CA;
          break;
      }
      break;
    case BOUTON_PLUS :
      switch (pompe_selectionnee)
      {
        case pompe_MG :
          pompe_selectionnee = pompe_SL;
          break;
        case pompe_SL :
          pompe_selectionnee = pompe_KH;
        break;
        case pompe_KH :
          pompe_selectionnee = pompe_CA;
          break;
        default :
          pompe_selectionnee = pompe_MG;
          break;
      }
      break;
    case BOUTON_VALID :
      switch (pompe_selectionnee)
      {
        case pompe_CA :
        case pompe_KH :
        case pompe_MG :
          ecran_affiche = ECRAN_MENU_PMP;
          ecran_selectionne = ECRAN_DOSAGE;
          break;
        case pompe_SL :
          ecran_affiche = ECRAN_ETALONNAGE;
          break;
        default :
          ecran_affiche = ECRAN_MENU;
          ecran_selectionne = ECRAN_SYSTEME;
          break;
      }
      break;
  }
  basculerLEDVerte(pompe_selectionnee);
}

void gererBoutonsEcranMenuPMP(uint8_t boutonAppuye)
{
  if (boutonAppuye == BOUTON_VALID)
  {
    ecran_affiche = ecran_selectionne;
  }
  else
  {
    if (ecran_selectionne == ECRAN_ETALONNAGE)
    {
      ecran_selectionne = ECRAN_DOSAGE;
    }
    else
    {
      ecran_selectionne = ECRAN_ETALONNAGE;
    }
  }
}

void gererBoutonsEcranDosage(uint8_t boutonAppuye)
{
  switch (boutonAppuye)
  {
    case BOUTON_MOINS :
      switch (pompe_selectionnee)
      {
        case pompe_CA :
          if (dosage_CA > 0)
          {
            dosage_CA--;
            recalculerDosageSL();
          }
          break;
        case pompe_KH :
          if (dosage_KH > 0)
          {
            dosage_KH--;
            recalculerDosageSL();
          }
          break;
        case pompe_MG :
          if (dosage_MG > 0) dosage_MG--;
          break;
      }
      break;
    case BOUTON_PLUS :
      switch (pompe_selectionnee)
      {
        case pompe_CA :
          if (dosage_CA < max_dosage_CA)
          {
            dosage_CA++;
            recalculerDosageSL();
          }
          break;
        case pompe_KH :
          if (dosage_KH < max_dosage_KH)
          {
            dosage_KH++;
            recalculerDosageSL();
          }
          break;
        case pompe_MG :
          if (dosage_MG < max_dosage_MG) dosage_MG++;
          break;
      }
      break;
    case BOUTON_VALID :
      terminerReglage();
      break;
  }
}

void gererBoutonsEcranEtalonnage(uint8_t boutonAppuye)
{
  if (boutonAppuye == BOUTON_PLUS)
  {
    switch (pompe_selectionnee)
    {
      case pompe_CA :
        declencherPompeCA(60000);
        ecran_affiche = ECRAN_DEBIT;
        break;
      case pompe_KH :
        declencherPompeKH(60000);
        ecran_affiche = ECRAN_DEBIT;
        break;
      case pompe_SL :
        declencherPompeSL(60000);
        ecran_affiche = ECRAN_DEBIT;
        break;
      case pompe_MG :
        declencherPompeMG(60000);
        ecran_affiche = ECRAN_DEBIT;
        break;
    }
  }
  if (boutonAppuye == BOUTON_MOINS)
  {
    terminerReglage();
  }
  if (boutonAppuye == BOUTON_VALID)
  {
    ecran_affiche = ECRAN_DEBIT;
  }
}

void gererBoutonsEcranDebit(uint8_t boutonAppuye)
{
  switch (boutonAppuye)
  {
    case BOUTON_MOINS :
      switch (pompe_selectionnee)
      {
        case pompe_CA :
          if (debit_pompe_CA > min_debit_pompe_CA) debit_pompe_CA--;
          break;
        case pompe_KH :
          if (debit_pompe_KH > min_debit_pompe_KH) debit_pompe_KH--;
          break;
        case pompe_SL :
          if (debit_pompe_SL > min_debit_pompe_SL) debit_pompe_SL--;
          break;
        case pompe_MG :
          if (debit_pompe_MG > min_debit_pompe_MG) debit_pompe_MG--;
          break;
      }
      break;
    case BOUTON_PLUS :
      switch (pompe_selectionnee)
      {
        case pompe_CA :
          if (debit_pompe_CA < 65535) debit_pompe_CA++;
          break;
        case pompe_KH :
          if (debit_pompe_KH < 65535) debit_pompe_KH++;
          break;
        case pompe_SL :
          if (debit_pompe_KH < 65535) debit_pompe_SL++;
          break;
        case pompe_MG :
          if (debit_pompe_KH < 65535) debit_pompe_MG++;
          break;
      }
      break;
    case BOUTON_VALID :
      terminerReglage();
      break;
  }
}

void gererBoutonsEcranMenu(uint8_t boutonAppuye)
{
  if (boutonAppuye == BOUTON_VALID)
  {
    ecran_affiche = ecran_selectionne;
    curseur_log = 0;
  }
  else
  {
    if (ecran_selectionne == ECRAN_SYSTEME)
    {
      ecran_selectionne = ECRAN_LOG;
    }
    else
    {
      ecran_selectionne = ECRAN_SYSTEME;
    }
  }
}

void gererBoutonsEcranSysteme(uint8_t boutonAppuye)
{
  if (boutonAppuye == BOUTON_VALID)
  {
    terminerReglage();
  }
}

void gererBoutonsEcranLog(uint8_t boutonAppuye)
{
  if (boutonAppuye == BOUTON_VALID)
  {
    terminerReglage();
  }
  if ((boutonAppuye == BOUTON_PLUS) && (curseur_log > 0))
  {
    curseur_log--;
  }
  if ((boutonAppuye == BOUTON_MOINS) && ((curseur_log+3) < index_log))
  {
    curseur_log++;
  }
}

void gererBoutons()
{
  static uint32_t chrono;
  static uint8_t repetition = 0;
  static uint8_t bouton_repete = 0;
  uint8_t boutonAppuye, boutonPlus, boutonMoins, boutonValid;
  uint32_t delai_repetition;

  boutonPlus  = (digitalRead(BOUTON_PLUS)  == LOW);
  boutonMoins = (digitalRead(BOUTON_MOINS) == LOW);
  boutonValid = (digitalRead(BOUTON_VALID) == LOW);

  if (boutonPlus || boutonMoins || boutonValid)
  {
    reglage_en_cours = 1;
    if (boutonMoins) boutonAppuye = BOUTON_MOINS;
    if (boutonPlus)  boutonAppuye = BOUTON_PLUS;
    if (boutonValid) boutonAppuye = BOUTON_VALID;

    switch (ecran_affiche)
    {
      //Eclatement en sous-fonctions pour all�ger le code
      case ECRAN_STANDARD :
        gererBoutonsEcranStandard(boutonAppuye);
        break;
      case ECRAN_MENU_PMP :
        gererBoutonsEcranMenuPMP(boutonAppuye);
        break;
      case ECRAN_DOSAGE :
        gererBoutonsEcranDosage(boutonAppuye);
        break;
      case ECRAN_ETALONNAGE :
        gererBoutonsEcranEtalonnage(boutonAppuye);
        break;
      case ECRAN_DEBIT :
        gererBoutonsEcranDebit(boutonAppuye);
        break;
      case ECRAN_MENU :
        gererBoutonsEcranMenu(boutonAppuye);
        break;
      case ECRAN_SYSTEME :
        gererBoutonsEcranSysteme(boutonAppuye);
        break;
      case ECRAN_LOG :
        gererBoutonsEcranLog(boutonAppuye);
        break;
    }

    chrono = millis();

    //Gestion des r�p�titions (bouton PLUS ou MOINS maintenu enfonc�)
    if ((boutonAppuye != BOUTON_VALID) && (ecran_affiche != ECRAN_ETALONNAGE))
    {
      //comptage du nombre de r�p�titions
      if (boutonAppuye == bouton_repete)
      {
        if (repetition < 255) repetition++;
      }
      else
      {
        repetition = 0;
        bouton_repete = boutonAppuye;
      }
      //Calcul du d�lai entre r�p�titions
      //Cadence progressive
      delai_repetition = 1000;
      if (repetition > 1) delai_repetition = 500;
      if (repetition > 9) delai_repetition = 250;
      if (repetition > 25) delai_repetition = 100;
      //Attendre que le bouton soit rel�ch� ou que le d�lai soit expir�
      while ((digitalRead(boutonAppuye)==LOW) && ((millis() - chrono) < delai_repetition))
      {
        delay(1);
      }
      //Si bouton rel�ch� : raz r�p�tition + anti-rebond
      if (digitalRead(boutonAppuye)==HIGH)
      {
        bouton_repete = 0;
        delay(delai_anti_rebond);
      }
    }
    else
    {
    //Attendre le rel�chement complet des boutons poussoirs
      while ((digitalRead(BOUTON_PLUS)==LOW) || (digitalRead(BOUTON_MOINS)==LOW) || (digitalRead(BOUTON_VALID)==LOW))
      {
        delay(1);
      }
      bouton_repete = 0;
      delay(delai_anti_rebond);
    }
  }
  else
  {
    repetition = 0;
    bouton_repete = 0;
    if (reglage_en_cours && ((millis() - chrono) > 120000))
    {
    //au bout de deux minutes � attendre l'appui sur un bouton
    //sortie automatique de la proc�dure de r�glage
    //pour reprise du fonctionnement normal des pompes doseuses
      terminerReglage();
    }
  }
}


//******************************************************************************************
//Gestion des affichages sur �cran LCD
//******************************************************************************************

#define TAILLE_LIGNE 20

void completerLigneBlancs(char ligne[])
{
  uint8_t i;

  i=0;
  while ((i<TAILLE_LIGNE) && ligne[i])
  {
    i++;
  }
  while (i<TAILLE_LIGNE)
  {
    ligne[i++] = ' ';
  }
  ligne[TAILLE_LIGNE] = '\0';
}

void afficherLigneStandard(uint8_t numligne, char ancienne_ligne[], char nouvelle_ligne[])
{
  uint8_t i;
  fixerCurseurLCD(numligne, 0);
  completerLigneBlancs(nouvelle_ligne);
  for (i=0;i<TAILLE_LIGNE;i++)
  {
    afficherCaractereLCD(nouvelle_ligne[i]);
    ancienne_ligne[i] = nouvelle_ligne[i];
  }
  ancienne_ligne[TAILLE_LIGNE] = '\0';
}

void afficherLigneRapide(uint8_t numligne, char ancienne_ligne[], char nouvelle_ligne[])
{
  uint8_t debut, fin, i;
  completerLigneBlancs(nouvelle_ligne);
  debut = 0;
  while ((debut<TAILLE_LIGNE) && (ancienne_ligne[debut] == nouvelle_ligne[debut]))
  {
    debut++;
  }
  if (debut<TAILLE_LIGNE)
  {
    fixerCurseurLCD(numligne, debut);
    for (i=debut; i<TAILLE_LIGNE; i++)
    {
      if (ancienne_ligne[i] != nouvelle_ligne[i]) fin=i;
    }
    for (i=debut; i<=fin; i++)
    {
      afficherCaractereLCD(nouvelle_ligne[i]);
      ancienne_ligne[i] = nouvelle_ligne[i];
    }
    ancienne_ligne[TAILLE_LIGNE] = '\0';
  }
}

char memorisation_ligne1[TAILLE_LIGNE+1];
char memorisation_ligne2[TAILLE_LIGNE+1];
char memorisation_ligne3[TAILLE_LIGNE+1];
char memorisation_ligne4[TAILLE_LIGNE+1];

void initialiserAffichage()
{
  initialiserLCD();
  memorisation_ligne1[0] = '\0';
  memorisation_ligne2[0] = '\0';
  memorisation_ligne3[0] = '\0';
  memorisation_ligne4[0] = '\0';
  completerLigneBlancs(memorisation_ligne1);
  completerLigneBlancs(memorisation_ligne2);
  completerLigneBlancs(memorisation_ligne3);
  completerLigneBlancs(memorisation_ligne4);
}

void afficherLignes(char ligne1[], char ligne2[], char ligne3[], char ligne4[])
{
  if (reglage_en_cours)
  //En mode rapide, on n'envoie au LCD que les caract�res ayant chang� depuis le dernier affichage
  {
    afficherLigneRapide(0, memorisation_ligne1, ligne1);
    afficherLigneRapide(1, memorisation_ligne2, ligne2);
    afficherLigneRapide(2, memorisation_ligne3, ligne3);
    afficherLigneRapide(3, memorisation_ligne4, ligne4);
  }
  else
  //Le mode standard est plus robuste face aux �ventuels parasites �lectriques
  {
    afficherLigneStandard(0, memorisation_ligne1, ligne1);
    afficherLigneStandard(1, memorisation_ligne2, ligne2);
    afficherLigneStandard(2, memorisation_ligne3, ligne3);
    afficherLigneStandard(3, memorisation_ligne4, ligne4);
  }
}

void formaterLigneStandard(char ligne[], char nom[], uint16_t dosage)
{//un peu lourdlingue, mais pas trouv� mieux et aussi robuste
  uint8_t i;
  char c;

  sprintf(ligne, "        %03d ml      ", dosage);

//insertion du nom
  c = ' ';
  for (i=0;i<6;i++)
  {
    if (c)
    {
      c = nom[i];
    }
    if (c)
    {
      ligne[i+1] = c;
    }
    else
    {
      ligne[i+1] = ' ';
    }
  }

//suppression des 0 disgracieux
  for (i=7;i<9;i++)
  {
    if ((ligne[i] == ' ') && (ligne[i+1] == '0'))
    {
      ligne[i+1] = ' ';
    }
  }
}

void afficherEcranStandard()
{
  char ligne1[21];
  char ligne2[21];
  char ligne3[21];
  char ligne4[21];
  uint32_t chrono, delai;

//Affichage de base
  formaterLigneStandard(ligne1, nom_CA, dosage_CA);
  formaterLigneStandard(ligne2, nom_KH, dosage_KH);
  formaterLigneStandard(ligne3, nom_SL, dosage_SL);
  formaterLigneStandard(ligne4, nom_MG, dosage_MG);

//Ajout indication ligne s�lectionn�e
  switch (pompe_selectionnee)
  {
    case pompe_CA :
      ligne1[0] = '>';
      break;
    case pompe_KH :
      ligne2[0] = '>';
      break;
    case pompe_SL :
      ligne3[0] = '>';
      break;
    case pompe_MG :
      ligne4[0] = '>';
      break;
  }

//Ajout prochain d�clenchement si dans moins d'une heure
  if (reglage_en_cours == 0)
  {
    chrono = millis() - chrono_pompes;
    if (chrono < intervalle)
    {
      delai = intervalle - chrono;
      if (delai < 3600000)
      {
        if (delai < 60000)
        {
          delai /= 1000;
          switch (prochaine_pompe_a_declencher)
          {
            case pompe_CA :
              sprintf(&ligne1[15],"%02dsec",delai);
              break;
            case pompe_KH :
              sprintf(&ligne2[15],"%02dsec",delai);
              break;
            case pompe_SL :
              sprintf(&ligne3[15],"%02dsec",delai);
              break;
            case pompe_MG :
              sprintf(&ligne4[15],"%02dsec",delai);
              break;
          }
        }
        else
        {
          delai /= 60000;
          switch (prochaine_pompe_a_declencher)
          {
            case pompe_CA :
              sprintf(&ligne1[15],"%02dmin",delai);
              break;
            case pompe_KH :
              sprintf(&ligne2[15],"%02dmin",delai);
              break;
            case pompe_SL :
              sprintf(&ligne3[15],"%02dmin",delai);
              break;
            case pompe_MG :
              sprintf(&ligne4[15],"%02dmin",delai);
              break;
          }
        }
      }
    }
  }

  afficherLignes(ligne1, ligne2, ligne3, ligne4);
}

void afficherEcranMenuPMP()
{
  char ligne1[21];
  char ligne2[21];
  char ligne3[21];
  char ligne4[21];

//Affichage de base
  switch (pompe_selectionnee)
  {
    case pompe_CA :
      sprintf(ligne1, "    Pompe %s", nom_CA);
      break;
    case pompe_KH :
      sprintf(ligne1, "    Pompe %s", nom_KH);
      break;
    case pompe_SL :
      sprintf(ligne1, "    Pompe %s", nom_SL);
      break;
    case pompe_MG :
      sprintf(ligne1, "    Pompe %s", nom_MG);
      break;
  }
  sprintf(ligne2, "                 ");
  sprintf(ligne3, " Modifier dosage ");
  sprintf(ligne4, " Etalonnage debit");

//Ajout indication ligne s�lectionn�e
  if (ecran_selectionne == ECRAN_DOSAGE)
  {
    ligne3[0] = '>';
  }
  else
  {
    ligne4[0] = '>';
  }

  afficherLignes(ligne1, ligne2, ligne3, ligne4);
}

void afficherEcranMenu()
{
  char ligne1[21];
  char ligne2[21];
  char ligne3[21];
  char ligne4[21];

  sprintf(ligne1,"        Menu");
  ligne2[0] = 0;
  sprintf(ligne3," Systeme");
  sprintf(ligne4," Log");

  if (ecran_selectionne == ECRAN_SYSTEME) ligne3[0] = '>';
  if (ecran_selectionne == ECRAN_LOG) ligne4[0] = '>';

  afficherLignes(ligne1, ligne2, ligne3, ligne4);
}

int freeRam()
{
  extern int __heap_start, *__brkval;
  int v;
  return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
}

void afficherEcranSysteme()
{
  char ligne1[21];
  char ligne2[21];
  char ligne3[21];
  char ligne4[21];

  sprintf(ligne1, "En marche depuis");
  sprintf(ligne2, "%luj %02dh %02dm %02ds", nb_jours, nb_heures, nb_minutes, nb_secondes);
  sprintf(ligne3, "Memoire disponible");
  sprintf(ligne4, "%d octets",freeRam());

  afficherLignes(ligne1, ligne2, ligne3, ligne4);
}

void afficherEcranLog()
{
  char ligne1[21];
  char ligne2[21];
  char ligne3[21];
  char ligne4[21];

  ligne1[0] = 0;
  ligne2[0] = 0;
  ligne3[0] = 0;
  ligne4[0] = 0;

  if (curseur_log < index_log) formaterLog(curseur_log, ligne1);
  if ((curseur_log+1) < index_log) formaterLog(curseur_log+1, ligne2);
  if ((curseur_log+2) < index_log) formaterLog(curseur_log+2, ligne3);
  if ((curseur_log+3) < index_log) formaterLog(curseur_log+3, ligne4);

  if (index_log == 0) sprintf(ligne2, "Log vide");

  afficherLignes(ligne1, ligne2, ligne3, ligne4);
}

void afficherEcranDosage()
{
  char ligne1[21];
  char ligne2[21];
  char ligne3[21];
  char ligne4[21];

//Affichage de base
  switch (pompe_selectionnee)
  {
    case pompe_CA :
      sprintf(ligne1, "Dosage pompe %s", nom_CA);
      sprintf(ligne2, "%d ml par jour", dosage_CA);
      break;
    case pompe_KH :
      sprintf(ligne1, "Dosage pompe %s", nom_KH);
      sprintf(ligne2, "%d ml par jour", dosage_KH);
      break;
    case pompe_SL :
      sprintf(ligne1, "Dosage pompe %s", nom_SL);
      sprintf(ligne2, "%d ml par jour", dosage_SL);
      break;
    case pompe_MG :
      sprintf(ligne1, "Dosage pompe %s", nom_MG);
      sprintf(ligne2, "%d ml par jour", dosage_MG);
      break;
  }
  sprintf(ligne3, "                    ");
  sprintf(ligne4, "Modif : bouton + - V");

  afficherLignes(ligne1, ligne2, ligne3, ligne4);
}

void afficherEcranEtalonnage()
{
  char ligne1[21];
  char ligne2[21];
  char ligne3[21];
  char ligne4[21];

//Affichage de base
  switch (pompe_selectionnee)
  {
    case pompe_CA :
      sprintf(ligne1, "    Pompe %s", nom_CA);
      break;
    case pompe_KH :
      sprintf(ligne1, "    Pompe %s", nom_KH);
      break;
    case pompe_SL :
      sprintf(ligne1, "    Pompe %s", nom_SL);
      break;
    case pompe_MG :
      sprintf(ligne1, "    Pompe %s", nom_MG);
      break;
  }
  sprintf(ligne2, "Etalonnage sur 1 min");
  sprintf(ligne3, "Bouton + : demarrer ");
  sprintf(ligne4, "Bouton - : retour   ");

  afficherLignes(ligne1, ligne2, ligne3, ligne4);
}

void afficherEcranDebit()
{
  char ligne1[21];
  char ligne2[21];
  char ligne3[21];
  char ligne4[21];

//Affichage de base
  switch (pompe_selectionnee)
  {
    case pompe_CA :
      sprintf(ligne1, "Debit pompe %s", nom_CA);
      sprintf(ligne2, "%d,%d ml / minute", debit_pompe_CA / 10, debit_pompe_CA % 10);
      break;
    case pompe_KH :
      sprintf(ligne1, "Debit pompe %s", nom_KH);
      sprintf(ligne2, "%d,%d ml / minute", debit_pompe_KH / 10, debit_pompe_KH % 10);
      break;
    case pompe_SL :
      sprintf(ligne1, "Debit pompe %s", nom_SL);
      sprintf(ligne2, "%d,%d ml / minute", debit_pompe_SL / 10, debit_pompe_SL % 10);
      break;
    case pompe_MG :
      sprintf(ligne1, "Debit pompe %s", nom_MG);
      sprintf(ligne2, "%d,%d ml / minute", debit_pompe_MG / 10, debit_pompe_MG % 10);
      break;
  }
  sprintf(ligne3, "                    ");
  sprintf(ligne4, "Modif : bouton + - V");

  afficherLignes(ligne1, ligne2, ligne3, ligne4);
}

uint8_t evolutionContenuEcran()
{
//Retourne 1 si le contenu de l'�cran doit �tre actualis�
//Retourne 0 sinon
  static uint8_t  premier = 0;
  static uint16_t sdosage_CA, sdosage_KH, sdosage_SL, sdosage_MG;
  static uint16_t sdebit_pompe_CA, sdebit_pompe_KH, sdebit_pompe_SL, sdebit_pompe_MG;
  static uint8_t  spompe_selectionnee, sreglage_en_cours, sprochaine_pompe_a_declencher, secran_affiche, secran_selectionne;
  static uint8_t  schronomin, schronosec, snb_secondes, sindex_log, scurseur_log;
  uint8_t pas_de_difference, chronomin, chronosec;
  uint32_t chrono;

//test sur les variables d'etat
  pas_de_difference = premier;
  pas_de_difference = (pas_de_difference && (sdosage_CA == dosage_CA));
  pas_de_difference = (pas_de_difference && (sdosage_KH == dosage_KH));
  pas_de_difference = (pas_de_difference && (sdosage_SL == dosage_SL));
  pas_de_difference = (pas_de_difference && (sdosage_MG == dosage_MG));
  pas_de_difference = (pas_de_difference && (sdebit_pompe_CA == debit_pompe_CA));
  pas_de_difference = (pas_de_difference && (sdebit_pompe_KH == debit_pompe_KH));
  pas_de_difference = (pas_de_difference && (sdebit_pompe_SL == debit_pompe_SL));
  pas_de_difference = (pas_de_difference && (sdebit_pompe_MG == debit_pompe_MG));
  pas_de_difference = (pas_de_difference && (spompe_selectionnee == pompe_selectionnee));
  pas_de_difference = (pas_de_difference && (sreglage_en_cours == reglage_en_cours));
  pas_de_difference = (pas_de_difference && (sprochaine_pompe_a_declencher == prochaine_pompe_a_declencher));
  pas_de_difference = (pas_de_difference && (secran_affiche == ecran_affiche));
  pas_de_difference = (pas_de_difference && (secran_selectionne == ecran_selectionne));

  chrono = millis() - chrono_pompes;
  if (chrono > intervalle)
  {
    chronomin = 0;
    chronosec = 0;
  }
  else
  {
    chrono = intervalle - chrono;
    if (chrono >= 3600000)
    {
      chronomin = 0;
      chronosec = 0;
    }
    else
    {
      if (chrono >= 60000)
      {
        chronomin = chrono / 60000;
        chronosec = 0;
      }
      else
      {
        chronomin = 0;
        chronosec = chrono / 1000;
      }
    }
  }
  pas_de_difference = (pas_de_difference && (schronomin == chronomin));
  pas_de_difference = (pas_de_difference && (schronosec == chronosec));
  pas_de_difference = (pas_de_difference && (snb_secondes == nb_secondes));
  pas_de_difference = (pas_de_difference && (sindex_log == index_log));
  pas_de_difference = (pas_de_difference && (scurseur_log == curseur_log));

//memorisation pour la prochaine fois
  premier = 1;
  sdosage_CA = dosage_CA;
  sdosage_KH = dosage_KH;
  sdosage_SL = dosage_SL;
  sdosage_MG = dosage_MG;
  sdebit_pompe_CA = debit_pompe_CA;
  sdebit_pompe_KH = debit_pompe_KH;
  sdebit_pompe_SL = debit_pompe_SL;
  sdebit_pompe_MG = debit_pompe_MG;
  spompe_selectionnee = pompe_selectionnee;
  sreglage_en_cours = reglage_en_cours;
  sprochaine_pompe_a_declencher = prochaine_pompe_a_declencher;
  secran_affiche = ecran_affiche;
  secran_selectionne = ecran_selectionne;
  schronomin = chronomin;
  schronosec = chronosec;
  snb_secondes = nb_secondes;
  sindex_log = index_log;
  scurseur_log = curseur_log;

//retour
  if (pas_de_difference)
  {
    return 0;
  }
  else
  {
    return 1;
  }
}


void securiserArretPompes()
{
  static uint32_t chrono = 0;
  uint32_t delai_ms;

  delai_ms = millis() - chrono; //compatible roll over
 
  if (delai_ms > 30000) //toutes les 30 secondes
  {
    motorCA.run(RELEASE);
    motorKH.run(RELEASE);
    motorSL.run(RELEASE);
    motorMG.run(RELEASE);
    chrono = millis();
  }
}


void gererAffichage()
{
  if (evolutionContenuEcran())
  {
    switch (ecran_affiche)
    {
      case ECRAN_STANDARD :
        afficherEcranStandard();
        break;
      case ECRAN_MENU_PMP :
        afficherEcranMenuPMP();
        break;
      case ECRAN_DOSAGE :
        afficherEcranDosage();
        break;
      case ECRAN_ETALONNAGE :
        afficherEcranEtalonnage();
        break;
      case ECRAN_DEBIT :
        afficherEcranDebit();
        break;
      case ECRAN_MENU :
        afficherEcranMenu();
        break;
      case ECRAN_SYSTEME :
        afficherEcranSysteme();
        break;
      case ECRAN_LOG :
        afficherEcranLog();
        break;
    }
  }
}


//******************************************************************************************
//Fonctions principales d'une complexit� folle
//******************************************************************************************

void setup()
{
  lireParametres();
  initialiserLEDs();
  initialiserBoutons();
  initialiserPompes();
  initialiserAffichage();
}

void loop()
{
  actualiserHorloge();
  gererAffichage();
  gererPompes();
  gererBoutons();
  securiserArretPompes();
  delay(1);
}

ca fait 1 semaine que je suis dessus, d essayer de trouver sur le net
toujours le meme probleme
"AF-DCMotor does not name a type"

il faut que tu copie dans ta librairie :
https://github.com/adafruit/Adafruit-Mo ... ld-library