Indicatore di livello dell'acqua wireless a ultrasuoni - Alimentazione solare

Indicatore di livello dell'acqua wireless a ultrasuoni - Alimentazione solare

Un controller del livello dell'acqua ad ultrasuoni è un dispositivo in grado di rilevare i livelli dell'acqua in un serbatoio senza un contatto fisico e inviare i dati a un indicatore LED distante in modalità GSM wireless.



In questo post costruiremo un indicatore di livello dell'acqua wireless alimentato a energia solare basato su ultrasuoni utilizzando Arduino in cui gli Arduino trasmetterebbero e riceverebbero alla frequenza wireless di 2,4 GHz. Rileveremo il livello dell'acqua nel serbatoio utilizzando gli ultrasuoni invece del metodo tradizionale con elettrodi.

Panoramica

L'indicatore del livello dell'acqua è un gadget indispensabile, se possiedi una casa o addirittura vivi in ​​una casa in affitto. UN indicatore del livello dell'acqua mostra un dato importante per la tua casa che è importante quanto la lettura del tuo contatore di energia, ovvero quanta acqua è rimasta? In questo modo possiamo tenere traccia del consumo di acqua e non abbiamo bisogno di salire le scale per accedere al serbatoio dell'acqua per controllare quanta acqua è rimasta e non più l'arresto improvviso dell'acqua dal rubinetto.





Viviamo nel 2018 (al momento della stesura di questo articolo) o più tardi, possiamo comunicare istantaneamente con qualsiasi parte del mondo, abbiamo lanciato un'auto da corsa elettrica nello spazio, abbiamo lanciato satelliti e rover su Marte, siamo persino in grado di atterrare umani esseri sulla luna, ancora nessun prodotto commerciale adeguato per rilevare quanta acqua è rimasta nei nostri serbatoi d'acqua?

Possiamo trovare indicatori del livello dell'acqua realizzati da studenti di quinta elementare per la fiera della scienza a scuola. In che modo progetti così semplici non sono entrati nella nostra vita quotidiana? La risposta è che gli indicatori di livello del serbatoio dell'acqua non sono progetti semplici che un bambino di 5a elementare può realizzare per la nostra casa. Ci sono molti considerazioni pratiche prima di progettarne uno.



• Nessuno vuole praticare un foro sul corpo del serbatoio dell'acqua per elettrodi che potrebbero perdere acqua in seguito.
• Nessuno vuole far passare un cavo da 230/120 V CA vicino al serbatoio dell'acqua.
• Nessuno desidera sostituire le batterie ogni mese.
• Nessuno vuole far passare cavi lunghi aggiuntivi appesi a una stanza per l'indicazione del livello dell'acqua poiché non è stato pianificato in anticipo durante la costruzione della casa.
• Nessuno vuole usare l'acqua mescolata alla corrosione metallica dell'elettrodo.
• Nessuno vuole rimuovere la configurazione dell'indicatore del livello dell'acqua durante la pulizia del serbatoio (interno).

Alcuni dei motivi sopra menzionati possono sembrare sciocchi, ma troverai meno soddisfacenti con prodotti disponibili in commercio con questi svantaggi. Ecco perché la penetrazione di questi prodotti è molto inferiore tra le famiglie medie *.
* Sul mercato indiano.

Dopo aver considerato questi punti chiave, abbiamo progettato un pratico indicatore del livello dell'acqua che dovrebbe eliminare gli svantaggi menzionati.

Il nostro design:

• Utilizza un sensore a ultrasuoni per misurare il livello dell'acqua, quindi nessun problema di corrosione.
• Indicazione wireless del livello dell'acqua in tempo reale a 2,4 GHz.
• Buona potenza del segnale wireless, sufficiente per edifici a 2 piani.
• Alimentazione solare non più rete AC o sostituzione della batteria.
• Allarme serbatoio pieno / troppo pieno durante il riempimento del serbatoio.

Esaminiamo i dettagli del circuito:

Trasmettitore:

Il circuito trasmettitore wireless posto sul serbatoio invierà i dati del livello dell'acqua ogni 5 secondi 24 ore su 24, 7 giorni su 7. Il trasmettitore è costituito da Arduino nano, sensore ad ultrasuoni HC-SR04, modulo nRF24L01 che collegherà il trasmettitore e il ricevitore in modalità wireless a 2,4 GHz.

Un pannello solare da 9 V a 12 V con uscita di corrente di 300 mA alimenterà il circuito del trasmettitore. Un circuito di gestione della batteria caricherà la batteria agli ioni di litio, in modo che possiamo monitorare il livello dell'acqua anche in assenza di luce solare.

Esploriamo come posizionare il sensore a ultrasuoni nel serbatoio dell'acqua:

Nota che devi usare la tua creatività per montare il circuito e proteggerlo dalla pioggia e dalla luce solare diretta.

Taglia un piccolo foro sopra il coperchio del serbatoio per posizionare il sensore a ultrasuoni e sigillalo con un qualche tipo di adesivo che puoi trovare.

posizionare il sensore a ultrasuoni in un serbatoio d

Ora misura l'altezza completa della vasca dal fondo al coperchio, annotala in metri. Ora misura l'altezza della capacità di ritenzione idrica del serbatoio come mostrato nell'immagine sopra e scrivi in ​​metri.
Devi inserire questi due valori nel codice.

Diagramma schematico del trasmettitore:

Collegamenti del trasmettitore ad ultrasuoni per il controllo del livello dell

NOTA: nRF24L01 utilizza 3,3 V poiché Vcc non si collega all'uscita 5 V di Arduino.

Alimentazione per trasmettitore:

progettazione dell

Assicurati che la potenza di uscita del tuo pannello solare, ovvero l'uscita (volt x corrente), sia superiore a 3 watt. Il pannello solare dovrebbe essere da 9V a 12V.

Si consiglia un pannello da 12V e 300mA che puoi trovare facilmente sul mercato. La batteria dovrebbe essere di circa 3,7 V 1000 mAh.

Modulo di ricarica agli ioni di litio 5V 18650:

L'immagine seguente mostra uno standard Circuito caricatore 18650

L'ingresso può essere USB (non utilizzato) o 5V esterno da LM7805 IC. Assicurati di ottenere il modulo corretto come mostrato sopra, dovrebbe avere TP4056 protezione, che ha interruzione della batteria scarica e protezione da cortocircuito.

L'uscita di questo dovrebbe essere alimentata all'ingresso di XL6009 che aumenterà a una tensione più alta, utilizzando un piccolo cacciavite l'uscita di XL6009 dovrebbe essere regolata a 9V per Arduino.

Illustrazione del convertitore boost da CC a CC XL6009:

Questo conclude l'hardware del trasmettitore.

Codice per trasmettitore:

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

Modificare i seguenti valori nel codice misurato:

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

Questo conclude il trasmettitore.

Il ricevente:

Schema del controller del ricevitore del livello dell

Il ricevitore può mostrare 5 livelli. Allarme, quando il serbatoio ha raggiunto la massima capacità di ritenzione d'acqua assoluta durante il riempimento del serbatoio. Dal 100 al 75% - Tutti e quattro i LED si accendono, dal 75 al 50% tre LED si accendono, dal 50 al 25% due LED si accendono, il 25% e meno un LED si accende.
Il ricevitore può essere alimentato da batteria 9V o da caricatore dello smartphone su USB cavo mini-B.

Codice per ricevitore:

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

Questo conclude il ricevitore.

NOTA: se nessun LED è acceso, significa che il ricevitore non può ricevere il segnale dal trasmettitore. È necessario attendere 5 secondi per ricevere il segnale dal trasmettitore dopo aver acceso il circuito del ricevitore.

Prototipi dell'autore:

Trasmettitore:

prototipo di trasmettitore a ultrasuoni

Ricevitore:

prototipo di ricevitore ad ultrasuoni

In caso di domande su questo circuito di controllo del livello dell'acqua wireless ad ultrasuoni ad energia solare, non esitate a esprimere nel commento, potete aspettarvi di ottenere una risposta rapida.




Precedente: Come realizzare semplici circuiti di conversione boost Avanti: Come progettare un convertitore flyback - Tutorial completo