Sensore TDS Arduino: misurare i ppm, calibrare e testare l'acqua

Unendo un sensore TDS ad Arduino ottieni un misuratore di qualità dell'acqua economico che mostra in pochi secondi, in ppm (parti per milione), quanti minerali, sali e metalli disciolti ci sono nell'acqua. Il TDS (Total Dissolved Solids), cioè i solidi disciolti totali, è la misura più pratica per valutare la durezza dell'acqua del rubinetto, verificare se un depuratore funziona ancora, capire quando cambiare l'acqua dell'acquario o controllare la concentrazione di una soluzione nutritiva idroponica. I misuratori TDS a penna funzionano con lo stesso principio; con Arduino puoi registrare la misura di continuo, mostrarla su un display e dare un allarme quando si supera una soglia.

In questo articolo vediamo passo passo cosa significano i ppm, come il sensore misura in realtà la conducibilità, come la temperatura influisce sul risultato e come correggerla con un DS18B20, la calibrazione con una soluzione di riferimento, il codice per Arduino Uno, le tabelle dei valori per acqua potabile, acquari e idroponica, il controllo di un depuratore, la registrazione con data e ora sull'ESP32 e il codice per il Raspberry Pi Pico. Nell'ultima sezione vedrai in cosa un sensore TDS differisce da un sensore di pH e gli errori più comuni.

Cos'è il TDS e cosa significa ppm?

Il TDS è la quantità totale di tutte le sostanze disciolte in un litro d'acqua: ioni come calcio, magnesio, sodio, potassio, bicarbonato, cloruro, solfato e nitrato ne costituiscono la parte maggiore. L'unità è il ppm (parti per milione) o il suo equivalente in acqua, il mg/L; 1 ppm significa 1 milligrammo di sostanza disciolta in 1 litro d'acqua. Ogni litro di un'acqua del rubinetto da 250 ppm contiene quindi un quarto di grammo di minerali. L'acqua pura (distillata) ha un TDS vicinissimo a zero, l'acqua di mare circa 35.000 ppm.

È importante sapere fin dall'inizio che il TDS da solo non dice se l'acqua è «pulita o sporca». Un'acqua di sorgente ricca di minerali può avere un TDS alto ed essere perfettamente sana; al contrario, un'acqua con TDS basso può contenere batteri, piombo o pesticidi, perché questi cambiano pochissimo la conducibilità. Il sensore TDS è perfetto per seguire il carico minerale dell'acqua e le sue variazioni; per la sicurezza microbiologica serve un'analisi di laboratorio.

Come funziona un sensore TDS? Dalla conducibilità ai ppm

I sensori TDS venduti per Arduino sono in realtà misuratori di conducibilità (EC). L'acqua pura non conduce quasi l'elettricità; più ioni disciolti contiene, più la conducibilità aumenta. La scheda applica una piccola tensione tra i due elettrodi in punta alla sonda e misura la corrente che passa. Questa tensione è alternata e non continua: con la corrente continua si formerebbero bolle di gas sugli elettrodi (polarizzazione), la misura deriverebbe e gli elettrodi si consumerebbero in fretta. La scheda trasforma il risultato in una tensione analogica tra 0 e 2,3 V; Arduino la legge, la converte prima in conducibilità (µS/cm) e poi in TDS con un fattore di conversione.

Il passaggio dalla conducibilità al TDS è un'approssimazione: TDS (ppm) = EC (µS/cm) × k. La maggior parte degli strumenti, e il codice di questo articolo, usano k = 0,5 (scala del cloruro di sodio o «scala 500»). Alcuni strumenti per idroponica usano 0,7; per questo due strumenti possono indicare la stessa acqua come 500 e 700 ppm ed entrambi «hanno ragione». Quando confronti i valori controlla il fattore usato e, in idroponica, lavora se puoi direttamente con la EC (mS/cm).

Compensazione della temperatura: perché serve un DS18B20

La conducibilità dell'acqua cambia molto con la temperatura: gli ioni si muovono più velocemente quando si scaldano e la stessa acqua sembra circa il 2% più conduttiva per ogni grado. Tra due misure della stessa acqua a 15 °C e a 30 °C c'è circa un terzo di differenza: un errore molto più grande di quello della misura stessa. Per questo le misure di TDS si riportano a 25 °C: tensione corretta = tensione misurata / (1 + 0,02 × (T − 25)). Il sensore più adatto per la temperatura dell'acqua è il DS18B20 impermeabile con guaina in acciaio inox, immerso nella stessa acqua accanto alla sonda TDS.

Il DS18B20 usa un protocollo a un solo filo dati chiamato OneWire e offre una precisione di ±0,5 °C. Richiede una resistenza di pull-up da 4,7 kΩ tra la linea dati e VCC; se non conosci il codice colori, usa lo strumento codice colori delle resistenze. Per i dettagli sul sensore e per collegare più DS18B20 sulla stessa linea, leggi l'articolo sensore di temperatura DS18B20. Senza sensore di temperatura il codice assume 25 °C, sufficiente per semplici prove a temperatura ambiente.

Collegamenti: Arduino Uno, ESP32 e Pico

Codice TDS per Arduino: filtro mediano e compensazione

1. Installa le librerie OneWire e DallasTemperature dal Gestore librerie.
2. Collega il modulo TDS e il DS18B20 come in tabella; immergi sonda e sensore di temperatura nella stessa acqua.
3. Carica il codice e apri il Monitor seriale a 115200 baud.
4. Aspetta 20–30 secondi che i numeri si stabilizzino; appena immersa la sonda, le prime letture oscillano.
5. Se hai una soluzione di calibrazione nota, immergici la sonda e scrivi nel Monitor seriale ad esempio cal:707.

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

Il polinomio di terzo grado nel codice è una curva empirica che converte la tensione d'uscita della scheda in conducibilità; un semplice moltiplicatore non basta perché il circuito non è lineare. Questa curva vale per la diffusa scheda TDS di tipo Gravity; con un'altra scheda usa la formula del produttore o ricava una tua curva con alcune soluzioni note. Ricorda che sull'Uno a 5 V la lettura analogica si riferisce a 5,0 V, mentre su ESP32 e Pico a 3,3 V; se non imposti il VREF della tua scheda, i risultati sono sbagliati fin dall'inizio.

Calibrare il sensore TDS con una soluzione di riferimento

Ogni sonda e ogni scheda hanno piccole differenze; per il risultato più preciso calibra il sensore con un liquido di valore noto. La soluzione standard di cloruro di potassio (KCl) da 1413 µS/cm, che si trova presso i fornitori di materiale da laboratorio ed elettronica, è la scelta più comune; con il fattore 0,5 corrisponde a circa 707 ppm. Va bene anche la soluzione di cloruro di sodio da 342 ppm fornita con alcuni misuratori a penna. Per calibrare sciacqua la sonda con acqua pulita, asciugala con carta assorbente, immergila nella soluzione, attendi 1–2 minuti e scrivi nel Monitor seriale cal: seguito dal valore in ppm della soluzione. Il codice salva nella EEPROM il rapporto tra valore misurato e valore reale come fattore K; l'impostazione resta anche a scheda spenta.

Tabella TDS: acqua potabile, acquario e idroponica

Sapere cosa significa il numero misurato è importante quanto il sensore stesso. Secondo la valutazione del gusto dell'Organizzazione Mondiale della Sanità, l'acqua sotto i 300 ppm ha un gusto eccellente, tra 300 e 600 ppm buono, tra 600 e 900 ppm discreto, tra 900 e 1200 ppm scarso e sopra i 1200 ppm inaccettabile. Sono fasce di gusto e di utilizzo, non limiti sanitari. La tabella riassume i valori tipici per gli usi più comuni.

In idroponica la soluzione nutritiva si esprime di solito come conducibilità (EC) e dipende dalla pianta. Attenzione però: il campo di questo sensore finisce a 1000 ppm e la soluzione per piante esigenti come pomodoro e peperone lo supera. In quel caso diluisci un campione con acqua distillata in un rapporto noto, misuralo e moltiplica il risultato, oppure usa direttamente un sensore EC con campo più ampio.

Controllare un depuratore d'acqua

L'uso più utile di un sensore TDS in casa è sorvegliare un depuratore a osmosi inversa (RO). Una membrana RO in buono stato trattiene la maggior parte dei minerali dell'acqua in ingresso; con 300 ppm in entrata, l'uscita è di solito intorno ai 10–30 ppm. Le prestazioni si calcolano con tasso di reiezione = (1 − uscita / ingresso) × 100: se entrano 300 ppm ed escono 15 ppm, il tasso è del 95%. Con l'invecchiamento della membrana il TDS in uscita sale lentamente; quando il tasso comincia a scendere sotto l'80–85%, si avvicina il momento di cambiare membrana e prefiltri. Un Arduino con due sonde e due DS18B20 che misura insieme ingresso e uscita può mostrare questa evoluzione in un grafico per mesi.

Registrare il TDS con l'ESP32

Con l'ESP32 puoi registrare le misure di TDS una volta al minuto con data e ora e inviarle poi su internet. Il codice qui sotto prende l'ora da internet tramite NTP, misura ogni minuto la temperatura dell'acqua e il TDS e aggiunge righe «data,temperatura,tds» a un file «/tds.csv» nel file system LittleFS della memoria flash della scheda. Potrai poi aprire il file in Excel e disegnare un grafico. L'ADC dell'ESP32 non è lineare; per questo il codice usa analogReadMilliVolts(), che sfrutta i dati di calibrazione salvati nel chip. Collega il segnale TDS a uno dei pin ADC1 (GPIO 32–39), che funzionano con il Wi-Fi attivo; i pin ADC2 non si possono usare insieme al Wi-Fi. L'ora NTP è spiegata nell'articolo 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

Se vuoi portare il registro online, puoi inviare la stessa riga a un foglio Google Sheets o a Home Assistant via MQTT invece che a LittleFS; dettagli negli articoli ESP32 Google Sheets ed ESP32 MQTT. La memoria flash ha un numero limitato di scritture; una riga breve al minuto non è un problema, ma invece di scrivere ogni secondo è buona abitudine raccogliere le misure in RAM e scriverle a blocchi.

TDS con il Raspberry Pi Pico (MicroPython)

Sul Pico il segnale TDS va su GP26 (ADC0) e il DS18B20 su GP22. In MicroPython i moduli onewire e ds18x20 necessari per il DS18B20 sono già inclusi nel firmware, non serve installare nulla. L'ADC del Pico restituisce con read_u16() un valore tra 0 e 65535, che convertiamo in tensione rispetto a 3,3 V. Formula e compensazione sono le stesse del codice Arduino; puoi ricavare K_FAKTOR con il metodo di calibrazione di Arduino e scriverlo nel codice.

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

Differenza tra sensore TDS e sensore di pH

Nei progetti sulla qualità dell'acqua i sensori TDS e pH vengono spesso confusi, ma misurano cose del tutto diverse. Il TDS indica la quantità di ioni nell'acqua, il pH quanto è acida o basica (attività degli ioni idrogeno). Se aggiungi qualche goccia di succo di limone a un bicchiere d'acqua il pH scende nettamente e il TDS cambia appena; con un pizzico di sale il TDS schizza in alto e il pH resta quasi uguale. In acquariofilia e idroponica di solito si controllano entrambi.

Idee di progetto con il sensore TDS

• Allarme depuratore: fai suonare un buzzer e mostra «cambia filtro» su un display quando l'uscita dell'osmosi supera i 50 ppm.
• Monitor per acquario: mostra TDS, temperatura e livello dell'acqua su un unico display e ricorda quando cambiare l'acqua.
• Controllo dei nutrienti in idroponica: aggiungi nutrienti con una pompa peristaltica quando la EC scende; abbinalo al progetto di serra intelligente.
• Registro dell'acqua del rubinetto: registra per giorni il TDS dell'acqua di casa e osserva nel grafico le variazioni dell'acquedotto.
• Acqua per irrigare: confronta acqua piovana, del rubinetto e filtrata e scegli la migliore per le piante sensibili al sale.
• Esperimento scolastico: sciogli diverse quantità di sale e zucchero per mostrare il legame tra conducibilità e tipo di sostanza disciolta.

Errori comuni e soluzioni

Il sensore TDS è lo strumento più economico e semplice per trasformare la qualità dell'acqua in un numero: con una corretta compensazione della temperatura e una calibrazione semplice puoi tenere d'occhio con fiducia l'acqua del rubinetto, il depuratore, l'acquario o la soluzione idroponica. Nell'interpretare i risultati ricorda che il TDS non misura la sicurezza microbiologica. Nell'app BlueGrays trovi progetti di stazione di irrigazione intelligente e registratore di temperatura con data e ora, passo passo con schema e codice, a cui puoi aggiungere il sensore TDS.