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 

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)

Objectifs pour la suite : 

• 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

• 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 :

1. 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)

2. 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é :  

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 Théry, 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.86 V. On en conclut que si les conditions de mesures sont « identiques », alors les mesures ont une reproductibilité fiable (en tout cas avec de l’eau déminéralisée). 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 différence.

#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é1 » 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 (en le branchant sur le montage de Pierre), 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 n'arrive pas à déterminer, même après un long temps passé dessus.

En plus de trouver une solution pour l’écran LDC, qui nous fait pour l’instant perdre trop de temps, nous devons aussi déterminer comment exporter nos données. 

Pour ce faire, dans un premier temps on reprend 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 après agitation la turbidité évolue vite dans un premier temps)
  • De 2 à 15 minutes : 1 mesure toutes les 30 secondes (dans cette période, 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; // Intervalle initial de mesure (2 secondes)

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

void loop() {
  unsigned long currentMillis = millis(); // Permet d'obtenir 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);

    // Consignes pour changer l'intervalle de mesure en fonction du temps écoulé
    if (currentMillis <= 120000) { // Pendant les 2 premières minutes (120 000 millisecondes)
      interval = 2000; // Faire une mesure toutes les 2 secondes
    } else if (currentMillis <= 900000) { // Jusqu'à 15 minutes (900 000 millisecondes)
      interval = 30000; // Faire une mesure toutes les 30 secondes
    } else {
      interval = 300000; // Après 15 minutes, faire une mesure 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 (ici test avec 2 minutes).

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

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

void setup() {
  Serial.begin(9600); // Baud rate: 9600
  startTime = millis(); // Enregistrer le temps de démarrage
  Serial.println("Temps (en s) Voltage (en V)"); // Titres des colonnes séparées avec un espace
}

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

  // Calcul du temps écoulé depuis le démarrage du programme
  unsigned long elapsedTime = currentMillis - startTime;

  // 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 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);

    // Consignes pour changer l'intervalle de mesure en fonction du temps écoulé
    if (elapsedTime <= 120000) { // Les 2 premières minutes (120 000 millisecondes)
      interval = 2000; // Mesurer toutes les 2 secondes
    } else if (elapsedTime <= 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
    }
  }

  // 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 « serial 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 : Exportation des données d’une période de mesure sur excel pour en faire un graphique. Effectivement, avec la relativement faible quantité de mesure qu’on obtient avec les modifications, c’est largement faisable. Surtout que le nombre de période de mesure ne sera pas conséquent. -> On a testé et ça marche assez bien !

Objectifs pour la suite :

• Trouver une solution pour l’écran LDC.

Problème résolu le 19/02 : dans lcd.setCursor(), il fallait mettre (11, 0) pour que le premier chiffre apparaisse en 11e colonne et en 1ere ligne… les colonnes 1 à 10 de l’écran lcd étant occupée par le texte “turbidite:”

#include <Wire.h>
#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

const int SENSOR_PIN = A0; // Broche analogique à laquelle est connecté le capteur

void setup() {
  Wire.begin();
  lcd.begin(16, 2);
  lcd.backlight(); // Allumer le rétroéclairage de l'écran LCD
  lcd.print("Turbidite: ");

  delay(2000); // Attendre 2 secondes pour que l'écran LCD démarre avant de continuer
}

void loop() {
  int sensorValue = analogRead(SENSOR_PIN); // Lecture de la valeur analogique du capteur

  // Convertir la valeur analogique en tension
  float voltage = sensorValue * (5.0/1024.0) ; 

 

  // Afficher les valeurs sur l'écran LCD
  Serial.println("voltage (v)");
  Serial.println(voltage);
  Serial.println();
  lcd.setCursor(11, 0); //affiche le voltage a la 11eme colonne
  lcd.print("      "); // Effacer l'ancienne valeur
  lcd.setCursor(11, 0);
  lcd.print(voltage, 2); // Afficher la turbidité en volts avec 2 décimales

  
  delay(500); // Délai entre chaque lecture pour éviter les rafraîchissements trop rapides
}

• Tester la constance des mesures avec la même concentration de sédiment.
  
• Trouver comment exporter facilement des données sur Excel.
• Commencer à faire les prises de données « calibrations » à différentes concentrations de sédiments pour obtenir des graphiques.

01/03/2024 :

1. Nous avons tout d'abord commencé par insérer le code "turbidité 3" dans le code "turbidité 2" afin d'afficher les valeurs sur l'écran LCD mais aussi dans le logiciel Arduino :

#include <Wire.h>
#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

const int SENSOR_PIN = A0; // Broche analogique à laquelle est connecté le capteur

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

void setup() {
  Wire.begin();
  lcd.begin(16, 2);
  lcd.backlight(); // Allumer le rétroéclairage de l'écran LCD
  lcd.print("Turbidite: ");

  delay(2000); // Attendre 2 secondes pour que l'écran LCD démarre avant de continuer

  Serial.begin(9600); // Baud rate: 9600
  startTime = millis(); // Enregistrer le temps de démarrage
  Serial.println("T V"); // Titres des colonnes séparées avec un espace
}

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

  // Calcul du temps écoulé depuis le démarrage du programme
  unsigned long elapsedTime = currentMillis - startTime;
  // 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 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);
    
    // Consignes pour changer l'intervalle de mesure en fonction du temps écoulé
    if (elapsedTime <= 120000) { // Les 2 premières minutes (120 000 millisecondes)
      interval = 2000; // Mesurer toutes les 2 secondes
   } else if (elapsedTime <= 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
    }
    
   // Afficher les valeurs sur l'écran LCD
   lcd.setCursor(11, 0); //affiche le voltage a la 11eme colonne
   lcd.print("      "); // Effacer l'ancienne valeur
   lcd.setCursor(11, 0);
   lcd.print(voltage, 2); // Afficher la force en newtons avec 2 décimales
   
   delay(500); // Délai entre chaque lecture pour éviter les rafraîchissements trop rapides
  }
  
  // Arrêter le programme après 45 minutes (2 700 000 millisecondes)
  if (elapsedTime >= 2700000) {
    exit(0); // Arrêter l'exécution du programme
  }
}

2. Nous avons ensuite cherché à exporter nos données afin de pouvoir tracer des courbes sur Excel. Pour cela nous avons téléchargé le logiciel CoolTerm (gratuit). 

Mode d'emploi :

• Upload le programme sur la carte Arduino reliée au capteur
• Ouvrir le logiciel CoolTerm puis aller dans Connection -> Capture to Text/Binary file -> Start. Cela permet d'enregistrer le fichier en version .txt
• Cliquer ensuite sur Connect
• Si la fenêtre Serial Monitor est bien fermée dans Arduino, les valeurs apparaissent sur le logiciel CoolTerm
• On peut arrêter les mesures en cliquant sur Disconnect.

Il faut ensuite ouvrir le fichier .txt dans Excel en veillant à bien choisir les tabulations et les espaces comme séparateurs, afin d'obtenir les valeurs de temps et de voltage dans deux colonnes séparées.

Après avoir remplacé les points par des virgules, on peut tracer la courbe Voltage = f(Temps). Un premier test avec le tube du 16/02 nous donne la courbe suivante : 

3. Nous pouvons enfin passer à une vraie phase de mesures avec une quantité exacte de sédiment. Nous avons prélevé 0,52 mg de sédiment de Limagnes et l'avons inséré dans 52 mL d'eau fraîchement déminéralisée, afin d'obtenir une concentration équivalente à 1 mg de sédiment pour 100 mL d'eau. 

Problème : le capteur n'est pas assez précis pour mesurer une aussi faible concentration. Aucune variation, autre que celle par défaut du capteur, n'était donc observable. Après discussion avec notre encadrant, nous avons décidé de ne pas descendre en dessous de 1 mg/100 mL. 

Objectifs pour la suite :

• Réaliser une solution mère à Q_mère = 2g/20mL de sédiment
• Effectuer des mesures pour Q_low = 1 mg/mL de sédiment 
• Effectuer des mesures pour Q_high = à déterminer pour que ce soit saturant
• Effectuer des mesures à différentes concentrations intermédiaires
• Tracer une courbe v = f(Q) :

• Reproduire le processus sur différents sédiments ?

08/03/2024 :

Pour aujourd’hui les objectifs étaient :

• Réaliser une solution mère à Q_mère = 2g/20mL de sédiment, qui servira à effectuer des dilutions à différentes concentrations en sédiment.

• Effectuer des mesures pour Q_low = 1 mg/mL de sédiment 

• Effectuer des mesures pour Qhigh = à déterminer pour que ce soit saturant

• Effectuer des mesures à différentes concentrations intermédiaires

• Tracer une courbe v = f(Q)

→ But : Déterminer le lien entre la concentration de sédiment en solution et la valeur de la turbidité, pour définir la plage des conditions de mesure du capteur.

1. D’abord, nous avons donc réalisé la solution mère à Q_mère = 0,1 g.L-1, soit 5,2 g de sédiment pour 52mL d’eau.

Pour ce faire, nous avons suivi ce protocole :

• Broyer un échantillon de Limagne à l’aide d’un mortier en agate

• Peser exactement 5,2 g de broyat à l’aide d’une balance de précision

• Mesurer le volume que représente 5,2g d’échantillon broyé à l’aide d’une éprouvette graduée. V poudre mère = 5,5mL

• Transvaser la poudre dans un bécher de 250mL

• Ajouter exactement 46,5mL d’eau déminéralisée dans le bécher.

• Recouvrir le bécher de parafilm pour éviter l’évaporation de l’eau.

2. Une fois la solution mère obtenue, nous avons réalisé une série de calculs à l’aide d’Excel pour déterminer le volume à prélever pour réaliser les dilutions aux Q désirées.

En sachant que C₁*V₁=C₂*V₂, on a V₁=(C₂*V₂)/C₁ 

> Avec C₁=Q_mère ; V₁=volume à prélever ; Q_désirée ; V₂=volume désiré dans un tube de mesure = 52mL

Calculs de volume à prélever et de volume à compléter par de l’eau déminéralisée :

3. A la suite de cela, nous avons réalisé les premières mesures de turbidité à 4 concentrations différentes. 

En partant de notre mesure de la semaine dernière, à Q=1.10^-5g.mL-1 qui n’avait pas influencé la turbidité de la solution (dans la limite de notre capteur), nous avons choisi de “déblayer” le terrain en faisant 3 autres mesures espacées d’un facteur 10, de concentration.

→ Cela correspond aux valeurs Q1, Q2 et Q3 dans le tableur.

Protocole suivi pour réaliser ces mesures :

• Faire la mesure du blanc avec un tube de mesure rempli uniquement d’eau déminéralisée (52 mL)

• Prendre un autre tube de mesure vide.

• Agiter le bécher contenant la solution mère pour homogénéiser la solution.

• Prélever à l’aide d’une pipette de précision le volume de solution mère nécessaire pour obtenir la concentration en sédiment désiré.

• Dans un tube de mesure à bouchon bleu, ajouter le volume de solution mère prélevé.

• Compléter avec de l’eau déminéralisée pour obtenir un volume final de mesure d'exactement 52mL.

• Placer le capteur de turbidité sur le tube de mesure

• Lancer le programme pour effectuer une mesure toutes les 500 ms

• Agiter le tube de mesure pour homogénéiser

• Prendre la première mesure de voltage immédiatement après que le mélange a été effectué

Blanc avec eau déminéralisée=4,64V

Une fois les 3 mesures effectuées, nous avons tracé la courbe v=f(Q)

Courbe obtenue :

Cela nous donne une première idée de la relation concentration en sédiment-turbidité.

On remarque que pour une concentration de 10^-2 g.mL-1, le voltage mesuré (= 0,59 V) approche fortement du voltage pour une occlusion totale du capteur (qui avait été mesuré aux alentours de  précédemment).

On va donc considérer que notre “Q_high” est atteint

Aussi, nous devons réaliser des mesures supplémentaires entre les Q1, Q2 et Q3 pour ajouter des points à notre courbe et avoir une meilleure idée de la relation Concentration-Voltage(=1/turbidité).

4. Dans un deuxième temps, Fabrice nous a proposé de réaliser un frottis avec un petit volume de notre solution mère pour qu’on ait une meilleure idée des éléments qui la compose. Notamment, l’idée était d’obtenir un ordre de grandeur de la granulométrie.

Après le frottis réalisé, on a pu observer la lame au microscope optique en lumière polarisée analysée.

→ Eléments observés :

• fragments de coccolithes

• coccolithes 

• coccosphères

• amas de calcite

Ordre de grandeur de la granulométrie : 5 μm (intervalle de 2μm pour les fragments à 50 μm pour les amas)

Objectifs suivants :

• Réaliser des photos du frottis

• Compléter la courbe v=f(Q) avec des Q_{intermédiaires}

• Se renseigner sur la charge particulaire de différentes eaux (type seine, Gange, etc)

15/03/2024 :

Notre objectif du jour était de déterminer plusieurs Q_{intermédiaires} afin de pouvoir tracer une courbe v = f(Q) ayant une allure plus proche de la réalité et de vérifier que notre valeur Q_high est la bonne.

1. Tout d'abord nous avons dilué le volume de solution-mère restant V_{mère restant} = 46,23 mL car la quantité de dépôts dans le fond du bécher rendait le pipetage de plus en plus compliqué.

Nous avons ainsi obtenu une solution-mère diluée de V_{mère diluée} = 100,78 mL et à Q_{mère diluée} = 0,05 g/mL.

2. Nous avons ensuite préparé différents tubes à différentes charges de sédiments et mesuré le voltage dans chacun d'eux.

Cela nous a donc permis de compléter la courbe v = f(Q) :

On remarque que la courbe a une allure logarithmique inverse et non pas linéaire comme nous pouvions le penser avec nos mesures de la semaine dernière seulement. De plus, la mesure de turbidité effectuée à Q = 1,2 x 10^-2 g/mL nous permet de confirmer que cela correspond bien à la valeur Q_high pour laquelle le capteur est quasiment saturé.

3. Pour la suite, nous allons devoir effectuer de nouvelles mesures afin de vérifier que notre protocole est réplicable et que nous obtenons toujours la même courbe. Pour ce faire, nous avons décidé de préparer 11 solutions de concentrations variables qui devraient nous permettre d'obtenir une courbe propre : 

En préparant chaque solution 3 fois, nous pourrons ainsi déterminer l'écart-type sur chaque mesure de turbidité et vérifier que nos mesures sont reproductibles.

Pour cela, nous allons préparer une nouvelle solution-mère à 0,025 g/mL. Nous allons donc utiliser 292 mL de solution mère minimum. Il nous faudra donc préparer un volume de solution-mère suffisant pour nous permettre de réaliser nos tubes dans des conditions optimales ainsi que d'utiliser un barreau aimanté pour avoir une solution homogène en permanence (et pas remuée manuellement comme nous l'avons fait jusque là). Ainsi, pour un volume V_mère2 = 400 mL, nous allons avoir besoin d'une masse de sédiments telle que m = Q_mère2/V_mère2 = 10g.

Objectifs suivants :

• Réaliser un cache opaque noir afin de permettre d'avoir une turbidité à blanc fixe et indépendante des conditions lumineuses extérieures
• Déterminer un protocole fixe à effectuer pour les mesures
• Préparer une solution mère unique avec un grand volume que nous pourrons utiliser pour réaliser tous nos tubes d'une traite (dans un grand bécher et avec un barreau aimanté)
• Déterminer et préciser toutes les incertitudes, sources d'erreur et de variation de notre protocole

22/03/2024 :

1. Dans un premier temps, nous avons mis en place un protocole expériemental pour réaliser nos futurs courbes :

remarque : Nous avons choisi d'utiliser de l'aluminium pour assurer des condition sans lumière lors des mesures

2. Ensuite, nous avons réalisé la solution mère qui nous servira à réaliser les mesures nécessaires pour produire 3 courbes V=f(Q)

Solution mère à 0,025g.mL-1 dans un volume de 400mL au total et pour une masse en sédiment de 10g :

photo solution mère avec barreau aimanté

3. A la suite de ça,nous avons réalisé la suite du protocole expériemental jusqu'à obtenir une première courbe.

photo du montage avec le cache en aluminium

mesure du blanc : 4,52 V

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/