Sensor TDS com Arduino: medir ppm, calibrar e monitorar a qualidade da água

Combine um sensor TDS com Arduino e você terá um medidor barato de qualidade da água que mostra em poucos segundos, em ppm (partes por milhão), a quantidade de minerais, sais e metais dissolvidos na água. TDS (sólidos dissolvidos totais) é a medida mais prática para avaliar a dureza da água da torneira, verificar se um filtro de água ainda funciona, saber quando trocar a água do aquário ou avaliar a concentração de uma solução nutritiva para hidroponia. Medidores TDS tipo caneta funcionam com o mesmo princípio; com um Arduino, você pode registrar a medição continuamente, exibi-la em um display e emitir um alerta quando um limite for ultrapassado.

Neste artigo, explicamos passo a passo o significado de ppm, como o sensor realmente mede a condutividade, como a temperatura afeta o resultado e como corrigi-lo com um DS18B20, a calibração com uma solução de referência, o código para Arduino Uno, tabelas de valores para água potável, aquários e hidroponia, o monitoramento de filtros de água, o registro com marcação de data e hora no ESP32 e o código para Raspberry Pi Pico. Na última seção, você verá a diferença entre um sensor TDS e um sensor de pH, além dos erros mais comuns.

O que é TDS e o que significa ppm?

TDS é a quantidade total de todas as substâncias dissolvidas em um litro de água: íons como cálcio, magnésio, sódio, potássio, bicarbonato, cloreto, sulfato e nitrato compõem a maior parte. A unidade é ppm (partes por milhão) ou seu equivalente na água, mg/L; 1 ppm significa 1 miligrama de matéria dissolvida em 1 litro de água. Por exemplo, cada litro de água da torneira com 250 ppm contém um quarto de grama de minerais. A água pura (destilada) tem TDS muito próximo de zero, enquanto a água do mar fica em torno de 35.000 ppm.

É importante saber desde o início que o TDS, por si só, não indica se a água está “limpa ou suja”. Uma água de nascente rica em minerais pode ter TDS alto e ser perfeitamente saudável; por outro lado, uma água com TDS baixo pode conter bactérias, chumbo ou agrotóxicos, pois eles quase não alteram a condutividade da água. Um sensor TDS é perfeito para acompanhar a carga mineral da água e as variações dessa carga; para avaliar a segurança microbiológica, você precisa de uma análise laboratorial.

Como funciona um sensor TDS? Da condutividade ao ppm

Os sensores TDS vendidos para Arduino são, na verdade, medidores de condutividade (EC). A água pura praticamente não conduz eletricidade; quanto mais íons dissolvidos ela contém, maior sua condutividade. A placa aplica uma pequena tensão entre os dois eletrodos na ponta da sonda e mede a corrente que circula. Essa tensão é alternada, em vez de contínua: com corrente contínua, bolhas de gás se acumulariam nos eletrodos (polarização), a leitura apresentaria deriva e os eletrodos se desgastariam rapidamente. A placa transforma o resultado em uma tensão analógica entre 0 e 2,3 V; o Arduino a lê, converte primeiro em condutividade (µS/cm) e depois em TDS usando um fator de conversão.

A conversão de condutividade em TDS é uma aproximação: TDS (ppm) = EC (µS/cm) × k. A maioria dos medidores, assim como o código deste artigo, usa k = 0.5 (a escala de cloreto de sódio ou “500”). Alguns medidores para hidroponia usam 0,7, por isso dois medidores podem indicar 500 e 700 ppm para a mesma água e ambos estarem “certos”. Verifique qual fator é usado ao comparar valores e, na hidroponia, trabalhe diretamente com EC (mS/cm) sempre que possível.

Compensação de temperatura: por que você precisa de um DS18B20

A condutividade da água varia bastante com a temperatura: os íons se movem mais rápido quando aquecem, e a mesma água apresenta cerca de 2% a mais de condutividade a cada 1 °C. Leituras da mesma água a 15 °C e 30 °C diferem em aproximadamente um terço; esse erro é muito maior que o da própria medição. Por isso, as leituras de TDS são corrigidas para 25 °C: tensão corrigida = tensão medida / (1 + 0,02 × (T − 25)). O sensor mais adequado para a temperatura da água é o DS18B20 à prova d’água, com revestimento de aço inox; você o coloca na mesma água, ao lado da sonda TDS.

O DS18B20 usa um protocolo de um único fio de dados chamado OneWire e oferece exatidão de ±0,5 °C. Ele precisa de um resistor de pull-up de 4,7 kΩ entre a linha de dados e VCC; se você não conhece o código de cores, consulte a ferramenta Código de cores de resistores. Para detalhes do sensor e a ligação de vários DS18B20 na mesma linha, leia o artigo sobre o sensor de temperatura DS18B20. Sem um sensor de temperatura, o código considera 25 °C, o que é suficiente para testes simples à temperatura ambiente.

Ligações: Arduino Uno, ESP32 e Pico

Código TDS para Arduino: filtro de mediana e compensação

1. Instale as bibliotecas OneWire e DallasTemperature pelo Gerenciador de Bibliotecas.
2. Conecte o módulo TDS e o DS18B20 conforme a tabela; coloque a sonda e o sensor de temperatura na mesma água.
3. Carregue o código e abra o Monitor Serial a 115200 baud.
4. Espere 20–30 segundos para os números se estabilizarem; as primeiras leituras oscilam quando a sonda acaba de entrar na água.
5. Se você tiver uma solução de calibração de valor conhecido, coloque a sonda nela e digite, por exemplo, cal:707 no Monitor Serial.

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

O polinômio de terceira ordem no código é uma curva empírica que transforma a tensão de saída da placa em condutividade; um simples multiplicador não basta, pois o circuito da placa não é linear. Essa curva se aplica à placa TDS comum do tipo Gravity; se você usar outra placa, use a fórmula do fabricante ou determine sua própria curva com algumas soluções conhecidas. Lembre-se de que, em um Uno de 5 V, a leitura analógica tem como referência 5,0 V e, no ESP32 e no Pico, 3,3 V; se você não definir VREF para sua placa, os resultados estarão errados desde o início.

Calibração do sensor TDS com uma solução de referência

Cada sonda e placa apresenta pequenas diferenças; para obter resultados mais exatos, calibre o sensor com um líquido de valor conhecido. A solução padrão de cloreto de potássio (KCl) de 1.413 µS/cm, disponível em fornecedores de materiais de laboratório e eletrônica, é a escolha mais comum; com o fator 0,5, corresponde a cerca de 707 ppm. A solução de cloreto de sódio de 342 ppm que acompanha alguns medidores TDS tipo caneta também serve. Para calibrar, enxágue a sonda com água limpa, seque suavemente com papel-toalha, coloque-a na solução, espere 1–2 minutos e digite cal: seguido do valor em ppm da solução no Monitor Serial. O código salva a razão entre o valor medido e o valor real como fator K na EEPROM, de modo que a configuração é mantida mesmo após desligar a alimentação.

Tabela de TDS: água potável, aquários e hidroponia

Saber o que seu número significa é tão importante quanto o próprio sensor. Segundo a avaliação de sabor da Organização Mundial da Saúde, água abaixo de 300 ppm tem sabor excelente; de 300–600 ppm, bom; de 600–900 ppm, razoável; de 900–1.200 ppm, ruim; e acima de 1.200 ppm, inaceitável. Essas são faixas de sabor e adequação ao uso, não limites de segurança para a saúde. A tabela abaixo resume valores típicos para usos comuns.

Na hidroponia, as soluções nutritivas geralmente são expressas em condutividade (EC) e variam conforme a planta. Mas atenção: a faixa deste sensor termina em 1.000 ppm, e a solução para plantas exigentes em nutrientes, como tomate e pimentão, ultrapassa esse valor. Nesse caso, dilua uma amostra com água destilada em uma proporção conhecida, faça a medição e multiplique o resultado, ou use um sensor de EC com uma faixa maior.

Monitoramento de um filtro de água

A função mais útil de um sensor TDS em casa é monitorar um filtro de osmose reversa (RO). Uma membrana de RO em bom estado retém a maior parte dos minerais da água de entrada; com 300 ppm na entrada, a saída costuma ficar em torno de 10–30 ppm. Você calcula o desempenho com taxa de rejeição = (1 − saída / entrada) × 100: se entram 300 ppm e saem 15 ppm, a taxa é de 95%. À medida que a membrana envelhece, o TDS da saída aumenta lentamente; quando a taxa começa a cair abaixo de 80–85%, está chegando a hora de substituir a membrana e os pré-filtros. Um Arduino com duas sondas e dois DS18B20 medindo entrada e saída ao mesmo tempo pode mostrar essa variação em um gráfico ao longo de meses.

Registro de TDS com o ESP32

Com o ESP32, você pode registrar leituras de TDS uma vez por minuto com marcação de data e hora e enviá-las à internet depois. O código abaixo obtém a hora pela internet com NTP, mede a temperatura da água e o TDS a cada minuto e acrescenta linhas “date,temperature,tds” a um arquivo chamado “/tds.csv” no sistema de arquivos LittleFS, na memória flash da própria placa. Depois, você pode abrir esse arquivo no Excel e criar um gráfico. O ADC do ESP32 não é linear, por isso o código usa analogReadMilliVolts(), que utiliza os dados de calibração armazenados no chip. Conecte o sinal TDS a um dos pinos ADC1 (GPIO 32–39), que funcionam com o Wi-Fi ligado; os pinos ADC2 não podem ser usados junto com o Wi-Fi. A hora por NTP é abordada no artigo sobre o relógio NTP com ESP32.

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 você quiser disponibilizar o registro na internet, pode enviar a mesma linha para uma planilha do Google Sheets ou para o Home Assistant via MQTT, em vez de usar o LittleFS; veja os detalhes nos artigos ESP32 com Google Sheets e ESP32 com MQTT. A memória flash tem uma vida útil limitada de gravações; uma linha curta por minuto não causa problemas, mas, em vez de gravar a cada segundo, é um bom hábito acumular as leituras na RAM e gravá-las em lotes.

TDS com o Raspberry Pi Pico (MicroPython)

No Pico, você conecta o sinal TDS ao GP26 (ADC0) e o DS18B20 ao GP22. No MicroPython, os módulos onewire e ds18x20 necessários para o DS18B20 já vêm no firmware, então não é preciso instalar nada extra. O ADC do Pico retorna um valor entre 0 e 65.535 com read_u16(); nós o convertemos em uma tensão relativa a 3,3 V. A fórmula e a compensação são as mesmas do código Arduino; você pode obter K_FAKTOR com o método de calibração do Arduino e inseri-lo no 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

Sensor TDS e sensor de pH: diferenças

Sensores TDS e de pH são frequentemente confundidos em projetos de qualidade da água, mas medem coisas completamente diferentes. O TDS indica a quantidade de íons na água, enquanto o pH indica o quanto ela é ácida ou alcalina (atividade dos íons de hidrogênio). Adicione algumas gotas de suco de limão a um copo de água e o pH cairá bastante, enquanto o TDS quase não mudará; adicione uma pitada de sal e o TDS disparará, enquanto o pH permanecerá quase igual. Em aquários e na hidroponia, geralmente os dois são monitorados juntos.

Ideias de projetos com sensor TDS

• Alarme de filtro: acione um buzzer e mostre “substituir filtro” em um display quando a saída de RO ultrapassar 50 ppm.
• Monitor de aquário: mostre TDS, temperatura e nível de água em um único display e receba um lembrete de quando trocar a água.
• Controle de nutrientes na hidroponia: adicione nutrientes com uma bomba peristáltica quando a EC cair; combine com o projeto de estufa inteligente.
• Registro da água da torneira: registre o TDS da água da sua casa durante dias e veja as mudanças no abastecimento em um gráfico.
• Água para regar plantas: compare água da chuva, da torneira e filtrada e escolha a melhor para plantas sensíveis à salinidade.
• Experimento escolar: dissolva diferentes quantidades de sal e açúcar para mostrar a relação entre a condutividade e o tipo de substância dissolvida.

Erros comuns e soluções

Um sensor TDS é a ferramenta mais barata e fácil para transformar a qualidade da água em um número: com a compensação de temperatura adequada e uma calibração simples, você pode monitorar de forma confiável a água da torneira, um filtro, um aquário ou sua solução hidropônica. Ao interpretar os resultados, lembre-se de que o TDS não mede a segurança microbiológica. No app BlueGrays, você encontra projetos passo a passo com esquemas do circuito e código para uma estação de irrigação inteligente e um registrador de temperatura com marcação de data e hora, e pode adicionar um sensor TDS a eles.