Comptabiliser et afficher sur écran LCD un volume et allumer des led

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
  }
}

merci par avance

Bonjour danielderedon

Qu'est ce qui te déplait dans ton programme?

Cordialement
jpbbricole

Bonjour ce qui me dérange c'est que les led ne s'allume pas à la bonne valeur

Bonjour danielderedon

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:

	etat_bouton = digitalRead(consommation*0.00222);  //Rappel:bouton = 2 rouge`
	if ((etat_bouton != consommation*0.00222) && (etat_bouton == LOW))`

que voulais tu faire ?
Si la fonction de tout ça est d'afficher des LED en fonction de la consommation, on peut faire plus simple :wink:

Cordialement
jpbbricole

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
  }

donc voila mon nouveau code:




//2 litre led_4 rouge
    if (consommation  < 2 && consommation < 1) {
      
       digitalWrite(led_4, LOW); // 1 litre Allumme
       digitalWrite(led_3, HIGH); //eteint
       digitalWrite(led_2, HIGH);  //eteint
       digitalWrite(led_1, HIGH);  //eteint     
 
    }
// 6 litre led_2 vert
    else if (consommation  >= 2.5 && consommation < 6) {
 
       digitalWrite(led_4, LOW );  //Allummer 
       digitalWrite(led_3, LOW); // 6 litre Allumme
       digitalWrite(led_2, HIGH); //eteint
       digitalWrite(led_1, HIGH); //eteint      
    }
//9 litre led_3 bleu
    else if (consommation  >= 8.5 && consommation < 9) {
        
       digitalWrite(led_4, LOW);  //Allummer 
       digitalWrite(led_3, LOW); //Allummer 
       digitalWrite(led_2, LOW); // 9 litre Allumme
       digitalWrite(led_1, HIGH); //eteint      

    }

//12 litre, led_1 jaune
    else {

       digitalWrite(led_4,LOW );  //Allummer 
       digitalWrite(led_3, LOW); //Allummer 
       digitalWrite(led_2, LOW); //Allummer
       digitalWrite(led_1, LOW);  // 12 litre Allumme
    }

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

bien cordialement
Danielderedon

Poste un code complet pas des morceaux.
Avec quelques lignes sorties de leur contexte on ne peut pas comprendre ce qu'il se passe.

Bonjour danielderedon

En effet, c'est le calcul de nombre_led qui pose problème. La fonction void affiche(int valeur_recue) que tu as réécrite fonctionnait très bien avant.

Tu n'as pas tenu compte de mes remarques du post #4

A+
Cordialement
jpbbricole

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
  }
}

cordialement danielderedon

Bonsoir danielderedon

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
	}

A+
Cordialement
jpbbricole

Qu'est-ce que ça fait digitalRead() selon toi?

Bonjour fdufnews

pour moi digitalRead() lit la valeur qui est afficher sur l'écran LCD.
Désoler pour mon incompétence .

Danielderedon

Regardes ici :wink:

Cordialement
jpbbricole

Voici la documentation de la fonction.

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.

Bonjour

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

merci monsieur
daniederedon

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
  }
}

cordialement

daniederedon

Tu utilise une variable de type double au lieu de int

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

daniederedon

Bonjour danielderedon

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.

A+
Cordialement
jpbbricole

Bonjour
ok pas de problème voilà mon programme

```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

bon noël a vous

daniederedon

Bonsoir danielderedon

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
	}
}

La méthode peut toujours servir plus tard :wink:

Joyeux Noël
Cordialement
jpbbricole