Explication du code

International Français
1

bonjour

je suis a la recherche d explication du code pour le capteur de debit YF-B2

j y ai passé du temps à travers les differents sites qui traitent arduino

volatile int flow_frequency; // Measures flow sensor pulsesunsigned 

int l_hour; // Calculated litres/hour
unsigned char flowsensor = 2; // Sensor Input
unsigned long currentTime;
unsigned long cloopTime;

void flow () // Interrupt function

{
   flow_frequency++;
}

   void setup()
 {
   pinMode(flowsensor, INPUT);
   digitalWrite(flowsensor, HIGH); // Optional Internal Pull-Up
   Serial.begin(9600);
   attachInterrupt(0, flow, RISING); // Setup Interrupt
   sei(); // Enable interrupts
   currentTime = millis();
   cloopTime = currentTime;
}

   void loop ()
{
   currentTime = millis();
   // Every second, calculate and print litres/hour
   if(currentTime >= (cloopTime + 1000))
   {
      cloopTime = currentTime; // Updates cloopTime
      // Pulse frequency (Hz) = 7.5Q, Q is flow rate in L/min.
      l_hour = (flow_frequency * 60 / 7.5); // (Pulse frequency x 60 min) / 7.5Q = flowrate in L/hour
      flow_frequency = 0; // Reset Counter
      Serial.print(l_hour, DEC); // Print litres/hour
      Serial.println(" L/hour");
   }
}

j aimerai savoir à quoi servent les 2 variables currentTime et cloopTime
et pourquoi il y est affirme :

saisissez ou collez du code ici

currentTime = millis();
cloopTime = currentTime;

je vous remercie pour votre attention et le temps que je passerai a y repondre
cdt

2

:warning:
Post mis dans la mauvaise section, on parle anglais dans les forums généraux. déplacé vers le forum francophone.

Merci de prendre en compte les recommandations listées dans Les bonnes pratiques du Forum Francophone

3

Salut!
Alors pour les variables,

  • currentTime stocke le temps écoulé depuis le démarrage du programme en millisecondes. Elle est mise à jour à chaque itération de la loop avec millis().
  • et la variable cloopTime sert de point de référence pour mesurer des intervalles de temps d'une seconde. Elle est mise à jour chaque fois qu'une seconde s'est écoulée.

Dans le code currentTime = millis(); et cloopTime = currentTime; initialise les deux variables avec le même temps de départ. C'est équivalent à

currentTime = cloopTime = millis();

Ensuite, currentTime sera mis à jour à chaque loop, alors que cloopTime ne sera mis à jour que toutes les secondes.

Ton code n'étant pas très lisible, je l'ai refais à ma façon, dis moi si c'est plus clair pour toi ?

#define PIN_CAPTEUR_DEBIT 2
#define IMPULSIONS_PAR_LITRE 450.0 // 7,5 impulsions/seconde = 1 L/min, donc en une minute : 7,5 * 60 = 450 impulsions pour 1L.
volatile unsigned long compteurImpulsions = 0;

#define INTERVALLE_AFFICHAGE 1000 // 1 seconde
unsigned long dernierAffichage = 0;

void compterImpulsion()
{
  compteurImpulsions++; // on incrémente le compteur d'impulsion avec ++ (donc +1)
}

void setup()
{
  Serial.begin(115200);
  pinMode(PIN_CAPTEUR_DEBIT, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(PIN_CAPTEUR_DEBIT), compterImpulsion, RISING);
  sei(); // on active les interruptions globalement
}

void loop()
{
  if ((millis() - dernierAffichage) >= INTERVALLE_AFFICHAGE) // à chaque seconde
  {
    // on récupère le nombre d'impulsion et on met le conteur d'impulsion à 0
    noInterrupts();
    unsigned long impulsions = compteurImpulsions;
    compteurImpulsions = 0;
    interrupts();
    // on calcule le débit (pas besoin de variable intermédiaire !)
    float debit = (impulsions * 60.0) / IMPULSIONS_PAR_LITRE; // L/heure
    // on affiche le débit en litre par heure
    Serial.print(debit, 2);
    Serial.println(" L/heure");
    // on affecte la valeur du temps courant à la valeur du temps précédent, pour savoir quand 1 seconde se sera écoulée
    dernierAffichage = millis();
  }
}

Tapé ici, non testé
En gros, on utilise une interruption matérielle pour compter le nombre d'impulsion (avec RISING c'est un front montant - donc quand on passe de 0 à 1 sur la pin) - pour en savoir plus sur les interruptions, un bon article :
https://www.locoduino.org/spip.php?article64

Le capteur YF-B2 envoie des impulsions électriques à chaque passage d'une certaine quantité d'eau. Ces impulsions sont comptées par la fonction d'interruption compterImpulsion(), qui incrémente un compteur.

Toutes les secondes, de manière non bloquante, on regarde le nombre d'impulsions, on remet à 0 le compteur, on calcule de débit, et on l'affiche sur le moniteur série (réglé à 115200 bauds/s, 9600 étant un peu trop lent :wink:). Enfin, on affecte le temps courant à la variable dernierAffichage, pour pouvoir savoir quand 1 seconde se sera écoulé ensuite (pour en savoir plus sur l'utilisation de millis, regarde l'exemple suivant).

Après n'ayant jamais utilisé ce capteur je te dis peut-être n'importe quoi autant sur le code que sur les variables, mais il me semble que c'est ça.

En espérant t'avoir aidé,
Cordialement
Pandaroux007

1 Like
4

En toute rigueur, il faudrait placer cette ligne juste après interrupts()