TDS-Sensor Arduino: ppm messen, kalibrieren, Wasserqualität

Mit einem TDS-Sensor am Arduino bekommst du ein günstiges Wasserqualitäts-Messgerät, das in wenigen Sekunden in ppm (Teile pro Million) anzeigt, wie viele gelöste Mineralien, Salze und Metalle im Wasser sind. TDS (Total Dissolved Solids), also die Gesamtheit der gelösten Feststoffe, ist das praktischste Maß, um die Härte des Leitungswassers einzuschätzen, zu prüfen, ob eine Wasserfilteranlage noch arbeitet, den richtigen Zeitpunkt für den Wasserwechsel im Aquarium zu finden oder die Stärke einer Hydroponik-Nährlösung zu bestimmen. TDS-Messstifte arbeiten nach demselben Prinzip; mit dem Arduino kannst du die Messung dauerhaft aufzeichnen, auf einem Display zeigen und bei Grenzwerten Alarm auslösen.

In diesem Beitrag erklären wir Schritt für Schritt, was ppm bedeutet, wie der Sensor eigentlich die Leitfähigkeit misst, wie die Temperatur das Ergebnis beeinflusst und wie du es mit einem DS18B20 korrigierst, die Kalibrierung mit einer Referenzlösung, den Code für den Arduino Uno, Wertetabellen für Trinkwasser, Aquarium und Hydroponik, die Überwachung eines Wasserfilters, Logging mit Zeitstempel auf dem ESP32 und den Code für den Raspberry Pi Pico. Im letzten Teil siehst du, wie sich ein TDS-Sensor von einem pH-Sensor unterscheidet, und die häufigsten Fehler.

Was ist TDS und was bedeutet ppm?

TDS ist die Gesamtmenge aller in einem Liter Wasser gelösten Stoffe: Ionen wie Calcium, Magnesium, Natrium, Kalium, Hydrogencarbonat, Chlorid, Sulfat und Nitrat machen den größten Teil aus. Die Einheit ist ppm (parts per million, Teile pro Million) bzw. das im Wasser gleichwertige mg/l; 1 ppm bedeutet 1 Milligramm gelöste Stoffe in 1 Liter Wasser. Jeder Liter eines Leitungswassers mit 250 ppm enthält also ein Viertelgramm Mineralien. Reines (destilliertes) Wasser hat einen TDS-Wert nahe null, Meerwasser etwa 35.000 ppm.

Wichtig ist von Anfang an: Der TDS-Wert allein sagt nicht, ob Wasser „sauber oder schmutzig“ ist. Ein mineralreiches Quellwasser kann einen hohen TDS-Wert haben und völlig gesund sein; umgekehrt kann Wasser mit niedrigem TDS Bakterien, Blei oder Pestizide enthalten, denn diese verändern die Leitfähigkeit kaum. Ein TDS-Sensor ist ideal, um die Mineralfracht des Wassers und deren Veränderung zu verfolgen; für die mikrobiologische Sicherheit braucht es eine Laboranalyse.

Wie funktioniert ein TDS-Sensor? Von der Leitfähigkeit zu ppm

Die für Arduino verkauften TDS-Sensoren sind eigentlich Leitfähigkeitsmesser (EC). Reines Wasser leitet Strom kaum; je mehr gelöste Ionen es enthält, desto höher ist die Leitfähigkeit. Die Platine legt eine kleine Spannung zwischen die beiden Elektroden an der Sondenspitze und misst den fließenden Strom. Diese Spannung ist eine Wechselspannung: Mit Gleichstrom würden sich Gasbläschen an den Elektroden sammeln (Polarisation), die Messung würde driften und die Elektroden würden schnell verschleißen. Die Platine wandelt das Ergebnis in eine analoge Spannung zwischen 0 und 2,3 V um; der Arduino liest sie, rechnet sie zuerst in Leitfähigkeit (µS/cm) und dann mit einem Umrechnungsfaktor in TDS um.

Der Schritt von der Leitfähigkeit zum TDS ist eine Näherung: TDS (ppm) = EC (µS/cm) × k. Die meisten Messgeräte und der Code in diesem Beitrag verwenden k = 0,5 (Natriumchlorid- bzw. „500er“-Skala). Manche Hydroponik-Messgeräte nutzen 0,7; deshalb können zwei Geräte dasselbe Wasser mit 500 und 700 ppm anzeigen, und beide haben „recht“. Achte beim Vergleichen auf den Faktor und arbeite in der Hydroponik möglichst direkt mit dem EC-Wert (mS/cm).

Temperaturkompensation: Warum ein DS18B20 nötig ist

Die Leitfähigkeit von Wasser ändert sich deutlich mit der Temperatur: Ionen bewegen sich bei Wärme schneller, und dasselbe Wasser erscheint pro 1 °C etwa 2 % leitfähiger. Zwischen Messungen desselben Wassers bei 15 °C und bei 30 °C liegt rund ein Drittel Unterschied; das ist ein viel größerer Fehler als die Messung selbst. Deshalb werden TDS-Werte auf 25 °C bezogen: korrigierte Spannung = gemessene Spannung / (1 + 0,02 × (T − 25)). Am besten misst du die Wassertemperatur mit einem wasserdichten DS18B20 im Edelstahlröhrchen, den du neben der TDS-Sonde ins selbe Wasser hängst.

Der DS18B20 arbeitet mit dem Eindraht-Protokoll OneWire und ist auf ±0,5 °C genau. Zwischen Datenleitung und VCC braucht er einen 4,7-kΩ-Pull-up-Widerstand; kennst du den Farbcode nicht, hilft das Werkzeug Widerstands-Farbcode. Details zum Sensor und zum Anschluss mehrerer DS18B20 an einer Leitung findest du im Beitrag Temperatursensor DS18B20. Ohne Temperatursensor nimmt der Code 25 °C an; für einfache Tests bei Raumtemperatur reicht das.

Anschluss: Arduino Uno, ESP32 und Pico

Arduino-TDS-Code: Medianfilter und Kompensation

1. Installiere über den Bibliotheksverwalter die Bibliotheken OneWire und DallasTemperature.
2. Schließ TDS-Modul und DS18B20 wie in der Tabelle an; Sonde und Temperatursensor kommen ins selbe Wasser.
3. Lade den Code hoch und öffne den seriellen Monitor mit 115200 Baud.
4. Warte 20–30 Sekunden, bis sich die Zahlen stabilisieren; direkt nach dem Eintauchen schwanken die ersten Werte.
5. Hast du eine Kalibrierlösung mit bekanntem Wert, tauch die Sonde hinein und gib im seriellen Monitor zum Beispiel cal:707 ein.

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

Das Polynom dritten Grades im Code ist eine empirische Kennlinie, die die Ausgangsspannung der Platine in Leitfähigkeit umrechnet; ein einfacher Faktor genügt nicht, weil die Schaltung nicht linear ist. Diese Kennlinie gilt für die verbreitete TDS-Platine im Gravity-Stil; nutzt du eine andere, verwende die Formel des Herstellers oder bestimme mit einigen bekannten Lösungen eine eigene Kennlinie. Denk daran: Am 5-V-Uno bezieht sich der Analogwert auf 5,0 V, bei ESP32 und Pico auf 3,3 V; stellst du VREF nicht passend ein, sind die Ergebnisse von Anfang an falsch.

TDS-Sensor mit Kalibrierlösung einstellen

Jede Sonde und jede Platine weichen leicht ab; für genaue Ergebnisse kalibrierst du den Sensor mit einer Flüssigkeit bekannten Werts. Die bei Labor- und Elektronikhändlern erhältliche Kaliumchlorid-Standardlösung (KCl) mit 1413 µS/cm ist die gängigste Wahl; mit dem Faktor 0,5 entspricht sie etwa 707 ppm. Auch die 342-ppm-Natriumchloridlösung, die manchen TDS-Messstiften beiliegt, eignet sich. Zum Kalibrieren spülst du die Sonde mit sauberem Wasser ab, tupfst sie mit Küchenpapier trocken, tauchst sie in die Lösung, wartest 1–2 Minuten und gibst im seriellen Monitor cal: und den ppm-Wert der Lösung ein. Der Code speichert das Verhältnis zwischen Mess- und Sollwert als Faktor K im EEPROM; die Einstellung bleibt auch ohne Strom erhalten.

TDS-Tabelle: Trinkwasser, Aquarium und Hydroponik

Zu wissen, was deine Zahl bedeutet, ist genauso wichtig wie der Sensor selbst. Nach der Geschmacksbewertung der Weltgesundheitsorganisation gilt Wasser unter 300 ppm geschmacklich als ausgezeichnet, 300–600 ppm als gut, 600–900 ppm als mittelmäßig, 900–1200 ppm als schlecht und über 1200 ppm als inakzeptabel. Das sind Bereiche für Geschmack und Gebrauch, keine Gesundheitsgrenzwerte. Die Tabelle fasst typische Werte für gängige Anwendungen zusammen.

In der Hydroponik wird die Nährlösung meist als Leitfähigkeit (EC) angegeben und hängt von der Pflanze ab. Aber Achtung: Der Messbereich dieses Sensors endet bei 1000 ppm, und die Lösung für nährstoffhungrige Pflanzen wie Tomaten und Paprika liegt darüber. Dann verdünnst du entweder eine Probe in bekanntem Verhältnis mit destilliertem Wasser, misst sie und multiplizierst das Ergebnis, oder du nutzt direkt einen EC-Sensor mit größerem Messbereich.

Wasserfilter überwachen

Am nützlichsten ist ein TDS-Sensor zu Hause zur Überwachung einer Umkehrosmoseanlage (RO). Eine gesunde RO-Membran hält den Großteil der Mineralien im Zulauf zurück; bei 300 ppm im Zulauf liegt der Ausgang meist bei etwa 10–30 ppm. Die Leistung berechnest du mit Rückhalterate = (1 − Ausgang / Zulauf) × 100: Gehen 300 ppm hinein und kommen 15 ppm heraus, sind es 95 %. Mit dem Alter der Membran steigt der Ausgangswert langsam; fällt die Rate unter 80–85 %, ist der Wechsel von Membran und Vorfiltern bald fällig. Ein Arduino mit zwei Sonden und zwei DS18B20, der Zu- und Ablauf gleichzeitig misst, kann diese Entwicklung über Monate als Diagramm zeigen.

TDS-Logging mit dem ESP32

Mit dem ESP32 zeichnest du TDS-Werte minütlich mit Zeitstempel auf und kannst sie später ins Internet schicken. Der Code unten holt die Uhrzeit per NTP aus dem Internet, misst jede Minute Wassertemperatur und TDS und hängt Zeilen „Datum,Temperatur,TDS“ an eine Datei „/tds.csv“ im Dateisystem LittleFS im Flash-Speicher des Boards an. Diese Datei kannst du später in Excel öffnen und ein Diagramm zeichnen. Der ADC des ESP32 ist nicht linear; der Code nutzt deshalb analogReadMilliVolts(), das die im Chip gespeicherten Kalibrierdaten verwendet. Schließ das TDS-Signal an einen der ADC1-Pins (GPIO 32–39) an, die auch bei aktivem WLAN funktionieren; ADC2-Pins lassen sich nicht zusammen mit WLAN nutzen. Die NTP-Uhrzeit erklärt der Beitrag ESP32 NTP Uhrzeit.

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

Willst du die Daten online haben, kannst du dieselbe Zeile statt in LittleFS an eine Google-Tabelle oder per MQTT an Home Assistant schicken; Details in den Beiträgen ESP32 Google Sheets und ESP32 MQTT. Flash-Speicher hat eine begrenzte Zahl an Schreibzyklen; eine kurze Zeile pro Minute ist unproblematisch, aber statt jede Sekunde zu schreiben, sammelst du Messwerte besser im RAM und schreibst sie gebündelt.

TDS mit dem Raspberry Pi Pico (MicroPython)

Am Pico kommt das TDS-Signal an GP26 (ADC0) und der DS18B20 an GP22. Die für den DS18B20 nötigen MicroPython-Module onewire und ds18x20 sind in der Firmware enthalten, es muss nichts nachinstalliert werden. Der ADC des Pico liefert mit read_u16() einen Wert zwischen 0 und 65535, den wir bezogen auf 3,3 V in eine Spannung umrechnen. Formel und Kompensation sind dieselben wie im Arduino-Code; K_FAKTOR bestimmst du mit der Kalibriermethode vom Arduino und trägst ihn in den Code ein.

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

TDS-Sensor und pH-Sensor im Vergleich

TDS- und pH-Sensoren werden in Wasserprojekten oft verwechselt, dabei messen sie völlig verschiedene Dinge. TDS zeigt die Menge der Ionen im Wasser, pH dagegen, wie sauer oder basisch es ist (Aktivität der Wasserstoffionen). Gibst du ein paar Tropfen Zitronensaft in ein Glas Wasser, sinkt der pH-Wert deutlich, der TDS-Wert ändert sich kaum; mit einer Prise Salz schießt der TDS-Wert hoch, der pH-Wert bleibt fast gleich. In Aquaristik und Hydroponik werden meist beide zusammen überwacht.

Projektideen mit dem TDS-Sensor

• Filteralarm: Lass einen Summer ertönen und zeig „Filter wechseln“ auf einem Display, wenn der RO-Ausgang 50 ppm überschreitet.
• Aquarium-Monitor: Zeig TDS, Temperatur und Wasserstand auf einem Display und erinnere an den Wasserwechsel.
• Hydroponik-Nährstoffregelung: Dosiere bei sinkendem EC mit einer Schlauchpumpe Nährstoffe nach; kombiniere es mit dem Projekt smartes Gewächshaus.
• Leitungswasser-Protokoll: Zeichne den TDS-Wert deines Leitungswassers tagelang auf und erkenne Änderungen der Versorgung im Diagramm.
• Gießwasser für Pflanzen: Vergleiche Regenwasser, Leitungswasser und gefiltertes Wasser und wähle das beste für salzempfindliche Pflanzen.
• Schulexperiment: Löse unterschiedliche Mengen Salz und Zucker und zeig den Zusammenhang zwischen Leitfähigkeit und Art des gelösten Stoffs.

Häufige Fehler und Lösungen

Ein TDS-Sensor ist das günstigste und einfachste Werkzeug, um Wasserqualität in eine Zahl zu fassen: Mit sauberer Temperaturkompensation und einer einfachen Kalibrierung überwachst du Leitungswasser, Filteranlage, Aquarium oder Hydroponik-Lösung zuverlässig. Denk bei der Bewertung daran, dass TDS keine mikrobiologische Sicherheit misst. In der BlueGrays-App findest du Projekte zu einer intelligenten Bewässerungsstation und einem Temperaturlogger mit Zeitstempel, jeweils Schritt für Schritt mit Schaltplan und Code, und kannst den TDS-Sensor dort einbauen.