Na WEB podemos encontrar inúmeros projetos com Arduino, que permitem o monitoramento do nível da caixa d’água. Mas pretendendo inovar e facilitar a instalação desse sistema, resolvi implementá-lo sem fio! Espero que seja útil e interessante para você, caro leitor.
Para melhorar a interface com o usuário desse sistema, usei um display OLED que pode informar o nível da caixa d’água, além de poder mostrar uma ou mais informações sobre o sistema de monitoramento. O Display OLED tem baixo consumo de energia, é fácil de usar e ainda tem recursos gráficos que um display LCD comum não tem.
O desenvolvimento do projeto usando a transmissão de dados sem fio demonstrou ser desafiante. Baseando-me nos inúmeros módulos para Arduino que podem transmitir dados através das ondas de rádiofrequência, a escolha foi difícil. Você poderia pensar, por que eu não usei WIFI ou um Módulo NRF24, tão comum e barato?
Já fiz alguns testes com os módulos NRF24 e a minha experiência não foi boa. Moro em um local, onde existem dezenas de roteadores WIFI. Sabendo-se que os roteadores WIFI e os módulos NRF24 usam a mesma faixa de frequência, percebi que o alcance do sinal dos módulos fica muito debilitado devido à grande quantidade de interferência. É claro, se for instalar esse sistema onde não tem tanta interferência, os módulos NRF24 poderão ser facilmente utilizados. Desde que faça alterações na montagem e no Sketch.
O que me agradou nos módulos RF433, usados nesse projeto, é que são baratos, fáceis de usar e tem um alcance satisfatório. Essa faixa de frequência dos 433 MHz é muita usada no Brasil, para controle remoto de portões de garagem e outros equipamentos. E como o sinal de RF é somente transmitido quando o botão do controle remoto é acionado, pode-se concluir que o nível de interferência é baixo.
A frequência desse sinal de 433 MHz se encaixa na Banda ISM ( Industrial, científica e médica). E atualmente é usada na faixa LORA (longo alcance) na Europa!
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.
Quando a boia sobe com a presença da água e fica próxima do pino frontal, o contato é fechado.
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.
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
Transmissor:
Receptor:
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.
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.
/* 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
}
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:
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.
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.
Itens necessários:
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.
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);
}
}
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.
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.
Conheça a Metodologia Eletrogate e ofereça aulas de robótica em sua escola!
|
A Eletrogate é uma loja virtual de componentes eletrônicos do Brasil e possui diversos produtos relacionados à Arduino, Automação, Robótica e Eletrônica em geral.
Tenha a Metodologia Eletrogate dentro da sua Escola! Conheça nosso Programa de Robótica nas Escolas!
Rua Rio de Janeiro, 441 - Sala 1301
Centro - Belo Horizonte/MG
CEP 30160-041
*Não temos atendimento físico
ANWAR SLEIMAN HACHOUCHE - ME
CNPJ: 18.917.521/0001-73
