Indicador de nível de água ultrassônico sem fio - alimentado por energia solar

Um controlador ultrassônico de nível de água é um dispositivo que pode detectar os níveis de água em um tanque sem contato físico e enviar os dados para um indicador LED distante em um modo GSM sem fio.

Neste post, vamos construir um indicador de nível de água sem fio movido a energia solar ultrassônico usando o Arduino no qual os Arduinos estariam transmitindo e recebendo na frequência sem fio de 2,4 GHz. Estaremos detectando o nível de água no tanque usando ultrassom em vez do método de eletrodo tradicional.

Visão geral

O indicador de nível de água é um gadget indispensável, se você possui uma casa ou mesmo vive em uma casa alugada. UMA indicador de nível de água mostra um dado importante para sua casa que é tão importante quanto a leitura do seu medidor de energia, ou seja, quanta água resta? Para que possamos acompanhar o consumo de água e não precisamos subir escadas para acessar o tanque de água para verificar a quantidade de água que resta e não há mais interrupção repentina de água da torneira.

Estamos vivendo em 2018 (no momento da redação deste artigo) ou depois, podemos nos comunicar com qualquer lugar do mundo instantaneamente, lançamos um carro de corrida elétrico para o espaço, lançamos satélites e rovers para Marte, conseguimos até pousar humanos seres na lua, ainda nenhum produto comercial adequado para detectar quanta água resta em nossos tanques de água?

Podemos encontrar indicadores de nível de água feitos por alunos da 5ª série para a feira de ciências na escola. Como esses projetos simples não fizeram parte de nossa vida cotidiana? A resposta é que os indicadores do nível do tanque de água não são projetos simples que um aluno do 5º ano pode fazer para a nossa casa. Existem muitos considerações práticas antes de projetarmos um.

• Ninguém quer fazer um furo no corpo do tanque de água para eletrodos que podem vazar água mais tarde.
• Ninguém quer passar fio de 230/120 VAC próximo ao tanque de água.
• Ninguém quer trocar as baterias todos os meses.
• Ninguém quer passar cabos longos adicionais pendurados em uma sala para indicação do nível de água, pois isso não é pré-planejado durante a construção da casa.
• Ninguém quer usar a água que se mistura com a corrosão do metal do eletrodo.
• Ninguém quer remover a configuração do indicador de nível de água durante a limpeza do tanque (interno).

Alguns dos motivos mencionados acima podem parecer bobos, mas você achará menos satisfatório com produtos disponíveis comercialmente com esses contras. É por isso que a penetração desses produtos é muito menor entre as famílias médias *.
* No mercado indiano.

Depois de considerar esses pontos-chave, projetamos um indicador de nível de água prático que deve remover os contras mencionados.

Nosso design:

• Usa sensor ultrassônico para medir o nível de água, sem problemas de corrosão.
• Indicação sem fio do nível de água em tempo real a 2,4 GHz.
• Boa intensidade do sinal sem fio, o suficiente para edifícios de 2 andares.
• Alimentação solar sem alimentação CA ou substituição da bateria.
• Alarme de tanque cheio / transbordamento durante o enchimento do tanque.

Vamos investigar os detalhes do circuito:

Transmissor:

O circuito transmissor sem fio que é colocado no tanque enviará dados do nível de água a cada 5 segundos, 24/7. O transmissor consiste em Arduino nano, sensor ultrassônico HC-SR04, módulo nRF24L01 que conectará o transmissor e o receptor sem fio a 2,4 GHz.

Um painel solar de 9 V a 12 V com saída de corrente de 300 mA alimentará o circuito do transmissor. Uma placa de circuito de gerenciamento de bateria carregará a bateria de íon de lítio, para que possamos monitorar o nível da água mesmo quando não há luz solar.

Vamos explorar como colocar o sensor ultrassônico no tanque de água:

Observe que você deve usar sua criatividade para montar o circuito e protegê-lo da chuva e da luz solar direta.

Corte um pequeno orifício acima da tampa do tanque para colocar o sensor ultrassônico e sele-o com algum tipo de adesivo que você possa encontrar.

Agora meça a altura total do tanque do fundo à tampa, escreva em metros. Agora meça a altura da capacidade de retenção de água do tanque conforme mostrado na imagem acima e escreva em metros.
Você precisa inserir esses dois valores no código.

Diagrama esquemático do transmissor:

NOTA: o nRF24L01 usa 3,3 V, pois o Vcc não se conecta à saída de 5 V do Arduino.

Fonte de alimentação para o transmissor:

Certifique-se de que a potência de saída do seu painel solar, ou seja, a saída (volt x corrente), é superior a 3 watts. O painel solar deve ser de 9V a 12V.

Recomenda-se um painel de 12 V e 300 mA, que você pode encontrar facilmente no mercado. A bateria deve ter cerca de 3,7 V 1000 mAh.

Módulo de carregamento de íons de lítio 5V 18650:

A imagem a seguir mostra um padrão Circuito carregador 18650

A entrada pode ser USB (não usada) ou 5V externa do LM7805 IC. Certifique-se de obter o módulo correto conforme mostrado acima, ele deve ter TP4056 proteção, que tem corte de bateria fraca e proteção contra curto-circuito.

A saída deste deve ser alimentada para a entrada do XL6009 que aumentará para uma tensão mais alta, usando uma pequena chave de fenda de saída do XL6009 deve ser ajustada para 9 V para Arduino

Ilustração do conversor de reforço XL6009 DC para DC:

Isso conclui o hardware do transmissor.

Código para o transmissor:

// ----------- Program Developed by R.GIRISH / Homemade-circuits .com ----------- //
#include
#include
RF24 radio(9, 10)
const byte address[6] = '00001'
const int trigger = 3
const int echo = 2
const char text_0[] = 'STOP'
const char text_1[] = 'FULL'
const char text_2[] = '3/4'
const char text_3[] = 'HALF'
const char text_4[] = 'LOW'
float full = 0
float three_fourth = 0
float half = 0
float quarter = 0
long Time
float distanceCM = 0
float distanceM = 0
float resultCM = 0
float resultM = 0
float actual_distance = 0
float compensation_distance = 0
// ------- CHANGE THIS -------//
float water_hold_capacity = 1.0 // Enter in Meters.
float full_height = 1.3 // Enter in Meters.
// ---------- -------------- //
void setup()
{
Serial.begin(9600)
pinMode(trigger, OUTPUT)
pinMode(echo, INPUT)
digitalWrite(trigger, LOW)
radio.begin()
radio.openWritingPipe(address)
radio.setChannel(100)
radio.setDataRate(RF24_250KBPS)
radio.setPALevel(RF24_PA_MAX)
radio.stopListening()
full = water_hold_capacity
three_fourth = water_hold_capacity * 0.75
half = water_hold_capacity * 0.50
quarter = water_hold_capacity * 0.25
}
void loop()
{
delay(5000)
digitalWrite(trigger, HIGH)
delayMicroseconds(10)
digitalWrite(trigger, LOW)
Time = pulseIn(echo, HIGH)
distanceCM = Time * 0.034
resultCM = distanceCM / 2
resultM = resultCM / 100
Serial.print('Normal Distance: ')
Serial.print(resultM)
Serial.println(' M')
compensation_distance = full_height - water_hold_capacity
actual_distance = resultM - compensation_distance
actual_distance = water_hold_capacity - actual_distance
if (actual_distance <0)
{
Serial.print('Water Level:')
Serial.println(' 0.00 M (UP)')
}
else
{
Serial.print('Water Level: ')
Serial.print(actual_distance)
Serial.println(' M (UP)')
}
Serial.println('============================')
if (actual_distance >= full)
{
radio.write(&text_0, sizeof(text_0))
}
if (actual_distance > three_fourth && actual_distance <= full)
{
radio.write(&text_1, sizeof(text_1))
}
if (actual_distance > half && actual_distance <= three_fourth)
{
radio.write(&text_2, sizeof(text_2))
}
if (actual_distance > quarter && actual_distance <= half)
{
radio.write(&text_3, sizeof(text_3))
}
if (actual_distance <= quarter)
{
radio.write(&text_4, sizeof(text_4))
}
}
// ----------- Program Developed by R.GIRISH / Homemade-circuits .com ----------- //

Altere os seguintes valores no código que você mediu:

// ------- CHANGE THIS -------//
float water_hold_capacity = 1.0 // Enter in Meters.
float full_height = 1.3 // Enter in Meters.
// ---------- -------------- //

Isso conclui o transmissor.

O receptor:

O receptor pode mostrar 5 níveis. Alarme, quando o tanque atinge a capacidade máxima absoluta de retenção de água durante o enchimento do tanque. 100 a 75% - Todos os quatro LEDs acenderão, 75 a 50% três LEDs acenderão, 50 a 25% dois LEDs acenderão, 25% e menos um LED acenderá.
O receptor pode ser alimentado por bateria de 9V ou de carregador de smartphone para USB cabo mini-B.

Código para o receptor:

// ----------- Program Developed by R.GIRISH / Homemade-circuits .com ----------- //
#include
#include
RF24 radio(9, 10)
int i = 0
const byte address[6] = '00001'
const int buzzer = 6
const int LED_full = 5
const int LED_three_fourth = 4
const int LED_half = 3
const int LED_quarter = 2
char text[32] = ''
void setup()
{
pinMode(buzzer, OUTPUT)
pinMode(LED_full, OUTPUT)
pinMode(LED_three_fourth, OUTPUT)
pinMode(LED_half, OUTPUT)
pinMode(LED_quarter, OUTPUT)
digitalWrite(buzzer, HIGH)
delay(300)
digitalWrite(buzzer, LOW)
digitalWrite(LED_full, HIGH)
delay(300)
digitalWrite(LED_three_fourth, HIGH)
delay(300)
digitalWrite(LED_half, HIGH)
delay(300)
digitalWrite(LED_quarter, HIGH)
delay(300)
digitalWrite(LED_full, LOW)
delay(300)
digitalWrite(LED_three_fourth, LOW)
delay(300)
digitalWrite(LED_half, LOW)
delay(300)
digitalWrite(LED_quarter, LOW)
Serial.begin(9600)
radio.begin()
radio.openReadingPipe(0, address)
radio.setChannel(100)
radio.setDataRate(RF24_250KBPS)
radio.setPALevel(RF24_PA_MAX)
radio.startListening()
}
void loop()
{
if (radio.available())
{
radio.read(&text, sizeof(text))
Serial.println(text)
if (text[0] == 'S' && text[1] == 'T' && text[2] == 'O' && text[3] == 'P')
{
digitalWrite(LED_full, HIGH)
digitalWrite(LED_three_fourth, HIGH)
digitalWrite(LED_half, HIGH)
digitalWrite(LED_quarter, HIGH)
for (i = 0 i <50 i++)
{
digitalWrite(buzzer, HIGH)
delay(50)
digitalWrite(buzzer, LOW)
delay(50)
}
}
if (text[0] == 'F' && text[1] == 'U' && text[2] == 'L' && text[3] == 'L')
{
digitalWrite(LED_full, HIGH)
digitalWrite(LED_three_fourth, HIGH)
digitalWrite(LED_half, HIGH)
digitalWrite(LED_quarter, HIGH)
}
if (text[0] == '3' && text[1] == '/' && text[2] == '4')
{
digitalWrite(LED_full, LOW)
digitalWrite(LED_three_fourth, HIGH)
digitalWrite(LED_half, HIGH)
digitalWrite(LED_quarter, HIGH)
}
if (text[0] == 'H' && text [1] == 'A' && text[2] == 'L' && text[3] == 'F')
{
digitalWrite(LED_full, LOW)
digitalWrite(LED_three_fourth, LOW)
digitalWrite(LED_half, HIGH)
digitalWrite(LED_quarter, HIGH)
}
if (text[0] == 'L' && text[1] == 'O' && text[2] == 'W')
{
digitalWrite(LED_full, LOW)
digitalWrite(LED_three_fourth, LOW)
digitalWrite(LED_half, LOW)
digitalWrite(LED_quarter, HIGH)
}
}
}
// ----------- Program Developed by R.GIRISH / Homemade-circuits .com ----------- //

Isso conclui o receptor.

NOTA: se nenhum LED estiver aceso, o que significa que o receptor não pode obter o sinal do transmissor. Você deve esperar 5 segundos para receber o sinal do transmissor depois de ligar o circuito do receptor.

Protótipos do autor:

Transmissor:

Destinatário:

Se você tiver alguma dúvida sobre este circuito controlador de nível de água ultrassônico sem fio alimentado por energia solar, sinta-se à vontade para expressar no comentário, você pode esperar uma resposta rápida.