Rappel de médecine automatique utilisant Arduino

Quand il s'agit de nos proches, nous voulons toujours les garder en bonne santé et en forme. Mais que se passera-t-il s'ils tombent malades et oublient de prendre leurs médicaments à temps? Nous serions inquiets, non? Dans les hôpitaux, les patients sont nombreux et il est difficile de rappeler à chaque patient de prendre ses médicaments à temps. Les méthodes traditionnelles nécessitent des efforts humains pour leur rappeler de prendre les médicaments à temps. L'ère numérique ne suit pas cela et nous pouvons utiliser des machines pour le faire. L'application de Smart Medicine Reminder est très large et peut être utilisée par les patients à domicile, les médecins des hôpitaux et dans de nombreux autres endroits. Quand il s'agit de rappeler, il peut y avoir de nombreuses façons de le rappeler:

1. Montrez-le sur un écran
2. Envoyer une notification par e-mail ou par téléphone
3. Utiliser des applications mobiles
4. Alarme sonore
5. Utilisation de Bluetooth / Wi-Fi
6. Recevoir un appel
7. Rappeler la prochaine heure du médicament tout en rappelant l'heure actuelle

Nous pouvons combiner les moyens en fonction des besoins. Pour garder les choses simples ici, nous avons fait un simple rappel de médicaments en utilisant Arduino qui nous rappelle de prendre des médicaments 1 ou 2 ou 3 fois par jour. La plage horaire peut être sélectionnée à l'aide des boutons poussoirs. En outre, il affiche la date et l'heure actuelles. Nous allons en outre l'étendre aux articles entrants d'un projet IoT où une notification par courrier électronique ou SMS sera envoyée à l'utilisateur. Ce rappel de médicaments peut également être intégré au système de surveillance des patients.

Composants requis pour le rappel automatique de médecine utilisant Arduino

1. Arduino Uno (Nous pouvons également utiliser d'autres cartes Arduino, comme Pro mini, Nano)
2. Module RTC DS3231
3. Écran LCD 16x2
4. Avertisseur sonore
5. Led (n'importe quelle couleur)
6. Planche à pain
7. Boutons poussoir
8. Potentiomètre 10K
9. Résistances 10K, 1K
10. Fils de cavalier

Rappel de médecine Arduino utilisant le circuit Arduino

Le schéma de circuit complet pour construire une boîte de médicaments intelligente à l'aide d'Arduino est illustré ci-dessous

Vous trouverez ci-dessous les connexions des broches d'Arduino avec différents périphériques

Pins Arduino Broches Périphériques

• 2 -----------------------------> D7 de l'écran LCD 16x2
• 3 -----------------------------> D6 de l'écran LCD 16x2
• 4 -----------------------------> D5 de l'écran LCD 16x2
• 5 -----------------------------> D4 de l'écran LCD 16x2
• 7 -----------------------------> 3ème bouton poussoir
• 8 -----------------------------> 2ème bouton poussoir
• 9 -----------------------------> 1er bouton poussoir
• 11 -----------------------------> Broche EN de l'écran LCD 16x2
• 12 -----------------------------> Broche RS de l'écran LCD 16x2
• 13 -----------------------------> + Ve Pin de Buzzer et Led
• A0 -----------------------------> Bouton poussoir d'arrêt
• A4 -----------------------------> SDA du DS3231
• A5 -----------------------------> SCL du DS3231
• 3.3V -----------------------------> Vcc de DS3231
• Gnd -----------------------------> Gnd

Dans ce projet de rappel de médecine, RTC DS3231 est interfacé via le protocole I2C avec Arduino Uno. Vous pouvez également utiliser RTC IC DS1307 pour lire l'heure avec Arduino. Le RTC DS3231 possède également une mémoire 32k intégrée qui peut être utilisée pour stocker des données supplémentaires. Le module RTC est alimenté par la broche 3,3 V d'Arduino uno. Un écran LCD 16x2 est interfacé à l'aide de SPI. Un buzze r est utilisé pour alerter et rappeler qu'il est temps de prendre des médicaments. Quatre boutons poussoirs sont utilisés, chacun ayant une fonction de sélection distincte. Le premier bouton-poussoir est utilisé pour rappeler de prendre des médicaments une fois par jour. Le deuxième bouton-poussoir est utilisé pour rappeler deux fois par jour et le troisième bouton-poussoir est utilisé pour rappeler trois fois par jour. Le quatrième bouton-poussoir est utilisé pour arrêter le buzzer lorsque l'utilisateur a entendu l'alerte.

Fonctionnement du système de rappel de médecine automatique

L' alarme de rappel de pilule est alimentée par une alimentation 5V. Lorsqu'il démarre pour la première fois, il affiche un massage de bienvenue comme « Bienvenue sur Circuit Digest ». L'écran LCD est configuré pour parcourir trois écrans. Le 1 ^er massage écran montre que « rester en bonne santé, Get Well Soon ». Le deuxième écran est un écran d'aide qui indique d'appuyer sur le bouton poussoir de sélection pour sélectionner n'importe quel créneau horaire à rappeler (une / deux / trois fois par jour). L'intervalle de temps est modifiable dans le programme et peut être configuré en conséquence. À l'heure actuelle, nous avons fixé cela en trois durées, à savoir 8h, 14h et 20h.

Nous avons divisé les plages horaires en trois modes. Le mode 1 sélectionne la prise de médicaments une fois / jour à 8h du matin lorsque l'utilisateur appuie sur le 1 ^er bouton-poussoir. Le mode 2 sélectionne la prise de médicaments deux fois / jour à 8h et 20h lorsque l'utilisateur appuie sur le 2 ^ème bouton-poussoir. Mode 3 choisit de prendre des médicaments trois fois / jour à 8h du matin, 14 heures et 20 heures si l'utilisateur appuie 3 ^e bouton-poussoir.

Nous pouvons également ajouter une fonctionnalité pour répéter le buzzer pendant 10 minutes (non inclus dans ce projet). Lorsque l'utilisateur sélectionne les créneaux souhaités en appuyant sur les boutons-poussoirs, l'entrée utilisateur est enregistrée et l'heure est tirée du RTC. Lorsque l'heure correspond à la plage horaire sélectionnée, le buzzer se met à sonner. L'utilisateur peut arrêter le buzzer en appuyant sur le bouton STOP. Le même processus se poursuit pour le prochain rappel de slot. Le processus complet est montré dans la vidéo donnée à la fin de cet article.

Programmation Arduino UNO pour le rappel de médecine

Il est très facile d'écrire un programme une fois que vous avez pensé aux moyens de vous rappeler de prendre les pilules. Ici, il affichera le rappel à l'écran, sonnera un buzzer et l'indiquera à l'aide de la LED. Il a également la possibilité de sélectionner trois plages horaires (une / deux / trois fois par jour) et lorsque le temps l'atteindra, commencez à alerter le patient en faisant sonner le buzzer. Ensuite, tout le système ressemblera à ceci:

L'utilisateur obtient des instructions d'aide à l'écran> L'utilisateur sélectionne les créneaux horaires (une fois / jour, deux fois / jour, trois fois / jour)> Imprimer le message de confirmation à l'écran> Heure de début> Le buzzer et la LED commencent lorsque l'heure correspond au créneau sélectionné par l'utilisateur> L'utilisateur s'arrête par appui sur un bouton poussoir d'arrêt> Fin

Nous pouvons changer le programme et le matériel si nous voulons ajouter plus de fonctionnalités. Pour comprendre de manière beaucoup plus simple, nous avons décomposé le programme en petites fonctions. Les fonctions sont faciles à comprendre et à mettre en œuvre. Le programme complet est donné à la fin de ce projet. Commençons par le programme.

Depuis, nous avons utilisé d'autres périphériques comme l'écran LCD 16x2, le RTC DS3231, donc nous devons d'abord inclure des bibliothèques pour cela. Les bibliothèques requises sont les suivantes:

(https://github.com/adafruit/RTClib)

La bibliothèque EEPROM est utilisée pour garder la trace de l'entrée sélectionnée par l'utilisateur si Arduino n'est pas allumé. Et lorsque l'utilisateur allume l'Arduino, il obtient l'état précédent des boutons-poussoirs à l'aide de la bibliothèque EEPROM. La bibliothèque Wire.h est utilisée car le module RTC DS3231 est communiqué via I2C.

Vérifiez toujours si le RTC est correctement câblé ou s'il n'est pas endommagé, car le RTC jouera un rôle important dans le chronométrage de l'ensemble du système de rappel.

if (! rtc.begin ()) {// vérifier si rtc est connecté Serial.println ("Impossible de trouver RTC"); tandis que (1); } if (rtc.lostPower ()) { Serial.println ("RTC a perdu l'alimentation, réglons l'heure!"); }

L'ajustement de l'heure peut être effectué de deux manières, soit automatiquement en utilisant l'heure de compilation du système, soit en la saisissant manuellement. Une fois que nous avons réglé l'heure, commentez les lignes ci-dessous, sauf si vous souhaitez modifier à nouveau l'heure RTC.

rtc.adjust (DateHeure (F (__ DATE__), F (__ HEURE__))); //rtc.adjust(DateTime(2019, 1, 10, 7, 59, 52));

Cette instruction de commutation est utilisée pour lire l'état précédemment enregistré du bouton-poussoir et pour reprendre l'état pour une heure de rappel appropriée et précise.

val2 = EEPROM.read (addr); // lire la valeur précédemment enregistrée du bouton-poussoir pour commencer à partir de l'endroit où il était précédemment switch (val2) { case 1: Serial.println ("Set for 1 / day"); push1state = 1; push2state = 0; push3state = 0; pushVal = 01; Pause; cas 2: Serial.println ("Set for 2 / day"); push1state = 0; push2state = 1; push3state = 0; pushVal = 10; Pause; cas 3: Serial.println ("Set for 3 / day"); push1state = 0; push2state = 0; push3state = 1; pushVal = 11; Pause; }

Cette instruction est utilisée pour obtenir les millisecondes à utiliser pour la synchronisation et le contrôle du cycle d'écran d'intervalle défini.

currentMillisLCD = millis (); // démarrer millis pour la commutation de l'écran LCD à un intervalle de temps défini

Commencez à lire les broches numériques connectées aux boutons poussoirs.

push1state = digitalRead (push1pin); push2state = digitalRead (push2pin); push3state = digitalRead (push3pin); stopinState = digitalRead (stopPin);

La fonction ci-dessous est utilisée pour lire l'état du bouton-poussoir et l'écrire dans l'EEPROM. Chaque fois que le bouton poussoir est enfoncé, l'état est écrit dans l'EEPROM. Il imprime également le message sur l'écran LCD du choix d'entrée utilisateur sélectionné. De même, les fonctions push2 () et push3 () sont utilisées.

void push1 () {// fonction pour définir un rappel une fois / jour if (push1state == 1) { push1state = 0; push2state = 0; push3state = 0; // pushPressed = true; EEPROM.write (adr, 1); Serial.print ("Push1 Written:"); Serial.println (EEPROM.read (addr)); // pour le débogage pushVal = 1; // sauvegarde l'état du bouton poussoir-1 lcd.clear (); lcd.setCursor (0, 0); lcd.print ("Ensemble de rappel"); lcd.setCursor (0, 1); lcd.print ("pour une fois / jour!"); retard (1200); lcd.clear (); } }

La fonction ci-dessous est utilisée pour arrêter le buzzer et la led. Il est toujours bon de faire des suggestions. Imprimez un message de suggestion sur l'écran «Prenez vos médicaments avec de l'eau chaude».

void stopPins () {// fonction pour arrêter le bourdonnement lorsque l'utilisateur appuie sur le bouton-poussoir d'arrêt if (stopinState == 1) { // stopinState = 0; // pushPressed = true; pushpressed = 1; lcd.clear (); lcd.setCursor (0, 0); lcd.print ("Take Medicine"); lcd.setCursor (0, 1); lcd.print ("avec de l'eau chaude"); retard (1200); lcd.clear (); } }

La fonction ci-dessous est indépendante du chronométrage mais passe toujours par trois écrans, ce qui aide l'utilisateur. Comme nous gardons un soin aux patients, imprimons un message de bienvenue car nous savons que le soutien émotionnel est très utile pour guérir les patients plus rapidement. Vous pouvez choisir votre propre message créatif. Nous allons imprimer un message comme « Rester en bonne santé, bien bientôt Get ».

Le deuxième écran sert à donner des instructions aux patients comme «Appuyez sur les boutons pour rappel..». Le troisième écran est utilisé pour afficher simplement la date et l'heure actuelles.

void changeScreen () {// fonction pour le cycle d'écran // Commencer à changer d'écran à chaque intervalle définiLCD if (currentMillisLCD - previousMillisLCD> intervalLCD) // enregistrer la dernière fois que vous avez changé l'affichage { previousMillisLCD = currentMillisLCD; écrans ++; if (screens> maxScreen) { screens = 0; // tous les écrans sur -> commencent à partir du 1er } isScreenChanged = true; } // Démarre l' affichage de l'écran actuel if (isScreenChanged) // ne met à jour l'écran que si l'écran est changé. { isScreenChanged = false; // réinitialisé pour la prochaine itération commutateur (écrans) { case getWellsoon: gwsMessege (); // guérir bientôt message Pause; case HELP_SCREEN: helpScreen (); // saut d' écran d'instructions ; case TIME_SCREEN: timeScreen (); // pour imprimer la pause de la date et de l'heure ; par défaut: // NOT SET. Pause; } } }

Cette fonction est utilisée pour démarrer le bourdonnement et le clignotement de la LED simultanément si l'heure sélectionnée est atteinte.

void startBuzz () {// fonction pour démarrer le bourdonnement lorsque le temps atteint l'intervalle défini // if (pushPressed == false) { if (pushpressed == 0) { Serial.println ("pushpressed is false in blink"); non signé long currentMillis = millis (); if (currentMillis - previousMillis> = intervalle) { previousMillis = currentMillis; // enregistre la dernière fois que vous avez clignoté la LED Serial.println ("Start Buzzing"); if (ledState == LOW) {// si la LED est éteinte, allumez-la et vice-versa: ledState = HIGH; } else { ledState = LOW; } digitalWrite (ledPin, ledState); } } else if (pushpressed == 1) { Serial.println ("pushpressed is true"); ledState = LOW; digitalWrite (ledPin, ledState); } }

Cette fonction est utilisée pour comparer le créneau horaire sélectionné par l'utilisateur à 8h du matin et commence à bourdonner le buzzer et à faire clignoter la LED jusqu'à ce que l'utilisateur appuie sur le bouton d'arrêt. De même, les fonctions void at2pm () et void at8pm sont utilisées pour démarrer le buzzer et led à 14h et 20h.

void at8am () {// fonction pour commencer à bourdonner à 8h DateTime now = rtc.now (); if (int (now.hour ())> = buzz8amHH) { if (int (now.minute ())> = buzz8amMM) { if (int (now.second ())> buzz8amSS) { ////// ///////////////////////////////////////////////// startBuzz (); //////////////////////////////////////////////////// /// } } } }

C'est ainsi que vous pouvez simplement créer votre propre rappel automatique de médicaments en utilisant Arduino. Vous pouvez également utiliser ESP8266 avec Arduino pour en faire un projet IoT qui pourra envoyer une alerte email à l'utilisateur.

Le code complet et la vidéo de démonstration sont donnés ci-dessous.