C’est toujours utile de savoir quel est le niveau de son puit ou de son réservoir. Et puis, il faut bien bien trouver des choses un peu intéressantes à faire avec les Arduino 😉

On va essayer de mener l’expérience sous la forme d’un mini-projet

Etape 1 : Expression de besoin

• Mesurer le niveau d’un réservoir ou d’un puits en mètre et en pourçentage.
• Attention au diamètre du puits peut être variable et même parfois faible (80cm).
• Le projet doit fournir un capteur qui fonctionne de manière isolée (capteur + affichage), mais qui peut s’interfacer à un système domotique via mySensors (il faut tenir compte de l’existant).
• La mesure soit être fiable (+/- 10cm) et mesurer un niveau jusqu’à 10 mètres.

Etape 2 : Possibilités techniques

Pour mesurer un niveau nous avons plusieurs possibilités:

Mesure ultra-son

La plus simple et la moins chère à mettre en œuvre. Le problème est que c’est aussi la moins fiable. En fonction de la forme du puits et notamment de son rapport diamètre profondeur la mesure devient rapidement impossible. Autre problème l’humidité ambiante provoque la corrosion rapide du capteur.

Mesure par capteur de niveau

La solution la plus basique. Ici, on prépare un rail et on place des capteurs à bascule à intervalles réguliers. Mis à part le fait que la détection soit purement mécanique il s’agit d’une solution extrêmement fiable (à l’usure des capteurs près). Néanmoins cela reste la solution la moins précise et la plus chère à mettre en œuvre (préparer un rail en inox de la bonne longueur, le percer, fixer les capteurs, tirer des tresses de câbles, selon le nombre de capteurs ajouter un multiplexeur).

Mesure par capteur de pression

Au final, il nous reste la solution la plus simple. immerger un capteur un capteur de pression. Il suffit d’un capteur de pression et d’une longueur de câble. Ici pas de parties mécaniques, pas de montage compliqué, pas composants complexes.

Etape 3 : Composants retenus

Le capteur

On ne va pas réinventer l’eau tiède. Quelqu’un a déjà fait tout le travail ICI. On va utiliser son travail pour la partie capteur et notamment son idée ingénieuse de fixer le capteur sur une bouteille remplie d’huile alimentaire pour ne pas risquer de boucher/altérer le capteur. Ensuite, le capteur sera pour sa part noyé dans de la résine pour assurer son étanchéité.

Composant

Nous allons utiliser un MPX5700AP de chez NXP disponible par exemple sur AliExpress pour moins de 8 euros. Il peut mesurer des pressions entre 15 et 700 kPa (soit 7bar). Ce qui nous permet au passage de réaliser des mesures jusqu’à 60 mètres sous le niveau de l’eau (1bar / 10mètres).

Filtrage du bruit

Puisqu’il s’agit d’un capteur analogique, il doit posséder des filtres adéquats pour que la mesure soit la plus précise possible. Le détail est disponible dans la fiche AN1646 sur le site de NXP. Trois solutions sont proposés : le filtrage RC, le filtrage par ampli-op et le filtrage logiciel. Pour la simplicité du montage, nous allons combiner un filtrage RC et un filtrage logiciel (après tout il faut bien que les 16Mhz de l’arduino servent à quelque chose). Le filtrage se fera par échantillonnage (64 échantillons), qui permet d’améliorer la précision à 1mV (pic à pic).

Précision de la mesure

Afin d’améliorer encore la précision, il faudra utiliser une alimentation régulée par un 7805 comme indiqué dans la fiche AN1646.

La mesure est donnée par la formule suivante :

Vout = Vs * (0.0012858 * P +0.04) ± Error
Vs = 5Vdc

Soit

// takes a A/D sample (0 to 1024) based on 5V ref
//  to compute pressure on MPX sensor
float getPressure(int analogValue) {
  // Convert the analog reading (which goes from 0 - 1023) to a voltage (0 - 5V):
  float value = analogValue * (5 / 1023.0);
  // print out the value you read:
  return ((value / 5) - 0.04) / 0.0012858;
}

Le problème est que le capteur mesure une pression entre 0.15 et 7bar. Et c’est justement cette plage qui va servir à la conversion A/D.

Si on considère un puits de 9 mètres maximum, cela correspond à une pression maximale de 2bars sur le capteur. De même, la pression minimale mesurée sera toujours de 1bar (pression atmosphérique ambiante). Cela signifie que notre plage de tension sera entre 0.7 et 1.5V soit une utilisation de seulement 16% de la plage de mesure. Le convertisseur A/D de l’arduino échantillonne sur 10 bits soit (1024 pour 5V), ce qui nous laisse environs 160 valeurs pour mesure une pression située entre 1 et 2 bars (9mètres) soit une précision approximative de 6cm par step.

Si on souhaite améliorer la précision, nous pouvons modifier la valeur de référence du convertisseur de l’arduino (pin Aref) afin de le calibrer sur une valeur plus faible, par exemple 1.5V. Cela permet des mesures jusqu’à 2bars soit 1 mètres. Du coup, notre plage de mesure représente 50% de la plage d’échantillonnage (de 1 à 2 bars), ce qui correspond à 512 valeurs pour 10 mètres soit une précision d’environ 2cm.

Attention, cette customisation n’est pas sans poser problème. A ne faire qu’en connaissance de cause et acceptation du risque :

• La modification de la référence s’applique à toutes les entrées du convertisseur
• Le dépassement du seuil de référence lors d’une mesure peut endommager le convertisseur

Une solution moins risquée mais plus complexe à mettre en œuvre pourrait être l’utilisation d’un amplificateur opérationnel qui amplifierai la mesure mais saturerait à la tension maximale, protégeant alors le convertisseur.

L’afficheur

Ici, pas de chichi, un bon vieux LCD1602 en I2C (1.96€ pièce) connecté directement à l’arduino avec la librairie LiquidCrystal_I2C.h.

L’unité de traitement

Pas de contraintes de RAM ni de CPU. N’importe quel Arduino fonctionnant en 5V fera l’affaire (donc exit les arduino pro mini).

J’ai retenu un Arduino Nano 3 à 1.70€ sur AliExpress.

On ajoutera une puce NRF24L01+ (à 6€ pour 10 pièces sur AliExpress) pour l’intégration au réseau mySensors ainsi qu’un régulateur 3.3V séparé pour alimenter correctement la puce NRF.

Le logiciel

Librairies

Nous avons besoin des librairies :

• mySensors
• LiquidCrystal_I2C.h

Spécifique

Affichage

On va afficher le niveau du puit en mètres ainsi qu’une évaluation en pourcentage (basé sur la hauteur max du puit. Cerise sur le gateau on éteint le rétro-éclairage au bout de 30 secondes (GreenIT). Pour le rallumer, on appuie sur le bouton prévu à cet effet. Du coup, une petite LED rouge en façade permet d’indiquer que le niveau du puits passe en dessous des 10% sans consulter l’écran.

Mesure

Il faudra quand même une petite fonction pour réaliser une mesure échantillonnée, moyennée et lui appliquer la formule pour obtenir le résultat escompté.

Les plus téméraires pourraient inclure une fonction de calibrage automatique avec un mesure à niveau 0 et une mesure à 2m par exemple. Si on suppose que la relation entre mesure et pression est linéaire, le tour est joué.

Calibrage

Comme le capteur va déjà réagir à la pression ambiante (à la manière d’un baromètre), il convient de le calibrer lors de sa mise en service. Pour faciliter cette étape, je vais ajouter un petit potentiomètre de 100KOhms sur une entrée analogique afin de disposer d’un offset réglable à l’aide d’un tournevis.

MySensors

On intègre la librairie MySensors afin de remonter les mesures au serveur de domotique. Cela permet une consultation à distance ainsi qu’une historisation des valeurs.

Capteur de température

Puisqu’on est en route, pourquoi s’arrêter là. Et si on ajoutait un capteur pour mesurer la température extérieure par la même occasion ? Allez hop, on ajoute un DS18B20 étanche de 5m (3,42€) connecté en OneWire sur l’arduino.

Etape 4 : Réalisation

Schéma

Facilité oblige, j’ai utilisé Fritzing. un logiciel OpenSource bien conçu qui permet de faire les schémas électroniques ainsi que préparer les PCB et le routage des pistes.

Circuit

En ajustant manuellement les pistes, j’ai préparé le PCB suivant que je n’ai pas imprimé faute de temps (et peut-être de maîtrise technique du procédé). Allez, les plaques de prototypage c’est pas si mal …

Assemblage

La partie capteur est faite comme dans le site de référence :

• les condensateurs de filtrage sont soudés sur les pattes du MPX
• les “oreilles” du MPX ont été coupée
• le MPX a été placé dans un petit tube PVC et noyé dans la résine Epoxy
• le tube PVC a été collé sur le bouchon d’une bouteille de produit vaisselle remplie d’huile

La partie centrale a été rangée dans une boite de dérivation. Une découpe a été réalisée pour l’écran LCD, la LED et le bouton.

Logiciel

Le logiciel a été réalisé avec ArduinoIDE.

#include <Wire.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <LiquidCrystal_I2C.h>
#include <SPI.h>
#include <MySensor.h>

#define LED_PIN_ALERT           3           // Pin for Alert LED
#define BIAS_PIN                A7
#define DIMMER_PIN              11           // Pin for led dimmer
#define BTN_PIN                 9                 // Btn to turn backlight on
#define SENSOR_PIN              A0            // Pin for MPX sensor
#define TEMPERATURE_PIN         2       // DS18B20 OneWire Data Pin

#define MAX_ATTACHED_DS18B20    1
#define LEVEL_THRESHOLD_PERCENT 5 // Alert threshold in percent to turn on LED
#define MAX_HEIGHT_WELL_METER   6  // Well height for percentage computing
#define BACKLIGHT_DELAY_SEC     30    // delay before screen backlight off
#define REDRAW_DELAY_SEC        0.5
#define SEND_DATA_DELAY_SEC     900 // Send data to mySensors Gateway every quarter hour
#define SEND_TEMP_DELAY_SEC     15 // Send data to mySensors Gateway every quarter hour

#define MAX_SAMPLES             64           // Number of collected sampled values
#define MEDIAN_SAMPLES          32         // Number of median values used for average

// Dimmer / Shift REgsiter
#define CHILD_ID_LEVEL 1
//#define CHILD_ID_DIMMER 2
#define CHILD_ID_TEMP 3

MySensor gw;
//kublib_dimmer myDimmer(CHILD_ID_DIMMER);
MyMessage msg(CHILD_ID_LEVEL, V_DISTANCE);
MyMessage msgTemp(CHILD_ID_LEVEL, V_TEMP);

int numSensors=0; // Supports multiple sensors connected
boolean metric = true; 
float temp=0; // Global value that stores temperature
OneWire ds(TEMPERATURE_PIN);
DallasTemperature sensors(&ds); // Pass the oneWire reference to Dallas Temperature.

// Set the LCD I2C address
// And the I2C pin mapping
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);  
boolean backlightOn = true;
boolean btnLastState = HIGH;
unsigned long timeRefBacklight = 0;
unsigned long timeRefRedraw = 0;
unsigned long timeRefSendData = 0;
unsigned long timeRefSendTemp = 0;
float samples[MAX_SAMPLES];
int sampleIndex = 0;
float waterHeight = 0;
int waterLevel = 0;
int digitalBias = analogRead(BIAS_PIN);
float lastTemperature;  // Stores last measured temperature
  
// the setup routine runs once when you press reset:
void setup() {
  // initialize serial communication at 9600 bits per second:
  Serial.begin(115200);
  lcd.begin(16,2);               // initialize the lcd 
  // Initialize LED
  pinMode(LED_PIN_ALERT, OUTPUT);
  digitalWrite(LED_PIN_ALERT, HIGH);
  delay(300);
  // Initialize BTN
  pinMode(BTN_PIN, INPUT_PULLUP);
  // Initialize timer
  //timeRefBacklight = millis();
  //timeRefRedraw = millis();
  // Initialize MySensors
  lcd.home ();                   // go home
  lcd.clear();
  lcd.print ("MySensors:");
  lcd.setCursor ( 0, 1 );        // go to the next line
  lcd.print ("Radio init.");


  
  gw.begin(incomingMessage);
  gw.sleep(1000);
  // Send the Sketch Version Information to the Gateway
  gw.sendSketchInfo("Kub Puits", "1.0");
  //myDimmer.initialize(&gw, DIMMER_PIN);
  // Configure Level sensor
  gw.present(CHILD_ID_LEVEL, S_DISTANCE, "Niveau Puits (cm)");

  // Startup up the OneWire library
  sensors.begin();
  // requestTemperatures() will not block current thread
  sensors.setWaitForConversion(false);
  // Fetch the number of attached temperature sensors  
  numSensors = sensors.getDeviceCount();

  // Present all sensors to controller
  char label[14] = "";
  
  for (int i=0; i<numSensors && i<MAX_ATTACHED_DS18B20; i++) {   
    sprintf(label, "Temperature %d", i + CHILD_ID_TEMP);
     gw.present(i + CHILD_ID_TEMP, S_TEMP, label);
  }
  
  lcd.setCursor ( 0, 1 );        // go to the next line
  lcd.print ("Intialized !   ");
  gw.sleep(1000);
  checkTemperature();
}

// the loop routine runs over and over again forever:
void loop() {
  gw.process(); 
  
  //myDimmer.check();
  // When MAX SAMPLES is reached
  //  we have enough values to compute a result
  if (sampleIndex >= MAX_SAMPLES) {
    float sum = 0.0;
    // Sort the sampled data
    BubbleSort(samples, MAX_SAMPLES);
    // Use only the median values to compute average
    for (int i =(MAX_SAMPLES-MEDIAN_SAMPLES)/2; i<(MAX_SAMPLES-MEDIAN_SAMPLES)/2 + MEDIAN_SAMPLES; i++)
      sum += samples[i];
    // Compute final values
    waterHeight = sum / MEDIAN_SAMPLES;
    waterHeight = (float)((int)(waterHeight *100) /100.0);
    waterLevel = waterHeight / MAX_HEIGHT_WELL_METER * 100;
    // Reset index
    sampleIndex = 0;
    // Send value
    if ((millis() - timeRefSendData) > (SEND_DATA_DELAY_SEC * 1000)) {
      gw.send(msg.set((int)(waterHeight*100))); // niveau d'eau en cm
      
      timeRefSendData = millis();
    }
    digitalBias = analogRead(BIAS_PIN);
  
  }
  if ((millis() - timeRefSendTemp) >= (SEND_TEMP_DELAY_SEC * 1000)) {
    checkTemperature();
    timeRefSendTemp = millis();
  }
  // Load sensor data to sampling array
  int value = analogRead(SENSOR_PIN);
  samples[sampleIndex] = getWaterHeight(getPressure(value), digitalBias);
  sampleIndex++;
  
  // Turn light off after delay (GreenIT)
  if (((millis() - timeRefBacklight) > (BACKLIGHT_DELAY_SEC * 1000)) && (backlightOn)) {
    Serial.println("Turn Off");
    backlightOn = false;
    lcd.noBacklight();
  }
  
  // Turn light ON on btn press
  if ((digitalRead(BTN_PIN) == LOW) && (btnLastState == HIGH)) {
    Serial.println("Turn On");
    btnLastState = LOW; // Manage simple debounce
    backlightOn = true;
    lcd.backlight();
    timeRefBacklight = millis();
  }

  // Manage simple debounce
  if ((digitalRead(BTN_PIN) == HIGH) && (btnLastState == LOW)){
    btnLastState = HIGH;
  }
  
  // If light on redraw screen according refresh rate
  if (backlightOn && ((millis() - timeRefRedraw) > (REDRAW_DELAY_SEC * 1000))) {
    char strResult[5]="";
    char strTemp[6]="";
    
    //ftoa(strResult,waterHeight, 3);
    dtostrf(waterHeight, 3, 1, strResult);
    dtostrf(lastTemperature, 4, 1, strTemp);
    
    // Show data on LCD Screen
    lcd.home ();                   // go home
    lcd.clear();
    lcd.print ("Puits: ");
    lcd.print (strResult);
    lcd.print ("m ");
    lcd.print (waterLevel);
    lcd.print ("%");
    
    lcd.setCursor ( 0, 1 );        // go to the next line
    lcd.print ("Temp Ext: ");
    lcd.print (strTemp);
    lcd.print ("C");
    timeRefRedraw = millis();
  }

  // Manage led alert
  if (waterLevel < LEVEL_THRESHOLD_PERCENT) {
    digitalWrite(LED_PIN_ALERT, HIGH);
  } else {
    digitalWrite(LED_PIN_ALERT, LOW);
  }

  
}

void incomingMessage(const MyMessage &message) {
  //myDimmer.processMessage(message);
}

// takes a A/D sample (0 to 1024) based on 5V ref
//  to compute pressure on MPX sensor
float getPressure(int analogValue) {
  // Convert the analog reading (which goes from 0 - 1023) to a voltage (0 - 5V):
  float value = analogValue * (5 / 1023.0);
  // print out the value you read:
  return ((value / 5) - 0.04) / 0.0012858;
}

// Compute water level in meters according to pressure (KPa)
float getWaterHeight(float pressureKPa, int digitalBias) {
  // Remove 100KPa for current air pressure (1 bar)
  // And convert from KPa to meters (10 meter of water = 1bar)
  float bias = ((float)(digitalBias)-512.0) / 100.0 / 4;
  return ((pressureKPa - 100) / 10) + bias;
  
}

void BubbleSort(float *num, int numLength)
{
      int i, j, flag = 1;    // set flag to 1 to start first pass
      float temp;             // holding variable
      for(i = 1; (i <= numLength) && flag; i++)
     {
          flag = 0;
          for (j=0; j < (numLength -1); j++)
         {
               if (num[j+1] > num[j])      // ascending order simply changes to <
              { 
                    temp = num[j];             // swap elements
                    num[j] = num[j+1];
                    num[j+1] = temp;
                    flag = 1;               // indicates that a swap occurred.
               }
          }
     }
     return;   //arrays are passed to functions by address; nothing is returned
}


void checkTemperature() {
  //
  // Manage temperature
  //
  // Fetch temperatures from Dallas sensors
  sensors.requestTemperatures();

  // query conversion time and sleep until conversion completed
  int16_t conversionTime = sensors.millisToWaitForConversion(sensors.getResolution());
  // sleep() call can be replaced by wait() call if node need to process incoming messages (or if node is repeater)
  gw.sleep(conversionTime);

  // Read temperatures and send them to controller 
  for (int i=0; i<numSensors && i<MAX_ATTACHED_DS18B20; i++) {
 
    // Fetch and round temperature to one decimal
    float temperature = static_cast<float>(static_cast<int>((gw.getConfig().isMetric?sensors.getTempCByIndex(i):sensors.getTempFByIndex(i)) * 10.)) / 10.;
    Serial.print("Temperature for sensor ");
    Serial.print(i);
    Serial.print(" :");
    Serial.println(temperature);
    // Only send data if temperature has changed and no error
    if (temperature != -127.00 && temperature != 85.00) {
    
      // Send in the new temperature
      gw.send(msgTemp.setSensor(i).set(temperature,1));
      // Save new temperatures for next compare
      lastTemperature=temperature;
    }
  }
}