forum base sur l aquariophilie marine et recifale.
Afin de profiter de l integralite de notre forum,merci de vous identifier si vous etes deja membre,ou de vous inscrire sur le forum pour partager notre passion.
Merci le staff de recifal-france.
rayan42 a écrit:bjr
ca pour 51 euros je reve ????????????????
http://www.reefshops.com/marine-color-d ... clone.html
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)
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
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 .
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 .
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é
#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);
}
Retourner vers le coin des bricoleurs
Retourner vers Index du forum
Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 22 invités