TurboCocco

Nom du projet : TurboCocco

Coordonnées : 

Alexandre Legou (alexandre.legou@etu.sorbonne-universite.fr), 

Fanny Ludowicz (fanny.ludowicz@etu.sorbonne-université.fr)

L3 Sciences de la Terre

Introduction :

Date de début : 26/01/2024

Date de fin estimée : 09/05/2024

Objectifs : 

Contexte : Dans le cadre de l'UE LU3ST062 - Atelier FabLab, nous avons choisi de participer à ce projet afin d'aider Fabrice Minoletti dans ses projets de recherche

• Matériaux / Outils / Machines (le plus détaillé possible)
• Construction (fichiers, photos, code, texte, paramètres d’usinage etc.)
• Journal de bord (étapes datées du projet)

26/01/2024 :

Modèle :

Caractéristiques du capteur :

• Operating Voltage: 5V DC

• Operating Current: 40mA (MAX)

• Response Time: <500ms

• Insulation Resistance: 100M (Min)

• Output Method: Analog

• Analog output: 0-4.5V

• Digital Output: High/Low level signal (you can adjust the threshold value by adjusting the potentiometer)

• Operating Temperature: 5℃~90 ℃

• Storage Temperature: -10℃~90℃

• Weight: 30g

• Adapter Dimensions: 38mm*28mm*10mm/1.5inches *1.1inches*0.4inches

Attention : Capteur non waterproof : maintenir la partie noire hors de l’eau

Principe : Le capteur mesure la turbidité, ce qui nous permet d'obtenir une valeur de voltage. Quand la turbidité augmente, le voltage diminue.

Mesure de la turbidité = mesure des particules en suspension avec rayon lumineux + détecteur de lumière réglé à 90° par rapport au faisceau -> modification de la quantité de lumière réfléchie en fonction de la quantité de particules en suspension

Utilité du projet : résoudre des problèmes de filtration des coccolithes. Les particules se déposent au fond et saturent la membrane. Il faut donc détecter quand est-ce que cela arrive (i.e quand est-ce que la turbidité est trop faible) pour que le moteur soit allumé 

Ce qu'on va devoir faire :

• créer un programme permettant de mesurer la turbidité en solution
• effectuer des mesures avec différents liquides (différentes granulométries, différentes natures des particules)
• vérifier qu'on obtient les mêmes résultats avec différents capteurs (si ce n'est pas le cas on a un problème)

02/02/2024 : 

But à ce stade :

Déterminer les valeurs seuils pour lesquelles il y a plus assez de particules en suspension i.e. la membrane est saturée donc il faut allumer le moteur 

et/ou ?

Déterminer la quantité seuil de sédiments à mettre dans le tube pour ne pas saturer la membrane

>Le tout avec différents échantillons de sédiments 

Démarche : (ordre de priorité 1 et 2)

1.

• Déterminer comment le turbidimètre marche :

Schéma explicatif du fonctionnement du capteur

Schéma du fonctionnement du capteur (https://how2electronics.com/)

> 2 broches se font face, l’une émettrice d’une source lumineuse, l’autre receveuse. La lumière émise se voit en partie réfléchie, ce qui est fonction de la turbidité du milieu extérieur entre les 2 broches. Le détecteur convertit la quantité de lumière transmise en une tension électrique comprise entre 0 et 5V. Plus le milieu est turbide, plus le voltage est bas

• Déterminer l’étanchéité du montage : 

Photo du tube monté avec le capteur de turbidité

Notre premier montage, ayant pour but de calibrer et déterminer la sensibilité du capteur dans différente conditions est composée d’un tube en plastique de 28mm de circonférence (la même que le pourtour du capteur) et du capteur, inséré par l’ouverture. 

En remplissant le tube d’eau jusqu’au détecteur, nous voulions tester l'étanchéité du système. Le système n’est pas complètement étanche mais apparemment suffisamment pour que ça marche à la verticale sans trop le retourner, les pertes d’eau sont minimes.

• Premières mesures dans différents milieux.

> En tout premier lieu, nous voulions déterminer l’ordre de grandeur des mesures effectuées dans différentes conditions. 

Tableau récapitulatif des mesures de turbidité du jour

Indice de réfraction de l’air = 1,0002 

Indice de réfraction de l’eau = 1,333 (à 20°C et 589,3 nm)

Reste à tester/ mettre en place : 

• déterminer les valeurs de mesure de la turbidité dans l’eau déminéralisé et eau minérale ?

• Comprendre comment marche le montage écran LCD/ breadboard/ arduino et le mettre en place.

Photo des premier tests

• Déterminer la sensibilité du capteur en fonction de la masse de sédiment en solution avec une solution « test ».

• + Déterminer la réplicabilité des expériences/mesures

2.

• Faire des mesures/avoir des données avec les sédiments de LIMAGNE. + BLANC de mesure

• Déterminer un protocole précis de mesure (quantité de solution = volume d’eau/volume sed)

09/02/2024 :

>>Problème avec l'écran LCD. L'éclairage s'allume mais seuls des rectangles blancs apparaissent, pas d'affichage autre, malgré différents codes testés. Problème à résoudre (tests avec un autre écran)

>>Mesures de turbidité : 

Eau minérale (Cristalline) : 4.57 V

Eau déminéralisée (prélevée dans la demi-journée des tests : 4,51 +/- 0,1 V

Tests avec eau déminéralisée + quantités variables de sédiments : 

• 1ère mesure avec le bout d’une paille de sédiment dans un tube d’eau déminéralisée agité manuellement après ajout du sédiment : 4,46 +/- 0,02 V

• 2e essai avec une plus grande qté de sédiment : 

• 3e essai avec le même tube (après nouvelle agitation) : 

Codes utilisés : 

Mesure de la turbidité :  Code « turbidité1 »

void setup() {
  Serial.begin(9600); //Baud rate: 9600
}
void loop() {
  int sensorValue = analogRead(A0);// read the input on analog pin 0:
  float voltage = sensorValue * (5.0 / 1024.0); // Convert the analog reading (which goes from 0 - 1023) to a voltage (0 - 5V):
  Serial.println(voltage); // print out the value you read:
  delay(500);
}

Code à tester sur un nouvel écran LCD :

#include "Wire.h"
#include "LiquidCrystal_I2C.h"


LiquidCrystal_I2C LCD(0x27,16,2); // définit le type d'ecran lcd 16 x 2


void setup() {
   LCD.init(); // initialisation de l'afficheur
   LCD.backlight();
   
   LCD.setCursor(1, 0);
   LCD.print("HELLO");
  
   LCD.setCursor(8, 1);
   LCD.print("WORLD");
}


void loop() {
   LCD.noDisplay();
   delay(1000);
   LCD.display();
   delay(1000);
}

16/02/2024 :

Pour aujourd’hui, nous avions plusieurs objectifs : 

1. Tester un nouveaux code donné par Pierre, qui marche déjà sur un projet différent, pour voir si un de nos composants est défectueux. 
2. Trouver une solution pour exporter nos données de mesures dans le but d’en faire des graphiques.

Au début, nous avons refait une mesure de turbidité « test » avec l’eau déminéralisée de la semaine dernière, il s’est avéré qu’on retrouvait, dans des conditions similaires, quasiment la même valeur, soit 3,86V. On en conclu que Si les conditions de mesures sont « identiques », alors les mesures ont une reproductibilité fiable (en tout cas avec de l’eau distillé). Aussi, on s’est rendu compte qu’il n’était sans doute pas essentiel d’utiliser de l’eau distillée « fraiche », à chaque fois pour faire le blanc, car il y a manifestement très peu de difference.

#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x3F, 16, 2); // Adresse I2C de l'écran LCD et les dimensions (16x2)

const float VOLTAGE_REFERENCE = 5.0; // Tension de référence de votre Arduino en volts

void setup() {
  Serial.begin(9600); //Baud rate: 9600
  lcd.begin(16, 2);
  lcd.backlight(); // Allumer le rétroéclairage de l'écran LCD
  lcd.print("Voltage: ");
  lcd.setCursor(0, 1);
  delay(5000); // Attendre 2 secondes pour que l'écran LCD démarre avant de continuer
}

void loop() {
  int sensorValue = analogRead(A0);// read the input on analog pin 0:
  float voltage = sensorValue * (5.0 / 1024.0); // Convert the analog reading (which goes from 0 - 1023) to a voltage (0 - 5V)
  Serial.println(voltage); // print out the value you read:

  // Afficher les valeurs sur l'écran LCD
  lcd.setCursor(7, 0);
  lcd.print("     "); // Effacer l'ancienne valeur
  lcd.setCursor(7, 0);
  lcd.print(voltage, 2); // Afficher le voltage avec 2 décimales

  lcd.setCursor(4, 1);
  lcd.print("     "); // Effacer l'ancienne valeur
  lcd.setCursor(4, 1);
  lcd.print(voltage, 2); // Afficher la voltage avec 2 décimales */
  
  delay(5000);
}

Le code donné par « Pierre », fusionné avec le code « turbidité » s’est avéré non fonctionnel sur notre montage, alors qu’il l’est sur son montage d’origine. De plus, nous avons déterminé que notre écran fonctionne, reste alors l’hypothèse du câblage ou de la breadboard défectueux(se). Vraisemblablement, il y a un problème matériel (ce qui est peu probable), ou de compatibilité entre le code et les entrées du capteur qu’on l’on arrive pas à déterminer, même après un long temps passé dessus.

Avant de trouver une solution pour l’écran LDC, qui nous fait pour l’instant perdre trop de temps, il faut déterminer comment exporter nos données. 

Pour se faire, dans un premier temps on reprend donc le montage « simple » (qui marche), c’est à dire avec uniquement le capteur, connecté à l’arduino avec le code « turbidité1 ».  Puis, plusieurs étapes sont nécessaires :

• On veut d’abord modifier le code pour que la prise de donnée se fasse de manière séquencée. C’est à dire que nous voulons, pour que le traitement sur tableur des données, les rendre moins denses, et plus adaptées à la période de mesure.
  • Dans les 2 premières minutes : 1 mesure toute les 2 secondes (car au après agitation la turbidité évolue vite dans un premier temps)
  • De 2 à 15 minutes : 1 mesure toutes les 30 secondes (dans cette periode, la turbidité varie moins)
  • A partir de 15 minutes : 1 mesure toutes les 5 minutes (c’est la phase où la turbidité revient lentement à sa valeur d’origine)

Via nos recherches, nous sommes arrivés à modifier le code d’origine vers celui ci : 

// Déclaration des variables globales
unsigned long previousMillis = 0; // Variable pour stocker le temps du dernier déclenchement de mesure
int interval = 2000; // Interval initial de mesure (2 secondes)

void setup() {
  Serial.begin(9600); // Baud rate: 9600
}

void loop() {
  unsigned long currentMillis = millis(); // Obtient le temps écoulé depuis le démarrage de la carte Arduino

  // Si le temps écoulé est supérieur à l'intervalle, il est temps de prendre une mesure
  if (currentMillis - previousMillis >= interval) {
    // Enregistrer le temps actuel comme dernier temps de mesure
    previousMillis = currentMillis;

    int sensorValue = analogRead(A0); // Lire la valeur du capteur de turbidité sur la broche analogique A0
    float voltage = sensorValue * (5.0 / 1024.0); // Convertir la valeur lue en tension

    // Afficher la valeur de tension mesurée
    Serial.println(voltage);

    // Logique pour changer l'intervalle de mesure en fonction du temps écoulé
    if (currentMillis <= 120000) { // Les 2 premières minutes (120 000 millisecondes)
      interval = 2000; // Mesurer toutes les 2 secondes
    } else if (currentMillis <= 900000) { // Jusqu'à 15 minutes (900 000 millisecondes)
      interval = 30000; // Mesurer toutes les 30 secondes
    } else {
      interval = 300000; // Après 15 minutes, mesurer toutes les 5 minutes
    }
  }
}

• On veut aussi modifier le code pour mettre en forme les données qui s’affichent dans le moniteur en série. 
  

Les données de temps et de voltage se doivent d’être précédées de leur nature en haut de colonne dans serial monitor, les deux colonnes séparées par un espace.

-> Code inséré dans « void setup » :

Serial.println("Temps (en s) Voltage (en V)"); // Titres des colonnes avec un espace

-> Code inséré dans « void loop » : 

    // Afficher la durée écoulée et la valeur de tension mesurée
    Serial.print(elapsedTime / 1000); // Convertir les millisecondes en secondes
    Serial.print(" ");
    Serial.println(voltage);

• Arrêter la période de mesure après un temps défini.

-> Code inséré dans la loop :

  // Arrêter le programme après 2 minutes (120 000 millisecondes)
  if (elapsedTime >= 120000) {
    exit(0); // Arrêter l'exécution du programme
  }

Pour traiter nos données, on a découvert l’outil « plotter » sur arduino, qui trace tout seul une courbe de mesure depuis l’initialisation du programme. Malheureusement, le format n’est pas du tout idéal. 

On s’est rabattu pour l’instant vers l’option :

Biblio : 

1. comment mesurer la turbidité en labo ? :  https://kalstein.eu/comment-mesure-t-on-la-turbidite-en-laboratoire/ 

2. page du capteur : https://wiki.dfrobot.com/Turbidity_sensor_SKU__SEN0189

3. Lien avec référence du capteur + vidéo explicative du fonctionnement :  https://www.dfrobot.com/product-1394.html

4. DIY Turbidity Meter using Turbidity Sensor & Arduino : https://how2electronics.com/diy-turbidity-meter-using-turbidity-sensor-arduino/ 

5. LCD avec Arduino : https://docs.arduino.cc/learn/electronics/lcd-displays/?_gl=1*1w37mui*_ga*NDQ0ODIxMjg0LjE3MDY4Nzc5NDM.*_ga_NEXN8H46L5*MTcwNjk1Nzk3Mi4zLjEuMTcwNjk1Nzk5OC4wLjAuMA..*_fplc*Zk51eHJHaXZxM2tLSzQlMkYzczMzS1B6Wm5uZnZpSFh6Nk4xUzdsZUI3STZIUmdmOWF2JTJCb25IMSUyQkZiY0x0aGdpUUpXUmk5T0dwcTZ3a2dSOUxDWmJqR3pMcms4UXFFQ1F5VjhvUmxYUjkyTkRydXdLblZtOVVnTXFkTXpYTnpnJTNEJTNE 

Cours Arduino : https://arduino.developpez.com/tutoriels/cours-complet-arduino/ 

Programmation : https://arduino.developpez.com/tutoriels/cours-complet-arduino/?page=programmer-arduino

Liste de tous les éléments de syntaxe : https://www.arduino.cc/reference/fr/ 

Bibliothèque arduino : https://www.arduino.cc/reference/en/libraries/