Como usar um Sensor de Nível de Água

Como usar um Sensor de Nível de Água

     Esse Tutorial apresentará para vocês todas as informações necessárias para uso do Sensor de Nível de Água e alguns dos principais modelos disponíveis no mercado, com uso e comparação do desempenho destes, assim você poderá escolher o modelo que mais se adequa ao seu projeto, vamos lá?

     O nosso tutorial será dividido nos seguintes tópicos, clique para ir em algum tópico específico.

-O que é um Sensor de Nível de Água

-Onde utilizar o Sensor de Nível de Água

-Tipos de Sensores de Nível de Água

-Teste do Sensor de Nível de Água

-Qual é o melhor Sensor de Nível de Água?

-Projeto Sensor de Nível de Água

-Conclusão

O que é um Sensor de Nível de Água

     Um Sensor de Nível de Água tem a função de agir como chave liga-desliga do sistema, podendo acionar bombas, lâmpadas, ou enviar um sinal a um microcontrolador como o Arduino, o Pic ou o Raspberry Pi.

     Em diversos projetos é necessário realizar o monitoramento do nível de água de um tanque ou reservatório, seja para simples controle, para prevenção de vazamentos ou automação do procedimento de encher o tanque de água e desligar automaticamente.

     Um sensor de nível de água, se programado, retransmite informações para um painel de controle para indicar se o tanque de água está vazio ou cheio, sendo que alguns indicadores de nível utilizam uma combinação de sensores para isso.

     Existem diversos modelos de sensores de nível, trataremos de alguns mais adiante.

Onde utilizar o Sensor de Nível de Água

     O Sensor de Nível de Água pode ser utilizado em inúmeros projetos para controle hidráulico, sendo em cafeteiras, piscinas, ativação de bombas de água, controle de fluídos, aquários, tigelas de água para animais de estimação, entre outros. Garantindo que o nível de água não ultrapasse o limite do tanque, ou que o tanque seja preenchido quando estiver com o nível baixo.

Tipos de Sensores de Nível de Água

     No mercado podemos encontrar muitos modelos de sensores de nível de água, apresentaremos alguns desses:

• Sensor de Nível de Água – T1592
  

     O Sensor de Nível de Água do modelo T1592 é desenvolvido com dez traços de linhas metálicas expostas, sendo que cinco destas são de energia e cinco são sensores, de forma revezada.

     O funcionamento desse sensor se baseia na mesma lógica de um resistor variável, sendo que a resistência é alterada de acordo com o nível de água, dessa forma, a resistência é inversamente proporcional ao nível de água, portanto, quando o módulo está submerso a resistência é menor, quando não há água a resistência é maior, sabemos que o ar é um isolante natural, enquanto que a água age como condutor. 
     Consequentemente, o sensor produz uma tensão de saída referente à resistência, lembrando que a tensão é inversamente proporcional a resistência.
     O módulo conta com 3 pinos, sendo que um deles é o VCC (responsável por fornecer energia ao sensor), o GND (pino de aterramento) e o S (pino de sinal que deve ser conectado em uma das entradas analógicas do Arduino).
     Esse modelo de sensor tem um contraponto, a vida útil pode ser muito curta, pois os filamentos metálicos rapidamente são corroídos pela energização em contato com o meio aquoso. Uma forma de aumentar o tempo de vida útil é não o deixando ligado durante muito tempo, então o VCC pode ser ligado em um pino digital do Arduino, alternando entre HIGH (nível lógico alto) ou LOW (nível lógico baixo).

Principais Características:

• Alimentação: 5VDC;
• Corrente de trabalho: Inferior a 20mA;
• Temperatura de operação: 10°C a 30°C
• Umidade: 10% a 90% (sem condensação)
• Tipo de sensor: Analógico
• Processo de produção: FR4HASL;
• Área de detecção: 40 x 16mm;

• Sensor de Nível de Água – tipo chave

     Esse sensor é produzido com uma haste de plástico na qual desliza um cilindro igualmente plástico, esse cilindro é solto e desliza com a elevação do nível da água, como pode ser visto na imagem abaixo, o cilindro é composto por um imã que aciona um sensor magnético presente no corpo da haste, fechando o contato dos fios do sensor. Como vantagem, esse sensor apresenta uma ligação simples, com dois fios (vcc e gnd).

Principais Características:

• Tensão de chaveamento: 100VDC (máx);
• Corrente de chaveamento: 0,5A (máx);
• Resistência Contato: 100mΩ;
• Temperatura de operação: -10 a 85°C;
• Datasheet: Sensor de Nível de água- Tipo chave;
  
  
  
• Sensor de Nível de Água – tipo boia 90°

     Assim como o sensor acima, este funciona através da flutuação do cilindro, tendo apenas a construção como diferença entre eles. O interruptor de flutuação detecta o nível de água e abre ou fecha a chave de acordo com a posição do cilindro, podendo acionar uma bomba, um indicador, um alarme ou outro dispositivo.

Principais Características:

• Potência na carga: 10W/50W;
• Contato: Normalmente fechado;
• Tensão de chaveamento: 100VDC;
• Tensão de contato aberto: 220VDC;
• Corrente de chaveamento: 500mA;
• Corrente de carga: 1A;
• Resistência de contato: 100mΩ;
• Classificação de temperatura: -10 a 85°C;

Teste do Sensor de Nível de Água

     Agora iremos demonstrar o funcionamento dos sensores de nível de água com projetos simples em conjunto com o Arduino Uno:

• Teste do Sensor de Nível de Água – T1592

     O S (pino do sinal) será ligado em um pino analógico do Arduino, esse pino é analógico porque é um dado variável, não é apenas 5V ou 0V como no caso do digital, teremos variações de acordo com o nível da água, então a tensão poderá ser qualquer uma entre 0V e 5V, como pino analógico eu selecionarei o A1.

     O + ( pino VCC), conectaremos em um pino digital, poderia ser no 5V pois consiste no pino de alimentação, mas eu ligarei em um digital para que eu consiga controlar a energização, eu não quero que o sensor fique ligado o tempo inteiro, o motivo foi explicado na descrição deste sensor. Como pino digital, eu escolherei o pino 2.

     O – (pino GND) deverá ser ligado ao GND do Arduino Uno.

     Depois de realizar a montagem do circuito, carregue o programa exemplo na sua IDE do Arduino, caso você tenha alguma dúvida de como carregar um programa na IDE do Arduino, siga o procedimento abaixo:

     Primeiramente, você irá copiar o programa e colar em sua IDE. Em seguida, selecione a placa que você está utilizando, no caso do meu exemplo, eu estou utilizando um Arduino Uno. Além disso, eu devo selecionar a porta de conexão do meu Arduino.

     Feitas as devidas configurações, compile o programa clicando nesse símbolo: 

/* Título: Teste do Sensor T1592
 * Desenvolvido: Curto Circuito
 */

/* Pinos correspondentes ao sensor */
#define sensorvcc 2     /*Define vcc como pino 2 */ 
#define sensorsinal A1  /*Define sinal como pino A1 */ 

/* Declara variável inteira para armazenamento dos dados */
int val = 0;

void setup() { /*abre laço de configuração*/
  /* define 2 como pino de saída do Arduino */
  pinMode(sensorvcc, OUTPUT);

  digitalWrite(sensorvcc, LOW); /* vcc tem nível lógico baixo até que haja alguma variação na leitura */
  Serial.begin(9600); /* Baudrate de 9600 */
}

void loop() { /*laço de repetição */
  /*variável level é igual a leitura do sensor */
  int level = readSensor(); 
  /*printa o nível da água no monitor serial */
  Serial.print("Nível de água: "); /*printa o "Nível da água: " no monitor serial */
  Serial.println(level); /*printa o nível da água no monitor serial */
  delay(1000);  /*Atraso de 1s entre leituras*/
}

/* leitura do sensor */
int readSensor() {  
digitalWrite(sensorvcc, HIGH);  /* alimenta o sensor */
delay(10);              /* espera 10ms */
val = analogRead(sensorsinal);    /* Realiza a leitura analógica do sinal do sensor */
digitalWrite(sensorvcc, LOW);   /* Desliga o sensor */
return val;             /* envia leitura */
}

     Agora veremos o funcionamento do sensor na prática, abra o seu monitor serial:

     Quando o meu sensor está fora da água, eu notei variações entre 0 e 50 aproximadamente, então eu submergi metade do sensor na água e obtive leituras entre 430 e 480, enquanto que submerso eu notei valores acima de 500.

     Para realizar configurações de interpretações de dados, é necessário entendermos o sensor que está em nossas mãos, não necessariamente o seu sensor terá a mesma variação numérica, apesar de provavelmente serem leituras próximas. Então se você quiser realizar um programa que envia um comando simples para indicar que não há água, que o copo está parcialmente com água ou que o copo está cheio, é necessário realizar esse teste para verificar as leituras do seu sensor nos três casos e definir os parâmetros, faremos isso no projeto desse tutorial. 

• Teste do Sensor de Nível de Água – tipo chave

     O sensor do tipo chave conta com uma instalação muito simples, como não há uma polarização, você não precisa se preocupar com o fio positivo ou negativo. Para conexão eu utilizarei um pino digital (pino 6) que será responsável pela leitura dos dados do sensor. O resistor de 220Ω entre o sensor e o GND age como um pull-down, eliminando quaisquer ruídos possíveis.

     O Sensor depende exclusivamente do movimento do cilindro plástico pelo corpo, esse cilindro flutua com a presença da água, o imã interno aciona um sensor no interior da haste, fechando o contato. Esse sensor pode ser colocado em qualquer ponto do tanque, isso será relativo ao seu projeto, ou seja, ao ponto de desejo de detecção.

     Abaixo você pode verificar o movimento do cilindro do sensor.

O programa para teste também é muito simples:

/*Programa: Teste sensor tipo chave
Desenvolvido: Curto Circuito*/

/*Pino ligado ao sensor de nivel de liquido */
int sensor = 6; /*Define sensor como pino 6*/

/*laço de configuração*/
void setup()
{
  Serial.begin(9600); /*Baudrate de 9600*/
  pinMode(sensor, INPUT); /*define o pino do sensor como saída*/
}

void loop() /*laço de repetição*/
{ /* Printa a leitura digital no monitor serial */
  int estado = digitalRead(sensor); /* define que estado é igual a leitura digital do sensor */
  Serial.print("Estado sensor : "); /*"Printa: Estado sensor:" */
  Serial.println(estado); /* Printa a leitura de estado */
  delay(100); /*atraso de 0,1s*/
}

     Carregue o programa e verifique o funcionamento no monitor serial, você verá que se movimentar o cilindro plástico, a leitura irá variar entre 1 ou 0, através dessas duas leituras  você pode aferir se o sensor está realizando uma leitura de tanque cheio ou vazio.

• Teste do Sensor de Nível de Água – tipo boia 90°

     O sensor do tipo boia é semelhante ao de tipo chave, a única diferença entre eles é a estrutura acrílica, mas toda a conexão é semelhante, além da programação ser a mesma.

     Como você pode ver no circuito abaixo, eu apenas substituí um sensor por outro, eu mantenho o resistor pull-down e ligo um dos fios ao pino 6 do Arduino, assim como no sensor anterior.

     Esse sensor é posicionado na horizontal e o seu cilindro se locomove verticalmente, como pode ser gif abaixo:

     E a programação, como mencionado, é a mesma:

/*Programa: Teste sensor tipo chave
Autor: Curto Circuito*/


int sensor = 6; /*Sensor ligado ao pino 6*/

void setup() /*laço de configuração*/
{
  Serial.begin(9600); /*Baudrate de 9600*/
  pinMode(sensor, INPUT); /*define o pino do sensor como entrada do Arduino*/

}

void loop() /*laço de repetição*/
{ 
  int estado = digitalRead(sensor); /*estado é igual a leitura digital*/
  Serial.print("Estado sensor : "); /*Printa "Estado do sensor:" */
  Serial.println(estado); /*Printa a leitura de estado*/
  delay(100); /*atraso de 0,1s*/
}

     Ao deslizar o cilindro, você pode verificar a variação de nível lógico, que oscila entre 0 e 1, sendo que é possível desenvolver uma programação mais complexa a partir disso, faremos esse procedimento adiante.

Qual é o melhor Sensor de Nível de Água?

     Não é possível determinar qual é o melhor sensor, pois isso dependerá exclusivamente da ideia de projeto: O sensor T1592 é recomendado para projetos em que o volume de água é menor, como o nível de água em um copo de água, por exemplo, isso acontece porque ele realiza a leitura do nível de forma mais precisa, apontando os casos de meio-termo. Os outros dois sensores, com cilindro flutuante, normalmente são utilizados para detectar se o tanque está completamente cheio ou completamente vazio, dessa forma, são utilizados em muitos projetos de alerta de volume de um reservatório.

     Como explicado, o sensor de nível de água tipo chave e o tipo boia 90° são muito semelhantes, as únicas diferenças são em estrutura do corpo plástico. Pela estrutura deles, o sensor do tipo chave é mais recomendado para o fundo do tanque e a borda, indicando quando o tanque está abaixo ou quando está no limite do volume. No caso do sensor de 90°, ele pode ser utilizado em qualquer posição da parede do tanque, indicando quando o volume de água atingiu a altura específica da sua localização.

Projeto Sensor de Nível de Água

     Agora desenvolveremos um projeto com cada um dos sensores apresentados acima, os projetos serão diferentes para cada um deles, mas podem ser adaptados para o uso de um dos outros sensores.

• Projeto com Sensor de Nível de Água – T1592

     Como mencionado acima, esse sensor pode ser melhor utilizado em projetos com tanques rasos. Em razão disso, eu preparei um projeto que acende LEDs indicando o nível de água em um copo. No caso desse sensor, ele não precisa necessariamente ser utilizado apenas em projetos de água em copos, o importante é que a altura do tanque não ultrapasse 4cm, que é a altura de medição do sensor, então pode ser utilizado em um amplo reservatório com pouca profundidade ou na borda de um tanque para aviso de limite.

Componentes Utilizados

- Arduino Uno;

- 3 Resistores de 220Ω;

- 2 Leds Vermelho;

- 2 Leds Azul;

- 2 Leds Amarelo;

- Sensor T1592;

- Jumpers macho-macho;

- Protoboard;

     Para desenvolvimento de um programa que acendesse os LEDs de forma que indicasse o nível da água naquele momento, eu tive que realizar marcações de nível no sensor, como o meu sensor tem 4cm de comprimento de medição e eu quero utilizar 6 LEDs em meu projeto, eu dividi esses 4cm por 6 para saber o comprimento aproximado de cada nível, serão 6 níveis indicados pelos LEDs. Realizando essa operação, eu cheguei à conclusão de que cada nível deve ter aproximadamente 0,67cm, então eu utilizei uma caneta a prova d’água e uma régua para essas marcações.

     Depois de realizar as marcações, vamos carregar o mesmo programa utilizado anteriormente, então colocaremos o sensor submerso em cada um dos níveis demarcados e faremos as medições para criarmos os parâmetros destes. Eu notei que para cada um dos níveis eu encontrei valores próximos ao que pode ser visto na tabela abaixo:

     Depois de criar essa tabela com os valores das medições em cada nível do sensor, eu elaborarei o programa que irá acender o LED respectivo de cada nível, esses valores serão importantes para o programa.

Instalação Sensor de Nível de Água- T1592 e Arduino

     Para desenvolvimento do projeto, faça a seguinte ligação entre o Arduino, Sensor, LEDs e resistores como mostrado abaixo.

Programação  Arduino e T1592

     O programa será dedicado em fazer as leituras assim como no de teste, mas como mencionado, definiremos que as medições serão informadas por LEDs, então faremos  linhas de comando indicando que quando a medição estiver entre valor x e valor y, acenderemos determinado LED.

     Você pode ver o programa comentado abaixo.

/* Projeto: Sensor de Nível T1592 e Leds
Autor: Curto Circuito
Descrição: Projeto de desenvolvimento de um sensor que realiza leituras de nível 
de água e acende o Led de forma correspondente */

#define sensorsinal A1 /* sensor ligado ao pino analógico A1 do Arduino */

int val = 0; /* declara val para armazenamento de dados */
int ledverde1 = 8; /* declara led verde 1 como pino 8*/
int ledverde2 = 9; /* declara led verde 2 como pino 9*/
int ledazul1 = 10; /* declara led azul 1 como pino 10*/
int ledazul2 = 11; /* declara led azul 2 como pino 11*/
int ledvermelho1 = 12; /* declara led vermelho 1 como pino 12*/
int ledvermelho2 = 13; /* declara led vermelho 2 como pino 13*/

void setup() { /* abre laço de configuração */
  pinMode (ledverde1, OUTPUT); /* define led verde 1 como saída do Arduino*/
  pinMode (ledverde2, OUTPUT); /* define led verde 2 como saída do Arduino*/
  pinMode (ledazul1, OUTPUT); /* define led azul 1 como saída do Arduino*/
  pinMode (ledazul2, OUTPUT); /* define led azul 2 como saída do Arduino*/
  pinMode (ledvermelho1, OUTPUT); /* define led vermelho 1 como saída do Arduino*/
  pinMode (ledvermelho2, OUTPUT);  /* define led vermelho 2 como saída do Arduino*/
  
  Serial.begin(9600); /*Baudrate de 9600*/
}

void loop() { /* laço de repetição */
  int level = readSensor(); /* level é o equivalente a leitura do sensor */

  Serial.print("Nível de água: "); /*Printa "Nível de água:" no monitor serial*/
  Serial.println(level); /* Printa o dado level no monitor serial*/
  if (level>=0 && level<280 ){  /* Se o nível está entre 0 e 279*/
    digitalWrite(ledverde1, HIGH); /* Nível lógico de Led verde 1 é alto*/
    digitalWrite(ledverde2, LOW); /* Nível lógico de Led verde 2 é baixo*/
    digitalWrite(ledazul1, LOW); /* Nível lógico de Led azul 1 é baixo*/
    digitalWrite(ledazul2, LOW); /* Nível lógico de Led azul 2 é baixo*/
    digitalWrite(ledvermelho1, LOW); /* Nível lógico de Led vermelho 1 é baixo */
    digitalWrite(ledvermelho2, LOW);  /* Nível lógico de Led vermelho 2 é baixo */ 
  }
  if (level>=280 && level<360 ){ /* Se o nível está entre 280 e 359*/
    digitalWrite(ledverde1, HIGH); /* Nível lógico de Led verde 1 é alto*/
    digitalWrite(ledverde2, HIGH); /* Nível lógico de Led verde 2 é alto*/
    digitalWrite(ledazul1, LOW); /* Nível lógico de Led azul 1 é baixo*/
    digitalWrite(ledazul2, LOW); /* Nível lógico de Led azul 2 é baixo*/
    digitalWrite(ledvermelho1, LOW);/* Nível lógico de Led vermelho 1 é baixo*/
    digitalWrite(ledvermelho2, LOW); /* Nível lógico de Led vermelho 2 é baixo*/
  }
  
  if (level>=360 && level<390 ){ /* Se o nível está entre 360 e 389*/
    digitalWrite(ledverde1, HIGH); /* Nível lógico de Led verde 1 é alto*/
    digitalWrite(ledverde2, HIGH); /* Nível lógico de Led verde 2 é alto*/
    digitalWrite(ledazul1, HIGH); /* Nível lógico de Led azul 1 é alto*/
    digitalWrite(ledazul2, LOW); /* Nível lógico de Led azul 2 é baixo*/
    digitalWrite(ledvermelho1, LOW); /* Nível lógico de Led vermelho 1 é baixo*/
    digitalWrite(ledvermelho2, LOW); /* Nível lógico de Led vermelho 2 é baixo*/   
  }
  if (level>=390 && level<420 ){ /* Se o nível está entre 360 e 389*/
    digitalWrite(ledverde1, HIGH); /* Nível lógico de Led verde 1 é alto*/
    digitalWrite(ledverde2, HIGH); /* Nível lógico de Led verde 2 é alto*/
    digitalWrite(ledazul1, HIGH); /* Nível lógico de Led azul 1 é alto*/
    digitalWrite(ledazul2, HIGH); /* Nível lógico de Led azul 2 é alto*/
    digitalWrite(ledvermelho1, LOW); /* Nível lógico de Led vermelho 1 é baixo*/
    digitalWrite(ledvermelho2, LOW); /* Nível lógico de Led vermelho 2 é baixo*/  
  }

  if (level>=420 && level<450 ){ /* Se o nível está entre 420 e 449*/
    digitalWrite(ledverde1, HIGH); /* Nível lógico de Led verde 1 é alto*/
    digitalWrite(ledverde2, HIGH); /* Nível lógico de Led verde 2 é alto*/
    digitalWrite(ledazul1, HIGH); /* Nível lógico de Led azul 1 é alto*/
    digitalWrite(ledazul2, HIGH); /* Nível lógico de Led azul 2 é alto*/
    digitalWrite(ledvermelho1, HIGH); /* Nível lógico de Led vermelho 1 é alto*/
    digitalWrite(ledvermelho2, LOW); /* Nível lógico de Led vermelho 2 é baixo*/  
  }
  if (level>=450){ /* Se o nível é maior ou igual a 450*/
    digitalWrite(ledverde1, HIGH); /* Nível lógico de Led verde 1 é alto*/
    digitalWrite(ledverde2, HIGH); /* Nível lógico de Led verde 2 é alto*/
    digitalWrite(ledazul1, HIGH); /* Nível lógico de Led azul 1 é alto*/
    digitalWrite(ledazul2, HIGH); /* Nível lógico de Led azul 2 é alto*/
    digitalWrite(ledvermelho1, HIGH); /* Nível lógico de Led vermelho 1 é alto*/
    digitalWrite(ledvermelho2, HIGH);  /* Nível lógico de Led vermelho 2 é alto*/ 
  }
  
  delay(1000); /* atraso de 1s entre uma leitura e outra */
}

int readSensor() {  /* leitura do sensor */
  val = analogRead(sensorsinal);    /* Realiza a leitura analógica do sinal do sensor */
  return val;             /* envia leitura */
}

     Assim como a maioria dos sensores, este não interpreta as medições sozinho, ele precisa de um microcontrolador que realiza a leitura e interpretação de acordo com o programado.

     Depois de realizar a ligação, copie o programa, cole em sua IDE e carregue para a placa Arduino, então você deve obter um resultado semelhante ao demonstrado:

     Veja que como definido no programa, os Leds acendem de acordo com as leituras.

• Projeto Sensor de Nível de Água – Tipo chave

     Para utilização do Sensor de Nível do tipo chave, devemos criar um programa que realiza a leitura do sinal binário recebido (0 ou 1) e então executa uma função. O Sinal será 0 ou 1 de acordo com a posição do cilindro que se movimenta pelo corpo do sensor. O nosso projeto consistirá em um sistema que ao detectar ausência de água, aciona um buzzer de alerta e ativa a bomba para encher o tanque até que o mesmo esteja cheio novamente.

Componentes Utilizados

     Para desenvolvimento, serão utilizados os seguintes componentes:

- Arduino Uno;

- Jumpers macho-macho;

- Protoboard;

-Buzzer 12mm – Auto-oscilante -5V;

-Resistor 220Ω;

-Mini bomba submersa;

-Sensor de Nível de Água – Tipo Chave

     Para desenvolvimento eu elaborei um programa que envia nível lógico alto para a bomba e o buzzer quando o sensor indica ausência de água, do contrário estes ficam em nível lógico baixo. Como pode ser visto na tabela lógica.

 Instalação Sensor de Nível de Água- Tipo chave e Arduino

     A instalação para o desenvolvimento desse projeto é muito simples, basta ligar o sensor como fizemos para o teste, o buzzer deve ser ligado em uma porta digital, como a alimentação deste é de 5V, não se faz necessário o uso de um resistor,  a bomba também será ligada em um pino digital, não necessitando de resistor.

Programação  Arduino e Sensor de Nível – Tipo Chave

     O programa está definido para realizar a leitura e acionar o buzzer e a bomba, assim como mencionado acima, para utilizar este programa basta copiar, colar em sua IDE do Arduino e carregar.

/*Programa: Sensor liquido Arduino
Descrição: Desenvolveremos um projeto que acionará um buzzer e uma bomba caso o sensor faça uma leitura de nível lógico baixo  
Autor: Curto Circuito
*/

int sensor = 6; /*define sensor como pino 6 do Arduino */
int buzzer = 5; /*define buzzer como pino 5 do Arduino */
int bomba = 4;  /*define bomba como pino 4 do Arduino  */


void setup() /*laço de configuração */
{
  Serial.begin(9600); /* Baudrate de 9600 */
  pinMode(sensor, INPUT); /* Baudrate de 9600 */
  pinMode(buzzer, OUTPUT);/* Baudrate de 9600 */
  pinMode(bomba, OUTPUT); /* Baudrate de 9600 */
}

void loop()  /* laço de repetição */
{
  int estado = digitalRead(sensor); /*estado é equivalente a leitura do sensor*/
  Serial.print("Estado sensor : "); /* printa "Estado sensor: " */
  Serial.println(estado); /* printa o estado*/
  delay(100); /* atraso de 0,1s */
  
  if (estado == HIGH) { /* se o estado de leitura do sensor for nível lógico alto (nível de água baixo) */
    digitalWrite (bomba, HIGH); /* escreve nível lógico alto na bomba */
    digitalWrite (buzzer, HIGH); /* escreve nível lógico alto no buzzer */
  } else { /* caso contrário */
    delay(1500); /* atraso de 1,5s*/
    digitalWrite (bomba, LOW); /* escreve nível lógico baixo na bomba*/ 
    digitalWrite (buzzer, LOW); /* escreve nível lógico baixo no buzzer */
  }  
}

• Projeto Sensor de Nível de Água - Tipo Boia 90°

     Para desenvolvimento do projeto, faremos a montagem do Arduino em conjunto com o sensor de nível e o sensor de temperatura tipo sonda, enquanto o sensor de nível realiza uma leitura digital, o sensor de temperatura realiza uma leitura digital. Então a partir disso é possível realizar um projeto para monitoramento de um aquário, por exemplo, ou uma máquina de bebidas. Você pode, por exemplo, desenvolver um projeto que dita que se o nível de água estiver alto e se a temperatura estiver em determinado valor, algo pode ser acionado.

Componentes Utilizados

     Para desenvolvimento, serão utilizados os seguintes componentes:

-Sensor de temperatura- DS18B20 (tipo sonda)

-Sensor de Nível de Água – Tipo Boia 90°

-Arduino Uno

-Protoboard

-Jumpers macho-macho

-Resistor 270KΩ

Instalação Sensor de Nível de Água- Tipo Boia 90°

     Para a instalação, faremos a ligação do sensor de nível no pino digital 6, enquanto que o sensor de temperatura será ligado no pino analógico A0 do Arduino, como mostrado no esquemático abaixo.

Programação  Arduino e Sensor de Nível – Tipo Boia 90°

/*Programa: Sensor de Nível - Tipo Boia
Descrição: Desenvolveremos um projeto que realiza a leitura de um sensor de temperatura, 
além de detectar o nível de água de um tanque 
Autor: Curto Circuito
*/


#include <OneWire.h> /*inclusão da biblioteca OneWire */
#include <DallasTemperature.h> /*Inclusão da biblioteca do sensor de temperatura */ 

int DS18B20 = 10; /*define o pino do sensor de temperatura como 10 */
int sensor = 6; /*define sensor de nível como pino 6 do Arduino */

OneWire ourWire(DS18B20); /*configura instância onewire para uso do sensor de temperatura */
DallasTemperature sensors(&ourWire); /* biblioteca dallastemperature */

void setup(){    /* laço de configuração */
  Serial.begin(9600); /* Baudrate de 9600 */
  sensors.begin(); /*inicia o sensor de temperatura */
  pinMode(sensor, INPUT); /* Baudrate de 9600 */
  delay(1000); /* Intervalo de 1s */
 
}

void loop(){
  sensors.requestTemperatures();/* requisita a temperatura do sensor */
  Serial.print("Temperatura: "); /*printa "Temperatura" */ 
  Serial.print(sensors.getTempCByIndex(0)); /* printa a temperatura */
  Serial.println("*C"); /* Printa *C na Serial */
  delay(250); /* 0,25s */
  int estado = digitalRead(sensor); /*leitura do sensor */
  Serial.print("Estado sensor : "); /*Printa "Estado do sensor:" */
  Serial.println(estado);  /* printa o estado */
  delay(100); /*atraso de 0,1s */
}

Conclusão

     Os sensores de nível de água são muito úteis para desenvolvimento de projetos que necessitam desse monitoramento de nível, e cada sensor se mostrou eficaz com a sua particularidade, cabendo ao projetista avaliar qual é o melhor de acordo com as comparações realizadas no tutorial. As instalações são simples e os sensores são de fácil manuseio, tornando-se assim um ótimo aliado em projetos de automação hidráulica.