Recordatorio automático de medicamentos usando arduino

Cuando se trata de nuestros seres queridos, siempre queremos mantenerlos sanos y en forma. Pero, ¿qué pasará si se enferman y se olvidan de tomar los medicamentos a tiempo? Estaríamos preocupados, ¿verdad? En los hospitales, hay muchos pacientes y es difícil recordar a todos los pacientes que deben tomar los medicamentos a tiempo. Las formas tradicionales requieren esfuerzos humanos para recordarles que deben tomar los medicamentos a tiempo. La era digital no sigue eso y podemos usar máquinas para hacer eso. La aplicación de Smart Medicine Reminder es muy amplia y puede ser utilizada por pacientes en casa, médicos en hospitales y en muchos otros lugares. Cuando se trata de recordar, puede haber muchas formas de recordarlo:

1. Muéstralo en una pantalla
2. Enviar notificación por correo electrónico o teléfono
3. Usando aplicaciones móviles
4. Alarma de zumbido
5. Usando Bluetooth / Wi-Fi
6. Recibir una llamada
7. Recordar la hora del próximo medicamento mientras se recuerda la hora actual

Podemos combinar formas dependiendo de la necesidad. Para simplificar las cosas, hicimos un recordatorio de medicamentos simple usando Arduino que nos recuerda que debemos tomar medicamentos 1 o 2 o 3 veces al día. La franja horaria se puede seleccionar mediante pulsadores. Además, muestra la fecha y hora actuales. Lo ampliaremos aún más a los artículos entrantes de un proyecto de IoT donde se enviará una notificación por correo electrónico o SMS al usuario. Este recordatorio de medicación también se puede integrar con el sistema de monitorización de pacientes.

Componentes necesarios para el recordatorio de medicina automática con Arduino

1. Arduino Uno (también podemos usar otras placas Arduino, como Pro mini, Nano)
2. Módulo RTC DS3231
3. Pantalla LCD 16x2
4. Zumbador
5. Led (cualquier color)
6. Tablero de circuitos
7. Apretar botones
8. Potenciómetro 10K
9. Resistencias 10K, 1K
10. Cables de puente

Recordatorio de medicina Arduino usando el circuito Arduino

El diagrama de circuito completo para construir una caja de medicina inteligente usando Arduino se muestra a continuación

A continuación se muestran las conexiones de pines de Arduino con diferentes periféricos

Pines periféricos de Arduino

• 2 -----------------------------> D7 de pantalla LCD 16x2
• 3 -----------------------------> D6 de pantalla LCD 16x2
• 4 -----------------------------> Pantalla LCD D5 de 16x2
• 5 -----------------------------> Pantalla LCD D4 de 16x2
• 7 -----------------------------> 3er pulsador
• 8 -----------------------------> 2do pulsador
• 9 -----------------------------> 1er pulsador
• 11 -----------------------------> Pin EN de la pantalla LCD 16x2
• 12 -----------------------------> Pin RS de pantalla LCD 16x2
• 13 -----------------------------> Pin + Ve de Zumbador y Led
• A0 -----------------------------> Botón de parada
• A4 -----------------------------> SDA de DS3231
• A5 -----------------------------> SCL de DS3231
• 3,3 V -----------------------------> Vcc de DS3231
• Gnd -----------------------------> Gnd

En este Proyecto de recordatorio de medicina, RTC DS3231 se interconecta a través del protocolo I2C con Arduino Uno. También puede usar RTC IC DS1307 para leer la hora con Arduino. El RTC DS3231 también tiene una memoria incorporada de 32k que se puede usar para almacenar datos adicionales. El módulo RTC se alimenta a través del pin 3.3V de Arduino uno. Una pantalla LCD de 16x2 se interconecta mediante SPI. Se usa un buzze r para alertar y recordar que es hora de tomar medicamentos. Se utilizan cuatro botones donde cada uno tiene una función de selección distinta. El primer botón se utiliza para recordar que debe tomar el medicamento una vez al día. El segundo botón se usa para recordar dos veces al día y el tercer botón se usa para recordar tres veces al día. El cuarto botón se usa para detener el timbre cuando el usuario ha escuchado la alerta.

Funcionamiento del sistema de recordatorio automático de medicamentos

La alarma de recordatorio de píldora se alimenta con un suministro de 5V. Cuando se inicia por primera vez, muestra un masaje de bienvenida como " Bienvenido a Circuit Digest ". La pantalla LCD está configurada para alternar en tres pantallas. La ^primera pantalla muestra el masaje como " Manténgase saludable, recupérese pronto ". La segunda pantalla es una pantalla de ayuda que le dice que presione el botón de selección para seleccionar cualquier intervalo de tiempo para recordar (una / dos / tres veces en un día). El intervalo de tiempo se puede cambiar en el programa y se puede configurar en consecuencia. En este momento, lo hemos arreglado en tres duraciones, es decir, 8 a. M., 2 p. M. Y 8 p. M.

Hemos dividido las franjas horarias en tres modos. El modo 1 selecciona tomar el medicamento una vez al día a las 8 am cuando el usuario presiona el ^primer botón. Modo 2 selecciona a tomar la medicina dos veces / día a las 8 am y 20:00 cuando el usuario pulsa 2 ^nd pulsador. Modo 3 selecciona a tomar la medicina tres veces / día en si el usuario pulsa 3 las 8 am, 14:00 y 20:00 ^rd pulsador.

También podemos agregar una función para posponer el timbre durante 10 minutos (no incluido en este proyecto). Cuando el usuario selecciona las ranuras deseadas presionando botones pulsadores, la entrada del usuario se registra y el tiempo se toma del RTC. Cuando el tiempo coincide con el intervalo de tiempo seleccionado, el timbre comienza a sonar. El usuario puede detener el timbre presionando el botón STOP. El mismo proceso continúa para el siguiente recordatorio de ranura. El proceso completo se muestra en el video que se encuentra al final de este artículo.

Programación de Arduino UNO para recordatorio de medicina

Es muy fácil escribir un programa una vez que haya pensado en las formas de recordar tomar las píldoras. Aquí mostrará el recordatorio en pantalla, hará sonar un zumbador y lo indicará mediante LED. También tiene la opción de seleccionar tres franjas horarias (una / dos / tres veces por día) y cuando llegue el tiempo, comience a alertar al paciente haciendo sonar el timbre. Entonces todo el sistema se verá así:

El usuario recibe instrucciones de ayuda en la pantalla> El usuario selecciona las franjas horarias (una vez al día, dos veces al día, tres veces al día)> Imprime el mensaje de confirmación en la pantalla> Se inicia el cronometraje> El zumbador y el LED se inician cuando el tiempo coincide con el intervalo seleccionado por el usuario> El usuario se detiene presionando un botón de parada> Fin

Podemos cambiar el programa y el hardware si queremos agregar más funciones. Para entenderlo de una manera mucho más sencilla, hemos dividido el programa en pequeñas funciones. Las funciones son fáciles de entender e implementar. El programa completo se da al final de este proyecto. Comencemos con el programa.

Desde entonces, hemos utilizado otros periféricos como pantalla LCD de 16x2, RTC DS3231, por lo que primero tenemos que incluir bibliotecas para eso. La biblioteca requerida es la siguiente:

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

La biblioteca EEPROM se utiliza para realizar un seguimiento de la entrada seleccionada por el usuario si Arduino no está encendido. Y cuando el usuario enciende el Arduino, obtiene el estado anterior de los botones mediante la biblioteca EEPROM. La biblioteca Wire.h se utiliza ya que el módulo RTC DS3231 se comunica mediante I2C.

Siempre verifique si el RTC está correctamente cableado o no está dañado, ya que el RTC desempeñará un papel importante en el control del tiempo de todo el sistema de recordatorios.

if (! rtc.begin ()) {// compruebe si rtc está conectado Serial.println ("No se pudo encontrar RTC"); mientras (1); } if (rtc.lostPower ()) { Serial.println ("RTC perdió energía, ¡establezcamos la hora!"); }

El ajuste de la hora se puede realizar de dos maneras, ya sea automáticamente usando el tiempo de compilación del sistema o ingresándolo manualmente. Una vez que hayamos establecido la hora, comente las siguientes líneas a menos que desee volver a cambiar la hora del RTC.

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

Esta declaración de cambio se utiliza para leer el estado previamente guardado del botón pulsador y reanudar el estado para el tiempo de recordatorio apropiado y preciso.

val2 = EEPROM.read (addr); // leer el valor guardado anteriormente del botón pulsador para comenzar desde donde se dejó anteriormente switch (val2) { caso 1: Serial.println ("Establecer para 1 / día"); push1state = 1; push2state = 0; push3state = 0; pushVal = 01; romper; caso 2: Serial.println ("Establecer para 2 / día"); push1state = 0; push2state = 1; push3state = 0; pushVal = 10; romper; caso 3: Serial.println ("Establecer para 3 / día"); push1state = 0; push2state = 0; push3state = 1; pushVal = 11; romper; }

Esta declaración se utiliza para que los milis se utilicen para cronometrar y controlar el ciclo de pantalla de intervalo definido.

currentMillisLCD = millis (); // iniciar milisegundos para el cambio de pantalla LCD en un intervalo de tiempo definido

Empiece a leer los pines digitales conectados a los pulsadores.

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

La siguiente función se utiliza para leer el estado del botón pulsador y escribirlo en EEPROM. Siempre que se presiona el botón pulsador, el estado se escribe en EEPROM. También imprime el mensaje en la pantalla LCD de la opción de entrada de usuario seleccionada. De manera similar, se utilizan las funciones push2 () y push3 () .

void push1 () {// función para establecer un recordatorio una vez al día if (push1state == 1) { push1state = 0; push2state = 0; push3state = 0; // pushPressed = verdadero; EEPROM.write (dirección, 1); Serial.print ("Push1 Written:"); Serial.println (EEPROM.read (addr)); // para depurar pushVal = 1; // guarda el estado de push button-1 lcd.clear (); lcd.setCursor (0, 0); lcd.print ("Conjunto de recordatorios"); lcd.setCursor (0, 1); lcd.print ("¡una vez al día!"); retraso (1200); lcd.clear (); } }

La siguiente función se utiliza para detener el zumbador y el led. Siempre es bueno dar sugerencias. Imprima un mensaje de sugerencia en la pantalla "Tome medicamentos con agua tibia".

void stopPins () {// función para detener el zumbido cuando el usuario presiona el botón de parada if (stopinState == 1) { // stopinState = 0; // pushPressed = verdadero; presionar presionado = 1; lcd.clear (); lcd.setCursor (0, 0); lcd.print ("Tomar medicina"); lcd.setCursor (0, 1); lcd.print ("con agua tibia"); retraso (1200); lcd.clear (); } }

La siguiente función es independiente del cronometraje, pero siempre circula en tres pantallas, lo que ayuda al usuario. Mientras estamos cuidando a los pacientes, imprimamos un mensaje de saludo, ya que sabemos que el apoyo emocional es muy útil para curar a los pacientes en un tiempo más rápido. Puede elegir su propio mensaje creativo. Imprimamos un mensaje como "Manténgase saludable, recupere pronto".

La segunda pantalla es para dar instrucciones a los pacientes como "Pulsar botones para recordatorio…". La tercera pantalla se utiliza para mostrar simplemente la fecha y hora actuales.

void changeScreen () {// función para el ciclo de la pantalla // Iniciar el cambio de pantalla cada intervalo definidoLCD if (currentMillisLCD - previousMillisLCD> intervalLCD) // guardar la última vez que cambió la pantalla { previousMillisLCD = currentMillisLCD; pantallas ++; if (pantallas> maxScreen) { pantallas = 0; // todas las pantallas terminaron -> empezar desde la 1ª } isScreenChanged = true; } // Comienza a mostrar la pantalla actual si (isScreenChanged) // solo actualiza la pantalla si se cambia la pantalla. { isScreenChanged = false; // reiniciar para la próxima iteración cambiar (pantallas) { caso getWellsoon: gwsMessege (); // mensaje que te mejores pronto romper; case HELP_SCREEN: helpScreen (); // salto de pantalla de instrucciones ; case TIME_SCREEN: timeScreen (); // para imprimir la fecha y la hora ; predeterminado: // NO ESTABLECIDO. romper; } } }

Esta función se utiliza para iniciar el zumbido y el parpadeo del LED simultáneamente si se ha alcanzado el tiempo seleccionado.

void startBuzz () {// función para iniciar el zumbido cuando el tiempo llega al intervalo definido // if (pushPressed == false) { if (pushpressed == 0) { Serial.println ("pushpressed es falso en parpadeo"); currentMillis largo sin firmar = millis (); if (currentMillis - previousMillis> = intervalo) { previousMillis = currentMillis; // guarde la última vez que parpadeó el LED Serial.println ("Start Buzzing"); if (ledState == LOW) {// si el LED está apagado, enciéndalo y viceversa: ledState = HIGH; } else { ledState = LOW; } digitalWrite (ledPin, ledState); } } else if (pushpressed == 1) { Serial.println ("pushpressed es verdadero"); ledState = BAJO; digitalWrite (ledPin, ledState); } }

Esta función se utiliza para comparar el intervalo de tiempo seleccionado por el usuario a las 8 a. M. Y comienza a hacer sonar el zumbador y a hacer parpadear el LED hasta que el usuario presiona el botón de parada. De manera similar, las funciones void at2pm () y void at8pm se utilizan para iniciar el timbre y el led a las 2pm y 8pm.

void at8am () {// función para comenzar a sonar a las 8am DateTime now = rtc.now (); if (int (ahora.hora ())> = buzz8amHH) { if (int (ahora.minuto ())> = buzz8amMM) { if (int (ahora.segundo ())> buzz8amSS) { ////// ///////////////////////////////////////////////// startBuzz (); //////////////////////////////////////////////////// /// } } } }

Así es como puede simplemente crear su propio recordatorio automático de medicina usando Arduino. También puede usar ESP8266 con Arduino para convertirlo en un proyecto de IoT que podrá enviar alertas por correo electrónico al usuario.

El código completo y el video de demostración se muestran a continuación.