Indicateur de niveau d'eau sans fil à ultrasons - À énergie solaire

Un contrôleur de niveau d'eau à ultrasons est un dispositif qui peut détecter les niveaux d'eau dans un réservoir sans contact physique et envoyer les données à un indicateur LED distant dans un mode GSM sans fil.

Dans cet article, nous allons construire un indicateur de niveau d'eau sans fil à énergie solaire à ultrasons utilisant Arduino dans lequel les Arduinos émettraient et recevraient à une fréquence sans fil de 2,4 GHz. Nous détecterons le niveau d'eau dans le réservoir en utilisant des ultrasons au lieu de la méthode traditionnelle des électrodes.

Aperçu

L'indicateur de niveau d'eau est un gadget indispensable, si vous possédez une maison ou même si vous vivez dans une maison louée. UNE indicateur de niveau d'eau montre une donnée importante pour votre maison qui est aussi importante que la lecture de votre compteur d'énergie, à savoir combien d'eau reste-t-il? Pour que nous puissions suivre la consommation d'eau et que nous n'ayons pas besoin de monter à l'étage pour accéder au réservoir d'eau pour vérifier la quantité d'eau restante et plus d'arrêt soudain de l'eau du robinet.

Nous vivons en 2018 (au moment de la rédaction de cet article) ou plus tard, nous pouvons communiquer avec n'importe où dans le monde instantanément, nous avons lancé une voiture de course électrique dans l'espace, nous avons lancé des satellites et des rovers vers mars, nous avons même pu atterrir des humains. êtres sur la lune, toujours pas de produit commercial approprié pour détecter la quantité d'eau restante dans nos réservoirs d'eau?

Nous pouvons trouver que les indicateurs de niveau d'eau sont fabriqués par des élèves de 5e année pour une foire scientifique à l'école. Comment des projets aussi simples n'ont-ils pas fait partie de notre vie quotidienne? La réponse est que les indicateurs de niveau de réservoir d'eau ne sont pas de simples projets qu'un élève de 5e peut en fabriquer pour notre maison. Il y a beaucoup de considérations pratiques avant d'en concevoir un.

• Personne ne veut percer un trou sur le corps du réservoir d’eau pour les électrodes qui pourraient fuir plus tard.
• Personne ne veut faire passer un fil 230/120 VCA près du réservoir d'eau.
• Personne ne veut remplacer les piles tous les mois.
• Personne ne veut faire passer de longs fils supplémentaires suspendus à une pièce pour l'indication du niveau d'eau car cela n'est pas pré-planifié lors de la construction de la maison.
• Personne ne veut utiliser l'eau qui est mélangée à la corrosion métallique de l'électrode.
• Personne ne souhaite retirer la configuration de l'indicateur de niveau d'eau pendant le nettoyage du réservoir (à l'intérieur).

Certaines des raisons mentionnées ci-dessus peuvent sembler idiotes, mais vous trouverez moins satisfaisantes avec les produits disponibles dans le commerce avec ces inconvénients. C’est pourquoi la pénétration de ces produits est très moindre parmi les ménages moyens *.
* Sur le marché indien.

Après avoir examiné ces points clés, nous avons conçu un indicateur de niveau d'eau pratique qui devrait supprimer les inconvénients mentionnés.

Notre conception:

• Il utilise un capteur à ultrasons pour mesurer le niveau d'eau donc pas de problème de corrosion.
• Indication sans fil du niveau d'eau en temps réel à 2,4 GHz.
• Bonne puissance du signal sans fil, suffisante pour les bâtiments de 2 étages.
• Alimentation solaire, plus de courant alternatif ou remplacement de batterie.
• Alarme de réservoir plein / débordement lors du remplissage du réservoir.

Examinons les détails du circuit:

Émetteur:

Le circuit émetteur sans fil qui est placé sur le réservoir enverra des données de niveau d'eau toutes les 5 secondes 24/7. L'émetteur se compose d'Arduino nano, d'un capteur à ultrasons HC-SR04, d'un module nRF24L01 qui connectera l'émetteur et le récepteur sans fil à 2,4 GHz.

Un panneau solaire de 9 V à 12 V avec une sortie de courant de 300 mA alimentera le circuit de l'émetteur. Une carte de circuit imprimé de gestion de batterie chargera la batterie Li-ion, de sorte que nous puissions surveiller le niveau d'eau même en l'absence de lumière du soleil.

Explorons comment placer le capteur à ultrasons sur le réservoir d'eau:

Veuillez noter que vous devez utiliser votre créativité pour arrondir le circuit et vous protéger de la pluie et de la lumière directe du soleil.

Découpez un petit trou au-dessus du couvercle du réservoir pour placer le capteur à ultrasons et scellez-le avec une sorte d’adhésif que vous pouvez trouver.

Mesurez maintenant la hauteur totale du réservoir du fond au couvercle, notez-la en mètres. Mesurez maintenant la hauteur de la capacité de rétention d'eau du réservoir comme indiqué dans l'image ci-dessus et notez-la en mètres.
Vous devez entrer ces deux valeurs dans le code.

Schéma de principe de l'émetteur:

REMARQUE: nRF24L01 utilise 3,3 V car Vcc ne se connecte pas à la sortie 5 V d'Arduino.

Alimentation de l'émetteur:

Assurez-vous que la puissance de sortie de votre panneau solaire, c'est-à-dire la sortie (volt x courant), est supérieure à 3 watts. Le panneau solaire devrait être de 9V à 12V.

Un panneau 12V et 300mA est recommandé que vous pouvez trouver facilement sur le marché. La batterie doit être d'environ 3,7 V 1000 mAh.

Module de charge Li-ion 5V 18650:

L'image suivante montre une norme Circuit de chargeur 18650

L'entrée peut être USB (non utilisée) ou externe 5V du LM7805 IC. Assurez-vous que vous obtenez le bon module comme indiqué ci-dessus, il devrait avoir TP4056 protection, qui a une coupure de batterie faible et une protection contre les courts-circuits.

La sortie de celui-ci doit être alimentée à l'entrée du XL6009 qui augmentera à une tension plus élevée, en utilisant une petite sortie de tournevis de XL6009 doit être ajustée à 9V pour Arduino.

Illustration du convertisseur élévateur DC vers DC XL6009:

Ceci conclut le matériel de l’émetteur.

Code de l'émetteur:

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

Modifiez les valeurs suivantes dans le code que vous avez mesuré:

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

Cela conclut l'émetteur.

Le récepteur:

Le récepteur peut afficher 5 niveaux. Alarme, lorsque le réservoir a atteint la capacité de rétention d'eau maximale absolue pendant le remplissage du réservoir. 100 à 75% - Les quatre LED vont briller, 75 à 50% trois LED vont briller, 50 à 25% deux LED vont briller, 25% et moins une LED va briller.
Le récepteur peut être alimenté par une pile 9V ou par chargeur de smartphone vers USB câble mini-B.

Code pour le récepteur:

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

Cela conclut le récepteur.

REMARQUE: si aucune LED ne s'allume, cela signifie que le récepteur ne peut pas recevoir de signal de l'émetteur. Vous devez attendre 5 secondes pour recevoir le signal de l'émetteur après avoir allumé le circuit du récepteur.

Prototypes de l'auteur:

Émetteur:

Destinataire:

Si vous avez des questions concernant ce circuit de contrôleur de niveau d'eau sans fil à ultrasons à énergie solaire, n'hésitez pas à exprimer dans le commentaire, vous pouvez vous attendre à une réponse rapide.