Promemoria automatico della medicina utilizzando arduino

Quando si tratta dei nostri cari, vogliamo sempre mantenerli sani e in forma. Ma cosa succederà se si ammalano e dimenticano di prendere le medicine in tempo. Saremmo preoccupati, vero? Negli ospedali ci sono molti pazienti ed è difficile ricordare a ogni paziente di prendere le medicine in tempo. I metodi tradizionali richiedono sforzi umani per ricordare loro di prendere le medicine in tempo. L'era digitale non segue quello e possiamo usare le macchine per farlo. L'applicazione di Smart Medicine Reminder è molto ampia e può essere utilizzata dai pazienti a casa, dai medici negli ospedali e in molti altri luoghi. Quando si tratta di ricordare, ci possono essere molti modi per ricordarlo:

1. Mostralo su un display
2. Invia notifica tramite e-mail o telefono
3. Utilizzo di app mobili
4. Buzz alarm
5. Utilizzando Bluetooth / Wi-Fi
6. Ricevi una chiamata
7. Ricorda l'ora della prossima medicina mentre ti ricordi l'ora attuale

Possiamo combinare modi a seconda delle necessità. Per semplificare le cose qui abbiamo creato un semplice Promemoria per le medicine usando Arduino che ci ricorda di prendere medicine 1 o 2 o 3 volte al giorno. La fascia oraria può essere selezionata tramite pulsanti. Inoltre, mostra la data e l'ora correnti. Lo estenderemo ulteriormente agli articoli in arrivo di un progetto IoT in cui verrà inviata all'utente una notifica e-mail o SMS. Questo promemoria farmaco può anche essere integrato con il sistema di monitoraggio del paziente.

Componenti necessari per il promemoria della medicina automatica utilizzando Arduino

1. Arduino Uno (possiamo usare anche altre schede Arduino, come Pro mini, Nano)
2. Modulo RTC DS3231
3. Display LCD 16x2
4. Cicalino
5. Led (qualsiasi colore)
6. Breadboard
7. Premi i pulsanti
8. Potenziometro 10K
9. Resistori 10K, 1K
10. Cavi per ponticelli

Promemoria Arduino Medicine utilizzando il circuito Arduino

Di seguito è mostrato lo schema circuitale completo per costruire una scatola di medicinali intelligenti utilizzando Arduino

Di seguito sono riportati i collegamenti dei pin di Arduino con diverse periferiche

Pin Arduino Pin periferici

• 2 -----------------------------> D7 del display LCD 16x2
• 3 -----------------------------> D6 di display LCD 16x2
• 4 -----------------------------> D5 del display LCD 16x2
• 5 -----------------------------> D4 di display LCD 16x2
• 7 -----------------------------> 3 ° pulsante
• 8 -----------------------------> 2 ° pulsante
• 9 -----------------------------> 1 ° pulsante
• 11 -----------------------------> Pin EN del display LCD 16x2
• 12 -----------------------------> Pin RS del display LCD 16x2
• 13 -----------------------------> + Ve Pin di Buzzer e Led
• A0 -----------------------------> Pulsante di arresto
• A4 -----------------------------> SDA di DS3231
• A5 -----------------------------> SCL di DS3231
• 3,3 V -----------------------------> Vcc di DS3231
• Gnd -----------------------------> Gnd

In questo Medicine Reminder Project, RTC DS3231 è interfacciato tramite protocollo I2C con Arduino Uno. Puoi anche usare RTC IC DS1307 per leggere l'ora con Arduino. RTC DS3231 ha anche una memoria incorporata da 32k che può essere utilizzata per memorizzare dati aggiuntivi. Il modulo RTC è alimentato tramite il pin 3.3V di Arduino uno. Un display LCD 16x2 è interfacciato tramite SPI. Una buzze r viene utilizzata per avvisare e ricordare che è ora di prendere medicine. Quattro pulsanti vengono utilizzati dove ciascuno ha una caratteristica di selezione distinta. Il primo pulsante serve per ricordare di prendere la medicina una volta al giorno. Il secondo pulsante viene utilizzato per ricordare due volte al giorno e il terzo pulsante viene utilizzato per ricordare tre volte al giorno. Il quarto pulsante viene utilizzato per interrompere il cicalino quando l'utente ha sentito l'allarme.

Funzionamento del sistema automatico di promemoria della medicina

L' allarme promemoria pillola è alimentato tramite alimentazione a 5V. Quando si avvia per la prima volta, mostra un messaggio di benvenuto come " Welcome to Circuit Digest ". Lo schermo LCD è impostato per scorrere in tre schermate. Il 1 ^st spettacoli schermo massaggio come “ rimanere in buona salute, Get Well Soon ”. La seconda schermata è una schermata di aiuto che dice di premere il pulsante di selezione per selezionare una qualsiasi fascia oraria da ricordare (una / due / tre volte in un giorno). La fascia oraria è modificabile nel programma e può essere configurata di conseguenza. In questo momento lo abbiamo fissato in tre durate, ovvero 8:00, 14:00 e 20:00.

Abbiamo diviso le fasce orarie in tre modalità. La modalità 1 seleziona di prendere la medicina una volta al giorno alle 8 del mattino quando l'utente preme il ^primo pulsante. La modalità 2 seleziona di prendere la medicina due volte al giorno alle 8:00 e alle 20:00 quando l'utente preme il 2 ^° pulsante. La modalità 3 seleziona di prendere la medicina tre volte al giorno alle 8:00, alle 14:00 e alle 20:00 se l'utente preme il 3 ^° pulsante.

Possiamo anche aggiungere una funzione per posticipare il cicalino per 10 minuti (non inclusa in questo progetto). Quando l'utente seleziona gli slot desiderati premendo i pulsanti, l'input dell'utente viene registrato e l'ora viene presa da RTC. Quando l'ora corrisponde alla fascia oraria selezionata, il cicalino inizia a suonare. L'utente può arrestare il cicalino premendo il pulsante STOP. Lo stesso processo continua per il promemoria dello slot successivo. Il processo completo è mostrato nel video fornito alla fine di questo articolo.

Programmazione di Arduino UNO per Medicine Reminder

È molto facile scrivere un programma una volta che hai pensato ai modi per ricordare di prendere le pillole. Qui mostrerà il promemoria sul display, suonerà un cicalino e lo indicherà tramite LED. Ha anche la possibilità di selezionare tre fasce orarie (una / due / tre volte al giorno) e quando il tempo lo raggiungerà inizierà ad avvisare il paziente suonando il cicalino. Quindi l'intero sistema apparirà come segue:

L'utente riceve istruzioni di aiuto sul display> L'utente seleziona le fasce orarie (una volta / giorno, due volte / giorno, tre volte / giorno)> Stampa messaggio di conferma sul display> Cronometraggio avviato> Buzzer e LED si accendono quando l'ora corrisponde allo slot selezionato dall'utente> L'utente si ferma per premendo un pulsante di arresto> Fine

Possiamo cambiare il programma e l'hardware se vogliamo aggiungere più funzionalità. Per capire in modo molto più semplice, abbiamo suddiviso il programma in piccole funzioni. Le funzioni sono facili da capire e implementare. Il programma completo è fornito alla fine di questo progetto. Cominciamo con il programma.

Da allora, abbiamo utilizzato altre periferiche come il display LCD 16x2, RTC DS3231, quindi dobbiamo prima includere le librerie per quello. Le librerie richieste sono le seguenti:

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

La libreria EEPROM viene utilizzata per tenere traccia dell'input selezionato dall'utente se Arduino non è acceso. E quando l'utente accende Arduino, ottiene lo stato precedente dei pulsanti utilizzando la libreria EEPROM. La libreria Wire.h viene utilizzata poiché il modulo RTC DS3231 viene comunicato tramite I2C.

Controllare sempre se l'RTC è cablato correttamente o non è danneggiato, poiché l'RTC svolgerà un ruolo importante nel controllo dell'ora dell'intero sistema di promemoria.

if (! rtc.begin ()) {// controlla se rtc è connesso Serial.println ("Couldn't find RTC"); mentre (1); } if (rtc.lostPower ()) { Serial.println ("RTC ha perso potenza, impostiamo l'ora!"); }

La regolazione dell'ora può essere eseguita in due modi, automaticamente utilizzando l'ora di compilazione del sistema o inserendola manualmente. Dopo aver impostato l'ora, commentare le righe seguenti a meno che non si desideri modificare nuovamente l'ora dell'RTC.

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

Questa istruzione switch viene utilizzata per leggere lo stato salvato in precedenza del pulsante e riprendere lo stato per un tempo di promemoria appropriato e preciso.

val2 = EEPROM.read (addr); // legge il valore precedentemente salvato del pulsante per ricominciare da dove era stato lasciato in precedenza switch (val2) { case 1: Serial.println ("Set for 1 / day"); push1state = 1; push2state = 0; push3state = 0; pushVal = 01; rompere; caso 2: Serial.println ("Set for 2 / day"); push1state = 0; push2state = 1; push3state = 0; pushVal = 10; rompere; caso 3: Serial.println ("Set for 3 / day"); push1state = 0; push2state = 0; push3state = 1; pushVal = 11; rompere; }

Questa istruzione viene utilizzata per ottenere i millisecondi da utilizzare per la temporizzazione e il controllo del ciclo della schermata dell'intervallo definito.

currentMillisLCD = millis (); // avvia millisecondi per la commutazione dello schermo LCD a un intervallo di tempo definito

Inizia a leggere i pin digitali collegati ai pulsanti.

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

La funzione sottostante viene utilizzata per leggere lo stato del pulsante e scriverlo su EEPROM. Ogni volta che il pulsante viene premuto, lo stato viene scritto nella EEPROM. Inoltre stampa il messaggio sul display LCD della scelta di input dell'utente selezionato. Allo stesso modo vengono utilizzate le funzioni push2 () e push3 () .

void push1 () {// funzione per impostare il promemoria una volta al giorno if (push1state == 1) { push1state = 0; push2state = 0; push3state = 0; // pushPressed = true; EEPROM.write (addr, 1); Serial.print ("Push1 Written:"); Serial.println (EEPROM.read (addr)); // per il debug pushVal = 1; // salva lo stato di push button-1 lcd.clear (); lcd.setCursor (0, 0); lcd.print ("Promemoria impostato"); lcd.setCursor (0, 1); lcd.print ("for Once / day!"); ritardo (1200); lcd.clear (); } }

La funzione sottostante viene utilizzata per interrompere il cicalino e il led. È sempre bene dare suggerimenti. Stampa un messaggio di suggerimento sul display “Assumere medicine con acqua calda”.

void stopPins () {// funzione per interrompere il ronzio quando l'utente preme il pulsante di arresto if (stopinState == 1) { // stopinState = 0; // pushPressed = true; premuto = 1; lcd.clear (); lcd.setCursor (0, 0); lcd.print ("Take Medicine"); lcd.setCursor (0, 1); lcd.print ("con acqua calda"); ritardo (1200); lcd.clear (); } }

La funzione seguente è indipendente dal cronometraggio, ma scorre sempre in tre schermate che aiutano l'utente. Dato che stiamo mantenendo una cura per i pazienti, stampiamo un messaggio di saluto poiché sappiamo che il supporto emotivo è molto utile per guarire i pazienti in tempi più rapidi. Puoi scegliere il tuo messaggio creativo. Diamo stampare un messaggio come “rimanere in buona salute, Guarisci presto”.

La seconda schermata serve per dare istruzioni ai pazienti come "Premere i pulsanti per il promemoria..". La terza schermata viene utilizzata per mostrare semplicemente la data e l'ora correnti.

void changeScreen () {// funzione per Screen Cycling // Avvia il cambio di schermata ogni intervalloLCD definito if (currentMillisLCD - previousMillisLCD> intervalLCD) // salva l'ultima volta che hai cambiato il display { previousMillisLCD = currentMillisLCD; schermi ++; if (schermi> maxScreen) { schermi = 0; // tutte le schermate sopra -> iniziano dal primo } isScreenChanged = true; } // Inizia a visualizzare lo schermo corrente se (isScreenChanged) // aggiorna lo schermo solo se lo schermo è cambiato. { isScreenChanged = false; // reimposta per la prossima iterazione cambia (schermate) { case getWellsoon: gwsMessege (); // guarisci presto messaggio rompere; case HELP_SCREEN: helpScreen (); // interruzione della schermata delle istruzioni ; case TIME_SCREEN: timeScreen (); // per stampare la data e l' intervallo di tempo ; predefinito: // NON IMPOSTATO. rompere; } } }

Questa funzione viene utilizzata per avviare il ronzio e il lampeggio simultaneo del LED se è stato raggiunto il tempo selezionato.

void startBuzz () {// funzione per avviare il ronzio quando il tempo raggiunge l'intervallo definito // if (pushPressed == false) { if (pushpressed == 0) { Serial.println ("pushpressed is false in blink"); currentMillis lungo senza segno = millis (); if (currentMillis - previousMillis> = intervallo) { previousMillis = currentMillis; // salva l'ultima volta che hai fatto lampeggiare il LED Serial.println ("Start Buzzing"); if (ledState == LOW) {// se il LED è spento accenderlo e viceversa: ledState = HIGH; } altro { ledState = LOW; } digitalWrite (ledPin, ledState); } } else if (pushpressed == 1) { Serial.println ("pushpressed is true"); ledState = LOW; digitalWrite (ledPin, ledState); } }

Questa funzione viene utilizzata per confrontare la fascia oraria selezionata dall'utente alle 8 del mattino e inizia a suonare il cicalino e a far lampeggiare il LED fino a quando l'utente non preme il pulsante di arresto. Allo stesso modo le funzioni void at2pm () e void at8pm vengono utilizzate per avviare il buzzer e il led alle 14:00 e alle 20:00.

void at8am () {// funzione per iniziare a ronzare alle 8:00 DateTime adesso = rtc.now (); if (int (now.hour ())> = buzz8amHH) { if (int (now.minute ())> = buzz8amMM) { if (int (now.second ())> buzz8amSS) { ////// /////////////////////////////////////////////// startBuzz (); ////////////////////////////////////////////////// /// } } } }

È così che puoi semplicemente creare il tuo promemoria automatico di medicina usando Arduino. Puoi anche utilizzare ESP8266 con Arduino per renderlo un progetto IoT che sarà in grado di inviare avvisi e-mail all'utente.

Di seguito vengono forniti il codice completo e il video dimostrativo.