Capteur TDS Arduino : mesurer les ppm, calibrer et suivre l'eau

Associer un capteur TDS à un Arduino, c'est obtenir un testeur de qualité d'eau bon marché qui indique en quelques secondes, en ppm (parties par million), la quantité de minéraux, de sels et de métaux dissous dans l'eau. Le TDS (Total Dissolved Solids), c'est-à-dire les solides dissous totaux, est la mesure la plus pratique pour juger de la dureté de l'eau du robinet, vérifier qu'un osmoseur fonctionne encore, savoir quand changer l'eau d'un aquarium ou doser une solution nutritive hydroponique. Les testeurs TDS en forme de stylo reposent sur le même principe ; avec un Arduino, tu peux enregistrer la mesure en continu, l'afficher sur un écran et déclencher une alerte quand un seuil est dépassé.

Dans cet article, on voit pas à pas ce que signifient les ppm, comment le capteur mesure en réalité la conductivité, comment la température influence le résultat et comment la corriger avec un DS18B20, le calibrage avec une solution étalon, le code pour Arduino Uno, des tableaux de valeurs pour l'eau potable, l'aquarium et l'hydroponie, le suivi d'un filtre à eau, l'enregistrement horodaté avec l'ESP32 et le code pour le Raspberry Pi Pico. Dans la dernière partie, tu verras ce qui distingue un capteur TDS d'un capteur de pH, ainsi que les erreurs les plus fréquentes.

Qu'est-ce que le TDS et que veut dire ppm ?

Le TDS est la quantité totale de toutes les substances dissoutes dans un litre d'eau : des ions comme le calcium, le magnésium, le sodium, le potassium, le bicarbonate, le chlorure, le sulfate et le nitrate en forment l'essentiel. L'unité est le ppm (parties par million) ou son équivalent dans l'eau, le mg/L ; 1 ppm signifie 1 milligramme de matière dissoute dans 1 litre d'eau. Chaque litre d'une eau du robinet à 250 ppm contient donc un quart de gramme de minéraux. L'eau pure (distillée) a un TDS très proche de zéro, l'eau de mer environ 35 000 ppm.

Il faut savoir d'emblée que le TDS à lui seul ne dit pas si l'eau est « propre ou sale ». Une eau de source très minéralisée peut avoir un TDS élevé et être parfaitement saine ; à l'inverse, une eau à faible TDS peut contenir des bactéries, du plomb ou des pesticides, car ils modifient à peine la conductivité. Le capteur TDS est parfait pour suivre la charge minérale de l'eau et ses variations ; pour la sécurité microbiologique, il faut une analyse en laboratoire.

Comment fonctionne un capteur TDS ? De la conductivité aux ppm

Les capteurs TDS vendus pour Arduino sont en réalité des conductimètres (EC). L'eau pure ne conduit presque pas l'électricité ; plus elle contient d'ions dissous, plus sa conductivité augmente. La carte applique une petite tension entre les deux électrodes au bout de la sonde et mesure le courant qui passe. Cette tension est alternative et non continue : en courant continu, des bulles de gaz s'accumuleraient sur les électrodes (polarisation), la mesure dériverait et les électrodes s'useraient vite. La carte convertit le résultat en une tension analogique de 0 à 2,3 V ; l'Arduino la lit, la convertit d'abord en conductivité (µS/cm), puis en TDS avec un facteur de conversion.

Le passage de la conductivité au TDS est une approximation : TDS (ppm) = EC (µS/cm) × k. La plupart des appareils, et le code de cet article, utilisent k = 0,5 (échelle chlorure de sodium, dite « 500 »). Certains appareils pour l'hydroponie utilisent 0,7 ; deux appareils peuvent donc afficher la même eau à 500 et 700 ppm et avoir « raison » tous les deux. Vérifie le facteur utilisé quand tu compares des valeurs et, en hydroponie, travaille si possible directement avec l'EC (mS/cm).

Compensation de température : pourquoi un DS18B20 ?

La conductivité de l'eau varie nettement avec la température : les ions bougent plus vite en chauffant, et la même eau paraît environ 2 % plus conductrice par degré. Entre deux mesures de la même eau à 15 °C et à 30 °C, l'écart atteint environ un tiers : une erreur bien plus grande que la mesure elle-même. C'est pourquoi les mesures de TDS sont ramenées à 25 °C : tension corrigée = tension mesurée / (1 + 0,02 × (T − 25)). Le capteur le plus adapté pour la température de l'eau est le DS18B20 étanche sous gaine inox, plongé dans la même eau à côté de la sonde TDS.

Le DS18B20 utilise un protocole à un seul fil de données appelé OneWire et offre une précision de ±0,5 °C. Il demande une résistance de rappel (pull-up) de 4,7 kΩ entre la ligne de données et VCC ; si tu ne connais pas le code couleur, consulte l'outil code couleur des résistances. Pour les détails du capteur et le branchement de plusieurs DS18B20 sur la même ligne, lis l'article capteur de température DS18B20. Sans capteur de température, le code suppose 25 °C, ce qui suffit pour des tests simples à température ambiante.

Câblage : Arduino Uno, ESP32 et Pico

Code TDS pour Arduino : filtre médian et compensation

1. Installe les bibliothèques OneWire et DallasTemperature depuis le gestionnaire de bibliothèques.
2. Branche le module TDS et le DS18B20 comme dans le tableau ; plonge la sonde et le capteur de température dans la même eau.
3. Téléverse le code et ouvre le moniteur série à 115200 bauds.
4. Attends 20 à 30 secondes que les valeurs se stabilisent ; juste après l'immersion, les premières mesures fluctuent.
5. Si tu as une solution d'étalonnage de valeur connue, plonges-y la sonde et tape par exemple cal:707 dans le moniteur série.

1#include <OneWire.h>
2#include <DallasTemperature.h>
3#include <EEPROM.h>
4
5const int TDS_PIN = A0;          // TDS modülü sinyal (A) / TDS module signal (A)
6const int DS_PIN = 2;            // DS18B20 veri, 4,7 kΩ pull-up / DS18B20 data, 4.7 kΩ pull-up
7const float VREF = 5.0;          // Uno ADC referansı / Uno ADC reference
8const int ORNEK = 30;            // medyan filtresi örnek sayısı / samples for the median filter
9
10OneWire oneWire(DS_PIN);
11DallasTemperature ds(&oneWire);
12
13int ornekler[ORNEK];
14int indeks = 0;
15float kFaktor = 1.0;             // kalibrasyon katsayısı (EEPROM'da) / calibration factor (in EEPROM)
16float sicaklik = 25.0;
17float gerilim = 0;
18unsigned long sonOrnek = 0, sonOlcum = 0;
19
20int medyan() {                   // gürültüye karşı ortanca değer / median against noise
21  int t[ORNEK];
22  memcpy(t, ornekler, sizeof(t));
23  for (int i = 1; i < ORNEK; i++) {          // ekleme sıralaması / insertion sort
24    int x = t[i], j = i - 1;
25    while (j >= 0 && t[j] > x) { t[j + 1] = t[j]; j--; }
26    t[j + 1] = x;
27  }
28  return (t[ORNEK / 2] + t[ORNEK / 2 - 1]) / 2;
29}
30
31float tdsHesapla(float volt, float derece, float k) {
32  float komp = 1.0 + 0.02 * (derece - 25.0); // %2/°C sıcaklık kompanzasyonu / 2 %/°C compensation
33  float v = volt / komp;                     // 25 °C'ye indirgenmiş gerilim / voltage at 25 °C
34  float ec = 133.42 * v * v * v - 255.86 * v * v + 857.39 * v;   // iletkenlik, µS/cm / conductivity
35  return ec * 0.5 * k;                       // TDS (ppm) = EC x 0,5 / TDS (ppm) = EC x 0.5
36}
37
38void setup() {
39  Serial.begin(115200);
40  ds.begin();
41  ds.setWaitForConversion(false);            // 750 ms beklemeden ölç / measure without blocking 750 ms
42  ds.requestTemperatures();
43  EEPROM.get(0, kFaktor);
44  if (isnan(kFaktor) || kFaktor < 0.5 || kFaktor > 2.0) kFaktor = 1.0;   // boş EEPROM / empty EEPROM
45  Serial.println("Kalibrasyon / calibration: cal:707 gibi yaz / type e.g. cal:707");
46}
47
48void loop() {
49  if (millis() - sonOrnek >= 40) {           // 40 ms'de bir örnek / one sample every 40 ms
50    sonOrnek = millis();
51    ornekler[indeks] = analogRead(TDS_PIN);
52    indeks = (indeks + 1) % ORNEK;
53  }
54
55  if (millis() - sonOlcum >= 1000) {         // saniyede bir sonuç / one result per second
56    sonOlcum = millis();
57    float t = ds.getTempCByIndex(0);
58    if (t != DEVICE_DISCONNECTED_C) sicaklik = t;   // sensör yoksa 25 °C / 25 °C if no sensor
59    ds.requestTemperatures();                // bir sonraki okuma için / for the next reading
60    gerilim = medyan() * VREF / 1024.0;
61    float tds = tdsHesapla(gerilim, sicaklik, kFaktor);
62    Serial.print("Sicaklik / temp: ");
63    Serial.print(sicaklik, 1);
64    Serial.print(" C  TDS: ");
65    Serial.print(tds, 0);
66    Serial.println(" ppm");
67  }
68
69  if (Serial.available()) {                  // "cal:707" -> bilinen sıvıya göre K / K from a known solution
70    String s = Serial.readStringUntil('\n');
71    s.trim();
72    if (s.startsWith("cal:")) {
73      float hedef = s.substring(4).toFloat();
74      float ham = tdsHesapla(gerilim, sicaklik, 1.0);
75      if (hedef > 0 && ham > 10) {
76        kFaktor = hedef / ham;
77        EEPROM.put(0, kFaktor);              // kalıcı kaydet / save permanently
78        Serial.print("Yeni K / new K: ");
79        Serial.println(kFaktor, 3);
80      }
81    }
82  }
83}
84

Le polynôme du troisième degré du code est une courbe empirique qui convertit la tension de sortie de la carte en conductivité ; un simple multiplicateur ne suffit pas car le circuit n'est pas linéaire. Cette courbe vaut pour la carte TDS courante de type Gravity ; avec une autre carte, utilise la formule du fabricant ou établis ta propre courbe avec quelques solutions connues. N'oublie pas que sur un Uno alimenté en 5 V la lecture analogique se rapporte à 5,0 V, et à 3,3 V sur l'ESP32 et le Pico ; si VREF ne correspond pas à ta carte, les résultats sont faux dès le départ.

Calibrer le capteur TDS avec une solution étalon

Chaque sonde et chaque carte présentent de petites différences ; pour un résultat précis, calibre le capteur avec un liquide de valeur connue. La solution étalon de chlorure de potassium (KCl) à 1413 µS/cm, disponible chez les fournisseurs de matériel de laboratoire et d'électronique, est la plus courante ; avec le facteur 0,5, elle correspond à environ 707 ppm. La solution de chlorure de sodium à 342 ppm fournie avec certains testeurs stylo convient aussi. Pour calibrer, rince la sonde à l'eau propre, sèche-la avec du papier absorbant, plonge-la dans la solution, attends 1 à 2 minutes et tape dans le moniteur série cal: suivi de la valeur en ppm de la solution. Le code enregistre dans l'EEPROM le rapport entre la valeur mesurée et la valeur réelle comme facteur K ; le réglage reste en mémoire même hors tension.

Tableau TDS : eau potable, aquarium et hydroponie

Savoir ce que signifie le nombre mesuré compte autant que le capteur lui-même. Selon l'évaluation gustative de l'Organisation mondiale de la santé, une eau sous 300 ppm a un goût excellent, de 300 à 600 ppm bon, de 600 à 900 ppm correct, de 900 à 1200 ppm médiocre et au-delà de 1200 ppm inacceptable. Ce sont des plages de goût et de confort, pas des limites sanitaires. Le tableau résume les valeurs typiques pour les usages courants.

En hydroponie, la solution nutritive s'exprime généralement en conductivité (EC) et dépend de la plante. Attention toutefois : la plage de ce capteur s'arrête à 1000 ppm, et la solution des plantes gourmandes comme la tomate ou le poivron la dépasse. Dans ce cas, dilue un échantillon dans de l'eau distillée selon un rapport connu, mesure-le et multiplie le résultat, ou utilise directement un capteur EC à plage plus large.

Suivre un filtre à eau

L'usage le plus utile d'un capteur TDS à la maison est la surveillance d'un osmoseur (RO). Une membrane d'osmose en bon état retient la plupart des minéraux de l'eau d'entrée ; avec 300 ppm en entrée, la sortie tourne en général autour de 10 à 30 ppm. On calcule la performance avec taux de rejet = (1 − sortie / entrée) × 100 : si 300 ppm entrent et 15 ppm sortent, le taux est de 95 %. En vieillissant, la membrane laisse remonter peu à peu le TDS de sortie ; quand le taux commence à passer sous 80 à 85 %, le moment de changer la membrane et les préfiltres approche. Un Arduino avec deux sondes et deux DS18B20 mesurant en même temps l'entrée et la sortie peut tracer cette évolution sur des mois.

Enregistrer le TDS avec l'ESP32

Avec l'ESP32, tu peux enregistrer les mesures de TDS une fois par minute avec un horodatage et les envoyer plus tard sur internet. Le code ci-dessous récupère l'heure sur internet par NTP, mesure chaque minute la température de l'eau et le TDS, et ajoute des lignes « date,température,tds » à un fichier « /tds.csv » du système de fichiers LittleFS dans la mémoire flash de la carte. Tu pourras ensuite ouvrir ce fichier dans Excel et tracer une courbe. L'ADC de l'ESP32 n'est pas linéaire ; le code utilise donc analogReadMilliVolts(), qui exploite les données d'étalonnage stockées dans la puce. Branche le signal TDS sur une broche ADC1 (GPIO 32 à 39), qui fonctionne Wi-Fi actif ; les broches ADC2 ne sont pas utilisables avec le Wi-Fi. L'heure NTP est expliquée dans l'article ESP32 NTP.

1#include <WiFi.h>
2#include <LittleFS.h>
3#include <OneWire.h>
4#include <DallasTemperature.h>
5#include <time.h>
6
7const char* WIFI_SSID = "AgAdi";
8const char* WIFI_PASS = "Sifre123";
9const int TDS_PIN = 34;                      // ADC1 kanalı, Wi-Fi ile çalışır / ADC1 channel, works with Wi-Fi
10const int DS_PIN = 4;
11const float K_FAKTOR = 1.0;                  // Arduino'daki gibi kalibre et / calibrate as on the Arduino
12const unsigned long ARALIK_MS = 60000;       // dakikada bir kayıt / one log per minute
13
14OneWire oneWire(DS_PIN);
15DallasTemperature ds(&oneWire);
16unsigned long sonKayit = 0;
17
18float gerilimOku() {                         // 30 örneğin ortancası, volt / median of 30 samples, volts
19  int mv[30];
20  for (int i = 0; i < 30; i++) { mv[i] = analogReadMilliVolts(TDS_PIN); delay(5); }
21  for (int i = 1; i < 30; i++) {
22    int x = mv[i], j = i - 1;
23    while (j >= 0 && mv[j] > x) { mv[j + 1] = mv[j]; j--; }
24    mv[j + 1] = x;
25  }
26  return mv[15] / 1000.0;
27}
28
29float tdsHesapla(float v, float derece) {
30  v = v / (1.0 + 0.02 * (derece - 25.0));    // sıcaklık kompanzasyonu / temperature compensation
31  return (133.42 * v * v * v - 255.86 * v * v + 857.39 * v) * 0.5 * K_FAKTOR;
32}
33
34void setup() {
35  Serial.begin(115200);
36  ds.begin();
37  LittleFS.begin(true);                      // ilk açılışta biçimlendir / format on first boot
38  WiFi.begin(WIFI_SSID, WIFI_PASS);
39  while (WiFi.status() != WL_CONNECTED) delay(500);
40  configTzTime("<+03>-3", "pool.ntp.org");   // zaman damgası için NTP / NTP for timestamps
41}
42
43void loop() {
44  if (millis() - sonKayit < ARALIK_MS && sonKayit != 0) return;
45  sonKayit = millis();
46
47  ds.requestTemperatures();                  // ~750 ms bekler / waits ~750 ms
48  float derece = ds.getTempCByIndex(0);
49  if (derece == DEVICE_DISCONNECTED_C) derece = 25.0;
50  float tds = tdsHesapla(gerilimOku(), derece);
51
52  struct tm t;
53  char zaman[20] = "saat-yok";
54  if (getLocalTime(&t, 2000)) strftime(zaman, sizeof(zaman), "%Y-%m-%d %H:%M:%S", &t);
55
56  char satir[64];
57  snprintf(satir, sizeof(satir), "%s,%.1f,%.0f", zaman, derece, tds);
58  File f = LittleFS.open("/tds.csv", FILE_APPEND);   // tarih,sicaklik,tds / date,temp,tds
59  if (f) { f.println(satir); f.close(); }
60  Serial.println(satir);
61}
62

Pour mettre l'historique en ligne, tu peux envoyer la même ligne vers une feuille Google Sheets ou vers Home Assistant en MQTT au lieu de LittleFS ; détails dans les articles ESP32 Google Sheets et ESP32 MQTT. La mémoire flash supporte un nombre limité d'écritures ; une courte ligne par minute ne pose aucun problème, mais plutôt que d'écrire chaque seconde, prends l'habitude de regrouper les mesures en RAM et de les écrire par lots.

TDS avec le Raspberry Pi Pico (MicroPython)

Sur le Pico, le signal TDS va sur GP26 (ADC0) et le DS18B20 sur GP22. En MicroPython, les modules onewire et ds18x20 nécessaires au DS18B20 sont intégrés au firmware, rien à installer. L'ADC du Pico renvoie avec read_u16() une valeur entre 0 et 65535, que l'on convertit en tension sur la base de 3,3 V. La formule et la compensation sont les mêmes que dans le code Arduino ; tu peux trouver K_FAKTOR avec la méthode d'étalonnage de l'Arduino et l'écrire dans le code.

1from machine import ADC, Pin
2import onewire, ds18x20, time
3
4adc = ADC(26)                     # GP26 = ADC0, TDS sinyali / TDS signal
5ds = ds18x20.DS18X20(onewire.OneWire(Pin(22)))   # DS18B20 veri pini / data pin
6roms = ds.scan()
7K_FAKTOR = 1.0                    # kalibrasyon katsayısı / calibration factor
8
9def gerilim_oku(n=31):            # ortanca ile gürültü filtresi / median noise filter
10    olcumler = []
11    for _ in range(n):
12        olcumler.append(adc.read_u16())
13        time.sleep_ms(5)
14    olcumler.sort()
15    return olcumler[n // 2] * 3.3 / 65535
16
17def tds_hesapla(v, derece):
18    v = v / (1.0 + 0.02 * (derece - 25.0))       # 25 °C'ye indir / normalise to 25 °C
19    ec = 133.42 * v ** 3 - 255.86 * v ** 2 + 857.39 * v
20    return ec * 0.5 * K_FAKTOR
21
22while True:
23    derece = 25.0
24    if roms:
25        ds.convert_temp()
26        time.sleep_ms(750)                       # DS18B20 dönüşüm süresi / conversion time
27        derece = ds.read_temp(roms[0])
28    tds = tds_hesapla(gerilim_oku(), derece)
29    print("Sicaklik: {:.1f} C  TDS: {:.0f} ppm".format(derece, tds))
30    time.sleep(1)
31

Capteur TDS ou capteur de pH : la différence

Dans les projets de qualité de l'eau, on confond souvent capteurs TDS et pH, alors qu'ils mesurent des choses complètement différentes. Le TDS indique la quantité d'ions dans l'eau, le pH dit si elle est acide ou basique (activité des ions hydrogène). Ajoute quelques gouttes de jus de citron dans un verre d'eau : le pH baisse nettement, le TDS bouge à peine ; ajoute une pincée de sel : le TDS grimpe, le pH reste presque identique. En aquariophilie et en hydroponie, on suit généralement les deux ensemble.

Idées de projets avec un capteur TDS

• Alarme de filtre : fais sonner un buzzer et affiche « changer le filtre » quand la sortie de l'osmoseur dépasse 50 ppm.
• Moniteur d'aquarium : affiche TDS, température et niveau d'eau sur un seul écran et rappelle le changement d'eau.
• Dosage hydroponique : ajoute des nutriments avec une pompe péristaltique quand l'EC baisse ; combine-le avec le projet de serre connectée.
• Journal de l'eau du robinet : enregistre pendant des jours le TDS de l'eau de la maison et repère les variations du réseau sur un graphique.
• Eau d'arrosage : compare eau de pluie, eau du robinet et eau filtrée et choisis la meilleure pour les plantes sensibles au sel.
• Expérience scolaire : dissous différentes quantités de sel et de sucre pour montrer le lien entre conductivité et type de substance dissoute.

Erreurs fréquentes et solutions

Le capteur TDS est l'outil le moins cher et le plus simple pour traduire la qualité de l'eau en un chiffre : avec une bonne compensation de température et un calibrage simple, tu peux surveiller sereinement l'eau du robinet, l'osmoseur, l'aquarium ou ta solution hydroponique. En interprétant les résultats, garde en tête que le TDS ne mesure pas la sécurité microbiologique. Dans l'application BlueGrays, tu trouveras des projets de station d'arrosage intelligente et d'enregistreur de température horodaté, pas à pas avec schéma et code, auxquels tu peux ajouter le capteur TDS.