Bonjour je vous expliquer mon projet
il s’agit de comptabiliser un volume d’essence avec un capteur à effet Hall YF-S201
d’afficher le volume sur un écran LCD et de pouvoir allumer 4 LED sur différent niveau .
J’ai déjà un bout de programme mais je ne suis pas satisfait de son fonctionnement c’est pourquoi je fais appel a vos connaissance pour m’expliquer ce qui ne va pas et améliorer les résultat.
Je suis bien conscient que le capteurs n’est pas le bon mais pour faire mes essaie c’est celui qui me coûtais le mois chère .
je vous joint mon programme:
```cpp
//.......nouveau programme qui mixe debit ecran et 4 led et bouton marche ok.......//
#include "LiquidCrystal.h" // ajout de la librairie
LiquidCrystal lcd(11, 10, 9, 8, 7, 6); // liaison 4 bits de données
const int led_4 = 3; //la LED Rouge à la broche 3
const int led_3 = 4; //la LED Bleu à la broche 4
const int led_2 = 5; //la LED Vert à la broche 5
const int led_1 = 13; //la LED Jaune à la broche 13
const int broche_debit = 2; // connection debitmetre
// Vérifiez les broches !
int nombre_led = 0; // varaible des leds
int etat_bouton; // variable qui enregistre l'état du bouton
/*declaration des variables utiliser pour le comptage */
volatile int compteurImpulsions;
int consommation = 0;
float debit;
volatile boolean mesureNouvelle = false;
unsigned long mesureMillis = millis(); // Mesure de la période
volatile unsigned long mesureChrono = millis; // Chronomètre
void ISRImpulsions() {
compteurImpulsions++;
mesureMillis = millis() - mesureChrono; // Mesure de la periode
mesureChrono = millis();
mesureNouvelle = true;
}
void setup() {
pinMode(broche_debit, INPUT); // Utilise la résistance de 1'Arduino
attachInterrupt(digitalPinToInterrupt(broche_debit), ISRImpulsions, RISING); // passe de LOW a HIGH = RISING
// prepare l'affichage sur l'ecran de l'ordinateur.
Serial.begin(2000000);
// prepare l'ecran LCD
lcd.begin(16, 2); // règle la taille du LCD 16 colonnes x 2 lignes
lcd.setCursor(0, 0); // affiche le curseur
// Test de l'afficheur LCD
lcd.clear(); // efface LCD
lcd.print("LCD OK"); // affiche texte
delay(1000); //pause
lcd.clear(); // efface LCD
//position les LED
pinMode(led_4, OUTPUT); //la led Rouge est une sortie
pinMode(led_3, OUTPUT); //la led Bleu est une sortie
pinMode(led_2, OUTPUT); //la led Vert est une sortie
pinMode(led_1, OUTPUT); //la led Jaune est une sortie
}
void loop() {
// Affiche sur l'ecran de l'ordinateur.
if (mesureNouvelle) {
("Nouvelle mesure : " + String((float)mesureMillis / 1000) + " secondes");
int comptage = compteurImpulsions;
compteurImpulsions = 0 ;
consommation += comptage;
Serial.print("consommation = ");
Serial.print(consommation*0.00222);
Serial.println(" L ");
float volume = comptage *0.00222;
float periodePulse = (float)mesureMillis / 1000;
debit = (0.00222 * volume) / periodePulse;
Serial.print("Debit = ");
Serial.print(debit, 1);
Serial.println(" L/min");
Serial.println();
mesureNouvelle = false;
}
// Affiche sur l'ecran LCD
lcd.print("conso = ");
lcd.print(consommation*0.00222);
lcd.println("L ");
lcd.setCursor(0, 1);
lcd.print("Debit= ");
lcd.print(debit, 1);
lcd.println("L/min ");
lcd.clear();
etat_bouton = digitalRead(consommation*0.00222); //Rappel:bouton = 2 rouge
//si le bouton a un etat different de celui enregistre et que cet etat est appuyer
if ((etat_bouton != consommation*0.00222) && (etat_bouton == LOW))
//test si le bouton a un niveau logique Haut
{
nombre_led++; // on incremente la variable qui inque combien de LED devrons s'allumer
}
// on applique des limites au nombre pour ne pas dépasser 12 ou 0
if (nombre_led > 12) {
nombre_led = 12;
}
if (nombre_led < 0) {
nombre_led = 0;
}
// appel de la fonction affiche() que l'on aura créée
// on lui passe en paramètre la valeur du nombre de LED à éclairer
affiche(nombre_led);
}
void affiche(int valeur_recue) {
// on éteint toutes les led
digitalWrite(led_4, HIGH); //rouge
digitalWrite(led_3, HIGH); //bleu
digitalWrite(led_2, HIGH); //vert
digitalWrite(led_1, HIGH); //jaune
// Puis on les allume une à une
if (valeur_recue >= 1) // 1 littre
{
digitalWrite(led_4, LOW); //rouge
}
if (valeur_recue >= 6) // 6 littre
{
digitalWrite(led_3, LOW); //bleu
}
if (valeur_recue >= 9) // 9 littre
{
digitalWrite(led_2, LOW); //vert
}
if (valeur_recue >= 12) // 12 littre
{
digitalWrite(led_1, LOW); //jaune
}
}
L'affichage des LED fonctionne très bien, c'est le traitement du bouton qui pose problème.
Ce bouton est connecté où, certainement pas sur cette broche:
Bonjour merci pour la réponse
il est vrai que j'ai du mal avec la programmation je débute vraiment mais j'essaie de m'informer sur le net en essayant de comprendre ce que je fait .
donc mon but c'est de compter le nombre de litre consommer en affichant la valeur sur le LCD et en même temps allumer des led avec différent litrage
j'ai donc compiler un bout de code en lieu est place de:
etat_bouton = digitalRead(consommation * 0.0045); //Rappel:bouton = 2 rouge
//si le bouton a un etat different de celui enregistre et que cet etat est appuyer
if ((etat_bouton != consommation * 0.0045) && (etat_bouton == LOW))
//test si le bouton a un niveau logique Haut
{
nombre_led++; // on incremente la variable qui inque combien de LED devrons s'allumer
}
// on applique des limites au nombre pour ne pas dépasser 4 ou 0
if (nombre_led > 12) {
nombre_led = 4;
}
if (nombre_led < 0) {
nombre_led = 0;
}
// appel de la fonction affiche() que l'on aura créée
// on lui passe en paramètre la valeur du nombre de LED à éclairer
affiche(nombre_led);
}
void affiche(int valeur_recue) {
// on éteint toutes les led
digitalWrite(led_4, HIGH); //rouge
digitalWrite(led_3, HIGH); //bleu
digitalWrite(led_2, HIGH); //vert
digitalWrite(led_1, HIGH); //jaune
// Puis on les allume une à une
if (valeur_recue >= 1) // 1 littre
{
digitalWrite(led_4, LOW); //rouge
}
if (valeur_recue >= 6) // 6 littre
{
digitalWrite(led_3, LOW); //bleu
}
if (valeur_recue >= 9) //9 litre
{
digitalWrite(led_2, LOW); //vert
}
if (valeur_recue >= 12) //12 litre
{
digitalWrite(led_1, LOW); //jaune
}
mais le problème maintenant est que la led rouge s'allume directement et dès que je fait tourne la turbine se met en marche toute les led s'allume .
je pense que je ne récupère pas la bonne infos pour allumer les led
Re je viens de refaire de récrire le code en remplacent " etat_bouton " par " nombre_led"
ce qui me donne
"nombre_led = digitalRead(consommation * 0.00222); //Rappel:bouton = 2 rouge
//si le bouton a un etat different de celui enregistre et que cet etat est appuyer
if ((nombre_led != consommation * 0.00222) && (nombre_led == LOW))"
j'ai aussi modifier le nombre de led en les mettants à 4
Mais le problème ces que quand j'envoie le code sur l'Arduino aussitôt la led rouge s'allume mais les autres ne s'allume plus
voila le nouveau code
//.......nouveau programme qui mixe debit ecran et 4 led ......//
#include "LiquidCrystal.h" // ajout de la librairie
LiquidCrystal lcd(11, 10, 9, 8, 7, 6); // liaison 4 bits de données
const int led_4 = 3; //la LED Rouge à la broche 3
const int led_3 = 4; //la LED Bleu à la broche 4
const int led_2 = 5; //la LED Vert à la broche 5
const int led_1 = 13; //la LED Jaune à la broche 13
const int broche_debit = 2; // connection debitmetre
// Vérifiez les broches !
int nombre_led = 0; // varaible des leds
int etat_bouton; // variable qui enregistre l'état du bouton
/*declaration des variables utiliser pour le comptage */
volatile int compteurImpulsions;
int consommation = 0;
float debit;
volatile boolean mesureNouvelle = false;
unsigned long mesureMillis = millis(); // Mesure de la période
volatile unsigned long mesureChrono = millis; // Chronomètre
void ISRImpulsions() {
compteurImpulsions++;
mesureMillis = millis() - mesureChrono; // Mesure de la periode
mesureChrono = millis();
mesureNouvelle = true;
}
void setup() {
pinMode(broche_debit, INPUT_PULLUP); // Utilise la résistance de 1'Arduino
attachInterrupt(digitalPinToInterrupt(broche_debit), ISRImpulsions, RISING); // passe de LOW a HIGH = RISING
// prepare l'affichage sur l'ecran de l'ordinateur.
Serial.begin(2000000);
// prepare l'ecran LCD
lcd.begin(16, 2); // règle la taille du LCD 16 colonnes x 2 lignes
lcd.setCursor(0, 0); // affiche le curseur
// Test de l'afficheur LCD
lcd.clear(); // efface LCD
lcd.print("LCD OK"); // affiche texte
delay(1000); //pause
lcd.clear(); // efface LCD
//position les LED
pinMode(led_4, OUTPUT); //la led Rouge est une sortie
pinMode(led_3, OUTPUT); //la led Bleu est une sortie
pinMode(led_2, OUTPUT); //la led Vert est une sortie
pinMode(led_1, OUTPUT); //la led Jaune est une sortie
}
void loop() {
// Affiche sur l'ecran de l'ordinateur.
if (mesureNouvelle) {
("Nouvelle mesure : " + String((float)mesureMillis / 1000) + " secondes");
int comptage = compteurImpulsions;
compteurImpulsions = 0;
consommation += comptage;
Serial.print("consommation = ");
Serial.print(consommation * 0.00222);
Serial.println(" L ");
float volume = comptage * 1;
float periodePulse = (float)mesureMillis / 1000;
debit = (0.6 * volume) / periodePulse;
Serial.print("Debit = ");
Serial.print(debit, 1);
Serial.println(" L/min");
Serial.println();
mesureNouvelle = false;
}
// Affiche sur l'ecran LCD
lcd.print("conso = ");
lcd.print(consommation * 0.00222);
lcd.println("L ");
lcd.setCursor(0, 1);
lcd.print("Debit= ");
lcd.print(debit, 1);
lcd.println("L/min ");
lcd.clear();
nombre_led = digitalRead(consommation * 0.00222); //Rappel:bouton = 2 rouge
//si le bouton a un etat different de celui enregistre et que cet etat est appuyer
if ((nombre_led != consommation * 0.00222) && (nombre_led == LOW))
//test si le bouton a un niveau logique Haut
{
nombre_led++; // on incremente la variable qui inque combien de LED devrons s'allumer
}
// on applique des limites au nombre pour ne pas dépasser 12 ou 0
if (nombre_led > 4) {
nombre_led = 4;
}
if (nombre_led < 0) {
nombre_led = 0;
}
// appel de la fonction affiche() que l'on aura créée
// on lui passe en paramètre la valeur du nombre de LED à éclairer
affiche(nombre_led);
}
void affiche(int valeur_recue) {
// on éteint toutes les led
digitalWrite(led_4, HIGH); //rouge
digitalWrite(led_3, HIGH); //bleu
digitalWrite(led_2, HIGH); //vert
digitalWrite(led_1, HIGH); //jaune
// Puis on les allume une à une
if (valeur_recue >= 1) // 1 litre
{
digitalWrite(led_4, LOW); //rouge
}
if (valeur_recue >= 6) // 6 litre
{
digitalWrite(led_3, LOW); //bleu
}
if (valeur_recue >= 9) // 9 litre
{
digitalWrite(led_2, LOW); //vert
}
if (valeur_recue >= 12) // 12 litre
{
digitalWrite(led_1, LOW); //jaune
}
}
Parce que tu n'a toujours pas corrigé cette partie:
nombre_led = digitalRead(consommation * 0.00222); //Rappel:bouton = 2 rouge
//si le bouton a un etat different de celui enregistre et que cet etat est appuyer
if ((nombre_led != consommation * 0.00222) && (nombre_led == LOW))
//test si le bouton a un niveau logique Haut
{
nombre_led++; // on incremente la variable qui inque combien de LED devrons s'allumer
}
En fait ce n'est pas trop un problème d'ignorance, mais plutôt de regarder si la fonction correspond à ce que tu veux faire.
Si la fonction lit ce qui est affiché sur l'écran LCD, comment le fait-elle et pourquoi lui donne tu la valeur que tu fais afficher à ton LCD?
Et surtout en quoi la consommation * 0.00222 tu donnera le nombre de LED(nombre_led)
De même si tu lis la valeur consommation * 0.00222, pourquoi teste tu l'égalité avec cette valeur juste en dessous?
Et encore pourquoi t'attends tu que le nombre de LED soit égale à la valeur logique LOW(0)
Je pense qu'il faudrait que tu regarde le site de Eskimon, qui te formera à la création de programme pour Arduino.
je vous remercie pour toute l'aide que vous m'avez apporter pour résoudre ce problème .
merci à toi fdufnews pour la question sur que fais digitalRead .
puis merci à toi jpbricole pour tout les conseil et le lien en fin ou l'info est très clair .
et merci à toi terwal pour les petites questions qui restait en suspend .
j'ai donc réussis a faire mon code il fonctionne avec le matériel de base que j'ai sous la main.
Encore quel heure de travail car il y a encore des modification dans le code du style un bouton pour remettre le compteur a zéro ,
passer la communication sur un écran plus grand avec I2C ,
peux être autre chose encore .
cordialement
Bonsoir
J'ai découvert un nouveau problème
j'aurai voulus allumer les différentes led avec des valeur en décimales style tout les 0,15litre et pas tous les litres.
voila mon code
```cpp
//.......Programme qui mixe debit ecran et 4 led OK .......//
//.........programme qui fonctionne tres bien ............//
#include "LiquidCrystal.h" // ajout de la librairie
LiquidCrystal lcd(11, 10, 9, 8, 7, 6); // liaison 4 bits de données
const int led_4 = 4; //la LED Jaune à la broche 4
const int led_3 = 5; //la LED Vert à la broche 5
const int led_2 = 12; //la LED Bleu à la broche 12
const int led_1 = 13; //la LED Rouge à la broche 13
const int broche_debit = 2; // connection debitmetre
// Vérifiez les broches !
int nombre_led = 0; // varaible des leds
//int etat_bouton; // variable qui enregistre l'état du bouton
/*declaration des variables utiliser pour le comptage */
volatile int compteurImpulsions;
int consommation = 0;
float debit;
volatile boolean mesureNouvelle = false;
unsigned long mesureMillis = millis(); // Mesure de la période
volatile unsigned long mesureChrono = millis; // Chronomètre
int litre_cos;// varible pour compter
void ISRImpulsions() {
compteurImpulsions++;
mesureMillis = millis() - mesureChrono; // Mesure de la periode
mesureChrono = millis();
mesureNouvelle = true;
}
void setup() {
pinMode(broche_debit, INPUT_PULLUP);
// Utilise la résistance de 1'Arduino
// passe de LOW a HIGH = RISING
attachInterrupt(digitalPinToInterrupt(broche_debit), ISRImpulsions, RISING);
//position les LED
pinMode(led_4, OUTPUT); //la led Jaune est une sortie
pinMode(led_3, OUTPUT); //la led Vert est une sortie
pinMode(led_2, OUTPUT); //la led Bleu est une sortie
pinMode(led_1, OUTPUT); //la led Rouge est une sortie
// prepare l'affichage sur l'ecran de l'ordinateur.
Serial.begin(2000000);
// prepare l'ecran LCD
lcd.begin(16, 2); // règle la taille du LCD 16 colonnes x 2 lignes
lcd.setCursor(0, 0); // affiche le curseur
// Test de l'afficheur LCD
lcd.clear(); // efface LCD
lcd.print("LCD OK"); // affiche texte
delay(1000); //pause
lcd.clear(); // efface LCD
}
void loop() {
// Affiche sur l'ecran de l'ordinateur.
if (mesureNouvelle) {
("Nouvelle mesure : " + String((float)mesureMillis / 1000) + " secondes");
int comptage = compteurImpulsions;
compteurImpulsions = 0;
consommation += comptage;
Serial.print("consommation = ");
Serial.print(consommation * 0.00222, 2);
Serial.println(" L ");
float volume = comptage * 1;
float periodePulse = (float)mesureMillis / 1000;
debit = (0.6 * volume) / periodePulse;
float litre_cos = consommation * 0.00222; //nouvelle modif
Serial.print("Debit = ");
Serial.print(debit, 2);
Serial.println(" L/min");
Serial.println();
mesureNouvelle = false;
}
// Affiche sur l'ecran LCD
lcd.print("conso = ");
lcd.print(consommation * 0.00222, 2);
lcd.println("L ");
lcd.setCursor(0, 1);
lcd.print("Debit= ");
lcd.print(debit, 2);
lcd.println("L/min ");
lcd.clear();
nombre_led = (consommation * 0.00222);
// on lui passe en paramètre la valeur du nombre de LED à éclairer
// appel de la fonction affiche() que l'on aura créée
affiche(nombre_led);
}
void affiche(int valeur_recue) {
// on éteint toutes les led
digitalWrite(led_4, HIGH); //jaune
digitalWrite(led_3, HIGH); //vert
digitalWrite(led_2, HIGH); //bleu
digitalWrite(led_1, HIGH); //rouge
// Puis on les allume une à une
if (valeur_recue >= 1) // 1 litre ici je voudrais avoir 0,5L environ
{
digitalWrite(led_4, LOW); //jaune
}
if (valeur_recue >= 6) // 6 litre ici je voudrais avoir 5,5L environ
{
digitalWrite(led_3, LOW); //vert
}
if (valeur_recue >= 9) // 9 litre ici je voudrais avoir 8,5L environ
{
digitalWrite(led_2, LOW); //bleu
}
if (valeur_recue >= 11) // 12 litre ici je voudrais avoir 11,5L environ
{
digitalWrite(led_1, LOW); //rouge
}
}
Bonjour
merci pour les infos j'ai réussis grasse a vos conseil.
Le code très fonctionne bien avec une grand précision.
bien qu'il y a encore une petite chose qui me chagrine
c'est au niveau de l'affichage du débit sur l'écran LCD qui clignote
mais je verrais ça avec le nouveau écran
chaque chose en son temps .
merci
bon noël a vous
Ce n'est pas une affaire d'écran, mais de programme, l'affichage sur l'écran LCD se fait, inutilement, en permanence, dans loop(). Il faut mettre à jour toutes les secondes, ça suffit.
Si tu mets ton programme en ligne, je t'indiquerai comment faire.
```cpp
//.......programme lecture debit qui mixe debit ecran et 4 led .......//
#include "LiquidCrystal.h" // ajout de la librairie
LiquidCrystal lcd(11, 10, 9, 8, 7, 6); // liaison 4 bits de données
const int led_4 = 4; //la LED Jaune à la broche 4
const int led_3 = 5; //la LED Vert à la broche 5
const int led_2 = 12; //la LED Bleu à la broche 12
const int led_1 = 13; //la LED Rouge à la broche 13
//const int etat_bouton = 12; //bouton de remise zero
const int broche_debit = 2; // connection debitmetre
// Vérifiez les broches !
/*declaration des variables utiliser pour le comptage */
double nombre_led = 0; // varaible des leds
volatile int compteurImpulsions;
int consommation = 0;
float debit;
volatile boolean mesureNouvelle = false;
unsigned long mesureMillis = millis(); // Mesure de la période
volatile unsigned long mesureChrono = millis; // Chronomètre
void ISRImpulsions() {
compteurImpulsions++;
mesureMillis = millis() - mesureChrono; // Mesure de la periode
mesureChrono = millis();
mesureNouvelle = true;
}
void setup() {
pinMode(broche_debit, INPUT_PULLUP);
// Utilise la résistance de l'Arduino
attachInterrupt(digitalPinToInterrupt(broche_debit), ISRImpulsions, RISING);
// passe de LOW a HIGH = RISING
//position les LED
pinMode(led_4, OUTPUT); //la led Jaune est une sortie
pinMode(led_3, OUTPUT); //la led Vert est une sortie
pinMode(led_2, OUTPUT); //la led Bleu est une sortie
pinMode(led_1, OUTPUT); //la led Rouge est une sortie
Serial.begin(2000000);// prepare l'affichage sur l'ecran de l'ordinateur.
// prepare l'ecran LCD
lcd.begin(16, 2); // règle la taille du LCD 16 colonnes x 2 lignes
// Test de l'afficheur LCD
lcd.clear(); // efface LCD
lcd.print("LCD OK"); // affiche texte
delay(1000); //pause
lcd.clear(); // efface LCD
}
void loop() {
if (mesureNouvelle) {
("Nouvelle mesure : " + String((float)mesureMillis / 1000) + " secondes");
int comptage = compteurImpulsions;
compteurImpulsions = 0;
consommation += comptage;
float volume = comptage * 1;
float periodePulse = (float)mesureMillis / 1000;
debit = (0.6 * volume) / periodePulse;
// Affiche sur l'ecran de l'ordinateur.
Serial.print("consommation = ");
Serial.print(consommation * 0.00222);
Serial.println(" L ");
Serial.print("Debit = ");
Serial.print(debit, 1);
Serial.println(" L/min");
Serial.println();
mesureNouvelle = false;
}
// Affiche sur l'ecran LCD
lcd.print("conso = ");
lcd.print(consommation * 0.00222);
lcd.println("L ");
lcd.setCursor(0, 1);
lcd.print("Debit= ");
lcd.print(debit, 1);
lcd.println("L/min ");
lcd.clear();
// appel de la fonction affiche
nombre_led = (consommation * 0.00222);
// on lui passe en paramètre la valeur du nombre de LED à éclairer
affiche(nombre_led);
}
void affiche(double valeur_recue) {
// on éteint toutes les led
digitalWrite(led_4, HIGH); //jaune
digitalWrite(led_3, HIGH); //vert
digitalWrite(led_2, HIGH); //bleu
digitalWrite(led_1, HIGH); //rouge
// Puis on les allume une à une
if (valeur_recue >= 0.567) // 0.557 litre
{
digitalWrite(led_4, LOW); //jaune
}
if (valeur_recue >= 3.87) // 3.87 litre
{
digitalWrite(led_3, LOW); //vert
}
if (valeur_recue >= 8.75) // 8.75 litre
{
digitalWrite(led_2, LOW); //bleu
}
if (valeur_recue >= 11.85) // 11.85 litre
{
digitalWrite(led_1, LOW); //rouge
}
}
``
Mais comme je le disais je vais changer d'écran pour en mettre un plus grand pour le montage final car il faut qu'il soit lisible a une distance d'environ 50/70cm dans un véhicule en roulage sans perturber le pilote.
Bon après ça beau être un véhicule de course maxi 90cv, les pointes de vitesse ne doivent pas dépasser les 90km/h environ au bout de ligne droite .
Merci encore pour tout
Cordialement
Voilà une façon de faire, la temporisation se fait avec les millis(), ça a l'avantage de ne pas âtre bloquant.
//.......programme lecture debit qui mixe debit ecran et 4 led .......//
#include "LiquidCrystal.h" // ajout de la librairie
LiquidCrystal lcd(11, 10, 9, 8, 7, 6); // liaison 4 bits de données
const int led_4 = 4; //la LED Jaune à la broche 4
const int led_3 = 5; //la LED Vert à la broche 5
const int led_2 = 12; //la LED Bleu à la broche 12
const int led_1 = 13; //la LED Rouge à la broche 13
//const int etat_bouton = 12; //bouton de remise zero
const int broche_debit = 2; // connection debitmetre
// Vérifiez les broches !
/*declaration des variables utiliser pour le comptage */
double nombre_led = 0; // varaible des leds
volatile int compteurImpulsions;
int consommation = 0;
float debit;
volatile boolean mesureNouvelle = false;
unsigned long mesureMillis = millis(); // Mesure de la période
volatile unsigned long mesureChrono = millis; // Chronomètre
unsigned long lcdAffichageTempo = 1000; // Toutes les secondes
unsigned long lcdAffichageMillis = millis(); // Chronô
void ISRImpulsions() {
compteurImpulsions++;
mesureMillis = millis() - mesureChrono; // Mesure de la periode
mesureChrono = millis();
mesureNouvelle = true;
}
void setup() {
pinMode(broche_debit, INPUT_PULLUP);
// Utilise la résistance de l'Arduino
attachInterrupt(digitalPinToInterrupt(broche_debit), ISRImpulsions, RISING);
// passe de LOW a HIGH = RISING
//position les LED
pinMode(led_4, OUTPUT); //la led Jaune est une sortie
pinMode(led_3, OUTPUT); //la led Vert est une sortie
pinMode(led_2, OUTPUT); //la led Bleu est une sortie
pinMode(led_1, OUTPUT); //la led Rouge est une sortie
Serial.begin(2000000);// prepare l'affichage sur l'ecran de l'ordinateur.
// prepare l'ecran LCD
lcd.begin(16, 2); // règle la taille du LCD 16 colonnes x 2 lignes
// Test de l'afficheur LCD
lcd.clear(); // efface LCD
lcd.print("LCD OK"); // affiche texte
delay(1000); //pause
lcd.clear(); // efface LCD
}
void loop() {
if (mesureNouvelle) {
("Nouvelle mesure : " + String((float)mesureMillis / 1000) + " secondes");
int comptage = compteurImpulsions;
compteurImpulsions = 0;
consommation += comptage;
float volume = comptage * 1;
float periodePulse = (float)mesureMillis / 1000;
debit = (0.6 * volume) / periodePulse;
// Affiche sur l'ecran de l'ordinateur.
Serial.print("consommation = ");
Serial.print(consommation * 0.00222);
Serial.println(" L ");
Serial.print("Debit = ");
Serial.print(debit, 1);
Serial.println(" L/min");
Serial.println();
mesureNouvelle = false;
}
// Affiche sur l'ecran LCD
if (millis() - lcdAffichageMillis >= lcdAffichageTempo)
{
lcd.setCursor(0, 0);
lcd.print("conso = ");
lcd.print(consommation * 0.00222);
lcd.print("L ");
lcd.setCursor(0, 1);
lcd.print("Debit= ");
lcd.print(debit, 1);
lcd.print("L/min ");
lcdAffichageMillis = millis(); // Redémarrage chrono
}
// appel de la fonction affiche
nombre_led = (consommation * 0.00222);
// on lui passe en paramètre la valeur du nombre de LED à éclairer
affiche(nombre_led);
}
void affiche(double valeur_recue) {
// on éteint toutes les led
digitalWrite(led_4, HIGH); //jaune
digitalWrite(led_3, HIGH); //vert
digitalWrite(led_2, HIGH); //bleu
digitalWrite(led_1, HIGH); //rouge
// Puis on les allume une à une
if (valeur_recue >= 0.567) // 0.557 litre
{
digitalWrite(led_4, LOW); //jaune
}
if (valeur_recue >= 3.87) // 3.87 litre
{
digitalWrite(led_3, LOW); //vert
}
if (valeur_recue >= 8.75) // 8.75 litre
{
digitalWrite(led_2, LOW); //bleu
}
if (valeur_recue >= 11.85) // 11.85 litre
{
digitalWrite(led_1, LOW); //rouge
}
}