Automatische Medizinerinnerung mit Arduino

Wenn es um unsere Lieben geht, wollen wir sie immer gesund und fit halten. Aber was passiert, wenn sie krank werden und vergessen, rechtzeitig Medikamente einzunehmen? Wir wären besorgt, oder? In Krankenhäusern gibt es viele Patienten, und es ist schwierig, jeden Patienten daran zu erinnern, Medikamente rechtzeitig einzunehmen. Die traditionellen Methoden erfordern menschliche Anstrengungen, um sie daran zu erinnern, Medikamente rechtzeitig einzunehmen. Das digitale Zeitalter folgt dem nicht und wir können Maschinen benutzen, um das zu tun. Die Anwendung von Smart Medicine Reminder ist sehr breit und kann von Patienten zu Hause, Ärzten in Krankenhäusern und an vielen anderen Orten verwendet werden. Wenn es um das Erinnern geht, gibt es viele Möglichkeiten, es zu erinnern:

1. Zeigen Sie es auf einem Display
2. Benachrichtigung per E-Mail oder Telefon senden
3. Mobile Apps verwenden
4. Buzz Alarm
5. Verwenden von Bluetooth / Wi-Fi
6. Einen Anruf bekommen
7. Erinnern Sie sich an die nächste Medizinzeit, während Sie an die aktuelle Zeit erinnern

Wir können Wege je nach Bedarf kombinieren. Um die Dinge hier einfach zu halten, haben wir mit Arduino eine einfache Medikamentenerinnerung erstellt, die uns daran erinnert, Medikamente 1, 2 oder 3 Mal am Tag einzunehmen. Das Zeitfenster kann über Drucktasten ausgewählt werden. Außerdem werden das aktuelle Datum und die aktuelle Uhrzeit angezeigt. Wir werden es weiter auf eingehende Artikel eines IoT-Projekts ausweiten, bei denen eine E-Mail- oder SMS-Benachrichtigung an den Benutzer gesendet wird. Diese Medikamentenerinnerung kann auch in das Patientenüberwachungssystem integriert werden.

Erforderliche Komponenten für die Erinnerung an die automatische Medizin mit Arduino

1. Arduino Uno (Wir können auch andere Arduino-Boards verwenden, wie Pro mini, Nano)
2. RTC DS3231-Modul
3. 16x2 LCD-Anzeige
4. Summer
5. Led (jede Farbe)
6. Steckbrett
7. Drück Knöpfe
8. 10K Potentiometer
9. 10K, 1K Widerstände
10. Überbrückungsdrähte

Arduino Medicine Reminder mit Arduino Circuit

Das vollständige Schaltbild zum Aufbau einer intelligenten Medizinbox mit Arduino ist unten dargestellt

Unten finden Sie die Pin-Verbindungen von Arduino mit verschiedenen Peripheriegeräten

Arduino Pins Peripherie-Pins

• 2 -----------------------------> D7 des 16x2 LCD-Displays
• 3 -----------------------------> D6 des 16x2 LCD-Displays
• 4 -----------------------------> D5 des 16x2 LCD-Displays
• 5 -----------------------------> D4 des 16x2 LCD-Displays
• 7 -----------------------------> 3. Druckknopf
• 8 -----------------------------> 2. Druckknopf
• 9 -----------------------------> 1. Druckknopf
• 11 -----------------------------> EN-Pin des 16x2-LCD-Displays
• 12 -----------------------------> RS-Pin des 16x2-LCD-Displays
• 13 -----------------------------> + Ve Pin von Summer und LED
• A0 -----------------------------> Stop Push Button
• A4 -----------------------------> SDA von DS3231
• A5 -----------------------------> SCL von DS3231
• 3,3 V -----------------------------> Vcc von DS3231
• Gnd -----------------------------> Gnd

In diesem Medicine Reminder-Projekt ist RTC DS3231 über das I2C-Protokoll mit Arduino Uno verbunden. Sie können auch den RTC IC DS1307 verwenden, um die Zeit mit Arduino zu lesen. RTC DS3231 verfügt außerdem über einen integrierten 32-KB-Speicher, in dem zusätzliche Daten gespeichert werden können. Das RTC-Modul wird über den 3,3-V-Pin von Arduino uno mit Strom versorgt. Ein 16x2 LCD-Display ist über SPI angeschlossen. Ein Summer wird verwendet, um zu warnen und daran zu erinnern, dass es Zeit ist, Medikamente einzunehmen. Es werden vier Drucktasten verwendet, von denen jede eine eigene Auswahlfunktion hat. Der erste Druckknopf wird verwendet, um daran zu erinnern, einmal täglich Medikamente einzunehmen. Der zweite Druckknopf wird verwendet, um zweimal pro Tag zu erinnern, und der dritte Druckknopf wird verwendet, um dreimal pro Tag zu erinnern. Mit dem vierten Druckknopf wird der Summer angehalten, wenn der Benutzer den Alarm gehört hat.

Funktionsweise des automatischen Medizinerinnerungssystems

Der Pillenerinnerungsalarm wird mit 5 V versorgt. Beim ersten Start wird eine Begrüßungsmassage als „ Welcome to Circuit Digest “ angezeigt . Der LCD-Bildschirm ist so eingestellt, dass er in drei Bildschirmen wechselt. Die 1 ^st Bildschirm zeigt Massage als „ Bleiben Sie gesund, Get Well Soon “. Der zweite Bildschirm ist ein Hilfebildschirm, in dem Sie aufgefordert werden, die Auswahltaste zu drücken, um einen beliebigen Zeitschlitz zum Erinnern auszuwählen (ein- / zweimal / dreimal am Tag). Das Zeitfenster kann im Programm geändert werden und kann entsprechend konfiguriert werden. Im Moment haben wir dies in drei Zeiträume festgelegt, nämlich 8 Uhr, 14 Uhr und 20 Uhr.

Wir haben Zeitfenster in drei Modi unterteilt. Modus 1 wählt Medizin zu nehmen einmal / Tag um 8 Uhr morgens, wenn der Benutzer drückt 1 ^st Druckknopf. Mode 2 wählt zweimal Medizin zu nehmen / Tag um 8 Uhr morgens und 20.00 Uhr, wenn der Benutzer drückt 2 ^nd Druckknopf. Modus 3 wählt Medizin dreimal / Tag um 8 Uhr, 14.00 Uhr und 20.00 Uhr, wenn der Benutzer drückt 3 nehmen ^rd Druckknopf.

Wir können auch eine Funktion hinzufügen, um den Summer für 10 Minuten zu dösen (nicht in diesem Projekt enthalten). Wenn der Benutzer die gewünschten Steckplätze durch Drücken von Drucktasten auswählt, wird die Benutzereingabe aufgezeichnet und die Zeit von RTC übernommen. Wenn die Zeit mit dem ausgewählten Zeitfenster übereinstimmt, beginnt der Summer zu summen. Der Benutzer kann den Summer durch Drücken der STOP-Taste stoppen. Der gleiche Vorgang wird für die nächste Slot-Erinnerung fortgesetzt. Der vollständige Vorgang wird im Video am Ende dieses Artikels gezeigt.

Programmierung von Arduino UNO für Medicine Reminder

Es ist sehr einfach, ein Programm zu schreiben, wenn Sie überlegt haben, wie Sie daran erinnern können, die Pillen einzunehmen. Hier wird die Erinnerung angezeigt, ein Summer ertönt und mit einer LED angezeigt. Sie können auch drei Zeitfenster auswählen (einmal / zweimal / dreimal pro Tag). Wenn die Zeit abgelaufen ist, wird der Patient durch Summen des Summers alarmiert. Dann sieht das gesamte System folgendermaßen aus:

Benutzer erhält Hilfeanweisungen auf dem Display> Benutzer wählt Zeitfenster aus (einmal / Tag, zweimal / Tag, dreimal / Tag)> Bestätigungsmeldung auf dem Display drucken> Zeitmessung gestartet> Summer und LED starten, wenn die Zeit mit dem vom Benutzer ausgewählten Zeitfenster übereinstimmt> Benutzer kommt vorbei Drücken eines Stopptasters> Ende

Wir können das Programm und die Hardware ändern, wenn wir weitere Funktionen hinzufügen möchten. Um dies viel einfacher zu verstehen, haben wir das Programm in kleine Funktionen unterteilt. Die Funktionen sind leicht zu verstehen und zu implementieren. Das vollständige Programm finden Sie am Ende dieses Projekts. Beginnen wir mit dem Programm.

Da wir andere Peripheriegeräte wie das 16x2-LCD-Display, RTC DS3231, verwendet haben, müssen wir zuerst Bibliotheken dafür einbinden. Folgende Bibliothek ist erforderlich:

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

Die EEPROM-Bibliothek wird verwendet, um die Eingabe der Benutzerauswahl zu verfolgen, wenn Arduino nicht aktiviert ist. Und wenn der Benutzer das Arduino einschaltet, erhält es mithilfe der EEPROM-Bibliothek den vorherigen Status der Drucktasten. Die Wire.h-Bibliothek wird verwendet, da das RTC DS3231-Modul über I2C kommuniziert wird.

Überprüfen Sie immer , ob die RTC ordnungsgemäß verdrahtet oder nicht beschädigt ist, da die RTC eine wichtige Rolle bei der Zeitmessung des gesamten Erinnerungssystems spielt.

if (! rtc.begin ()) {// prüfe, ob rtc verbunden ist Serial.println ("RTC konnte nicht gefunden werden"); während (1); } if (rtc.lostPower ()) { Serial.println ("RTC hat Strom verloren, lassen Sie uns die Zeit einstellen!"); }}

Die Zeitanpassung kann auf zwei Arten erfolgen, entweder automatisch mithilfe der Systemkompilierungszeit oder durch manuelle Eingabe. Wenn wir die Zeit eingestellt haben, kommentieren Sie die folgenden Zeilen, es sei denn, Sie möchten die RTC-Zeit erneut ändern.

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

Diese switch-Anweisung wird verwendet, um den zuvor gespeicherten Status des Druckknopfs zu lesen und den Status für eine angemessene und genaue Erinnerungszeit fortzusetzen.

val2 = EEPROM.read (addr); // Lesen Sie den zuvor gespeicherten Wert des Druckknopfs, um an der Stelle zu beginnen, an der er zuvor verlassen wurde. switch (val2) { case 1: Serial.println ("Set for 1 / day"); push1state = 1; push2state = 0; push3state = 0; pushVal = 01; Unterbrechung; Fall 2: Serial.println ("Set for 2 / day"); push1state = 0; push2state = 1; push3state = 0; pushVal = 10; Unterbrechung; Fall 3: Serial.println ("Set for 3 / day"); push1state = 0; push2state = 0; push3state = 1; pushVal = 11; Unterbrechung; }}

Diese Anweisung wird verwendet, um die Millis für das Timing und die Steuerung des definierten Intervall-Bildschirmzyklus zu verwenden.

currentMillisLCD = millis (); // Millis für das Umschalten des LCD-Bildschirms in einem definierten Zeitintervall starten

Beginnen Sie mit dem Lesen der digitalen Stifte, die mit den Drucktasten verbunden sind.

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

Die folgende Funktion wird verwendet, um den Status der Drucktaste zu lesen und in das EEPROM zu schreiben. Immer wenn der Druckknopf gedrückt wird, wird der Status in das EEPROM geschrieben. Außerdem wird die Meldung der ausgewählten Benutzereingabeauswahl auf dem LCD-Display gedruckt. Ebenso werden die Funktionen push2 () und push3 () verwendet.

void push1 () {// Funktion zum Festlegen der Erinnerung einmal / Tag if (push1state == 1) { push1state = 0; push2state = 0; push3state = 0; // pushPressed = true; EEPROM.write (addr, 1); Serial.print ("Push1 Written:"); Serial.println (EEPROM.read (addr)); // zum Debuggen pushVal = 1; // speichere den Status von Druckknopf-1 lcd.clear (); lcd.setCursor (0, 0); lcd.print ("Erinnerungssatz"); lcd.setCursor (0, 1); lcd.print ("einmal / Tag!"); Verzögerung (1200); lcd.clear (); } }

Die folgende Funktion wird verwendet, um den Summer und die LED anzuhalten. Es ist immer gut, Vorschläge zu machen. Drucken Sie eine Vorschlagsnachricht auf dem Display „Nehmen Sie Arzneimittel mit warmem Wasser ein“.

void stopPins () {// Funktion zum Stoppen des Summens, wenn der Benutzer den Stopp-Druckknopf drückt, wenn (stopinState == 1) { // stopinState = 0; // pushPressed = true; Pushpressed = 1; lcd.clear (); lcd.setCursor (0, 0); lcd.print ("Take Medicine"); lcd.setCursor (0, 1); lcd.print ("mit warmem Wasser"); Verzögerung (1200); lcd.clear (); } }

Die folgende Funktion ist unabhängig von der Zeitmessung, wechselt jedoch immer in drei Bildschirmen, was dem Benutzer hilft. Da wir uns um die Patienten kümmern, können Sie eine Begrüßungsnachricht ausdrucken, da wir wissen, dass emotionale Unterstützung sehr hilfreich ist, um Patienten in kürzerer Zeit zu heilen. Sie können Ihre eigene kreative Nachricht auswählen. Drucken wir eine Nachricht mit dem Titel „Bleib gesund, gute Besserung“.

Der zweite Bildschirm dient dazu, den Patienten Anweisungen zu geben: „Drücken Sie die Tasten zur Erinnerung.“. Der dritte Bildschirm wird verwendet, um einfach das aktuelle Datum und die aktuelle Uhrzeit anzuzeigen.

void changeScreen () {// Funktion für Screen Cycling // Schalte jedes definierte Intervall um, wenn (currentMillisLCD - previousMillisLCD> intervalLCD) // speichere das letzte Mal, als du die Anzeige geändert hast { previousMillisLCD = currentMillisLCD; Bildschirme ++; if (Bildschirme> maxScreen) { Bildschirme = 0; // alle Bildschirme über -> ab dem 1. } isScreenChanged = true; } // Zeigt den aktuellen Bildschirm an, wenn (isScreenChanged) // den Bildschirm nur aktualisiert, wenn der Bildschirm geändert wird. { isScreenChanged = false; // für nächsten Iterationsschalter zurücksetzen (Bildschirme) { case getWellsoon: gwsMessege (); // Gute Besserung Nachricht Unterbrechung; case HELP_SCREEN: helpScreen (); // Anweisungsbildschirmunterbrechung ; case TIME_SCREEN: timeScreen (); // um Datums- und Uhrzeitpause zu drucken ; Standard: // NICHT SETZEN. Unterbrechung; } } }

Diese Funktion wird verwendet, um die LED gleichzeitig zu summen und zu blinken, wenn die ausgewählte Zeit erreicht ist.

void startBuzz () {// Funktion zum Starten des Summens, wenn die Zeit das definierte Intervall erreicht // if (pushPressed == false) { if (pushpressed == 0) { Serial.println ("pushpressed is false in blink"); unsigned long currentMillis = millis (); if (currentMillis - previousMillis> = Intervall) { previousMillis = currentMillis; // speichere das letzte Mal, als du die LED blinkst Serial.println ("Start Buzzing"); if (ledState == LOW) {// Wenn die LED aus ist, schalten Sie sie ein und umgekehrt: ledState = HIGH; } else { ledState = LOW; } digitalWrite (ledPin, ledState); } } else if (pushpressed == 1) { Serial.println ("pushpressed is true"); ledState = LOW; digitalWrite (ledPin, ledState); } }

Diese Funktion wird verwendet, um das vom Benutzer ausgewählte Zeitfenster um 8 Uhr morgens zu vergleichen und den Summer zu summen und die LED zu blinken, bis der Benutzer den Stopp-Druckknopf drückt. In ähnlicher Weise werden die Funktionen void at2pm () und void at8pm zum Starten des Summers verwendet und um 14pm und 20pm geführt.

void at8am () {// Funktion, um um 8 Uhr morgens mit dem Summen zu beginnen DateTime now = rtc.now (); if (int (now.hour ())> = summ8amHH) { if (int (now.minute ())> = summ8amMM) { if (int (now.second ())> summ8amSS) { ////// /////////////////////////////////////////////// startBuzz ();; /////////////////////////////////////////////////////////// /// } } } }

Auf diese Weise können Sie mit Arduino einfach Ihre eigene automatische Medizinerinnerung erstellen. Sie können ESP8266 auch mit Arduino verwenden, um daraus ein IoT-Projekt zu machen, das E-Mail-Benachrichtigungen an den Benutzer senden kann.

Der vollständige Code und das Demonstrationsvideo sind unten angegeben.