Sensores de Nível D'água

Escolhi usar os sensores de nível d’água (chave boia) pois eles têm boa
durabilidade, fácil uso e são à prova d’água. O ambiente interno de uma caixa
d’água, além da água e da umidade, pode ser quente e pode provocar a breve
destruição de outros tipos de sensores.

Essas imagens abaixo são dos sensores de nível d’água. Dentro da boia (parte
móvel) tem um pequeno imã. Dentro do pino frontal do sensor, tem uma chave
(reed switch) que é sensível ao magnetismo. Veja que quando a boia está para
baixo, o contato fica aberto.

Chave boia aberta

Quando a boia sobe com a presença da água e fica próxima do pino frontal, o
contato é fechado.

Chave boia fechada

Na WEB e no YOUTUBE, descobri um método bem interessante de instalação

desses sensores, sem a necessidade de fazer furos na caixa d’água. Usando uma
montagem com canos de PVC, o aparato fica totalmente à prova d’água e permite
uma manutenção fácil, já que ele pode ser retirado inteiramente da caixa d’água.
Monte os canos e conexões de PVC, prenda os sensores e cole tudo para impedir a
entrada de água. A fiação dos sensores deverá ser passada dentro dos canos e
conectada no Arduino. A quantidade de sensores usadas por mim foi de quatro,
mas poderá utilizar mais ou menos sensores dependendo da sua necessidade. Mas
lembre-se que terá que fazer modificações no programa e na interface do display
OLED, se não for usar os quatro sensores.

Montagem (Sensores)
O sistema de monitoramento utiliza dois Arduinos UNO. Um dos Arduinos ficará
junto da caixa d’água e será usado para monitorar os sensores (chaves boias).
Conectado à esse Arduino fica o módulo transmissor RF433. Ele transmite as
informações sobre os sensores. Para simplificar a manutenção, com esse Arduino
existem 4 leds, um para cada sensor. Se o led acender é porque o sensor está
fechado (com o nível d’água). Se o led estiver apagado é porque a boia está para
baixo (sem água) e com a chave aberta.
Para permitir um maior alcance do sinal de rádiofrequência usei uma fonte de 9
Volts (poderá usar uma fonte de até 12 V) para alimentar o módulo transmissor
RF433. Para alimentar o Arduino conecte essa fonte no plug de energia do mesmo.
O regulador interno do Arduino reduz a tensão para 5 Volts. Os sensores e os leds
deverão usar somente o 5 V do Arduino.

Material necessário para o projeto Sensor de Nível de Caixa D’água sem Fio!
– Arduino TX:
 Arduino Uno
 Módulo RF433 Transmissor
 4 sensores de nível d’água
 4 Led difuso amarelo 5 mm
 resistores – 4 x 2,2K ohms e 4 x 10 K ohms
 Fonte 9 V
 Protoboard
 Jumpers

Diagrama da montagem – Arduino – Caixa Dagua TX

A biblioteca usada para controlar os módulos RF433 TX e RX, chama-se RC-
switch. Para instalar a nova biblioteca na Arduino IDE, clique em :

Sketch > Incluir Biblioteca > Gerenciar Bibliotecas

Após abrir a janela do Gerenciador de Biblioteca, refine a busca digitando rc-

switch. Na biblioteca RC-switch, clique em More Info e depois em Instalar.
Após alguns segundos, ela será automaticamente instalada. Lembre-se que o seu
computador precisa estar conectado na internet, para poder baixar a biblioteca.
Após a instalação da Biblioteca, é necessário que feche e abra novamente o
programa Arduino IDE.

Biblioteca RC switch

Esse é o Sketch desenvolvido por mim para ser gravado no primeiro Arduino TX.
Os sensores de nível d’água são monitorados. Quando o Arduino detecta que a
boia fechou o contato do sensor, o Led respectivo ao sensor acende. Isso é
importante para a avaliação do funcionamento dos sensores, durante uma
manutenção.

Dentro do Loop do programa, verifica-se também a combinação de sensores

acionados. Somente quando combinações válidas são detectadas, o Arduino
transmite códigos, periodicamente à cada 3 segundos. Dessa forma, se algum
sensor estragar, nada será transmitido e o Arduino Receptor mostrará uma falha.
Esses códigos foram escolhidos por mim, para facilitar a recepção dos dados, pelo
módulo RF433 RX. Toda vez que os dados forem transmitidos, o led da placa
Arduino (D13) piscará também.

 Caixa d’água vazia – código 1285

 Caixa d’água 25% – código 1301
  Caixa d’água 50% – código 1333
 Caixa d’água 75% – código 1397
 Caixa d’água 100% – código 1525
/* Blog Eletrogate - Monitor de Nível de Caixa Dagua - Transmissor

Gustavo Murta 14/ago/2019

Arduino UNO - IDE 1.8.9

pino D12 - transmite dados

https://github.com/sui77/rc-switch/

*/

#include <RCSwitch.h> // biblioteca RCSwitch V 2.62

RCSwitch transmissor = RCSwitch(); // cria a instancia transmissor

int sensor_100 = 7; // chave boia 100% - pino D7

int sensor_75 = 6; // chave boia 75% - pino D6

int sensor_50 = 5; // chave boia 50% - pino D5

int sensor_25 = 4; // chave boia 25% - pino D4

int led_100 = 11; // Led 100% - pino D11

int led_75 = 10; // Led 75% - pino D10

int led_50 = 9; // Led 50% - pino D9

int led_25 = 8; // Led 25% - pino D8

int nivel_100; // variáveis de niveis

int nivel_75;

int nivel_50;

int nivel_25;

void setup()

pinMode(LED_BUILTIN, OUTPUT); // led D13 integrado na placa

pinMode(led_100, OUTPUT); pinMode(led_75, OUTPUT); // configurações das portas dos

Leds

pinMode(led_50, OUTPUT); pinMode(led_25, OUTPUT);

pinMode(sensor_100, INPUT); pinMode(sensor_75, INPUT); // configurações das portas

dos sensores

pinMode(sensor_50, INPUT); pinMode(sensor_25, INPUT);

transmissor.enableTransmit(12); // pino usado para transmissão

transmissor.setPulseLength(500); // largura do pulso em microseg

transmissor.setProtocol(6); // protocolo de trasmissão

transmissor.setRepeatTransmit(16); // numero de repetidas transmissões

void loop()

digitalWrite(LED_BUILTIN,HIGH); // acende Led do Arduino

nivel_100 = digitalRead(sensor_100); // leitura do sensor 100%

digitalWrite(led_100,nivel_100);

nivel_75 = digitalRead(sensor_75); // leitura do sensor 75%

digitalWrite(led_75,nivel_75);

nivel_50 = digitalRead(sensor_50); // leitura do sensor 50%

digitalWrite(led_50,nivel_50);

nivel_25 = digitalRead(sensor_25); // leitura do sensor 25%

digitalWrite(led_25,nivel_25);

if ((nivel_100 == HIGH) && (nivel_75 == HIGH) && (nivel_50 == HIGH) && (nivel_25 ==
HIGH))

transmissor.send(1285, 24); // caixa dagua vazia

if ((nivel_100 == HIGH) && (nivel_75 == HIGH) && (nivel_50 == HIGH) && (nivel_25 ==
LOW))

transmissor.send(1301, 24); // caixa dagua 25%

if ((nivel_100 == HIGH) && (nivel_75 == HIGH) && (nivel_50 == LOW) && (nivel_25 ==
LOW))

transmissor.send(1333, 24); // caixa dagua 50%

if ((nivel_100 == HIGH) && (nivel_75 == LOW) && (nivel_50 == LOW) && (nivel_25 ==
LOW))

transmissor.send(1397, 24); // caixa dagua 75%

if ((nivel_100 == LOW) && (nivel_75 == LOW) && (nivel_50 == LOW) && (nivel_25 ==
LOW))

{
transmissor.send(1525, 24); // caixa dagua 100% cheia

digitalWrite(LED_BUILTIN,LOW); // apaga Led do Arduino

delay(2000); // pausa de 2 segundos

Informações sobre as antenas

Tanto o módulo RF433 transmissor, quanto o receptor precisam ter antenas
adequadas. A não instalação de antenas ou o ajuste inadequado, inviabilizarão o
projeto, já que o sinal de RF não poderá ser recebido.

Nesse Guia básico sobre os módulos RF433, eu explico como são montadas as
antenas, usando fios rígidos de 17,3 cm:
https://blog.eletrogate.com/guia-basico-dos-modulos-tx-rx-rf-433mhz/

Para aumentar o alcance das antenas, fiz algumas experiências. Um dos testes que
deu um bom resultado, foi usando um fio rígido de 34,6 cm (1/2 comprimento de
onda) todo enrolado em um lápis. Depois da antena todo enrolada, eu removi o
lápis e fui espichando a antena enrolada. Com um comprimento de
aproximadamente 14 cm, os resultados foram melhores. Lembrando que as duas
antenas precisam ser aproximadamente iguais em comprimento e precisam ser
soldadas nos módulos RF433.

Segundo Arduino – receptor e display OLED

O outro Arduino Uno serve como monitor do nível da água. Ele poderá ser
instalado à uma certa distância da caixa d’água, por exemplo no andar térreo de
uma casa. Nesse Arduino, são acoplados o módulo receptor RF433 para receber as
informações e o display OLED para mostrar o nível da água.

Para alimentar o Arduino Uno, poderá usar uma fonte externa entre 6,5 V e 12 V.
Ou se preferir, use um carregador de celular (5V) e o cabo USB para energizá-lo.
Material necessário para o projeto Sensor de Nível de Caixa D’água sem Fio!
– Arduino RX:

 Arduino UNO
 Módulo RF433 Receptor
 Display OLED 128×64 – I2C
 Fonte 9 V
 Buzzer ativo (para testes)
 Protoboard ou placa PCI
 fios para ligações

Diagrama da montagem – Arduino – Caixa Dagua RX

Uma coisa bem pensada no sistema, foi a indicação de alerta mostrada no display,
quando algum sensor da caixa d’água falhar ou quando o módulo receptor não
receber a transmissão. O tempo de espera do sinal de RF poderá ser alterado no
sketch, se achar necessário. Se os dados dos sensores não forem recebidos dentro
desse tempo (timeout), a indicação de falha será mostrada no display.
Para o uso do display OLED, duas bibliotecas precisam ser instaladas na Arduino
IDE – a Adafruit_SSD1306 e a Adafruit-GFX. Use o mesmo procedimento
usado para a instalação da biblioteca RC-switch.

Biblioteca Adafruit SSD1306

Biblioteca Adafruit GFX

Esse é o Sketch para ser gravado no segundo Arduino com o módulo receptor e o
display OLED. A cada três segundos, o Arduino recebe os dados do transmissor. E
as indicações de níveis de água são mostradas no display OLED. Se ocorrer
alguma falha na recepção, a indicação de Falha de sinal será mostrada. Nesse
caso, certifique-se que o módulo transmissor está ligado e transmitindo o sinal
adequado. Para ajudar nos testes, sugiro que monte um Buzzer ativo (campainha
sonora), conectando o pino positivo do Buzzer no pino D13 do Arduino. O outro
pino negativo do Buzzer, conecte-o no pino terra (GND). Sempre que o sinal com
os dados corretos for recebido, o led da placa Arduino piscará e um apito será
emitido.
/* Blog Eletrogate - Monitor de Nível de Caixa Dagua - Receptor + display Oled

Gustavo Murta 14/ago/2019

Arduino UNO - IDE 1.8.9

pino D2 - receptor de dados

https://github.com/sui77/rc-switch/

https://github.com/adafruit/Adafruit_SSD1306

https://github.com/adafruit/Adafruit-GFX-Library

OLED I2C SDA = A4 e SCL = A5

drawRoundRect(x,y,w,h,r,color)

x coordenada x (topo esquerda)

y coordenada y (topo esquerda)

w largura em pixels

h altura em pixels

r raio da borda

color cor

*/

//#include <Wire.h> // biblioteca I2C

#include <Adafruit_GFX.h> // biblioteca gráfica da Adafruit

#include <Adafruit_SSD1306.h> // biblioteca Oled da Adafruit

#include <Fonts/FreeMono9pt7b.h> // tipo de fonte do caracter

#include <RCSwitch.h> // biblioteca RCswitch V 2.6.2

RCSwitch receptor = RCSwitch();

#define SCREEN_WIDTH 128 // largura do display 128 pixels

#define SCREEN_HEIGHT 64 // altura do display 64 pixels

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

int valor;

unsigned long inicialTimer = 0;

unsigned long finalTimer;

boolean falha = false;

void setup()

pinMode(13, OUTPUT);
display.begin(SSD1306_SWITCHCAPVCC, 0x3C);

display.clearDisplay(); // limpa o display

display.setFont(&FreeMono9pt7b); // tipo de fonte

display.setTextSize(1); // tamamho do caracter

displayMessage (); // mostra mensagem no display

caixa25(false); caixa50(false); caixa75(false); caixa100(false); // caixa vazia

receptor.enableReceive(0); // ativa Recepção - pino do receptor = D2 Arduino

void caixa25(boolean cheia)

if (cheia == true)

display.fillRoundRect(0, 0, 30, 40, 2, WHITE); // preencha o retangulo

display.setTextColor(BLACK);

else

display.fillRoundRect(0, 0, 30, 40, 2, BLACK); // apague o retangulo

display.drawRoundRect(0, 0, 30, 40, 2, WHITE); // desenhe o retangulo

display.setTextColor(WHITE);

display.setCursor(4, 25);

display.println("25");

display.display();

void caixa50(boolean cheia)

if (cheia == true)

display.fillRoundRect(31, 0, 30, 40, 2, WHITE); // preencha o retangulo

display.setTextColor(BLACK);

else

{
display.fillRoundRect(31, 0, 30, 40, 2, BLACK); // apague o retangulo

display.drawRoundRect(31, 0, 30, 40, 2, WHITE); // desenhe o retangulo

display.setTextColor(WHITE);

display.setCursor(35, 25);

display.println("50");

display.display();

void caixa75(boolean cheia)

if (cheia == true)

display.fillRoundRect(62, 0, 30, 40, 2, WHITE); // preencha o retangulo

display.setTextColor(BLACK);

else

display.fillRoundRect(62, 0, 30, 40, 2, BLACK); // apague o retangulo

display.drawRoundRect(62, 0, 30, 40, 2, WHITE); // desenhe o retangulo

display.setTextColor(WHITE);

display.setCursor(66, 25);

display.println("75");

display.display();

void caixa100(boolean cheia)

if (cheia == true) // se caixa 100 estiver cheia

display.fillRoundRect(93, 0, 31, 40, 2, WHITE); // preencha o retangulo cor branca

display.setTextColor(BLACK); // selecione cor preta

else // senão

{
display.fillRoundRect(93, 0, 31, 40, 2, BLACK); // apague o retangulo

display.drawRoundRect(93, 0, 31, 40, 2, WHITE); // desenhe o retangulo cor branca

display.setTextColor(WHITE); // selecione cor branca

display.setCursor(91, 25); // coordenadas x e y

display.println("100"); // escreva 100

display.display(); // mostra no display

void displayMessage ()

display.setTextColor(WHITE); // selecione cor branca

display.setCursor(2, 60); // coordenadas x e y

display.println("CAIXA DAGUA"); // escreve mensagem

display.display(); // mostra no display

void displayFalha ()

display.fillRoundRect(0, 0, 127, 40, 1, BLACK); // apague o retangulo

display.setTextColor(WHITE); // selecione cor branca

display.setCursor(30, 10); // coordenadas x e y

display.println("FALHA"); // escreve mensagem

display.setCursor(20, 30); // coordenadas x e y

display.println("DE SINAL"); // escreve mensagem

display.display(); // mostra no display

void loop()

valor = 0;

finalTimer = millis();

if (receptor.available())

valor = receptor.getReceivedValue();

receptor.resetAvailable();

inicialTimer = millis();
}

if (finalTimer - inicialTimer >= 4000)

displayFalha ();

inicialTimer = finalTimer;

if (valor == 1285) // caixa dagua vazia

digitalWrite(13, HIGH);

caixa25(false); caixa50(false); caixa75(false); caixa100(false);

digitalWrite(13, LOW);

if (valor == 1301) // caixa dagua 25%

digitalWrite(13, HIGH);

caixa25(true); caixa50(false); caixa75(false); caixa100(false);

digitalWrite(13, LOW);

if (valor == 1333) // caixa dagua 50%

digitalWrite(13, HIGH);

caixa25(true); caixa50(true); caixa75(false); caixa100(false);

digitalWrite(13, LOW);

if (valor == 1397) // caixa dagua 75%

digitalWrite(13, HIGH);

caixa25(true); caixa50(true); caixa75(true); caixa100(false);

digitalWrite(13, LOW);

if (valor == 1525) // caixa dagua 100% cheia

digitalWrite(13, HIGH);

caixa25(true); caixa50(true); caixa75(true); caixa100(true);

digitalWrite(13, LOW);

Sugestões
Para testes iniciais do sistema, sugiro que faça as montagens em Protoboards. Mas
para um funcionamento definitivo, sugiro que monte tudo em placas de circuito
impresso pré-fabricadas. Soldes os componentes e os fios de ligações nas placas e
nos Arduinos. Confira todas as montagens, antes de energizar os circuitos! Se tiver
conhecimento e experiência, poderá projetar placas de circuito impresso dedicadas
para o sistema.

Placa PCI para protótipos

Esse sistema foi desenvolvido para o monitoramento do nível da caixa d’água. Mas
poderá ser usado também para acionamento de uma bomba d’água quando o nível
da caixa estiver baixo. Dessa forma, é só acrescentar um módulo de relé para
controlar a bomba e fazer as alterações no sketch.

Use o display OLED para mostrar mais outras mensagens. Esse display é bem
versátil e poderá acrescentar mais funcionalidades ao seu projeto!
Se você necessitar do registro dos níveis de água durante um certo período, por
exemplo durante dias ou semanas, sugiro que acrescente um relógio RTC DS3231
e um módulo de cartão SD.

Se precisar de um alerta sobre o baixo nível de água da caixa, acrescente um

Buzzer ativo (campainha sonora) e ou um indicador luminoso maior, para chamar a
atenção.

Ao informar meus dados, e