Bouteille d'eau alimentée par Arduino

Outils et machines nécessaires

	Fer à souder (générique)
	Pistolet à colle chaude (générique)

Applications et services en ligne

Arduino IDE

À propos de ce projet

Présentation :

Boire suffisamment d'eau est très important pour notre santé. Boire plus d'eau peut entraîner une peau plus claire, une meilleure santé globale, une productivité et une fonction cérébrale améliorées, une augmentation des niveaux d'énergie et même une perte de poids.

Dans nos vies bien remplies, il est vraiment difficile de se rappeler de boire suffisamment d'eau. Et la plupart du temps, nous oublions de boire suffisamment d'eau, que nous soyons à la maison, au bureau ou en déplacement. Environ 75 % des Américains sont chroniquement déshydratés tout le temps.

Ainsi, afin de développer une saine habitude de boire de l'eau, il est important de suivre votre consommation d'eau chaque jour.

Pour suivre ma consommation d'eau, j'ai rendu ma bouteille d'eau intelligente à l'aide d'Arduino. Il peut :

1. Suivre ma consommation d'eau quotidienne

2. Suivre ma consommation d'eau moyenne hebdomadaire

3. Rappelez-moi de prendre de l'eau

4. Suivez l'heure de la dernière admission

5. Exécutez plus d'un mois en une seule charge.

Création d'un module RTC

Pour enregistrer ou suivre les informations sur la prise d'eau, il faut que les informations d'heure et de date actuelles soient stockées avec les données accumulées. Une puce d'horloge temps réel (RTC) telle que DS1307 avec une batterie de secours appropriée peut être utilisée pour fournir les informations requises. Le processus de programmation de la puce RTC (dans le logiciel) est également très simple et est pris en charge dans la majorité des environnements de programmation.

Voici la conception d'un module RTC compact, basé sur le populaire RTC IC DS1307, pour vos projets de microcontrôleurs quotidiens. L'horloge temps réel série DS1307 (RTC) est une horloge/calendrier décimal codé binaire (BCD) à faible consommation plus 56 octets de SRAM NV. L'adresse et les données sont transférées en série via un bus bidirectionnel I2C. L'horloge/calendrier au format 24 heures/12 heures fournit des informations sur les secondes, les minutes, les heures, le jour, la date, le mois et l'année, y compris les corrections pour les années bissextiles.

Faisons le module d'horloge en temps réel selon le schéma ci-joint. DS1307 RTC nécessite un cristal externe pour fonctionner correctement. Deux résistances pull-up sont nécessaires pour les broches SCL et SDA du circuit intégré. La valeur de la résistance peut être de l'ordre de 2k à 10k. J'ai utilisé 4.7k. Pendant la soudure, j'ai essayé de garder le module aussi petit que possible car l'espace est limité pour mon circuit. Vous pouvez utiliser DS3231 au lieu de DS1307 et le circuit intégré dispose d'un oscillateur à cristal interne. Ainsi, vous n'avez pas besoin d'ajouter de cristal externe. Vous pouvez également acheter un petit module RTC prêt à l'emploi si vous n'aimez pas le faire vous-même. Comme le système complet fonctionnera sur batterie, j'ai donc connecté la broche VBAT du RTC à la terre sans utiliser de pile bouton.

Épingles importantes du DS1307 :

• Broche 5V  :lorsque cette broche est haute, le ds1307 envoie les données, et lorsqu'elle est basse, elle s'exécute sur la pile bouton de sauvegarde.

• GND :Il s'agit de la broche de masse du module. La masse de la batterie et l'alimentation sont liées ensemble.

• SCL :C'est la broche d'horloge I2C - qui communique avec le microcontrôleur. Devrait se connecter avec la broche Arduino SCL.

• SDA :C'est la broche de données I2C - qui communique avec le microcontrôleur. Devrait se connecter avec la broche Arduino SDA.

• VBAT :Entrée de batterie pour n'importe quelle pile au lithium 3V standard ou autre source d'énergie. Doit être mis à la terre s'il n'est pas utilisé.

Faire un panneau d'affichage à sept segments

Pour le module d'affichage ici, j'ai utilisé un module à cathode commune autonome et compact contenant quatre affichages numériques à LED à 7 segments, parfaits pour afficher des données numériques avec un caractère simple.

Chaque segment du module d'affichage est multiplexé, ce qui signifie qu'il partage les mêmes points de connexion d'anode. Et chacun des quatre chiffres du module a son propre point de connexion cathodique commun. Cela permet à chaque chiffre d'être activé ou désactivé indépendamment. De plus, cette technique de multiplexage transforme la quantité massive de broches de microcontrôleur nécessaires pour contrôler un affichage en seulement onze ou douze (au lieu de trente-deux) !

Les segments LED de l'affichage nécessitent des résistances de limitation de courant lorsqu'ils sont alimentés par une broche logique de 5 V. La valeur de la résistance est typiquement comprise entre 330 et 470 ohms pour 5 V. Pour un fonctionnement sur batterie Li-ion elle peut être de 220 ohms. De plus, les transistors de commande sont recommandés pour fournir un courant d'entraînement supplémentaire aux segments LED, car chaque broche d'un microcontrôleur peut générer ou absorber près de 40 mA de courant uniquement. Lorsque tous les (sept) segments de l'affichage sont allumés en même temps (le chiffre 8), la demande de courant dépassera cette limite de 40 mA. L'image ci-dessous indique le schéma de câblage de base des résistances de limitation de courant et des transistors de commande.

Cette section d'affichage à 4 chiffres et à 7 segments est câblée autour de quatre affichages à LED à cathode commune à 7 segments et de quatre transistors 2N2222 NPN. Les résistances 1K sont utilisées pour la limitation du courant de base, et les résistances 220R limitent le courant de fonctionnement des segments d'affichage à LED.

Dans la carte Arduino, les sorties numériques de D10 à D17 sont utilisées pour piloter les segments (a à g et dp), et les sorties numériques D6 à D9 sont utilisées pour les chiffres (D0-D3) de l'affichage LED 4 × 7.

Un interrupteur à bouton est ajouté avec le module d'affichage pour accéder aux différentes options. Il sera également utilisé pour réveiller l'Arduino du mode veille à l'aide d'une interruption matérielle externe. ainsi, le bouton est connecté à la broche numérique Arduino #2 (INT0).

Connexion de la carte d'affichage avec Arduino Mini Pro

Selon le schéma fourni avant de souder tous les segments pin à la mini pin Arduino. Puis soudez 4 broches communes à la broche collectrice du transistor. Les bases du transistor sont connectées à la broche Arduino. Après avoir connecté l'écran, connectez l'interrupteur à bouton avec la broche numérique Arduino 2 (INT 0). Assurez-vous d'avoir connecté le bouton à la broche 2 d'Arduino, car nous mettrons en œuvre une interruption matérielle externe pour sortir Arduino du mode veille à l'aide de ce bouton.

Connexion du module RTC et du buzzer

Maintenant, connectez le module RTC que vous avez créé précédemment à la carte Arduino. La broche SDA du module doit être connectée à la broche SDA (A4) de la broche Arduino et la broche SCL du module doit être connectée à la broche SCL (A5) de l'Arduino. Connectez ensuite le buzzer à la carte Arduino.

Connexions :

RTC ------> Arduino Mini Pro

• SDA ------> A4

• SCL ------> A5

• Sonnerie ------> D3

Fixation du capteur à ultrasons avec bouchon de bouteille

Faites un trou dans le bouchon de la bouteille comme indiqué sur l'image. Sortez quatre fils du capteur à ultrasons à travers le trou et fixez le capteur à ultrasons au milieu du bouchon de la bouteille. Le capteur doit être fixé à l'intérieur du bouchon de la bouteille et il doit être placé en position centrale.

Connexions :

Capteur à ultrasons ------> Arduino Mini Pro

• VCC ------> VCC

• GND ------> GND

• Déclencheur ------> D4

• Écho ------> D5

Téléchargement du programme et des tests

Après avoir terminé toutes les connexions, il est temps de télécharger le programme sur la carte Arduino et de tester la fonctionnalité. Vous aurez besoin de plusieurs bibliothèques pour que le programme fonctionne correctement. Pour l'interfaçage des boutons, vous devez ajouter la bibliothèque OneButton. Comme l'appareil fonctionnera sur batterie, la consommation d'énergie est un problème important. J'ai implémenté le mode veille dans mon sketch Arduino. Une minuterie de surveillance et une interruption matérielle externe ont été utilisées pour sortir l'Arduino du mode veille. Arduino prend la lecture du capteur trois fois, en fait la moyenne et calcule les informations nécessaires et affiche les informations pendant 10 secondes, puis passe en mode veille pendant 1 minute. Il se réveille à tout moment lorsque vous appuyez sur le bouton connecté à INT0 (broche numérique 2). Donc, si vous voulez voir les informations sur votre consommation d'eau, appuyez simplement sur le bouton d'option à tout moment. Il se réveillera pour vous. Sans aucune pression sur un bouton, la lecture prendra toutes les minutes. Pour implémenter le mode veille, j'ai utilisé la bibliothèque Arduino Low-Power. Pour lire l'heure du module DS1307 RTC, j'ai utilisé la bibliothèque DS1307RTC. Donc, pour compiler le programme joint, ajoutez toute la bibliothèque à votre environnement.

Je n'expliquerai ici que l'algorithme de calcul en bref. Voir le remplissage ci-joint pour un croquis complet. Le calcul est effectué à partir de la moyenne de cinq lectures de capteur pour le rendre suffisamment précis. La lecture quotidienne est réinitialisée à 24 heures et préparée pour une nouvelle lecture pour le nouveau jour.

La consommation moyenne d'eau est calculée à partir de la moyenne de la consommation quotidienne des sept jours précédents. Si vous avez passé 2 heures sans boire d'eau, il alertera l'utilisateur avec un double bip toutes les 15 minutes et s'arrêtera pendant les 2 heures suivantes après avoir pris de l'eau.

Téléchargez le code ci-joint et téléchargez-le sur votre Arduino Mini Pro. Connectez tous les modules et mettez-le sous tension pour tester si tous les composants fonctionnent correctement ou non. Si l'écran affiche un résultat, alors félicitations ! Vous avez déjà fait les choses difficiles.

Fixation Arduino avec bouchon de bouteille

À l'aide de colle chaude, fixez Arduino mini sur la partie supérieure du bouchon de la bouteille. Gardez à l'esprit que vous devez fixer tous les composants dans le bouchon de la bouteille. Ajoutez suffisamment de colle pour qu'elle soit bien fixée au bouchon de la bouteille.

Fixation du module de batterie et de chargeur

Maintenant, fixez la batterie Li-ion en haut de l'Arduino. Faites attention de ne pas court-circuiter la batterie avec une broche ouverte. Connectez ensuite le module chargeur avec le capuchon. Gardez le port USB facilement accessible depuis le côté extérieur afin qu'il puisse être facilement connecté au chargeur.

Rendre tous les circuits étanches

Après avoir connecté tous les composants et le moduler, c'est le bon moment pour rendre notre appareil complètement étanche. C'est très important car il s'agit d'une bouteille d'eau et à tout moment, de l'eau peut tomber dans le circuit et endommager le circuit. Pour le rendre complètement étanche, ajoutez suffisamment de colle dans chaque partie extérieure des circuits sans le port USB. Vous pouvez rendre le capuchon agréable en utilisant de la colle pour le rendre rond au capuchon d'origine.

Ne plongez pas le bouchon de la bouteille dans l'eau.

Profitez-en

Code

• Esquisse Arduino

Arduino SketchArduino

// Fonctions date et heure utilisant un DS1307 RTC connecté via I2C et Wire lib#include #include #include #include #include " LowPower.h"#include "OneButton.h"Bouton OneButton(2, true);const byte interruptPin =2;volatile int state =0;const int trigPin =4;const int echoPin =5;int piezoPin =3;const int digit[4] ={9,6,7,8};int digit_value[4];int digit_value1[4];int button_press_count =1;const int segment[8] ={16,10,12,14,15, 17,11,13};nombre d'octets const[10][8] ={{1,1,1,1,1,1,0,0}, //0 {0,1,1,0,0, 0,0,0}, //1 {1,1,0,1,1,0,1,0}, //2 {1,1,1,1,0,0,1,0}, / /3 {0,1,1,0,0,1,1,0}, //4 {1,0,1,1,0,1,1,0}, //5 {1,0,1 ,1,1,1,1,0}, //6 {1,1,1,0,0,0,0,0}, //7 {1,1,1,1,1,1,1 ,0}, //8 {1,1,1,1,0,1,1,0}} ; //9octet const d[8] ={0,1,1,1,1,0,1,1};octet const a[8] ={1,1,1,0,1,1,1,1 };octet const r[8] ={0,0,0,0,1,0,1,1};octet const t[8] ={0,0,0,1,1,1,1,1 };int secondes, minutes, heures;int water_in_ounch[15];int water_intake_ounch[15];int water_intake_days[7];int water_intake_times =0;int previous_water_amount =0;int total_water_intake_today =0;int average_intake_last_week =0;int inatke_day =1;float average_water_level =0; //stocker la moyenne des lectures multiplesint water_amount_in_ounce =0; //stocker la quantité calculée de waterint idle_time =0;int input_day =1;int previous_value =0;void setup() { Serial.begin(9600); pinMode(interruptPin, INPUT_PULLUP); // mettez votre code de configuration ici, à exécuter une fois :for(int i=6; i<=17; i++) pinMode(i, OUTPUT); pinMode(trigPin, SORTIE); pinMode(echoPin, INPUT); button.attachClick(appuyé); button.attachDoubleClick(doubleclick); button.attachLongPressStart(longPressStart); button.attachDuringLongPress(longPress);}long previous_state =millis();int count =1;int daily_intake =0;intweek_intake =0;long sleep_time =millis();void loop() { read_time(); bouton.tick(); // continuez à surveiller les boutons poussoirs :calcul(); daily_intake =total_water_intake_in_day(); week_intake =average_water_intake_last_week (); if(button_press_count ==1){ display_d(); display_number(daily_intake); } else if(button_press_count ==2){ display_a(); display_number(weekly_intake); } else if(button_press_count ==3){ display_r(); display_number(water_amount_in_ounce); } else if(button_press_count ==4){ display_first_2(hours); display_last_2(minutes); } if(idle_time>=120){ alert(); alerte(); } if((millis() - sleep_time)>=15000){ display_off(); attachInterrupt(digitalPinToInterrupt(interruptPin), vide, FALLING); LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF); LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF); LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF); LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF); LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF); LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF); detachInterrupt(digitalPinToInterrupt(interruptPin)); sleep_time =millis(); } }void display_digit(int digit){ for(int i=0; i<8; i++){ digitalWrite(segment[i], number[digit][i]); } }void display_number(int number){ int i=0; while(nombre>0){ digit_value[2-i] =nombre%10 ; nombre =nombre/10 ; je++ ; } digitalWrite(chiffre[1], HAUT); digitalWrite(chiffre[2], LOW); digitalWrite(chiffre[3], LOW); display_digit(digit_value[0]); retard (5) ; digitalWrite(chiffre[1], LOW); digitalWrite(chiffre[2], HAUT); digitalWrite(chiffre[3], LOW); display_digit(digit_value[1]); retard (5) ; digitalWrite(chiffre[1], LOW); digitalWrite(chiffre[2], LOW); digitalWrite(chiffre[3], HAUT); display_digit(digit_value[2]); retard (5) ; digitalWrite(chiffre[3], LOW); valeur_chiffre[0] =0 ; valeur_chiffre[1] =0 ; valeur_chiffre[2] =0 ; }void display_first_2(int number){ digitalWrite(digit[2], LOW); digitalWrite(chiffre[3], LOW); entier i=0; while(nombre>0){ digit_value[1-i] =nombre%10 ; nombre =nombre/10 ; je++ ; } digitalWrite(chiffre[0], HAUT); digitalWrite(chiffre[1], LOW); display_digit(digit_value[0]); retard(3) ; digitalWrite(chiffre[0], LOW); digitalWrite(chiffre[1], HAUT); display_digit(digit_value[1]); retard(3) ; }void display_last_2(int number){ digitalWrite(digit[0], LOW); digitalWrite(chiffre[1], LOW); entier i=0; while(nombre>0){ digit_value1[1-i] =nombre%10 ; nombre =nombre/10 ; je++ ; } digitalWrite(chiffre[2], HAUT); digitalWrite(chiffre[3], LOW); display_digit(digit_value1[0]); retard(3) ; digitalWrite(chiffre[2], LOW); digitalWrite(chiffre[3], HAUT); display_digit(digit_value1[1]); retard(3) ; }void display_d(){ digitalWrite(chiffre[0], HIGH); for(int i=0; i<8; i++){ digitalWrite(segment[i], d[i]); } délai(5) ; digitalWrite(chiffre[0], LOW); }void display_a(){ digitalWrite(digit[0], HIGH); for(int i=0; i<8; i++){ digitalWrite(segment[i], a[i]); } délai(5) ; digitalWrite(chiffre[0], LOW); } void display_r(){ digitalWrite(chiffre[0], HIGH); for(int i=0; i<8; i++){ digitalWrite(segment[i], r[i]); } délai(5) ; digitalWrite(chiffre[0], LOW); } void display_t(){ digitalWrite(digit[0], HIGH); for(int i=0; i<8; i++){ digitalWrite(segment[i], t[i]); } délai(5) ; digitalWrite(chiffre[0], LOW); }void display_off(){ digitalWrite(chiffre[0], LOW); digitalWrite(chiffre[1], LOW); digitalWrite(chiffre[2], LOW); digitalWrite(chiffre[3], LOW); for(int i=0; i<8; i++){ digitalWrite(segment[i], LOW); } délai(5) ; }void read_time() { tmElements_t tm; if (RTC.read(tm)) { secondes =tm.Second; minutes =tm.Minute ; heures =tm.Heure; } }int distance_in_cm(){ longue durée, cm ; // Le capteur est déclenché par une impulsion HAUTE de 10 microsecondes ou plus. // Donner une courte impulsion LOW au préalable pour assurer une impulsion HIGH propre :digitalWrite(trigPin, LOW); délaiMicrosecondes(2) ; digitalWrite(trigPin, HAUT); délaiMicrosecondes(10) ; digitalWrite(trigPin, LOW); // Lecture du signal du capteur :une impulsion HAUTE dont // la durée est le temps (en microsecondes) depuis l'envoi // du ping jusqu'à la réception de son écho provenant d'un objet. durée =pulseIn(echoPin, HIGH); // convertir le temps en distance cm =microsecondsToCentimeters(duration); retour cm; }long microsecondsToCentimeters(long microseconds) { // La vitesse du son est de 340 m/s ou 29 microsecondes par centimètre. // Le ping va et vient, donc pour trouver la distance de l'objet // nous prenons la moitié de la distance parcourue. retour microsecondes / 29 / 2; }alerte vide(){ tone(piezoPin, 2000, 50); tonalité (piezoPin, 2000, 200); //délai(10) ; }void blank() { //tone(piezoPin, 2000, 100); //state++;}// Cette fonction sera appelée lorsque le bouton1 a été pressé 1 fois (et aucun 2ème appui sur le bouton n'a suivi).void pressed() { //Serial.println("Bouton 1 clic."); button_press_count++ ; alerte(); if(button_press_count ==5){ button_press_count =1; }} // click// Cette fonction sera appelée lorsque le bouton1 a été pressé 2 fois dans un court laps de temps.void doubleclick() { Serial.println("Button 1 doubleclick.");} // doubleclick// Cette fonction être appelé une fois, lorsque le bouton1 est enfoncé pendant une longue période.void longPressStart() { Serial.println("Button 1 longPress start");} // longPressStart// Cette fonction sera appelée souvent, tandis que le button1 est enfoncé pendant a long time.void longPress() { Serial.println("Bouton 1 longPress..."); water_intake_ounch[water_intake_times - 1] =0; //ignorer la dernière valeur} // longPressvoid calcul(){ float water_level =0;// stocker le niveau à chaque étape int read_value =0; //lire la lecture du capteur en cm for(int i=0; i<5; i++){ //prendre cinq lecture read_value =distance_in_cm(); if(read_value>16 || read_value<3){// lecture instable retour ; // retour à la fonction appelante car la lecture est instable } else if(read_value<=16 &&read_value>=3){//valeur valide water_level =water_level + read_value; } délai(10) ; } average_water_level =17 - water_level/5; //trouver la moyenne à partir de cinq lectures, 17 =hauteur de la bouteille water_amount_in_ounce =int(average_water_level*1.87) ;//16 cm niveau d'eau =30 onces if(water_intake_times==0){ previous_water_amount =water_amount_in_ounce ; water_intake_times =1; } if((water_amount_in_ounce  previous_water_amount){ //l'eau est remplie //l'eau est rechargée ici previous_water_amount =water_amount_in_ounce; } else if(water_amount_in_ounce ==previous_water_amount){ // pas d'eau consommée ou recharger idle_time+=1; } if(hours==23 &&minutes==59){ // un jour est terminé et toutes les valeurs commencent à zéro pour le nouveau jour for(int i=0; i<15; i++){ water_intake_ounch[i] =0; } water_intake_times =0; apport_jour++ ; if(apport_jour==8){ apport_jour =1 ; } }}int total_water_intake_in_day(){//calculer la consommation totale d'eau en une journée total_water_intake_today =0; for(int i=0; i 

Schémas