Automatisk medisinepåminnelse ved hjelp av arduino

Når det gjelder våre kjære, vil vi alltid holde dem sunne og i form. Men hva vil skje hvis de blir syke og glemmer å ta medisiner i tide. Vi ville være bekymret, ikke sant? På sykehus er det mange pasienter, og det er vanskelig å minne hver pasient på å ta medisiner i tide. De tradisjonelle måtene krever menneskelig innsats for å minne dem om å ta medisiner i tide. Den digitale æra følger ikke det, og vi kan bruke maskiner til å gjøre det. Anvendelsen av Smart Medicine Reminder er veldig bred og kan brukes av pasienter hjemme, leger på sykehus og mange andre steder. Når det gjelder påminnelse, kan det være mange måter å minne det på:

1. Vis det på en skjerm
2. Send varsel på e-post eller telefon
3. Bruke mobilapper
4. Buzz alarm
5. Bruker Bluetooth / Wi-Fi
6. Ring
7. Påminn om neste medisintid mens du påminner om gjeldende tid

Vi kan kombinere måter avhengig av behovet. For å holde ting enkelt her laget vi en enkel medisinepåminnelse med Arduino som minner oss om å ta medisiner 1 eller 2 eller 3 ganger om dagen. Tidsluken kan velges ved hjelp av trykknapper. Den viser også gjeldende dato og klokkeslett. Vi vil videre utvide det til et IoT-prosjekt innkommende artikler der en e-post eller SMS-varsling vil bli sendt til brukeren. Denne medisinerpåminnelsen kan også integreres i pasientovervåkingssystemet.

Komponenter som kreves for automatisk medisinpåminnelse ved bruk av Arduino

1. Arduino Uno (vi kan også bruke andre Arduino-kort, som Pro mini, Nano)
2. RTC DS3231-modul
3. 16x2 LCD-skjerm
4. Summer
5. Led (hvilken som helst farge)
6. Brettbrett
7. Trykke knapper
8. 10K potensiometer
9. 10K, 1K motstander
10. Jumper Wires

Påminnelse om Arduino medisin ved hjelp av Arduino Circuit

Det komplette kretsskjemaet for å bygge en smart medisinboks med Arduino er vist nedenfor

Nedenfor er pin-tilkoblingene til Arduino med forskjellige eksterne enheter

Arduino Pins Perifere pins

• 2 -----------------------------> D7 på 16x2 LCD-skjerm
• 3 -----------------------------> D6 på 16x2 LCD-skjerm
• 4 -----------------------------> D5 på 16x2 LCD-skjerm
• 5 -----------------------------> D4 på 16x2 LCD-skjerm
• 7 -----------------------------> 3. trykknapp
• 8 ----------------------------> 2. trykknapp
• 9 -----------------------------> 1. trykknapp
• 11 ----------------------------> EN-pinne på 16x2 LCD-skjerm
• 12 ----------------------------> RS-pinne på 16x2 LCD-skjerm
• 13 -----------------------------> + Ve Pin of Buzzer and Led
• A0 -----------------------------> Stopp trykknapp
• A4 -----------------------------> SDA av DS3231
• A5 ----------------------------> SCL av DS3231
• 3,3 V -----------------------------> Vcc av DS3231
• GND -----------------------------> GND

I dette medisinpåminnelsesprosjektet er RTC DS3231 grensesnittet gjennom I2C-protokollen med Arduino Uno. Du kan også bruke RTC IC DS1307 for å lese tiden med Arduino. RTC DS3231 har også innebygd 32k minne som kan brukes til å lagre tilleggsdata. RTC-modulen drives av 3,3V-pinnen til Arduino uno. En 16x2 LCD-skjerm er grensesnittet ved hjelp av SPI. En summende r brukes til å varsle og minne om at det er på tide å ta medisiner. Fire trykknapper brukes der hver har forskjellige valgfunksjoner. Den første trykknappen brukes til å minne om å ta medisin en gang per dag. Den andre trykknappen brukes til å minne to ganger om dagen, og den tredje trykknappen brukes til å minne på tre ganger per dag. Den fjerde trykknappen brukes til å stoppe summeren når brukeren har hørt varselet.

Arbeid med automatisk påminnelsessystem for medisiner

The Pill Reminder Alarm drives ved hjelp av 5V forsyning. Når den først starter opp, viser den en velkomstmassasje som “ Welcome to Circuit Digest ”. LCD-skjermen er satt til å sykle i tre skjermer. De 1 ^st skjermen viser massere som “ holde seg frisk, Get Well Soon ”. Det andre skjermbildet er et hjelpeskjermbilde som forteller at du trykker på velg trykknapp for å velge en tidsluke å minne om (en / to ganger / tre ganger om dagen). Tidsruten kan endres i programmet og kan konfigureres deretter. Akkurat nå har vi løst dette i tre varigheter, dvs. 08.00, 14.00 og 20.00.

Vi har delt tidsluker i tre moduser. Mode 1 velger å ta medisin gang / dag 8 am når brukeren trykker på en ^st knapp. Mode 2 velger å ta medisin to ganger / dag 8 am og 20:00 når brukeren trykker på 2 ^nd trykknapp. Modus 3 velger å ta medisin tre ganger om dagen klokka 8.00, 14.00 og 20.00 hvis brukeren trykker på ^tredje trykknapp.

Vi kan også legge til en funksjon for å snooze summeren i 10 minutter (ikke inkludert i dette prosjektet). Når brukeren velger ønskede spor ved å trykke på trykknapper, registreres brukerinngangen og tiden tas fra RTC. Når tiden matches med valgt tidsluke, begynner summeren å surre. Brukeren kan stoppe summeren ved å trykke på STOPP-knappen. Den samme prosessen fortsetter for neste påminnelse. Fullstendig prosess vises i videoen gitt på slutten av denne artikkelen.

Programmering Arduino UNO for medisinpåminnelse

Det er veldig enkelt å skrive program når du har tenkt på måtene å minne deg på å ta pillene. Her vil den vise påminnelsen på skjermen, surre en summer og indikere den ved hjelp av LED. Det har også muligheten til å velge tre tidsluker (en gang / to ganger / tre ganger per dag), og når tiden kommer, begynn å varsle pasienten ved å summere summeren. Da vil hele systemet se ut som følger:

Brukeren får hjelpinstruksjoner på skjermen> Bruker velger tidsluker (en gang / dag, to ganger / dag, tre ganger / dag)> Skriv ut bekreftelsesmelding på skjermen> Tidsforhold startet> Summer og LED starter når tiden samsvarer med bruker valgt spor> Bruker stopper ved trykke på en stoppknapp> Avslutt

Vi kan endre program og maskinvare hvis vi vil legge til flere funksjoner. For å forstå på en mye enklere måte har vi brutt programmet ned i små funksjoner. Funksjonene er enkle å forstå og implementere. Hele programmet blir gitt på slutten av dette prosjektet. La oss starte med programmet.

Siden har vi brukt andre eksterne enheter som 16x2 LCD-skjerm, RTC DS3231, så vi må først inkludere biblioteker f eller det. Biblioteket som kreves er som følger:

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

EEPROM-biblioteket brukes til å holde oversikt over brukervalginndata hvis Arduino ikke er slått på. Og når brukeren slår på Arduino, får den forrige tilstand av trykknapper ved hjelp av EEPROM-biblioteket. Wire.h-biblioteket brukes siden RTC DS3231-modulen kommuniseres ved hjelp av I2C.

Sjekk alltid om RTC er riktig koblet eller om den ikke er skadet, siden RTC vil spille en viktig rolle i å holde hele påminnelsessystemet tidsmessig.

hvis (! rtc.begin ()) {// sjekk om rtc er koblet til Serial.println ("Kunne ikke finne RTC"); mens (1); } hvis (rtc.lostPower ()) { Serial.println ("RTC mistet strøm, la oss stille tiden!"); }

Tidsjusteringen kan gjøres på to måter, enten automatisk ved hjelp av systemkompileringstid eller ved å angi den manuelt. Når vi har angitt tiden, kan du kommentere linjene nedenfor med mindre du vil endre RTC-tiden igjen.

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

Denne bryteruttalelsen brukes til å lese den tidligere lagrede tilstanden til trykknappen og gjenoppta tilstanden for riktig og nøyaktig påminnelsestid.

val2 = EEPROM.read (addr); // les tidligere lagret verdi på trykknappen for å starte der den ble stående tidligere bryter (val2) { tilfelle 1: Serial.println ("Sett for 1 / dag"); push1state = 1; push2state = 0; push3state = 0; pushVal = 01; gå i stykker; tilfelle 2: Serial.println ("Sett for 2 / dag"); push1state = 0; push2state = 1; push3state = 0; pushVal = 10; gå i stykker; tilfelle 3: Serial.println ("Sett for 3 / dag"); push1state = 0; push2state = 0; push3state = 1; pushVal = 11; gå i stykker; }

Denne påstanden brukes til å få millis til å bruke for timing og kontroll av den definerte intervallskjermsyklingen.

currentMillisLCD = millis (); // start millis for å bytte LCD-skjerm ved definert tidsintervall

Begynn å lese de digitale pinnene som er koblet til trykknapper.

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

Funksjonen nedenfor brukes til å lese trykknappstilstanden og skrive den til EEPROM. Når trykknappen blir trykket, skrives tilstanden til EEPROM. Den skriver også ut meldingen på LCD-skjermen om det valgte brukerinngangsvalget. Tilsvarende brukes funksjonene push2 () og push3 () .

ugyldig push1 () {// funksjon for å stille påminnelse en gang / dag hvis (push1state == 1) { push1state = 0; push2state = 0; push3state = 0; // pushPressed = true; EEPROM.write (addr, 1); Serial.print ("Push1 Skrevet:"); Serial.println (EEPROM.read (addr)); // for feilsøking pushVal = 1; // lagre tilstanden til trykknapp-1 lcd.clear (); lcd.setCursor (0, 0); lcd.print ("Påminnelsessett"); lcd.setCursor (0, 1); lcd.print ("for En gang / dag!"); forsinkelse (1200); lcd.clear (); } }

Funksjonen nedenfor brukes til å stoppe summeren og ledet. Det er alltid bra å komme med forslag. Skriv ut en forslagsmelding på displayet "Ta medisin med varmt vann".

ugyldig stopPins () {// funksjon for å stoppe summingen når brukeren trykker på trykknapp hvis (stopinState == 1) { // stopinState = 0; // pushPressed = true; trykkpresset = 1; lcd.clear (); lcd.setCursor (0, 0); lcd.print ("Ta medisin"); lcd.setCursor (0, 1); lcd.print ("med varmt vann"); forsinkelse (1200); lcd.clear (); } }

Funksjonen nedenfor er uavhengig av tidsstyring, men sykler alltid i tre skjermer som hjelper brukeren. Når vi tar vare på pasienter, kan vi skrive ut en hilsen når vi vet at følelsesmessig støtte er veldig nyttig for å helbrede pasienter på raskere tid. Du kan velge din egen kreative melding. La oss skrive ut en melding som “Hold deg frisk, bli frisk snart”.

Det andre skjermbildet er for å gi pasienter instruksjoner som “Trykk på knappene for påminnelse..”. Det tredje skjermbildet brukes til å bare vise gjeldende dato og klokkeslett.

void changeScreen () {// funksjon for skjermsykling // Begynn å bytte skjerm hvert definert intervallLCD hvis (currentMillisLCD - previousMillisLCD> intervalLCD) // lagre sist gang du endret skjermen { previousMillisLCD = currentMillisLCD; skjermer ++; hvis (skjermer> maxScreen) { skjermer = 0; // alle skjermbilder over -> start fra 1. } isScreenChanged = true; } // Begynn å vise gjeldende skjermbilde hvis (isScreenChanged) // bare oppdater skjermen hvis skjermen endres. { isScreenChanged = false; // reset for neste iterasjonsbryter (skjermer) { case getWellsoon: gwsMessege (); // bli frisk snart melding gå i stykker; sak HELP_SCREEN: helpScreen (); // instruksjonsskjermbrudd ; sak TIME_SCREEN: timeScreen (); // å skrive ut dato og tidsavbrudd ; standard: // NOT SET. gå i stykker; } } }

Denne funksjonen brukes til å begynne å surre og blinke LED-en samtidig hvis den valgte tiden har nådd.

void startBuzz () {// funksjon for å begynne å surre når tiden når til definert intervall // if (pushPressed == false) { if (pushpressed == 0) { Serial.println ("pushpressed is false in blink"); usignert langstrømMillis = millis (); hvis (currentMillis - previousMillis> = intervall) { previousMillis = currentMillis; // lagre sist gang du blinket LED Serial.println ("Start Buzzing"); if (ledState == LOW) {// hvis LED-en er av, slå den på og omvendt: ledState = HIGH; } annet { ledState = LAV; } digitalWrite (ledPin, ledState); } } annet hvis (pushpressed == 1) { Serial.println ("pushpressed is true"); ledState = LAV; digitalWrite (ledPin, ledState); } }

Denne funksjonen brukes til å sammenligne det valgte tidssporet klokka 8.00 og begynner å summere summeren og blinke LED til brukeren trykker på stoppknappen. Tilsvarende brukes funksjonene ugyldig kl. 14 () og ugyldige kl. 20.00 for å starte summer og ledet kl. 14 og 20.

ugyldig at8am () {// funksjon for å begynne å surre klokka 8.00 DateTime nå = rtc.now (); if (int (now.hour ())> = buzz8amHH) { if (int (now.minute ())> = buzz8amMM) { if (int (now.second ())> buzz8amSS) { ////// /////////////////////////////////////////////// startBuzz (); //////////////////////////////////////////////// /// } } } }

Slik kan du ganske enkelt lage din egen påminnelse om automatisk medisin ved hjelp av Arduino. Du kan også bruke ESP8266 med Arduino for å gjøre det til et IoT-prosjekt som vil kunne sende e-postvarsel til brukeren.

Fullstendig kode og demonstrasjonsvideo er gitt nedenfor.