Memento automat de medicină folosind arduino

Când vine vorba de cei dragi, vrem mereu să îi menținem sănătoși și în formă. Dar ce se va întâmpla dacă se îmbolnăvesc și uită să ia medicamente la timp. Am fi îngrijorați, nu? La spitale, există mulți pacienți și este dificil să le reamintim fiecărui pacient să ia medicamente la timp. Căile tradiționale necesită eforturi umane pentru a le reaminti să ia medicamente la timp. Era digitală nu urmează acest lucru și putem folosi mașini pentru a face acest lucru. Aplicația Smart Medicine Reminder este foarte largă și poate fi utilizată de pacienții de acasă, de medicii din spitale și din multe alte locuri. Când vine vorba de reamintire, pot exista mai multe moduri de a-i reaminti:

1. Afișați-l pe un ecran
2. Trimiteți o notificare prin e-mail sau telefon
3. Utilizarea aplicațiilor mobile
4. Alarma Buzz
5. Utilizarea Bluetooth / Wi-Fi
6. Primeste un telefon
7. Amintiți-vă pentru următoarea oră de medicament, în timp ce amintiți ora curentă

Putem combina moduri în funcție de nevoie. Pentru a simplifica lucrurile aici, am făcut un simplu memento de medicină folosind Arduino, care ne amintește să luăm medicamente de 1 sau 2 sau 3 ori pe zi. Intervalul de timp poate fi selectat folosind butoane. De asemenea, arată data și ora curente. Îl vom extinde în continuare la articolele primite ale unui proiect IoT în care va fi trimis utilizatorului o notificare prin e-mail sau SMS. Acest memento de medicamente poate fi, de asemenea, integrat cu sistemul de monitorizare a pacientului.

Componente necesare pentru reamintirea medicinii automate folosind Arduino

1. Arduino Uno (Putem folosi și alte plăci Arduino, cum ar fi Pro mini, Nano)
2. Modulul RTC DS3231
3. Afișaj LCD 16x2
4. Buzzer
5. Led (orice culoare)
6. Breadboard
7. Apasa butoanele
8. Potențiometru 10K
9. Rezistențe 10K, 1K
10. Sârme jumper

Memento Arduino Medicine folosind circuitul Arduino

Schema completă a circuitului pentru a construi o cutie de medicamente inteligentă folosind Arduino este prezentată mai jos

Mai jos sunt conexiunile pin ale Arduino cu diferite periferice

Pinii Arduino Pinii periferici

• 2 -----------------------------> D7 de afișaj LCD 16x2
• 3 -----------------------------> D6 de afișaj LCD 16x2
• 4 -----------------------------> D5 de afișaj LCD 16x2
• 5 -----------------------------> D4 de afișaj LCD de 16x2
• 7 -----------------------------> Al treilea buton
• 8 -----------------------------> Al doilea buton
• 9 -----------------------------> primul buton
• 11 -----------------------------> EN pin of 16x2 LCD Display
• 12 -----------------------------> Pin RS al afișajului LCD 16x2
• 13 -----------------------------> + Ve Pin de Buzzer și Led
• A0 -----------------------------> Buton de oprire
• A4 -----------------------------> SDA din DS3231
• A5 -----------------------------> SCL al DS3231
• 3.3V -----------------------------> Vcc al DS3231
• Gnd -----------------------------> Gnd

În acest proiect Medical Reminder, RTC DS3231 este interfațat prin protocolul I2C cu Arduino Uno. De asemenea, puteți utiliza RTC IC DS1307 pentru citirea orei cu Arduino. RTC DS3231 are, de asemenea, memorie încorporată de 32 k, care poate fi utilizată pentru a stoca date suplimentare. Modulul RTC este alimentat prin pinul de 3,3 V al Arduino uno. Un ecran LCD de 16x2 este interfațat utilizând SPI. Un buzze r este folosit pentru a alerta și a reaminti că este timpul să luați medicamente. Sunt utilizate patru butoane în care fiecare are o funcție distinctă de selectare. Primul buton este utilizat pentru a reaminti să luați medicamente o dată pe zi. Al doilea buton este folosit pentru a reaminti de două ori pe zi și al treilea buton este folosit pentru a reaminti de trei ori pe zi. Al patrulea buton este folosit pentru a opri soneria când utilizatorul a auzit alerta.

Funcționarea sistemului automat de reamintire a medicamentelor

Alarma Pilula memento este alimentat folosind 5V de aprovizionare. Când pornește pentru prima dată, arată un masaj de bun venit ca „ Welcome to Circuit Digest ”. Ecranul LCD este setat să funcționeze în trei ecrane. Cei 1 ^st arată ecran masaj ca „ rămâne sănătos, însănătoșire grabnică “. Al doilea ecran este un ecran de ajutor care vă spune să apăsați butonul selectați pentru a selecta orice interval de timp de reamintit (o dată / de două ori / de trei ori într-o zi). Intervalul de timp se poate modifica în program și poate fi configurat corespunzător. Chiar acum am stabilit acest lucru în trei durate, adică 8am, 2pm și 8pm.

Am împărțit intervalele de timp în trei moduri. Modul 1 selectează să ia medicamente o dată pe zi la 8am când utilizatorul apasă ^primul buton. Modul 2 selectează să ia medicamente de două ori pe zi la 8am și 8pm când utilizatorul apasă al ^doilea buton. Modul 3 selectează administrarea medicamentului de trei ori pe zi la 8am, 2pm și 8pm dacă utilizatorul apasă ^{al treilea} buton.

De asemenea, putem adăuga o funcție pentru a amâna soneria timp de 10 minute (neincluse în acest proiect). Când utilizatorul selectează sloturile dorite apăsând butoanele, intrarea utilizatorului este înregistrată și timpul este preluat de la RTC. Când timpul se potrivește cu intervalul de timp selectat, atunci soneria începe să bâzâie. Utilizatorul poate opri soneria apăsând butonul STOP. Același proces continuă pentru următorul memento de slot. Procesul complet este prezentat în videoclipul prezentat la sfârșitul acestui articol.

Programare Arduino UNO pentru reminder pentru medicină

Este foarte ușor să scrieți programul după ce v-ați gândit la modalitățile prin care vă amintiți să luați pastilele. Aici va afișa memento-ul pe afișaj, va emite un buzzer și îl va indica folosind LED-ul. De asemenea, are opțiunea de a selecta trei intervale de timp (o dată / de două ori / de trei ori pe zi) și când va ajunge timpul, începeți să avertizați pacientul prin sonerie. Apoi întregul sistem va arăta după cum urmează:

Utilizatorul primește instrucțiuni de ajutor pe afișaj> Utilizatorul selectează intervale de timp (o dată / zi, de două ori / zi, de trei ori / zi)> Imprimați mesajul de confirmare pe afișaj> Timpul a început> Buzzer și LED-ul pornește când timpul se potrivește cu slotul selectat de utilizator> Utilizatorul se oprește de apăsarea unui buton de oprire> Terminare

Putem schimba programul și hardware-ul dacă dorim să adăugăm mai multe caracteristici. Pentru a înțelege într-un mod mult mai simplu, am împărțit programul în funcții mici. Funcțiile sunt ușor de înțeles și implementat. Programul complet este dat la sfârșitul acestui proiect. Să începem cu programul.

De atunci, am folosit alte periferice, cum ar fi afișajul LCD de 16x2, RTC DS3231, deci trebuie mai întâi să includem biblioteci f sau altele. Biblioteca necesară este următoarea:

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

Biblioteca EEPROM este utilizată pentru a ține evidența intrării selectate de utilizator dacă Arduino nu este pornit. Și când utilizatorul pornește Arduino, acesta primește starea anterioară a butoanelor prin utilizarea bibliotecii EEPROM. Biblioteca Wire.h este utilizată deoarece modulul RTC DS3231 este comunicat folosind I2C.

Verificați întotdeauna dacă RTC este bine conectat sau nu este deteriorat, deoarece RTC va juca un rol important în menținerea timpului întregului sistem de memento.

if (! rtc.begin ()) {// verificați dacă rtc este conectat Serial.println ("Nu s-a putut găsi RTC"); în timp ce (1); } if (rtc.lostPower ()) { Serial.println ("RTC a pierdut puterea, să setăm ora!"); }

Reglarea timpului se poate face în două moduri, fie folosind automat timpul de compilare a sistemului, fie introducându-l manual. Odată ce am setat ora, comentați liniile de mai jos, cu excepția cazului în care doriți să schimbați din nou ora RTC.

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

Această declarație de comutare este utilizată pentru a citi starea salvată anterior a butonului și pentru a relua starea pentru un timp de memento adecvat și precis.

val2 = EEPROM.read (addr); // citiți valoarea memorată anterior a butonului pentru a porni de unde a fost lăsat anterior comutați (val2) { caz 1: Serial.println ("Setat pentru 1 / zi"); push1state = 1; push2state = 0; push3state = 0; pushVal = 01; pauză; cazul 2: Serial.println ("Set pentru 2 / zi"); push1state = 0; push2state = 1; push3state = 0; pushVal = 10; pauză; caz 3: Serial.println („Set pentru 3 / zi”); push1state = 0; push2state = 0; push3state = 1; pushVal = 11; pauză; }

Această declarație este utilizată pentru a obține milis-urile folosite pentru sincronizarea și controlul ciclului de ecran de interval definit.

currentMillisLCD = millis (); // porniți milis pentru comutarea ecranului LCD la un interval de timp definit

Începeți să citiți pinii digitali conectați la butoane.

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

Funcția de mai jos este utilizată pentru a citi starea butonului și a o scrie în EEPROM. De fiecare dată când butonul este apăsat, starea este scrisă în EEPROM. De asemenea, imprimă mesajul pe afișajul LCD al opțiunii de intrare selectate de utilizator. În mod similar sunt utilizate funcțiile push2 () și push3 () .

void push1 () {// funcție pentru a seta memento o dată / zi dacă (push1state == 1) { push1state = 0; push2state = 0; push3state = 0; // pushPressed = adevărat; EEPROM.write (addr, 1); Serial.print ("Push1 Scris:"); Serial.println (EEPROM.read (addr)); // pentru depanare pushVal = 1; // salvați starea butonului-1 lcd.clear (); lcd.setCursor (0, 0); lcd.print („Set de memento”); lcd.setCursor (0, 1); lcd.print („pentru O dată / zi!”); întârziere (1200); lcd.clear (); } }

Funcția de mai jos este utilizată pentru a opri soneria și ledul. Este întotdeauna bine să dai sugestii. Imprimați un mesaj de sugestie pe ecran „Luați medicamente cu apă caldă”.

void stopPins () {// funcție pentru a opri buzzing atunci când utilizatorul apasă butonul stop stop dacă (stopinState == 1) { // stopinState = 0; // pushPressed = adevărat; presat = 1; lcd.clear (); lcd.setCursor (0, 0); lcd.print („Ia medicamente”); lcd.setCursor (0, 1); lcd.print („cu apă caldă”); întârziere (1200); lcd.clear (); } }

Funcția de mai jos este independentă de menținerea timpului, dar întotdeauna se deplasează în trei ecrane, ceea ce ajută utilizatorul. Deoarece păstrăm îngrijirea pacienților, putem să imprimăm un mesaj de salut, deoarece știm că sprijinul emoțional este foarte util în vindecarea pacienților într-un timp mai rapid. Puteți alege propriul mesaj creativ. Să imprimăm un mesaj ca „Rămâi sănătos, vindecă-te curând”.

Al doilea ecran este pentru a oferi instrucțiuni pacienților sub forma „Apăsați butoanele pentru memento..”. Al treilea ecran este utilizat pentru a arăta pur și simplu data și ora curente.

void changeScreen () {// funcție pentru Screen Cycling // Începeți să comutați ecranul la fiecare interval definit LCD dacă (currentMillisLCD - previousMillisLCD> intervalLCD) // salvați ultima dată când ați schimbat afișajul { previousMillisLCD = currentMillisLCD; ecrane ++; if (ecrane> maxScreen) { ecrane = 0; // toate ecranele peste -> începe de la primul } isScreenChanged = true; } // Începeți afișarea ecranului curent dacă (isScreenChanged) // actualizați ecranul numai dacă ecranul este modificat. { isScreenChanged = false; // reset pentru următorul comutator de iterație (ecrane) { case getWellsoon: gwsMessege (); // primeste-te curand mesaj pauză; caz HELP_SCREEN: helpScreen (); // pauză de ecran de instrucțiuni ; caz TIME_SCREEN: timeScreen (); // pentru a tipări pauza de dată și oră ; implicit: // NOT SET. pauză; } } }

Această funcție este utilizată pentru a începe să bâzâie și să clipească simultan LED-ul dacă a ajuns timpul selectat.

void startBuzz () {// funcție pentru a începe buzzing când timpul ajunge la intervalul definit // if (pushPressed == false) { if (pushpressed == 0) { Serial.println ("pushpressed este fals în clipire"); curent lung nesemnat Millis = millis (); if (currentMillis - previousMillis> = interval) { previousMillis = currentMillis; // salvați ultima dată când ați clipit LED-ul Serial.println („Start Buzzing”); if (ledState == LOW) {// dacă LED-ul este stins, porniți-l și invers: ledState = HIGH; } else { ledState = LOW; } digitalWrite (ledPin, ledState); } } else if (pushpressed == 1) { Serial.println ("pushpressed este adevărat"); ledState = LOW; digitalWrite (ledPin, ledState); } }

Această funcție este utilizată pentru a compara intervalul de timp selectat de utilizator la 8am și începe să bâzâie buzzerul și să clipească LED-ul până când utilizatorul apasă butonul de oprire. În mod similar, funcțiile void at2pm () și void at8pm sunt utilizate pentru a porni buzzer-ul și a condus la 14:00 și 20:00.

void at8am () {// funcție pentru a începe buzzing la 8am DateTime acum = rtc.now (); if (int (now.hour ())> = buzz8amHH) { if (int (now.minute ())> = buzz8amMM) { if (int (now.second ())> buzz8amSS) { ////// //////////////////////////////////////////////// startBuzz (); ////////////////////////////////////////////////////// /// } } } }

Acesta este modul în care vă puteți crea pur și simplu propriul memento automat de medicină folosind Arduino. De asemenea, puteți utiliza ESP8266 cu Arduino pentru a face din acesta un proiect IoT care va putea trimite alerte de e-mail utilizatorului.

Codul complet și videoclipul demonstrativ sunt prezentate mai jos.