TurboCocco 3e génération

26/01/2024 :

1. Capteur de turbidité

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

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

2. Projet

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 : 

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

2. Démarche :

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

3. 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 quantité de sédiment : 

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

3. 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 « fraîche », à 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 le traitement des données sur tableur, 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ère,2/V_mère,2 = 10 g.

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 :

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

Mesure du blanc : 4.52 V

Données obtenues pour la courbe 1 : 

Allure de la courbe 1 :

Objectifs suivants :

• Réaliser les courbes 2 et 3 pour pouvoir avoir un écart-type
• identifier précisément toutes les sources d'erreurs du protocole
• faire des photos des montages pour les ajouter au wiki
• faire des photos du frottis de Limagne pour illustrer nos propos

19/03/2024 :

1. Notre objectif du jour était d'effectuer les mesures de turbidité restantes. Après discussion avec Fabrice Minoletti pour qui nous réalisons ce projet, nous avons décider de ne pas réaliser 3 fois les mesures pour chaque concentration mais d'en réaliser 10 à trois concentrations différentes afin de pouvoir déterminer un écart-type moyen en chaque point. Nous avons donc décider de réaliser ces mesures à Q₃ = 5x10^-4 g/mL, Q5 = 2x10^-3 g/mL et Q7 = 4x10^-3 g/mL car ces points sont situés dans la partie de la courbe où le capteur est très sensible à des changements de turbidité. Nous avons ainsi réutilisé le même protocole que la semaine dernière pour réaliser nos solutions filles et effectuer nos mesures avec un cache en aluminium.

Nous avons obtenu les résultats suivant : 

L'écart-type moyen sur ces mesures est de 0.044 V ce qui est faible compte-tenu de la sensibilité de notre capteur. On peut donc en déduire que notre protocole est bien reproductible et que les variations sont faibles. De plus, l'écart-type est similaire à ces 3 concentrations donc nous pouvons supposer qu'il le sera également à d'autres charges sédimentaires. Ainsi, nous pouvons ajouter l'écart-type sur notre courbe v = f(Q) : 

Nous avons également tracé la courbe de tendance grâce à Excel. Celle-ci s'apparente à une polynomiale de degré 4 dont l'équation pourra être utilisé pour prédire le résultat de potentielles mesures à différentes concentrations et donc calibrer le capteur en g/mL de charge sédimentaire.

2. Nous avons par ailleurs réalisé un nouveau frottis avec notre solution mère, afin de déterminer précisément la nature des éléments présents dedans. 

Nous avons ensuite observé le résultat de notre frottis au microscope et pu identifier les fragments présents dans notre solution.

Éléments observés : 

• Coccolithes de taille allant de 3,5 à 4 µm
• Coccosphères de 6-7 µm
• Oxydes de fer

Photo du frottis de Ste Marguerite broyé puis passé aux ultrasons, observé au MO

Objectifs suivants :

• Lister toutes les incertitudes de notre protocole
• Calculer la variance de nos mesures 
• Mol affiche la concentration de la solution (équation de la forme Q = valeur numérique + résidu systématique)

05/04/2024 :

1. Nous avons commencé par lister toutes les sources d'incertitudes de notre protocole, dans un soucis de clarification.

Liste des incertitudes :

• Notre solution-mère n’est pas parfaitement homogène : des grosses particules sédimentaires sont présentes dans le fond du bécher et en suspension. Ainsi, lors du pipetage, ces grosses particules ont une faible probabilité d’être pipettées, donc la solution dans le tube est toujours légèrement moins concentrée qu’en théorie. De plus, les grosses particules peuvent bloquer le cône de la pipette et donc modifier le volume prélevé (cette incertitude peut être enlevée en faisant suffisamment attention ?)

• Incertitudes liées à la pipette elle-même

• A chaque fois, nous avons rempli le tube jusqu’au trait de jauge. Le volume n’était donc pas parfaitement exact mais toujours suffisant pour que les broches du capteur soient totalement immergées, afin que les mesures se fassent dans des conditions optimales. La seule conséquence est donc liée à une faible variation de la charge sédimentaire dans notre tube.

• L’obscurité a été faite grâce à un cache en aluminium qui ne peut pas garantir une obscurité idéale. Pour avoir des conditions parfaites, il aurait fallu se mettre dans une pièce complètement noire ou créer un cache noir sur mesure.

• Un seul capteur a été utilisé. Nous n’avons donc pas testé la reproductibilité de notre protocole avec un autre capteur similaire

• Dans des conditions constantes, il y a une variation de 0,02 V environ, qui est dûe au capteur.

• incertitudes liées à l’expérimentateur

• Lecture de la mesure : les mesures se font toutes les 500 ms. Or on lit la mesure avec à plus ou moins une seconde d’écart près après le dépôt du tube dans le portoir. Cependant, cela ne change pas réellement la valeur de turbidité notée car il n’y a pas de variation significative dans les premières secondes.

2. Modélisation; sortie Arduino

Il s'est avéré que notre équation de modélisation (polynôme d'ordre 4) pour notre courbe V = f(Q) présentait plusieurs inconvénients. D'abord, à la différence de modèles comme une exponentielle ou un logarithme, un polynôme d'ordre 4 ne peut pas être rapproché à une réelle signification physique (exemple : la décroissance radioactive pour une exponentielle). Aussi, il est presque impossible de résoudre l'équation.

Nous voulions adapter notre programme sous Arduino pour que les mesures en volt soient automatiquement converties en charge sédimentaire. Or, il est impossible de trouver x dans l'équation modèle : 

y = 6*10^8x^4 - 2*10^7x^3 + 273764x^2 - 1685,8x + 4,5528

avec x = inconnue = charge sédimentaire ; y = Voltage. 

Une première approche serait de mettre la charge en ordonnée et le voltage en abscisse, ce qui rendrait la conversion possible en sortie Arduino.

D'un autre côté, nous avons essayé d'adapter notre courbe au modèle exponentiel mais le logiciel Excel ne permet pas de modifier soi-même les paramètres. En passant par le logiciel R, nous voulions voir si le modèle exponentielle ajusté au maximum pourrait convenir.

library(minpack.lm)
library(ggplot2)

y <- c(data3$Q)
x <- c(data3$V)

start_values <- c(a=4, b=2)
fit <- nls(y ~ a * exp(b * x),
           start = start_values,
           algorithm = "port",
           control = nls.control(maxiter = 1000))
summary(fit)

# plotting
ggplot(data.frame(x, y), aes(x, y)) +
  geom_point(size=3) +
  geom_smooth(aes(x, predict(fit, newdata = data.frame(x))), se=FALSE, size=1, color="blue") +
  ggtitle("Suivi de la concentration en sédiment de Limagne en fonction du voltage") +
  xlab("Voltage (en V)") +
  ylab("[Limagne] (en g/mL)")+
  annotate("text", x=3, y=0.0091, label="y = 0.0149441 * e(-1.2379691 * x)")+
  theme_bw()+
  theme(plot.title = element_text(hjust = 0.5))

install.packages("minpack.lm")
install.packages("ggplot2")

Figure obtenue sous R

On obtient une modélisation assez satisfaisante avec cette méthode : c'est probablement ce modèle que nous allons retenir pour la suite.

3. Poster et présentation orale

Nous avons commencé à réfléchir à la structure de notre poster, sous les conseils de Fabrice Minoletti

Objectifs suivants : 

• Finaliser d'adapter la modélisation et le code Arduino

• Préparer le matériel pour une possible démonstration lors de la présentation orale

• Préparer notre poster de présentation

26/04/2024 :

Notre objectif du jour était de finaliser notre modélisation afin de pouvoir mettre en place notre code Arduino final.

1. Modélisation de la courbe et détermination de l'équation

Après avoir réétudié notre courbe v = f(Q), nous avons supposé qu'il est plus judicieux d'associer notre exponentielle modèle avec une droite. En effet, on peut remarquer que la première partie de la courbe suit bien une exponentielle mais que la seconde partie s'apparente plus à une droite. Pour cela, nous avons conservé notre équation de la forme y = ax + exp(bx) mais nous y avons ajouté une seconde partie avec l'équation d'une droite. Ainsi, on obtient une équation de la forme :

y = ax + exp(bx) + cx + d avec y la charge sédimentaire en mg/mL et x le voltage en volts.

La courbe ainsi obtenue sous R n'étant pas convaincante, nous avons rentré nos valeurs de charge sédimentaire, de voltage ainsi que notre équation dans Matlab. On obtient alors le graphique suivant dans lequel on voit que la courbe modèle correspond très bien aux valeurs expérimentales :

Le logiciel nous a également déterminé les valeurs des différents paramètres de notre courbe avec leurs écarts-types. Ainsi, on obtient :

      Valeur     Lower        Upper  
a    0.0176      0.0152      0.0200
b    -3.1739    -3.7525    -2.5952
c    -0.0009     -0.0011    -0.0008
d    0.0041      0.0035      0.0047

Le coefficient de régression R2 étant de 0.9986, c'est-à-dire très proche de 1, on en déduit que notre modèle est bien adapté à nos valeurs. On obtient donc l'équation suivante : 

Q = 0.018 * exp(-3.174 * voltage) - 0.0009 * voltage + 0.004

2. Adaptation du code Arduino

Notre objectif est de créer un code Arduino permettant de déterminer la charge sédimentaire d'une suspension en fonction du voltage mesuré par le capteur. Pour cela, nous avons modifié le code préexistant afin d'y ajouter le calcul de la charge (=turbidité).

Tout d'abord nous avons défini les limites de notre modèle au-delà desquelles notre modèle n'est plus valide car le capteur est saturé. 

const float MIN_VOLTAGE = 0.25; // Tension minimale pour le calcul de turbidité
const float MAX_VOLTAGE = 4.45; // Tension maximale pour le calcul de turbidité

Nous avons ensuite inséré l'équation de la turbidité que nous avons obtenue précédemment : 

 // Utiliser l'équation de courbe modèle pour calculer la turbidité
    float turbidity = 0.018 * exp(-3.174 * voltage) - 0.0009 * voltage + 0.004;

On indique ensuite au programme de vérifier que la valeur de tension est comprise dans notre intervalle. Si oui, il nous affiche le temps écoulé depuis le début des mesures, le voltage mesuré et la turbidité calculée. Sinon, le programme affiche un message "turbidité hors calibration" signifiant à l'utilisateur que le capteur n'est pas calibré pour mesurer une turbidité à ce voltage. Autrement, le voltage mesuré est trop faible ou trop élevé par rapport à la sensibilité du capteur.

    // Vérifier si la tension est dans la plage spécifiée
    if (voltage >= MIN_VOLTAGE && voltage <= MAX_VOLTAGE) {
    // 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.print(voltage, 3); // Afficher la valeur du voltage avec 3 décimales
    Serial.print(" ");
    Serial.println(turbidity, 5); //Aficher la valeur de la turbidité avec 5 décimales. La fonction serial.println permet d'aller à la ligne
  }  else {
   // La tension est hors de la plage de calibration
    Serial.print(elapsedTime / 1000); // Convertir les millisecondes en secondes
    Serial.print(" ");
    Serial.print(voltage, 3); // Afficher la valeur du voltage avec 3 décimales
    Serial.print(" ");
    Serial.println("turbidité hors calibration"); // Afficher la valeur de la turbidité avec 5 décimales
  }

3. Détermination de l'écart-type

Nous souhaitons également déterminer un écart-type qui s'affichera sur le code pour chaque valeur de turbidité. Pour cela, nous sommes partis sur une première méthode : calculer l'écart-type σ en fonction des dérivées partielles en a, b, c et d, ce qui correspond à l'incertitude sur notre modèle et y ajouter l'incertitude sur nos propres valeurs : 

σ_y = (σ_a + ab * σ_b) * e^bx + xσ_c + σ_d + (ab e^bx + c) * σ_x

Pour cela nous avons utilisé les valeurs obtenues sur Matlab pour calculer l'écart-type moyen sur a, b, c et d respectivement. On obtient : 

Pour σ_x, nous avons utilisé la valeur de l'écart-type moyen calculé le 19/03 soit 0, 04438 V. Cependant, après avoir installé cet écart-type dans Arduino afin qu'il soit calculé en chaque point, nous avons remarqué que les valeurs étaient beaucoup trop élevées pour que l'écart-type soit significatif. 

Nous avons donc choisi d'utiliser une autre méthode qui ne calcule pas l'écart-type en chaque point mais qui permet d'obtenir une valeur moyenne qui sera correcte à chaque fois. Nous avons ainsi utilisé la formule de la SCE_R (Somme des Carrés des Écarts résiduelle) qui permet de déterminer la dispersion des résidus. 

SCE_R = Σ(y_observé - y_théorique)² 

Les y_théorique ont été obtenus grâce à l'équation de notre courbe tandis que les y_observé correspondent aux charges sédimentaires que nous avions mis en place lors de nos mesures. 

On trouve : SCE_R = 3.17 * 10^-7

Cela nous permet de calculer l'écart-type des résidus d'après la formule : σ² = SCE_R/(N-n) où N correspond au nombre d'échantillons (ici 11 mesures) et n le nombre de paramètres (ici 4 : a, b, c et d). 

On a donc σ = √(3.17 10^-7 / (11-4) = 2.13 * 10^-4 g/mL

4. Insertion de l'écart-type dans Arduino

Tout d'abord, nous avons rajouté une colonne correspondant à l'écart-type dans l'affichage de nos résultats : 

 Serial.println("T V Q σ"); // Titres des colonnes séparées avec un espace

Nous avons ensuite indiquer que nous voulons afficher la valeur de σ : 

 // Vérifier si la tension est dans la plage spécifiée
    if (voltage >= MIN_VOLTAGE && voltage <= MAX_VOLTAGE) {
    // 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.print(voltage, 3); // Afficher la valeur du voltage avec 3 décimales
    Serial.print(" ");
    Serial.print(turbidity, 5); //Aficher la valeur de la turbidité avec 5 décimales. La fonction serial.println permet d'aller à la ligne
    Serial.print(" ");
    Serial.println(2.13E-04, 6); //Afficher l'écart-type avec 6 décimales

On obtient alors le code suivant : 

#include <Wire.h>

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
const float MIN_VOLTAGE = 0.25; // Tension minimale pour le calcul de turbidité
const float MAX_VOLTAGE = 4.45; // Tension maximale pour le calcul de turbidité

// 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 = 1000; // Intervalle initial de mesure (1000 millisecondes)

void setup() {
  Serial.begin(9600); // Baud rate: 9600
  startTime = millis(); // Enregistrer le temps de démarrage
  Serial.println("T V Q σ"); // 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
    
    // Utiliser l'équation de courbe modèle pour calculer la turbidité
    float turbidity = 0.018 * exp(-3.174 * voltage) - 0.0009 * voltage + 0.004;

    // Vérifier si la tension est dans la plage spécifiée
    if (voltage >= MIN_VOLTAGE && voltage <= MAX_VOLTAGE) {
    // 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.print(voltage, 3); // Afficher la valeur du voltage avec 3 décimales
    Serial.print(" ");
    Serial.print(turbidity, 5); //Aficher la valeur de la turbidité avec 5 décimales. La fonction serial.println permet d'aller à la ligne
    Serial.print(" ");
    Serial.println(2.13E-04, 6); //Afficher l'écart-type avec 6 décimales
  }  else {
   // La tension est hors de la plage de calibration
    Serial.print(elapsedTime / 1000); // Convertir les millisecondes en secondes
    Serial.print(" ");
    Serial.print(voltage, 3); // Afficher la valeur du voltage avec 3 décimales
    Serial.print(" ");
    Serial.println("turbidité hors calibration"); // Afficher la valeur de la turbidité avec 5 décimales
  }
  }
}

Nous avons réussi à atteindre notre objectif ! En utilisant le capteur et notre programme, l'expérimentateur pourra connaître la charge sédimentaire d'une suspension de sédiments de Limagne. Ce projet pourra être réutilisé pour des types de sédiments similaires ou être adapté sur d'autres sédiments.

Objectifs suivants : 

• Préparer le matériel pour une possible démonstration lors de la présentation orale
• Préparer notre poster de présentation

• Voltage de fonctionnement : 5V 

• Intensité du courant électrique en fonctionnement : 40mA (MAX)

• Temps de réponse : <500ms

• Méthodes de sortie :

• Sortie analogique: 0-4.5V

• Sortie digitale : Signal faible/fort (ajustable en adaptant le potentiomètre)

• Température de fonctionnement : 5℃~90℃

• Température de stockage : -10℃~90℃

• Poids : 30g

• Dimensions : 38mm*28mm*10mm

Représentation schématique du fonctionnement du capteur

Une première broche contient un émetteur de lumière, l’autre un récepteur. La tension du système varie en fonction de la quantité de lumière transmise. Plus la turbidité du milieu extérieur (=entre les deux broches) est élevée, plus la tension électrique en sortie du capteur est faible. 

La tension électrique en volts est donc reliée négativement à la turbidité. 

Notons, qu’il est plus habituel de voir la turbidité quantifiée en NTU (Nephelometric Turbidity Unit). Nous n’avons cependant pas testé la correspondance entre le voltage mesuré par notre capteur et les NTU.

De ce fait, toutes nos mesures et nos résultats sont pour l’instant à considérer uniquement avec ce capteur (jusqu’à ce que la relation volts-NTU soit caractérisée). Néanmoins, cela n’est pas censé avoir d’impact sur la relation que l’on a réussi à caractériser entre la charge de sédiment en suspension et la turbidité de la suspension.

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

#include <Wire.h>

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
const float MIN_VOLTAGE = 0.25; // Tension minimale pour le calcul de turbidité
const float MAX_VOLTAGE = 4.45; // Tension maximale pour le calcul de turbidité

// 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 = 1000; // Intervalle initial de mesure (1000 millisecondes)

void setup() {
  Serial.begin(9600); // Baud rate: 9600
  startTime = millis(); // Enregistrer le temps de démarrage
  Serial.println("T V Q σ"); // 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
    
    // Utiliser l'équation de courbe modèle pour calculer la turbidité
    float turbidity = 0.018 * exp(-3.174 * voltage) - 0.0009 * voltage + 0.004;

    // Vérifier si la tension est dans la plage spécifiée
    if (voltage >= MIN_VOLTAGE && voltage <= MAX_VOLTAGE) {
    // 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.print(voltage, 3); // Afficher la valeur du voltage avec 3 décimales
    Serial.print(" ");
    Serial.print(turbidity, 5); //Aficher la valeur de la turbidité avec 5 décimales. La fonction serial.println permet d'aller à la ligne
    Serial.print(" ");
    Serial.println(2.13E-04, 6); //Afficher l'écart-type avec 6 décimales
  }  else {
   // La tension est hors de la plage de calibration
    Serial.print(elapsedTime / 1000); // Convertir les millisecondes en secondes
    Serial.print(" ");
    Serial.print(voltage, 3); // Afficher la valeur du voltage avec 3 décimales
    Serial.print(" ");
    Serial.println("turbidité hors calibration"); // Afficher la valeur de la turbidité avec 5 décimales
  }
  }
}

• Notre solution-mère n’est pas parfaitement homogène : des grosses particules sédimentaires sont présentes dans le fond du bécher et en suspension. Ainsi, lors du pipetage, ces grosses particules ont une faible probabilité d’être pipettées, donc la solution dans le tube est toujours légèrement moins concentrée qu’en théorie. De plus, les grosses particules peuvent bloquer le cône de la pipette et donc modifier le volume prélevé (cette incertitude peut être enlevée en faisant suffisamment attention ?)
• Incertitudes liées à la pipette elle-même
• A chaque fois, nous avons rempli le tube jusqu’au trait de jauge. Le volume n’était donc pas parfaitement exact mais toujours suffisant pour que les broches du capteur soient totalement immergées, afin que les mesures se fassent dans des conditions optimales. La seule conséquence est donc liée à une faible variation de la charge sédimentaire dans notre tube.
• L’obscurité a été faite grâce à un cache en aluminium qui ne peut pas garantir une obscurité idéale. Pour avoir des conditions parfaites, il aurait fallu se mettre dans une pièce complètement noire ou créer un cache noir sur mesure.
• Un seul capteur a été utilisé. Nous n’avons donc pas testé la reproductibilité de notre protocole avec un autre capteur similaire
• Dans des conditions constantes, il y a une variation de 0,02 V environ, qui est due au capteur.
• incertitudes liées à l’expérimentateur
• Lecture de la mesure : les mesures se font toutes les 500 ms. Or on lit la mesure avec à plus ou moins une seconde d’écart près après le dépôt du tube dans le portoir. Cependant, cela ne change pas réellement la valeur de turbidité notée car il n’y a pas de variation significative dans les premières secondes.