Discussion :

[legrandse]

Bonjour à tous,

Pourriez-vous svp me dire quelle serait la manière la plus adéquate pour calculer le volume d'eau quotidien consommé par une pompe ?
La pompe en question est gérée par une sonde qui relève l'humidité de celui-ci toutes les x minutes.

Jusque là il n'y a rien de bien compliqué pour moi dans la réalisation sauf que c'est le terme "quotidien" qui me pose problème.
Si dans ma conception actuelle j'additionne un volume x (2,1L) à chaque fois que la pompe fonctionne disons 10x, je me retrouverai avec 21L de consommation.
Cette façon de concevoir ne tiens pas compte du "quotidien" car je ne sais pas comment le définir.
En gros comment dois-je m'y prendre pour réinitialiser le compteur au bout de 24h ?

Est-ce qu'un module RTC est pertinent dans ce cas ? ou autre suggestion ?
PS: ma carte est une MKRFOX1200

Merci pour votre aide

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
const int groundHumidity1Pin = A1;               // Declare humidity ground sensor A1 pin
const int waterRelayPin = 0;                         // Initialized a pin for water relay module
 
int setInterval = 2;                                     // default value in minute
int setWatering = 1;                                  // default value in minute
 
float prevWaterVolume = 0.0;                          // Initialize variable for water volume calculation
float waterVolume = 0.0 ;                             // determine water volume consumption
 
unsigned long prevGroundHumidityTime = 0;             // Initialize variable for time calculation
unsigned long groundHumidityInterval = setInterval*60*1000;       // check sensor every x minutes
unsigned long wateringDuration = setWatering*60*1000;              // running water pump during x minutes
 
enum : byte {groundHumidity1, groundHumidity2};  //used for sensor returning data
 
 
int humidityCheck(int param) {
    if (param == groundHumidity1) 
    {
      int analog_value = analogRead(groundHumidity1Pin);
      int moisture = map(analog_value,1023,10,0,100);
 
     return moisture;
 
    }
 
    else return analogRead(groundHumidity2Pin);   // actually not in use
 
}
 
 
 
void watering() {
     if ( millis() - prevGroundHumidityTime >= groundHumidityInterval) {    //check ground humidity sensor every X minutes
         Serial.print(F("Humidity: "));
         Serial.print(humidityCheck(groundHumidity1) );
         Serial.println(F(" %"));
 
         if(humidityCheck(groundHumidity1) <= 40 ) {
             digitalWrite(waterRelayPin, LOW);
             Serial.println(F("Watering..."));
 
             waterVolume = prevWaterVolume + 2.1 ;                  //add 2,1 liter to the counter because of pump limitation per minute
             prevWaterVolume = waterVolume ;                           //refresh variable with new value
 
           Serial.print(F("Water consumption: "));
           Serial.print(prevWaterVolume);
           Serial.println(F("Liter"));
 
             prevWateringTime = millis();                                   //reset the counter
          }
          else  { 
            Serial.println(F("No watering needed..."));
           }
 
       prevGroundHumidityTime = millis();
     }
      if(millis()- prevWateringTime >= wateringDuration){
          digitalWrite(waterRelayPin, HIGH);                          //
          //Serial.println("Watering Stop...");
      }         
}

[Jerome Briot]

Il y a déjà un périphérique RTC dans le microcontrôleur de la carte MKR FOX 1200 qui s'utilise avec cette bibliothèque : RTCZero
Pour te familiariser avec le concept, c'est largement suffisant.

Pour aller plus loin, il faudrait que tu estimes la précision du timing souhaitée, la dérive acceptable de la RTC et la manière avec laquelle tu comptes mettre à jour l'heure de la RTC par rapport à une référence externe (manuelle, Wifi…)

[legrandse]

Merci pour l'info.

Je vais creuser l'idée. Les exemples de la lib sont faciles à comprendre.
L'idéal serait de mettre l'heure à jour en liaison bluetooth.

Par contre il faudra prévoir une pile en cas de panne de courant.
Heureusement la MKRFOX1200 dispose de tout ce qu'il faut pour gérer cela

[Guesset]

Bonjour,

La précision de la RTC sert à garantir que la mesure est de minuit à minuit. Si cela n'est pas fondamental et qu'une tranche de 24h peut être légèrement glissante, alors la mise à jour peut être manuelle et assez sporadique.

En revanche, qu'en est il d'une activation de la pompe au moment de la journalisation ?

Il est vraisemblable qu'une variable volume VolSum est incrémentée en fin d'activation de la pompe. Avec un peu de malchance, la dernière activation peut être comptée sur un jour ou le suivant ce qui induit un battement possible de 10% (si environ 10 activations par jour). Pour amoindrir cela, on peut noter le début d'activation de la pompe et si la journalisation arrive alors que la pompe est active, attendre la fin d'activation et faire un prorata temporis : V = Vol*(T_log - T_start)/(T_end - T_start); VolSum[jour] += V; VolSum[++jour] = Vol - V;

Tout dépend de la précision recherchée.

Salutations