Últimos:
ArduinoMódulosNovidade

Como Monitorar a Turbidez da Água com Arduino e Sensor de Turbidez

Matheus Caires

A turbidez está relacionada à presença de partículas em suspensão na água. Quanto maior a quantidade dessas partículas, mais turva ela pode parecer. Com um sensor de turbidez e um Arduino, podemos acompanhar essa variação e criar uma classificação simples para representar diferentes condições da água.

Neste tutorial, vamos desenvolver um projeto utilizando um Arduino Uno, um Sensor de Turbidez, um Display LCD 16×2 com comunicação I2C e três LEDs. O LCD será responsável por informar o estado identificado pelo sensor, enquanto os LEDs funcionarão como uma indicação visual semelhante a um semáforo:

  • LED verde: água cristalina;
  • LED amarelo: água turva;
  • LED vermelho: água muito suja.

Para demonstrar o funcionamento, começaremos colocando o sensor em um recipiente com água limpa. Em seguida, adicionaremos gradativamente água suja ao recipiente. Conforme a turbidez aumentar, a leitura analógica será alterada e o Arduino atualizará automaticamente o estado mostrado no display e o LED correspondente.

Importante: este projeto realiza uma classificação experimental com base na leitura do sensor. Ele não determina se uma água é potável ou própria para consumo.

Materiais Necessários

Para desenvolver o projeto, serão utilizados:

Esquemático de Ligação dos Componentes

Para realizar a montagem, conecte os componentes ao Arduino Uno conforme a tabela abaixo.

O display LCD utiliza o protocolo I2C para se comunicar com o Arduino. Esse protocolo usa apenas dois fios: SDA (transferência de dados) e SCL (sinal de clock para sincronização). Cada dispositivo I2C possui um endereço único que o identifica na comunicação.

ComponentePino do componenteArduino Uno
Módulo Sensor de TurbidezV – (VCC)5V
Módulo Sensor de TurbidezG – (GND)GND
Módulo Sensor de TurbidezA – (Saída analógica)A0
LCD 16×2 I2CVCC5V
LCD 16×2 I2CGNDGND
LCD 16×2 I2CSDAA4 / SDA
LCD 16×2 I2CSCLA5 / SCL
LED VerdeÂnodo (+)D5
LED AmareloÂnodo (+)D6
LED VermelhoÂnodo (+)D7
LEDsCátodo (-)GND através de resistor

Os resistores conectados aos LEDs são obrigatórios para limitar a corrente elétrica. Sem eles, o LED pode queimar e o pino digital do Arduino pode ser danificado. Conecte o resistor em série entre o pino do Arduino e o ânodo (perna mais longa, polo positivo) do LED. O cátodo (perna mais curta, polo negativo) vai direto ao GND.

O sensor será lido pela entrada analógica A0. O display LCD utilizará a comunicação I2C do Arduino Uno por meio dos pinos SDA e SCL.

Figura 1 – Esquemático de ligação do Sensor de Turbidez, LCD 16×2 I2C e LEDs ao Arduino Uno.

Caso o módulo do seu sensor possua saídas identificadas como A (Analógico) e D (Digital), neste projeto utilizamos a saída A, pois precisamos acompanhar a variação da leitura analógica.

Configurações Iniciais

Antes de carregar o programa, conecte o Arduino Uno ao computador utilizando um cabo USB e abra a Arduino IDE. Dentro da Arduino IDE, siga o caminho:

Ferramentas > Placa > Arduino AVR Boards > Arduino Uno

Figura 2 – Caminho configuração inicial Arduino.

Depois, em Ferramentas > Porta, selecione a porta correspondente ao Arduino conectado ao computador.

Instalando a biblioteca do LCD

O projeto utiliza a biblioteca LiquidCrystal_I2C, responsável pela comunicação entre o Arduino e o módulo I2C do display LCD 16×2.

Na Arduino IDE, abra o Gerenciador de Bibliotecas, pesquise por LiquidCrystal_I2C e instale a biblioteca.

Figura 3 – Caminho para adicionar biblioteca.

Neste projeto, o endereço I2C utilizado para o display é 0x27, mas o seu pode ser diferente. Para verificar qual o endereço do seu display, acesse nosso tutorial Como utilizar o Display LCD 16×02 com módulo I2C no Arduino.

Testando o Sensor Antes de Montar Tudo

Antes de montar o circuito completo, vale testar o sensor de turbidez sozinho. Isso confirma que o sensor está funcionando corretamente e permite observar os valores que ele retorna com água limpa e com água turva, o que facilita a escolha dos limites usados no programa.

Para o teste, conecte apenas o sensor ao Arduino: VCC ao 5V, GND ao GND e o pino de saída analógica ao pino A0. Depois, carregue o sketch abaixo:

Atenção: o sketch abaixo serve apenas para verificar se o sensor está lendo corretamente. Ele não usa LCD nem LEDs e não é o programa final do projeto.

int sensorPin = A0;
int leitura;

void setup() {
  Serial.begin(9600);
}

void loop() {
  leitura = analogRead(sensorPin);
  Serial.print("Leitura do sensor: ");
  Serial.println(leitura);
  delay(500);
}

Abra o Monitor Serial em Ferramentas > Monitor Serial e configure a velocidade para 9600 baud. Com o sensor na água limpa, observe o valor exibido. Em seguida, adicione impurezas à água e acompanhe a variação dos números. Se os valores mudarem conforme a turbidez aumenta, o sensor está funcionando corretamente e você está pronto para montar o projeto completo.

Elaborando o Código

Com o sensor testado e o circuito montado, é hora de programar o Arduino. O programa lê continuamente o sensor de turbidez e compara o valor encontrado com três faixas para determinar o estado da água.

Os valores de referência utilizados neste projeto são:

  • Acima de 700: água cristalina;
  • Entre 601 e 700: água turva;
  • 600 ou menos: água muito suja.

Esses valores foram definidos a partir dos testes realizados neste projeto e podem variar de acordo com o sensor e as condições do experimento. A seguir, o código é apresentado em três blocos para facilitar o aprendizado. Cada bloco é um fragmento do programa completo e serve apenas para estudo da lógica. O código final, pronto para carregar no Arduino, está ao final desta seção.

Bloco 1: Declarações e Bibliotecas

O programa começa incluindo as bibliotecas necessárias e declarando todas as variáveis usadas ao longo do código.

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// Endereço I2C e configuração do display (16 colunas, 2 linhas)
LiquidCrystal_I2C lcd(0x27, 16, 2);

// Pino de leitura analógica do sensor
int sensorPin = A0;
int leitura;

// Pinos dos LEDs
int LedVerde = 5;
int LedAmarelo = 6;
int LedVermelho = 7;

A biblioteca Wire.h gerencia a comunicação I2C e a LiquidCrystal_I2C.h controla o display. A linha LiquidCrystal_I2C lcd(0x27, 16, 2) cria o objeto do display informando o endereço I2C e o tamanho da tela (16 colunas e 2 linhas). Os pinos 5, 6 e 7 são reservados para os LEDs verde, amarelo e vermelho.

Bloco 2: Inicialização no setup()

A função setup() é executada uma única vez quando o Arduino é ligado. Ela configura os pinos dos LEDs como saída e inicializa o display com uma mensagem de boas-vindas.

void setup() {
  // Configurar pinos dos LEDs como saída
  pinMode(LedVerde, OUTPUT);
  pinMode(LedAmarelo, OUTPUT);
  pinMode(LedVermelho, OUTPUT);

  // Inicializar o display e ligar a iluminação de fundo
  lcd.init();
  lcd.backlight();
  lcd.clear();

  // Exibir mensagem de inicialização
  lcd.setCursor(0, 0);
  lcd.print("Sensor Turbidez");
  lcd.setCursor(0, 1);
  lcd.print("Iniciando...");
  delay(1000);

  lcd.clear();
}

Os três pinos dos LEDs são configurados como saída com pinMode(). O display é inicializado com lcd.init() e a iluminação de fundo é ligada com lcd.backlight(). A mensagem “Iniciando…” fica visível por 1 segundo. Atenção: a função delay() recebe o tempo em milissegundos, portanto delay(1000) equivale a 1 segundo e delay(500) equivale a meio segundo.

Bloco 3: Lógica Principal no loop()

A função loop() é executada continuamente enquanto o Arduino estiver ligado. A cada ciclo, ela lê o sensor e decide qual estado exibir no LCD e qual LED acender.

void loop() {
  leitura = analogRead(sensorPin);
  lcd.setCursor(0, 0);
  lcd.print("Estado da Agua:");

  if (leitura > 700) {
    lcd.setCursor(0, 1);
    lcd.print("Cristalina      ");
    digitalWrite(LedVermelho, LOW);
    digitalWrite(LedAmarelo, LOW);
    digitalWrite(LedVerde, HIGH);
  }
  else if (leitura > 600) {
    lcd.setCursor(0, 1);
    lcd.print("Turva           ");
    digitalWrite(LedVermelho, LOW);
    digitalWrite(LedVerde, LOW);
    digitalWrite(LedAmarelo, HIGH);
  }
  else {
    lcd.setCursor(0, 1);
    lcd.print("Muito Suja      ");
    digitalWrite(LedAmarelo, LOW);
    digitalWrite(LedVerde, LOW);
    digitalWrite(LedVermelho, HIGH);
  }

  delay(500);
}

A leitura do sensor é feita com analogRead(sensorPin), que retorna um número entre 0 e 1023. Quanto mais turva a água, menor o valor retornado. O programa usa três condições if/else if/else para comparar o valor lido com os limites definidos e atualizar o LCD e os LEDs. Os dois LEDs que não correspondem ao estado atual são sempre apagados antes de acender o correto, garantindo que apenas um LED fique aceso por vez.

Código Completo

Com a lógica compreendida em partes, veja abaixo o programa completo pronto para carregar no Arduino:

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// Endereço I2C mais comum para o display LCD
LiquidCrystal_I2C lcd(0x27, 16, 2);

// Pino utilizado para leitura analógica do sensor
int sensorPin = A0;

// Armazena a leitura analógica do sensor
int leitura;

// LEDs de indicação
int LedVerde = 5;
int LedAmarelo = 6;
int LedVermelho = 7;

void setup() {

  pinMode(LedVerde, OUTPUT);
  pinMode(LedAmarelo, OUTPUT);
  pinMode(LedVermelho, OUTPUT);

  lcd.init();
  lcd.backlight();
  lcd.clear();

  lcd.setCursor(0, 0);
  lcd.print("Sensor Turbidez");

  lcd.setCursor(0, 1);
  lcd.print("Iniciando...");

  delay(1000);

  lcd.clear();
}

void loop() {

  // Realiza a leitura analógica do sensor
  leitura = analogRead(sensorPin);

  lcd.setCursor(0, 0);
  lcd.print("Estado da Agua:");

  // Água cristalina
  if (leitura > 700) {

    lcd.setCursor(0, 1);
    lcd.print("Cristalina      ");

    digitalWrite(LedVermelho, LOW);
    digitalWrite(LedAmarelo, LOW);
    digitalWrite(LedVerde, HIGH);
  }

  // Água turva
  else if (leitura > 600) {

    lcd.setCursor(0, 1);
    lcd.print("Turva           ");

    digitalWrite(LedVermelho, LOW);
    digitalWrite(LedVerde, LOW);
    digitalWrite(LedAmarelo, HIGH);
  }

  // Água muito suja
  else {

    lcd.setCursor(0, 1);
    lcd.print("Muito Suja      ");

    digitalWrite(LedAmarelo, LOW);
    digitalWrite(LedVerde, LOW);
    digitalWrite(LedVermelho, HIGH);
  }

  delay(500);
}

Ajustando os Valores do Sensor de Turbidez

Os limites 700 e 600 utilizados no programa foram definidos a partir do comportamento observado durante este experimento e não devem ser considerados valores universais para todos os sensores ou amostras de água.

Se você estiver reproduzindo o projeto, realize seus próprios testes com água limpa e água progressivamente mais turva para encontrar os valores que funcionam melhor com o seu sensor. Use o sketch de teste da seção anterior para observar os valores antes de montar o circuito completo.

Para ajustar, altere diretamente os números nestas linhas do programa:

if (leitura > 700)    // altere 700 conforme seus testes
else if (leitura > 600)    // altere 600 conforme seus testes

Alterando esses números, você modifica os pontos nos quais o programa muda entre os estados Cristalina, Turva e Muito Suja. Essa é também uma ótima forma de experimentar com o projeto e entender como uma leitura analógica pode ser transformada em informações úteis pelo Arduino.

Aplicações e Possíveis Melhorias

O projeto apresentado é uma forma prática de estudar sensores analógicos, leitura de dados e representação de informações utilizando Arduino. Como evolução, é possível:

  • realizar uma calibração mais detalhada do sensor;
  • mostrar no LCD também o valor da leitura analógica;
  • utilizar mais faixas de classificação;
  • armazenar as leituras para acompanhar as alterações ao longo do tempo;
  • adicionar alertas sonoros com um Buzzer;
  • utilizar uma placa com conectividade para acompanhar os valores remotamente (IoT).

É importante lembrar que a classificação utilizada neste tutorial tem finalidade experimental e educacional. A indicação “Cristalina”, por exemplo, representa apenas a faixa de leitura definida no programa e não comprova que uma amostra seja própria para consumo.

Espero que tenha gostado do tutorial. Caso tenha dúvidas ou sugestões, deixe um comentário abaixo.

Valeu!

📅 Última atualização: 21/08/2026 às 11:25

Graduando em Engenharia da Computação.

Matheus Caires

Graduando em Engenharia da Computação.

Você pode gostar também

Experimento de Eletromagnetismo Como Fazer uma Bobina se Mover com Corrente Elétrica e Ímã

Experimento de Eletromagnetismo: Como Fazer uma Bobina se Mover com Corrente Elétrica e Ímã

Kleber Bastos

Como usar o Regulador de Tensão MT3608 (Step-Up) Corretamente

Matheus Caires

Jogo da memória com Arduino: do jogador ao criador

Bruno Gabriel

Deixe um comentário

Este site utiliza o Akismet para reduzir spam. Saiba como seus dados em comentários são processados.

Powered by  GDPR Cookie Compliance
Visão geral de privacidade

Este site usa cookies para que possamos oferecer a melhor experiência de usuário possível. As informações dos cookies são armazenadas em seu navegador e executam funções como reconhecê-lo quando você retorna ao nosso site e ajudar nossa equipe a entender quais seções do site você considera mais interessantes e úteis.