24 setembro 2017

Monitore sua caixa dágua usando Arduino

E não só a caixa dágua, mas também tanques, reservatórios e aquários, usando o sensor de nível de água, um sensor do tipo bóia que é um sensor de funcionamento bem simples, como você vai ver nesse projeto de monitoramento.

Sensor de nível de líquidos com Arduino

Para entender melhor o funcionamento do sensor de nível de água, recomendo a leitura deste post aqui do Arduino e Cia.

Material necessário para o projeto


Para esse projeto você vai precisar do seguinte material:


O material mostrado acima será usado para a montagem da parte eletrônica do projeto. Se você pretende instalar isso na sua casa, vai precisar de outros materiais para fixar os sensores na caixa dágua, cabos para ligação dos sensores ao Arduino, caixa para proteção do circuito, etc.

O projeto de monitoramento de caixa dágua


Este projeto consiste em um Arduino Uno que vai efetuar a leitura dos sensores de nível de água, que são do tipo "bóia" e ficarão dentro do reservatório. Serão utilizados 3 sensores que, conforme o nível da água, vão enviar sinais para o microcontrolador, que por sua vez vai acionar um display LCD 16x2 I2C e mostrar o nível de água no reservatório.
Sensores posicionados em uma caixa dágua
Coloquei um relé no circuito, mas o uso é opcional, já que ele pode ser usado para ligar uma bomba que vai encher a caixa. O relé permanece desligado até que o nível da água atinja o ponto mais baixo (sensor 3), quando então ele é acionado, e permanece assim até que o nível do reservatório atinja o nível máximo (sensor 1).

Circuito monitoração de caixa dágua


O circuito abaixo mostra a ligação dos 3 sensores no Arduino Uno, conectados às portas 8, 9 e 10, com o relé conectado na porta 7.

O display utiliza interface I2C, e é ligado nas portas analógicas A4 (SDA) e A5 (SCL) do Arduino. Ele está "de lado" justamente para facilitar a visão do nível da água, representado pelos quadrados no lado direito do display.

Arduino Uno - LCD 16x2 e Sensor de nivel de água módulo relé

Os resistores usados nos sensores são de 10K, funcionando como resistores pull-down. Você não precisa usar necessariamente esses valores, ajuste de acordo com os resistores que tiver em mãos.

Programa monitoramento de caixa dágua


O programa usa a biblioteca LiquidCrystal_I2C (download), e você deve descompactar a biblioteca e colocá-la na pasta Libraries da IDE do Arduino. Atenção: Observe que esta biblioteca é diferente de outras LiquidCrystal_I2C que já usei aqui no Arduino e Cia, e foi escolhida por aceitar caracteres customizados, ok?

No código temos a inicialização do display e depois a leitura do estado dos sensores. Se houver alguma mudança, o nível do reservatório é atualizado, passando pelos níveis C (caixa cheia), M (nível médio) e V (caixa vazia).

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
//Programa: Monitoracao de Caixa d´agua usando Arduino
//Autor: Arduino e Cia

//Display HD44780 com adaptador I2C
#include <Wire.h>
#include <hd44780.h> // include hd44780 library header file
#include <hd44780ioClass/hd44780_I2Cexp.h> // i/o expander/backpack class
hd44780_I2Cexp lcd; // auto detect backpack and pin mappings

#define pino_rele 7
#define sensor1 8
#define sensor2 9
#define sensor3 10

int valor_s1 = 1, valor_s2 = 1, valor_s3 = 1;

//Simbolos
uint8_t letra_C[8] = {0x0, 0xE, 0x11, 0x11, 0x11, 0x11, 0x0, 0x0};
uint8_t letra_M[8] = {0x0, 0x1F, 0x2, 0x4, 0x2, 0x1F, 0x0, 0x0};
uint8_t letra_v[8] = {0x0, 0x7, 0x8, 0x10, 0x8, 0x7 , 0x0, 0x0};
uint8_t caracter_nivel[8] = {0x0, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x0};

int nivel_anterior = 0;

void setup()
{
  Serial.begin(9600);
  //Inicializa o display I2C
  lcd.begin(16, 2);
  //Caracteres customizados
  lcd.createChar(0, letra_C);
  lcd.createChar(1, letra_M);
  lcd.createChar(2, letra_v);
  lcd.createChar(3, caracter_nivel);

  //Define os pinos dos sensores como entrada
  pinMode(sensor1, INPUT);
  pinMode(sensor2, INPUT);
  pinMode(sensor3, INPUT);

  //Mostra a letra C no display
  lcd.setCursor(15, 0);
  lcd.write(uint8_t(0));
  //Mostra a letra M no display
  lcd.setCursor(8, 0);
  lcd.write(uint8_t(1));
  //Mostra a letra V no display
  lcd.setCursor(0, 0);
  lcd.write(uint8_t(2));

  Serial.println("Monitoracao de Caixa Dagua");
  Serial.println();
}

void loop()
{
  //Leitura dos sensores
  int valor_s1 = digitalRead(sensor1);
  int valor_s2 = digitalRead(sensor2);
  int valor_s3 = digitalRead(sensor3);

  //Mostra valor dos sensores no serial monitor
  Serial.print("S1: ");
  Serial.print(valor_s1);
  Serial.print(" S2: ");
  Serial.print(valor_s2);
  Serial.print(" S3: ");
  Serial.println(valor_s3);

  //Checa o nivel e atualiza o display
  if ((valor_s1 == 0) && valor_s2 == 0 && valor_s3 == 0)
  {
    //Atualiza o nivel no display, enviando o numero de
    //"quadrados" que devem ser mostrados para indicar
    //o nivel
    mostra_nivel(15);
    //Desliga o rele
    digitalWrite(pino_rele, HIGH);
  }

  if ((valor_s1 == 1) && valor_s2 == 0 && valor_s3 == 0)
  {
    //Atualiza o nivel no display
    mostra_nivel(11);
  }

  if ((valor_s1 == 1) && valor_s2 == 1 && valor_s3 == 0)
  {
    //Atualiza o nivel no display
    mostra_nivel(4);
  }

  if ((valor_s1 == 1) && valor_s2 == 1 && valor_s3 == 1)
  {
    mostra_nivel(0);
    //Liga o rele
    digitalWrite(pino_rele, LOW);
  }
  delay(100);
}

void mostra_nivel(int nivel)
{
  if (nivel != nivel_anterior)
  {
    //Apaga informacao anterior
    lcd.setCursor(0, 1);
    lcd.print("                ");
    //Atualiza o nivel no display
    for (int i = 0; i <= nivel; i++)
    {
      lcd.setCursor(i, 1);
      lcd.write(uint8_t(3));
    }
    nivel_anterior = nivel;
  }
}

Na imagem abaixo, temos a saída de mensagens no serial monitor, onde você pode acompanhar o estado de cada um dos sensores e também incluir mensagens para o seu próprio controle:

Saída sensores Serial Monitor

Você pode expandir facilmente esse projeto, se precisar utilizar mais sensores, e também pode incrementá-lo adicionando funcionalidades como envio de avisos via Wifi, SMS, MQTT e outros.

Nenhum comentário:

Postar um comentário