Sensor do nível da caixa d’água (Arduino) – sem fio!

Para melhorar a interface com o usuário deste sistema, usaremos 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 demonstra ser desafiante. Baseando-se nos inúmeros módulos para Arduino que podem transmitir dados através das ondas de radiofrequência, a escolha é difícil. Deve estar a pensar, por que não usar WIFI ou um Módulo NRF24, tão comum e barato?

Após alguns testes com os módulos NRF24 descobrimos que este não apresenta um bom desempenho num local onde existem dezenas de routers WIFI. Sabendo-se que os routers WIFI e os módulos NRF24 usam a mesma faixa de frequência, percebemos que o alcance do sinal dos módulos fica muito debilitado devido à grande quantidade de interferência. É claro, se for instalar este sistema onde não tem tanta interferência, os módulos NRF24 poderão ser facilmente utilizados. Desde que faça as devidas alterações na montagem e no Sketch.

O melhor dos módulos RF433, usados neste projeto, é que são baratos, fáceis de usar e tem um alcance satisfatório. A faixa de frequência dos 433 MHz é muita usada em Portugal, para o controlo remoto de portões de garagem e outros equipamentos. E como o sinal de RF é somente transmitido quando o botão do comando é acionado, pode-se concluir que o nível de interferência é baixo.

A frequência deste sinal de 433 MHz encaixa-se na Banda ISM (Industry, Science and Medicine). E atualmente é usada na faixa LORA (longo alcance) na Europa!

Sensores do nível d’água

Para os sensores usaremos os sensores de nível d’água (chave bóia) pois eles têm uma 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 humidade, pode ser quente e pode provocar a breve destruição de outros tipos de sensores.

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

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

Na Internet e no Youtube existe um método bem interessante de instalação destes 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. Para o projeto usaremos quatro sensores, mas poderia utilizar mais ou menos sensores dependendo da sua necessidade. Mas lembre-se que tem de fazer modificações no programa e na interface do display OLED, se não for usar os quatro sensores.

Montagem com o primeiro Arduino – 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 bóia). Conectado a esse Arduino fica o módulo transmissor RF433. Ele transmite as informações sobre os sensores. Para simplificar a manutenção, com este 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 bóia está para baixo (sem água) e com a chave aberta.

Para permitir um maior alcance do sinal de radiofrequência usaremos uma fonte de 9 Volts (poderá usar uma fonte de até 12V) 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 5V do Arduino.

Material necessário – Arduino TX:

• Arduino Uno;
• Módulo RF433 Transmissor;
• 4 sensores de nível d’água;
• 4 LEDs;
• Resistências – 4 x 2.2K ohms e 4 x 10K ohms;
• Fonte 9V;
• Breadboard ou placa PCI;
• Shunts para as ligações.

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 > Gerir Bibliotecas 

Após abrir a janela do Gestor de Bibliotecas, procure rc-switch. Na biblioteca RC-switch, clique em Instalar. Após alguns segundos, ela será automaticamente instalada. Lembre-se que o seu computador precisa de 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

Este é o Sketch Code que deve ser gravado no primeiro Arduino TX. Os sensores de nível d’água são monitorados. Quando o Arduino deteta que a bóia fechou o contacto do sensor, o LED respetivo ao sensor acende. Isto é 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 a cada 3 segundos. Desta forma, se algum sensor estragar, nada será transmitido e o Arduino Recetor mostrará uma falha. Estes códigos servem para facilitar a receção dos dados, pelo módulo RF433 RX. Todas as vezes 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 Electrofun - Monitor de Nível de Caixa D'água - Transmissor
   Arduino UNO - IDE 1.8.9
   pino D12 - transmite dados
*/

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

RCSwitch transmissor = RCSwitch();   // cria a instância transmissor 

int sensor_100 = 7;   // chave bóia 100% - pino D7
int sensor_75 = 6;    // chave bóia 75%  - pino D6
int sensor_50 = 5;    // chave bóia 50%  - pino D5
int sensor_25 = 4;    // chave bóia 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

// variáveis de níveis
int nivel_100;
int nivel_75;
int nivel_50;
int nivel_25;

void setup() {
  pinMode(LED_BUILTIN, OUTPUT); // led D13 integrado na placa
  
  // configurações das portas dos LEDs
  pinMode(led_100, OUTPUT);
  pinMode(led_75, OUTPUT);
  pinMode(led_50, OUTPUT);
  pinMode(led_25, OUTPUT);
  
  // configurações das portas dos sensores
  pinMode(sensor_100, INPUT);
  pinMode(sensor_75, INPUT);
  pinMode(sensor_50, INPUT);
  pinMode(sensor_25, INPUT);

  transmissor.enableTransmit(12);      // pino usado para a transmissão
  transmissor.setPulseLength(500);     // largura do impulso em microseg
  transmissor.setProtocol(6);          // protocolo de transmissã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 d'água vazia
  }
  if ((nivel_100 == HIGH) && (nivel_75 == HIGH) && (nivel_50 == HIGH) && (nivel_25 == LOW)) {
       transmissor.send(1301, 24);             // caixa d'água 25%
  }
  if ((nivel_100 == HIGH) && (nivel_75 == HIGH) && (nivel_50 == LOW) && (nivel_25 == LOW)) {
       transmissor.send(1333, 24);             // caixa d'água 50%
  }
  if ((nivel_100 == HIGH) && (nivel_75 == LOW) && (nivel_50 == LOW) && (nivel_25 == LOW)) {
      transmissor.send(1397, 24);              // caixa d'água 75%
  }
  if ((nivel_100 == LOW) && (nivel_75 == LOW) && (nivel_50 == LOW) && (nivel_25 == LOW)) {
        transmissor.send(1525, 24);            // caixa d'água 100% cheia
  }
  digitalWrite(LED_BUILTIN,LOW);               // apaga o LED do Arduino
  delay(2000);                                 // pausa de 2 segundos
}

Informações importantes sobre as antenas

Tanto o módulo RF433 transmissor, quanto o recetor 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.

Neste guia básico sobre os módulos RF433 está explicado como são montadas as antenas, usando fios rígidos de 17,3 cm:

Guia Básico dos Módulos TX / RX – RF 433MHZ

Para aumentar o alcance das antenas, fizemos algumas experiências. Um dos testes que deu bom resultado foi usando um fio rígido de 34,6 cm (1/2 comprimento de onda) todo enrolado num lápis. Depois da antena toda enrolada, removemos o lápis e aumentamos 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 – Recetor e display OLED

O outro Arduino Uno serve como monitor do nível da água. Ele poderá ser instalado a 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 recetor 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 telemóvel (5V) e o cabo USB para ligá-lo.

Material necessário – Arduino RX:

• Arduino UNO;
• Módulo RF433 Recetor;
• Display OLED 128×64 – I2C;
• Fonte 9 V;
• Buzzer ativo (para testes);
• Breadboard ou placa PCI;
• Shunts para as ligações.

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 recetor 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, é necessário instalar duas bibliotecas 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

Este é o Sketch que deve gravar no segundo Arduino com o módulo recetor 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 receçã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 Electrofun - Monitor de Nível de Caixa D'água - Recetor + display OLED
   Arduino UNO - IDE 1.8.9
   pino D2 - recetor 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 pixeis
   h   altura em pixeis
   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 recetor = RCSwitch();

#define SCREEN_WIDTH 128           // largura do display 128 pixeis
#define SCREEN_HEIGHT 64           // altura do display 64 pixeis 
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);          // tamanho do caracter
  displayMessage ();               // mostra mensagem no display
  caixa25(false);
  caixa50(false);
  caixa75(false);
  caixa100(false);                 // caixa vazia
  recetor.enableReceive(0);        // ativa Recepção - pino do recetor = D2 Arduino
}

void caixa25(boolean cheia) {
  if (cheia == true) {
    display.fillRoundRect(0, 0, 30, 40, 2, WHITE); // preencha o retângulo
    display.setTextColor(BLACK);
  } else {
    display.fillRoundRect(0, 0, 30, 40, 2, BLACK); // apague o retângulo
    display.drawRoundRect(0, 0, 30, 40, 2, WHITE); // desenhe o retângulo
    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 retângulo
    display.setTextColor(BLACK);
  } else {
    display.fillRoundRect(31, 0, 30, 40, 2, BLACK); // apague o retângulo
    display.drawRoundRect(31, 0, 30, 40, 2, WHITE); // desenhe o retângulo
    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 retângulo
    display.setTextColor(BLACK);
  } else {
    display.fillRoundRect(62, 0, 30, 40, 2, BLACK); // apague o retângulo
    display.drawRoundRect(62, 0, 30, 40, 2, WHITE); // desenhe o retângulo
    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 retângulo cor branca
    display.setTextColor(BLACK);                    // selecione cor preta
  } else {                                          // senão
    display.fillRoundRect(93, 0, 31, 40, 2, BLACK); // apague o retângulo
    display.drawRoundRect(93, 0, 31, 40, 2, WHITE); // desenhe o retângulo 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 retângulo
  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 (recetor.available()) {
    valor = recetor.getReceivedValue();
    recetor.resetAvailable();
    inicialTimer = millis();   
  }
  if (finalTimer - inicialTimer >= 4000) {
    displayFalha ();
    inicialTimer = finalTimer;
  }
  if (valor == 1285)  {                             // caixa d'água vazia
    digitalWrite(13, HIGH);
    caixa25(false);
    caixa50(false);
    caixa75(false);
    caixa100(false);
    digitalWrite(13, LOW);
  }
  if (valor == 1301)  {                             // caixa d'água 25%
    digitalWrite(13, HIGH);
    caixa25(true);
    caixa50(false);
    caixa75(false);
    caixa100(false);
    digitalWrite(13, LOW);
  }
  if (valor == 1333)  {                             // caixa d'água 50%
    digitalWrite(13, HIGH);
    caixa25(true);
    caixa50(true);
    caixa75(false);
    caixa100(false);
    digitalWrite(13, LOW);
  }
  if (valor == 1397)  {                             // caixa d'água 75%
    digitalWrite(13, HIGH);
    caixa25(true);
    caixa50(true);
    caixa75(true);
    caixa100(false);
    digitalWrite(13, LOW);
  }
  if (valor == 1525)  {                             // caixa d'água 100% cheia
    digitalWrite(13, HIGH);
    caixa25(true);
    caixa50(true);
    caixa75(true);
    caixa100(true);
    digitalWrite(13, LOW);
  }
}

Sugestões para outras implementações

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

Placa PCI para protótipos

Este sistema foi desenvolvido para o monitoramento do nível da caixa d’água. Mas pode 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. Este display é bem versátil e poderá acrescentar mais funcionalidades ao seu projeto!

Se necessitar do registo dos níveis de água durante um certo período, por exemplo durante dias ou semanas, sugerimos 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.