Indicator de nivel al apei fără fir cu ultrasunete - alimentat cu energie solară

Un controlor cu ultrasunete al nivelului apei este un dispozitiv care poate detecta nivelurile apei într-un rezervor fără un contact fizic și poate trimite datele către un indicator LED îndepărtat într-un mod GSM fără fir.

În acest post vom construi un indicator de nivel al apei fără fir alimentat cu ultrasunete bazat pe energie solară folosind Arduino în care Arduino ar transmite și primi la o frecvență wireless de 2,4 GHz. Vom detecta nivelul apei din rezervor folosind ultrasunete în loc de metoda tradițională a electrodului.

Prezentare generală

Indicatorul nivelului apei este un obiect obligatoriu, dacă dețineți o casă sau chiar locuiți într-o casă închiriată. A indicator al nivelului apei afișează una dintre datele importante pentru casa dvs., care este la fel de importantă ca citirea contorului dvs. de energie, adică câtă apă rămâne? Pentru a putea urmări consumul de apă și nu este nevoie să urcăm la etaj pentru a accesa rezervorul de apă pentru a verifica cât de multă apă a rămas și nu mai opriți brusc apa de la robinet.

Trăim în 2018 (în momentul scrierii acestui articol) sau mai târziu, putem comunica instantaneu oriunde în lume, am lansat o mașină electrică de curse în spațiu, am lansat sateliți și roveri pe Marte, chiar putem ateriza oameni ființe pe lună, încă nu există un produs comercial adecvat pentru detectarea cantității de apă rămasă în rezervoarele noastre de apă?

Putem găsi indicatorii nivelului apei sunt realizați de elevii clasei a V-a pentru târgul științific la școală. Cum nu s-au transformat astfel de proiecte simple în viața noastră de zi cu zi? Răspunsul este că indicatorii de nivel al rezervorului de apă nu sunt proiecte simple pe care un elev de clasa a V-a le poate face unul pentru casa noastră. Există multe consideratii practice înainte de a proiecta una.

• Nimeni nu dorește să facă o gaură pe corpul rezervorului de apă pentru electrozi care ar putea scurge apă mai târziu.
• Nimeni nu dorește să ruleze sârmă de 230/120 VCA lângă rezervorul de apă.
• Nimeni nu vrea să înlocuiască bateriile în fiecare lună.
• Nimeni nu dorește să ruleze cabluri lungi suplimentare agățate pe o cameră pentru indicarea nivelului apei, deoarece nu este pre-planificat în timpul construirii casei.
• Nimeni nu vrea să folosească apa amestecată cu coroziunea metalică a electrodului.
• Nimeni nu dorește să elimine setarea indicatorului de nivel al apei în timp ce curăța rezervorul (în interior).

Unele dintre motivele menționate mai sus pot părea o prostie, dar veți găsi mai puțin satisfăcătoare cu produsele disponibile comercial cu aceste contra. De aceea, penetrarea acestor produse este foarte redusă în rândul gospodăriilor medii *.
* Pe piața indiană.

După luarea în considerare a acestor puncte cheie, am proiectat un indicator practic al nivelului apei care ar trebui să elimine dezavantajele menționate.

Designul nostru:

• Folosește senzor cu ultrasunete pentru a măsura nivelul apei, deci nu există probleme de coroziune.
• Indicație fără fir a nivelului apei în timp real la 2,4 GHz.
• Putere bună a semnalului wireless, suficientă pentru clădiri cu 2 etaje.
• Nu mai este alimentată cu energie electrică sau nu înlocuiește bateria.
• Alarma rezervorului plin / preaplin în timpul umplerii rezervorului.

Să investigăm detaliile circuitului:

Transmiţător:

circuit emițător fără fir care este plasat pe rezervor va trimite date privind nivelul apei la fiecare 5 secunde 24/7. Transmițătorul este format din nano Arduino, senzor cu ultrasunete HC-SR04, modul nRF24L01 care va conecta emițătorul și receptorul fără fir la 2,4 GHz.

Un panou solar de 9 V la 12 V cu curent de ieșire de 300 mA va alimenta circuitul emițătorului. O placă cu circuite de gestionare a bateriei va încărca bateria Li-ion, astfel încât să putem monitoriza nivelul apei chiar și atunci când nu există lumina soarelui.

Să explorăm cum să plasăm senzorul cu ultrasunete în rezervorul de apă:

Vă rugăm să rețineți că trebuie să vă folosiți creativitatea pentru a crea circuitul și a vă proteja de ploaie și de lumina directă a soarelui.

Tăiați o gaură mică deasupra capacului rezervorului pentru a plasa senzorul cu ultrasunete și sigilați-l cu un fel de adeziv pe care îl puteți găsi.

Acum măsurați întreaga înălțime a rezervorului de jos până la capac, scrieți-l în metri. Acum măsurați înălțimea capacității de reținere a apei a rezervorului așa cum se arată în imaginea de mai sus și scrieți în metri.
Trebuie să introduceți aceste două valori în cod.

Diagrama schematică a emițătorului:

NOTĂ: nRF24L01 folosește 3,3V deoarece Vcc nu se conectează la ieșirea de 5V a Arduino.

Sursa de alimentare pentru transmițător:

Asigurați-vă că puterea de ieșire a panoului solar, adică ieșirea (volt x curent) este mai mare de 3 wați. panou solar ar trebui să fie de 9V la 12V.

Este recomandat panoul de 12V și 300mA pe care îl puteți găsi cu ușurință pe piață. Bateria ar trebui să fie în jur de 3,7 V 1000 mAh.

Modul de încărcare Li-ion 5V 18650:

Următoarea imagine prezintă un standard 18650 circuit încărcător

Intrarea poate fi USB (neutilizată) sau externă de 5V de la LM7805 IC. Asigurați-vă că obțineți modulul corect așa cum se arată mai sus, ar trebui să aibă TP4056 protecție, care are întrerupere a bateriei slabă și protecție la scurtcircuit.

Ieșirea acestuia ar trebui să fie alimentată la intrarea XL6009, care va crește la tensiune mai mare, folosind o șurubelniță mică, ieșirea XL6009 ar trebui să fie reglată la 9V pentru Arduino.

Ilustrație a convertorului XL6009 DC-DC boost:

Aceasta încheie hardware-ul emițătorului.

Cod pentru emițător:

// ----------- 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 ----------- //

Modificați următoarele valori din codul pe care l-ați măsurat:

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

Asta încheie emițătorul.

Destinatarul:

Receptorul poate afișa 5 nivele. Alarmă, când rezervorul a atins capacitatea maximă absolută de reținere a apei în timpul umplerii rezervorului. 100 până la 75% - Toate cele patru LED-uri vor lumina, 75 până la 50% trei LED-uri vor lumina, 50 până la 25% două LED-uri vor lumina, 25% și mai puțin un LED va străluci.
Receptorul poate fi alimentat de la baterie de 9V sau de la încărcător smartphone la USB cablu mini-B.

Cod pentru 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 ----------- //

Asta încheie receptorul.

NOTĂ: dacă nu aprind LED-uri, ceea ce înseamnă că receptorul nu poate primi semnal de la emițător. Ar trebui să așteptați 5 secunde pentru a primi semnalul de la transmițător după pornirea circuitului receptorului.

Prototipurile autorului:

Transmiţător:

Receptor:

Dacă aveți întrebări cu privire la acest circuit de control al nivelului de apă fără fir cu ultrasunete alimentat cu energie solară, vă rugăm să nu ezitați să exprimați în comentariu, vă puteți aștepta să primiți un răspuns rapid.