Sensor TDS Arduino: medir ppm, calibrar y vigilar el agua

Al unir un sensor TDS con Arduino obtienes un medidor de calidad de agua barato que muestra en pocos segundos, en ppm (partes por millón), cuántos minerales, sales y metales disueltos hay en el agua. El TDS (Total Dissolved Solids), es decir, los sólidos disueltos totales, es la medida más práctica para valorar la dureza del agua del grifo, comprobar si un equipo de ósmosis sigue funcionando, saber cuándo cambiar el agua del acuario o controlar la concentración de una solución nutritiva hidropónica. Los medidores TDS tipo bolígrafo funcionan con el mismo principio; con Arduino puedes registrar la medida de forma continua, mostrarla en una pantalla y dar un aviso cuando se supere un umbral.

En este artículo explicamos paso a paso qué significan los ppm, cómo mide realmente la conductividad el sensor, cómo afecta la temperatura al resultado y cómo corregirla con un DS18B20, la calibración con una solución patrón, el código para Arduino Uno, tablas de valores para agua potable, acuarios e hidroponía, el control de un filtro de agua, el registro con fecha y hora en el ESP32 y el código para la Raspberry Pi Pico. En la última sección verás en qué se diferencia un sensor TDS de un sensor de pH y los errores más habituales.

¿Qué es el TDS y qué significa ppm?

El TDS es la cantidad total de sustancias disueltas en un litro de agua: iones como calcio, magnesio, sodio, potasio, bicarbonato, cloruro, sulfato y nitrato forman la mayor parte. La unidad es el ppm (partes por millón) o su equivalente en agua, mg/L; 1 ppm significa 1 miligramo de materia disuelta en 1 litro de agua. Por ejemplo, cada litro de un agua del grifo de 250 ppm contiene un cuarto de gramo de minerales. El agua pura (destilada) tiene un TDS muy próximo a cero, y el agua de mar ronda los 35 000 ppm.

Es importante saber desde el principio que el TDS por sí solo no dice si el agua está «limpia o sucia». Un agua de manantial rica en minerales puede tener un TDS alto y ser perfectamente sana; en cambio, un agua con TDS bajo puede contener bacterias, plomo o pesticidas, porque apenas cambian la conductividad. El sensor TDS es perfecto para vigilar la carga mineral del agua y sus cambios; para la seguridad microbiológica hace falta un análisis de laboratorio.

¿Cómo funciona un sensor TDS? De la conductividad a los ppm

Los sensores TDS que se venden para Arduino son en realidad medidores de conductividad (EC). El agua pura casi no conduce la electricidad; cuantos más iones disueltos contiene, mayor es su conductividad. La placa aplica una pequeña tensión entre los dos electrodos de la punta de la sonda y mide la corriente que circula. Esa tensión es alterna, no continua: con corriente continua se acumularían burbujas de gas en los electrodos (polarización), la lectura derivaría y los electrodos se desgastarían enseguida. La placa convierte el resultado en una tensión analógica de 0 a 2,3 V; el Arduino la lee, la convierte primero en conductividad (µS/cm) y después en TDS con un factor de conversión.

El paso de la conductividad al TDS es una aproximación: TDS (ppm) = EC (µS/cm) × k. La mayoría de medidores, y el código de este artículo, usan k = 0,5 (escala de cloruro sódico o «escala 500»). Algunos medidores de hidroponía usan 0,7; por eso dos medidores pueden marcar el mismo agua como 500 y 700 ppm y ambos «tienen razón». Fíjate en el factor al comparar valores y, en hidroponía, trabaja si puedes directamente con la EC (mS/cm).

Compensación de temperatura: por qué hace falta un DS18B20

La conductividad del agua cambia mucho con la temperatura: los iones se mueven más rápido al calentarse y la misma agua parece alrededor de un 2 % más conductora por cada 1 °C. Entre las medidas de una misma agua a 15 °C y a 30 °C hay cerca de un tercio de diferencia; un error mucho mayor que el de la propia medida. Por eso las medidas de TDS se corrigen a 25 °C: tensión corregida = tensión medida / (1 + 0,02 × (T − 25)). El sensor más adecuado para medir la temperatura del agua es el DS18B20 impermeable con funda de acero inoxidable, que se sumerge en la misma agua junto a la sonda TDS.

El DS18B20 funciona con un protocolo de un solo cable de datos llamado OneWire y ofrece una precisión de ±0,5 °C. Necesita una resistencia pull-up de 4,7 kΩ entre la línea de datos y VCC; si no conoces el código de colores, consulta la herramienta código de colores de resistencias. Para los detalles del sensor y cómo conectar varios DS18B20 a la misma línea, lee el artículo sensor de temperatura DS18B20. Si no tienes sensor de temperatura, el código supone 25 °C, suficiente para pruebas sencillas a temperatura ambiente.

Conexión: Arduino Uno, ESP32 y Pico

Código TDS para Arduino: filtro de mediana y compensación

1. Instala las librerías OneWire y DallasTemperature desde el Gestor de Librerías.
2. Conecta el módulo TDS y el DS18B20 como en la tabla; sumerge la sonda y el sensor de temperatura en la misma agua.
3. Sube el código y abre el Monitor Serie a 115200 baudios.
4. Espera 20–30 segundos a que se estabilicen los números; recién sumergida la sonda, las primeras lecturas oscilan.
5. Si tienes una solución de calibración conocida, mete la sonda en ella y escribe por ejemplo cal:707 en el Monitor Serie.

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

El polinomio de tercer grado del código es una curva empírica que convierte la tensión de salida de la placa en conductividad; un simple multiplicador no basta porque el circuito no es lineal. Esta curva vale para la placa TDS habitual de tipo Gravity; si usas otra, emplea la fórmula del fabricante o saca tu propia curva con varias soluciones conocidas. Recuerda que en el Uno de 5 V la lectura analógica se calcula sobre 5,0 V y en el ESP32 y la Pico sobre 3,3 V; si no eliges el VREF de tu placa, los resultados serán erróneos desde el principio.

Calibrar el sensor TDS con una solución patrón

Cada sonda y cada placa tienen pequeñas diferencias; para obtener el resultado más exacto, calibra el sensor con un líquido de valor conocido. La solución patrón de cloruro potásico (KCl) de 1413 µS/cm, que venden los proveedores de material de laboratorio y electrónica, es la opción más común; con el factor 0,5 equivale a unos 707 ppm. También sirve la solución de cloruro sódico de 342 ppm que traen algunos medidores tipo bolígrafo. Para calibrar, enjuaga la sonda con agua limpia, sécala con papel, sumérgela en la solución, espera 1–2 minutos y escribe en el Monitor Serie cal: seguido del valor en ppm de la solución. El código guarda en la EEPROM la relación entre el valor medido y el real como factor K; el ajuste no se pierde al apagar.

Tabla de TDS: agua potable, acuario e hidroponía

Saber qué significa el número que mides es tan importante como el propio sensor. Según la valoración de sabor de la Organización Mundial de la Salud, el agua por debajo de 300 ppm tiene un sabor excelente, de 300 a 600 ppm bueno, de 600 a 900 ppm aceptable, de 900 a 1200 ppm malo y por encima de 1200 ppm inaceptable. Son rangos de sabor y uso, no límites sanitarios. La tabla resume los valores típicos para los usos más comunes.

En hidroponía, la solución nutritiva suele expresarse como conductividad (EC) y depende de la planta. Pero ojo: el rango de este sensor termina en 1000 ppm, y la solución para plantas exigentes como el tomate o el pimiento lo supera. En ese caso, diluye una muestra con agua destilada en una proporción conocida, mídela y multiplica el resultado, o usa directamente un sensor de EC de rango más amplio.

Control de un filtro de agua

El uso más útil de un sensor TDS en casa es vigilar un equipo de ósmosis inversa (RO). Una membrana RO en buen estado retiene la mayor parte de los minerales del agua de entrada; con 300 ppm a la entrada, la salida suele rondar los 10–30 ppm. El rendimiento se calcula con tasa de rechazo = (1 − salida / entrada) × 100: si entran 300 ppm y salen 15 ppm, la tasa es del 95 %. A medida que la membrana envejece, el TDS de salida sube poco a poco; cuando la tasa empieza a bajar del 80–85 %, se acerca el momento de cambiar la membrana y los prefiltros. Un Arduino con dos sondas y dos DS18B20 que mida a la vez entrada y salida puede mostrar esta evolución en una gráfica durante meses.

Registro de TDS con el ESP32

Con el ESP32 puedes registrar las medidas de TDS una vez por minuto con fecha y hora y enviarlas más tarde a internet. El código de abajo obtiene la hora de internet por NTP, mide cada minuto la temperatura del agua y el TDS y añade líneas «fecha,temperatura,tds» a un archivo «/tds.csv» del sistema de archivos LittleFS en la memoria flash de la propia placa. Después puedes abrir ese archivo en Excel y dibujar una gráfica. El ADC del ESP32 no es lineal; por eso el código usa analogReadMilliVolts(), que aprovecha los datos de calibración guardados en el chip. Conecta la señal TDS a uno de los pines ADC1 (GPIO 32–39), que funcionan con el Wi-Fi activo; los pines ADC2 no pueden usarse junto con el Wi-Fi. La hora NTP se explica en el artículo 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

Si quieres llevar el registro a internet, puedes enviar la misma línea a una hoja de Google Sheets o a Home Assistant por MQTT en lugar de a LittleFS; detalles en los artículos ESP32 Google Sheets y ESP32 MQTT. La memoria flash tiene una vida limitada de escrituras; una línea corta por minuto no es problema, pero en vez de escribir cada segundo es buena costumbre acumular las medidas en RAM y escribirlas por lotes.

TDS con la Raspberry Pi Pico (MicroPython)

En la Pico conectas la señal TDS a GP26 (ADC0) y el DS18B20 a GP22. En MicroPython los módulos onewire y ds18x20 que necesita el DS18B20 ya vienen en el firmware, así que no hay que instalar nada. El ADC de la Pico devuelve con read_u16() un valor entre 0 y 65535, que convertimos en tensión respecto a 3,3 V. La fórmula y la compensación son las mismas que en el código de Arduino; puedes obtener K_FAKTOR con el método de calibración de Arduino y escribirlo en el código.

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

Diferencia entre sensor TDS y sensor de pH

En los proyectos de calidad del agua se confunden a menudo los sensores de TDS y de pH, pero miden cosas completamente distintas. El TDS muestra la cantidad de iones en el agua, mientras que el pH indica lo ácida o básica que es (actividad de los iones de hidrógeno). Si añades unas gotas de zumo de limón a un vaso de agua, el pH baja claramente y el TDS apenas cambia; si añades una pizca de sal, el TDS se dispara y el pH casi no varía. En acuarios e hidroponía suelen vigilarse los dos juntos.

Ideas de proyectos con el sensor TDS

• Alarma de filtro: haz sonar un zumbador y muestra «cambiar filtro» en una pantalla cuando la salida de la ósmosis supere los 50 ppm.
• Monitor de acuario: muestra TDS, temperatura y nivel de agua en una sola pantalla y recuerda cuándo cambiar el agua.
• Control de nutrientes hidropónico: añade nutrientes con una bomba peristáltica cuando baje la EC; combínalo con el proyecto de invernadero inteligente.
• Registro del agua del grifo: guarda durante días el TDS del agua de casa y observa en una gráfica los cambios en el suministro.
• Agua de riego: compara agua de lluvia, del grifo y filtrada y elige la mejor para plantas sensibles a la sal.
• Experimento escolar: disuelve distintas cantidades de sal y azúcar para mostrar la relación entre conductividad y tipo de sustancia disuelta.

Errores frecuentes y soluciones

El sensor TDS es la herramienta más barata y sencilla para convertir la calidad del agua en un número: con una buena compensación de temperatura y una calibración simple puedes vigilar con confianza el agua del grifo, el equipo de ósmosis, el acuario o tu solución hidropónica. Al interpretar los resultados, recuerda que el TDS no mide la seguridad microbiológica. En la app BlueGrays encontrarás proyectos de estación de riego inteligente y registrador de temperatura con fecha y hora, paso a paso con esquema y código, y podrás añadirles el sensor TDS.