Compañero Inteligente para Alzheimer: Sistema de Alertas Basado en Arduino

Componentes y suministros

Arduino MKR1000	×1
Infineon Sensor Hub Nano	×1
Pantalla LCD Nokia 5110	×1
Módulo Bluetooth HC-05	×1
Protoboard (genérica)	×1
Cables jumper (genéricos)	×1
Interruptor pulsador 12mm SparkFun	×1
Zumbador (Buzzer)	×1
Transmisor FT1235 5W	×1
Receptor FT1236 5W	×1

Herramientas y máquinas necesarias

• Soldador (genérico)

Aplicaciones y servicios en línea

• Arduino IDE
• Blynk
• IFTTT Maker service

Sobre este proyecto

Estos datos citados directamente de la web de la Asociación de Alzheimer (tomados en septiembre 2017) son suficientes para dar una idea de los problemas que una persona atraviesa si ella o sus seres queridos tienen la enfermedad de Alzheimer.

Siendo un maker, pensé en esto y decidí que construiría un dispositivo wearable, un sistema que pueda ayudar tanto a pacientes como a cuidadores.

Este sistema debería ser capaz de realizar al menos las siguientes tareas:

• Recordar al paciente las tareas que debe realizar diariamente (medicación, ejercicio, etc.)
• Monitorear dónde está el paciente en la casa
• Alertar a los cuidadores en caso de emergencia de cualquier tipo
• Mostrar la hora (¡es un reloj, al fin y al cabo!)
• Debe ser portátil y fácil de usar, incluso para un paciente mayor
• El coste debe mantenerse al mínimo

Cuando vi el Sensor Hub Nano de Infineon, pareció un buen candidato para este proyecto, por su tamaño muy reducido y capacidades BLE. Con la detección de presión precisa, podría usarse para detectar si el paciente se ha caído y también decir exactamente dónde está el paciente en la casa.

Usaré las siguientes partes para el proyecto básico para que funcione:

• Sensor Hub Nano de Infineon
• Arduino MKR1000
• Módulo Bluetooth HC-05
• Pantalla Nokia 5110

Sabrás a qué me refiero con "proyecto básico" cuando leas la sección 'Personalizando el Asistente de Alzheimer'.

Cómo funciona

En esta sección, describiré brevemente cómo funciona el reloj y describiré los pasos que tenemos que seguir para hacerlo funcionar.

La placa de evaluación Sensor Hub Nano de Infineon tiene un sensor barométrico de presión DPS310, que envía sus datos a través de la placa de evaluación vía Bluetooth. Los valores de presión, altitud y temperatura pueden verse en la app de Android de Infineon (descarga aquí) así como en el software de evaluación SES2G. Los usuarios también pueden construir aplicaciones para Android con la librería que Infineon proporciona, basada en sus propios requerimientos.

Puedes encontrar más información sobre el Sensor Hub Nano aquí.

Pero, quiero que el Asistente de Alzheimer funcione sin un teléfono Android de por medio. Debe ser un wearable que funcione por sí mismo, y también tenga la capacidad de conectarse a un smartphone para ver los datos del sensor. Así que decidí usar una placa Arduino MKR1000 por su factor de forma pequeño y capacidad WiFi, y conectarla de algún modo al Sensor Hub Nano.

Este es el pinout del Arduino MKR1000 que te será útil:

Tenía un módulo Bluetooth HC-05, y tuve que usarlo para la conexión entre el Arduino MKR1000 y el Sensor Hub Nano. Pero primero, necesitamos conectar correctamente el HC-05 a los pines Tx y Rx de hardware del Arduino, teniendo en cuenta los niveles lógicos. Mi módulo Bluetooth trabaja a 3.3V, que es lo mismo que el MKR1000, así que no hubo necesidad de ningún conversor de nivel. Pero si tu módulo Bluetooth trabaja a 5V, puede que necesites usar un conversor de nivel similar al que se muestra.

Después de igualar los niveles de voltaje, necesitamos emparejar el HC-05 con el Sensor Hub Nano para iniciar la comunicación de datos entre ellos, y encontrar una forma fácil de que se emparejen automáticamente cada vez que el Sensor Hub Nano entre en rango Bluetooth del HC-05.

Para hacer eso, pensé en configurar el HC-05 para actuar como dispositivo Bluetooth 'maestro', y emparejarlo solo con una dirección MAC específica: la del Sensor Hub Nano. Así, tras configurarlo así, una vez enciendes el HC-05, busca un dispositivo con una dirección MAC específica (la del Sensor Hub Nano), y se empareja automáticamente con él, dejando al usuario el envío y recepción de datos.

Esto se hace usando comandos AT para el HC-05 y se cubre en la sección "Configurando el Módulo Bluetooth".

Nota: He adjuntado un documento que encontré online, que lista todos los comandos AT que el HC-05 soporta, así que úsalos según necesites.

Una vez emparejado y conectado correctamente, enviar comandos al Sensor Hub Nano es como un terminal Bluetooth. Puedes usar los comandos que especifiqué arriba simplemente imprimiéndolos como String, a través del puerto serial de hardware al que está conectado el HC-05. Por ejemplo, este es el comando que enviarás para iniciar el flujo de datos del sensor:

$start_sensor id=1 // Para iniciar el flujo de datos del sensor

Aquí hay una lista de los comandos que conozco:

$hello id= // Hola
$info id= // Info
$sinfo id=1 // Info Sensor
$set_mode sid=1;md=mode;val=bg // Bajo consumo
$set_mode sid=1;md=prs_osr;val=16 // Modo estándar
$set_mode sid=1;md=prs_mr;val=32 // Alta precisión
$start_sensor id=1 // Iniciar
$stop id= // Parar

Los datos del sensor que vienen del Sensor Hub Nano están en este formato:

$1,t,36.9299,1154206 // Temperatura
$1,p,997.6813,1154206 // Presión
$1,a,130.4305,1154206 // Altitud

Nota: Me gustaría dar referencia al post del blog de Peter Smith, que me ayudó a iniciar la comunicación con el Sensor Hub Nano usando Bluetooth.

Una vez que podemos iniciar el flujo de datos del módulo, necesitamos una forma de parsear los datos de él. Este fue, debo admitir, la parte más dura del proyecto; una vez envías el comando para iniciar el flujo de datos, el Sensor Hub Nano solo envía un flujo de datos, dejando al dispositivo receptor parsear algo sensato. Así que, tras probar muchos métodos de variada complejidad (que no repasaré aquí), este fue el método más simple y eficiente que se me ocurrió para parsear datos del Sensor Hub Nano.

void getSensorValues() {
  // Recupera los valores del sensor del Sensor Hub Nano a través del puerto Serial1
  String junkVal;
  if (Serial1.available()) {
    junkVal = Serial1.readStringUntil('\n');
    junkVal = Serial1.readStringUntil('t');
    t = Serial1.parseFloat();
    junkVal = Serial1.readStringUntil('p');
    p = Serial1.parseFloat();
    junkVal = Serial1.readStringUntil('a');
    a = Serial1.parseFloat();
    junkVal = Serial1.readStringUntil('\n');
  }
}

Una pantalla también se conectará al Arduino para interactuar con el usuario, y mostrar cualquier mensaje, o la hora o los datos del sensor (más sobre esto conforme sigas leyendo).

Una vez obtienes los datos en el Arduino MKR1000, gracias a su conectividad inalámbrica, puedes enviar los datos a varias plataformas IoT diferentes, como Cayenne o Blynk.

Había decidido usar Cayenne para esto, ya que me impresionó su bonita interfaz y fácil configuración. Pero, tristemente, tenía algunos bugs con la conexión WiFi del MKR1000 que impedían seleccionar pines. Debería mencionar que la gente de Cayenne fue muy servicial, pero el problema no se resolvió. Por tanto, decidí usar Blynk al final, pero son muy similares en uso, así que cambiando solo unas líneas de código Arduino, puedes cambiar de Blynk a Cayenne si quieres probarlo o una vez resuelto el problema. Ambos tienen más o menos las mismas características, así que es solo preferencia personal. Pero la única ventaja de Cayenne es que puedes acceder desde PC también, mientras que Blynk solo funciona en smartphones.

Ahora, hemos recibido datos del Sensor Hub Nano, los hemos metido en el Arduino, y los hemos transferido a una plataforma IoT (diré Blynk a partir de ahora), y ahora solo necesitas personalizar el Asistente de Alzheimer según tus propias necesidades, y eso se trata en otra sección (detección de caídas y localización se discuten allí).

Nota: He intentado documentar cada paso en detalle, pero si no sabes algo (como subir código a tu Arduino), sería mejor idea ir a la página de inicio de Arduino, familiarizarte un rato y luego volver aquí, una vez sepas al menos lo básico.

Configurando el módulo Bluetooth

Lo primero que necesitas hacer es obtener la dirección MAC de tu Sensor Hub Nano Evaluation Kit. Hay muchas formas diferentes de hacerlo, pero te diré cómo lo hice yo.

Empareja el Sensor Hub Nano con tu smartphone:

Descarga la app de evaluación Sensor Hub Nano de Infineon (para Android) aquí y enciende tu Sensor Hub Nano. Abre la app, y mostrará el Sensor Hub Nano como "IFX_NANOHUB", con la dirección MAC debajo.

Anota esto, lo necesitarás después.

Nota: Sería mejor desemparejar el Sensor Hub Nano de tu smartphone si no lo estás usando ahora, porque si tu teléfono está cerca con Bluetooth activado y el Sensor Hub Nano emparejado, el teléfono se conecta automáticamente con él. Y cuando configures el HC-05 e intentes que se empareje con el Nano Hub, simplemente no conectará.

Poniendo el HC-05 en modo AT:

El modo AT nos permite configurar ajustes del módulo Bluetooth HC-05; establecer el baud rate o si conectar como dispositivo esclavo o maestro y más. Necesitaremos cambiar algunos ajustes para que el módulo pueda recuperar datos exitosamente del Sensor Hub Nano de Infineon.

Primero, sube el sketch "Comandos AT" al Arduino MKR1000. Esto nos permitirá dar comandos al módulo Bluetooth en modo AT, a través del Arduino MKR1000.

// Sketch original del blog de Martyn Currey aquí:
// https://www.martyncurrey.com/arduino-with-hc-05-bluetooth-module-at-mode/
//
// Sketch modificado por mí para funcionar con Arduino MKR1000!
//
// Sketch Bluetooth básico
// Conecta el módulo HC-05 y comunica usando el monitor serial
//
// El HC-05 por defecto entra en modo comunicación al encenderse.
// Necesita ser puesto en modo AT
// Tras un reset de fábrica, el baud rate por defecto para modo comunicación es 38400
char c = ' ';
void setup() {
  // iniciar comunicación serial con el host computer
  Serial.begin(9600);
  Serial.println("Arduino con HC-05 listo");
  // iniciar comunicación con HC-05 usando 38400
  Serial1.begin(38400);
  Serial.println("Serial1 iniciado a 38400");
}
void loop() {
  // Leer de HC-05 y enviar a Monitor Serial Arduino
  if (Serial1.available()) {
    c = Serial1.read();
    Serial.write(c);
  }
  // Leer de Monitor Serial Arduino y enviar a HC-05
  if (Serial.available()) {
    c = Serial.read();
    // espejar comandos de vuelta al monitor serial
    // facilita seguir los comandos
    Serial.write(c);
    Serial1.write(c);
  }
}

Luego conecta solo el módulo Bluetooth al Arduino MKR1000 siguiendo el diagrama.

Nota: Sería buena idea cablearlo todo primero en una protoboard, y pasar a cableado definitivo una vez lo hayas configurado bien.

Si intentas encender el Sensor Hub Nano y el HC-05, verás que no se conectan automáticamente en este momento. Esto es lo que verías:

Para cambiar los ajustes del HC-05, necesitarás poner tu módulo Bluetooth en modo AT. El método para hacer esto depende de qué breakout board tengas, así que puede que tengas que hacerlo diferente. Si tienes un módulo diferente al mío, ve al blog de Martyn Currey aquí donde encontrarás información detallada sobre cómo poner los módulos Bluetooth HC-05 en modo AT. Si estás atascado, busca en Google tu problema o comenta e intentaré ayudar.

Mi módulo Bluetooth tiene el interruptor de botón, así que tengo que hacer los siguientes pasos para ponerlo en modo comando AT (¡No olvides subir el código de comandos AT al Arduino!):

• Desconecta la alimentación del módulo. (¡Las líneas TX y RX siguen conectadas!)
• Presiona y mantén pulsado el botón del módulo
• Aplica alimentación manteniendo pulsado el botón
• Cuando el LED se encienda, suelta el interruptor

Un video mostrando cómo poner el HC-05 en modo AT:

Una vez en modo AT notarás una diferencia considerable en el patrón de parpadeos del LED en el HC-05. En modo comunicación, el LED parpadea rápido, unas 5 veces por segundo, mientras que en modo AT el LED parpadea una vez cada par de segundos.

Configurando el módulo HC-05:

Abre el monitor serial, pon baud rate a 9600 y selecciona "Both NL & CR".

Nota: Necesitarás ponerlo a newline y carriage return, o los comandos AT no funcionan.

Escribe "AT" en el monitor serial y deberías recibir un "OK". Si lo haces, puedes proceder y dar los comandos como hice yo.

Básicamente, necesitamos cambiar estos ajustes en modo AT:

• Borrar todos los dispositivos emparejados actualmente
• Hacer que se conecte solo a una dirección MAC Bluetooth especificada
• Poner modo de conexión Bluetooth a 'Maestro'
• Especificar la dirección MAC a la que necesita conectarse
• Poner baud rate a 115200, bit de parada a 2 bits y paridad par

Las instrucciones de arriba se dieron para que puedas usarlas incluso si tienes otro módulo Bluetooth, consultando los comandos y qué hacen. Pero ahora listaré los comandos que di para que el HC-05 se empareje con el Sensor Hub Nano.

• AT+RMAAD
• AT+CMODE=0
• AT+ROLE=1
• AT+BIND=1234,56,abcdef (Reemplaza con la dirección MAC del Sensor Hub Nano)
• AT+UART=115200,0,0

Aquí hay un registro de mis comandos AT para tu referencia:

Ahora deberías desconectar el Arduino para apagar el módulo Bluetooth. Esto lo devolverá al modo comunicación.

Nota: Si metes la pata en los ajustes del HC-05, sería buena idea resetear el módulo a ajustes por defecto y empezar desde cero con el comando: AT+ORGL

Probando la conexión:

Ahora, necesitarás probar si el último paso fue exitoso; puedes hacerlo encendiendo el Sensor Hub Nano. El LED azul parpadeará muy lento, una vez cada par de segundos. Luego, conecta tu Arduino a tu PC, y nota el cambio en los parpadeos del LED en ambos el HC-05 y el Sensor Hub Nano.

Mira el parpadeo ahora y compáralo con el de antes:

Hay una diferencia notable, y deberías darte cuenta de que ambos módulos están conectados. Ahora puedes pasar a la siguiente parte, cablear el proyecto y probarlo.

Nota: Si has emparejado tu smartphone con el Sensor Hub Nano antes, puede que tengas que desemparejarlo, si no causaría problemas de conexión. Solo puede conectarse a un dispositivo a la vez.

Probando el proyecto básico

Una vez confirmada una conexión correcta entre el HC-05 y el Sensor Hub Nano por los patrones de parpadeo del LED, pasa a configurar la app Blynk en el smartphone.

Configurando la app Blynk:

Descarga la app Blynk (si no la tienes ya) para tu dispositivo iOS o Android aquí, y escanea el código QR a través de la app Blynk. Replicará automáticamente los widgets básicos necesarios en este momento.

Verás una pantalla similar:

No hagas cambios aquí en este punto, y sigue leyendo.

Instalando las librerías requeridas:

Necesitarás tener dos librerías diferentes para el Arduino IDE instaladas para que el código compile sin errores. Son:

• Blynk, para conectarlo a tu smartphone
• u8g2lib, para la pantalla

Hay dos formas de instalar las librerías requeridas. La primera es a través del 'Gestor de librerías' disponible en versiones nuevas del Arduino IDE, y la segunda es instalación manual. Ambos métodos se describen en detalle aquí así que revisa el enlace ya que no pasaré por eso.

Subiendo el código y probando:

Una vez instaladas las librerías, descarga el código adjunto y haz algunos cambios. Necesitarás añadir tu código de autenticación de Blynk (que te envían por email cuando creas un nuevo proyecto en Blynk), así como tu SSID y contraseña WiFi. Una vez hecho, sube el código al MKR1000.

Después de subir el código, cablea el circuito según el esquemático.

Luego abre la app Blynk en tu smartphone, abre el proyecto Asistente de Alzheimer y pulsa el botón play. Conecta el MKR1000 (con el HC-05 y la pantalla cableados), y deberías ver el logo, Asistente de Alzheimer en la pantalla. Se quedará un momento y luego verás el mensaje "Esperando Sensor Hub Nano". Enciende el pequeño interruptor en el Sensor Hub Nano, asegurándote de que estás dentro del rango Bluetooth del módulo HC-05. Debería decir "Conectado al Sensor Hub Nano de Infineon", y tras unos segundos, deberías ver valores de presión, temperatura y altitud en tu smartphone.

Y tras unos segundos también verás la hora en formato 24 horas, así como la fecha, y eso se sincroniza con internet.

Este es un video probándolo:

Si es así, ¡enhorabuena, has completado la parte difícil de configurarlo, y ahora viene personalizarlo para pacientes individuales, según sus preferencias!

Personalizando el Asistente de Alzheimer

Hasta ahora, lo que hemos configurado recupera datos del sensor DPS310 de Infineon en una configuración limpia y elegante, pero para hacer algo útil de eso, tenemos que configurar el setup según requerimientos y preferencias individuales. Por tanto, en esta sección, hablaré sobre el código y cómo modificar el Asistente de Alzheimer para que funcione según la preferencia de cada usuario. Daré el fragmento de código para cada 'función' y podrás simplemente añadirlo en el código principal con pequeños cambios.

Nota: Cuando mires el código que adjunté para el 'proyecto básico', verás que usa funciones envueltas en BlynkTimer. Sería buena idea usarlas si quieres hacer cualquier personalización, ya que pueden realizar tareas a intervalos especificados, y también prevenir el error de flood de Blynk que ocurre cuando tu hardware envía muchas peticiones a Blynk. Además, el código es 'básico' en el sentido de que todas las funciones están presentes pero no incluidas en el código principal; el usuario tiene que editar el código principal según requerimiento, y puede que tenga que ajustar el intervalo de tiempo en que cada función se ejecuta.

El DPS310:-

El DPS310 de Infineon es un sensor barométrico digital de bajo coste que proporciona muy alta precisión, en un factor de forma muy pequeño. Por eso es perfecto para usar en este proyecto, y los valores pueden usarse para detectar caídas en un paciente mayor, o en qué habitación está exactamente el paciente.

Nota: No he hecho la carcasa del reloj inteligente aún, así que estoy usando el Sensor Hub Nano en mi mano, conectado con el Arduino vía Bluetooth, como en esta imagen:

Detección de caídas: Para detectar caídas, necesitaremos dar un valor de caída (la diferencia de presión aérea entre dos lecturas en un tiempo especificado), y configurar un margen. Por ejemplo, si el cambio de altitud entre dos valores sucesivos (en un tiempo de, digamos, un segundo) está entre el valor de caída ± el valor de margen, se detectará una caída.

He hecho un par de pruebas y encontré que el valor de caída debería ser 0.7, y el valor de margen ±0.2, pero pueden no funcionar en todas las situaciones. Esto se debe a una razón simple y entendible: cuando una persona se cae, puede ocurrir de muchas formas diferentes. Por tanto, el uso de un sensor secundario (probablemente un acelerómetro) será necesario para ganar más precisión en el sistema de detección de caídas, y eso se añadirá al trabajo futuro. Pero siempre podría ser posible que haya otros algoritmos más precisos para detectar caídas, y estoy abierto a oírlos; siéntete libre de comentar si tienes ideas sobre esto.

Un video demostrando detección de caídas:

Detectando dónde está el paciente: Esto funciona similar al algoritmo de detección de caídas. Por ejemplo, si necesitas saber en qué planta está el paciente, puedes tomar el valor de altitud actual y restarle el anterior. Y luego comparar la diferencia con un valor predefinido. Esto indicará en qué planta está el paciente.

Solo sería cuestión de usar lógica simple if/else para determinar en qué planta está el paciente (los valores de altitud ya están en el código principal). Eso podría indicarse usando los widgets LED en Blynk.

Nota: No he incluido la detección de localización en el código principal pero los usuarios pueden añadirla según necesiten, solo no olvides usarla como función de BlynkTimer.

La misma técnica podría usarse también para detectar en qué habitación está una persona. En ese caso, un sensor secundario como un sensor de movimiento sería necesario, si no podría haber muchos falsos positivos.

Temperatura: El DPS310 también muestra el valor de temperatura que podemos usar para alertar sobre cualquier percance que pueda pasarle al paciente, por ejemplo un incendio. Si la temperatura sube a un valor específico, digamos 45℃, alerta al cuidador.

Pero como el sensor DPS310 no está pegado directamente a la piel (al menos en este caso de uso), lo que obtenemos no es la temperatura corporal, sino que sería más exacto decir que es la temperatura del Sensor Hub Nano.

El código para esto es muy simple (úsalo en cualquier parte del loop principal) y podría ser algo así:

if (t > maxTemp) {
  // Haz lo que quieras si temperatura es mayor que máxima
}
else {
  // Haz lo que quieras si temperatura es menor que máxima
}

Nota: Todas las gráficas de arriba están creadas usando el software de evaluación SESG2 proporcionado por Infineon.

Un zumbador y un interruptor:-

No he mencionado esto antes, pero un zumbador y un interruptor también deberían estar presentes en el sistema y serán muy útiles. Por ejemplo, un zumbador podría usarse para atraer la atención del paciente, cuando sea hora de tomar medicina por ejemplo, y el interruptor podría usarse como dispositivo de seguridad.

Y como usaremos Blynk, el interruptor pulsador podría configurarse de forma que al pulsarlo, aparezca una notificación en el teléfono del cuidador o llame o envíe un SMS (eso se puede hacer usando IFTTT y se da más adelante). Este podría ser el fragmento de código para hacer eso:

void emailOnButtonPress()
{
  // *** ADVERTENCIA: ¡Estás limitado a enviar SOLO UN EMAIL CADA 15 SEGUNDOS! ***
  // Enviemos un email cuando pulses el botón
  // conectado al pin digital 2 en tu Arduino
  int isButtonPressed = !digitalRead(2); // Invertir estado, ya que el botón es "Active LOW"
  if (isButtonPressed) // Puedes escribir cualquier condición para disparar envío de email
  {
    Serial.println("Botón pulsado."); // Esto se ve en el Monitor Serial
    Blynk.email("tu_email@mail.com", "Asunto: Button Logger", "Acabas de pulsar el botón...");
    // O, si quieres usar el email especificado en la App (como para Exportar App):
    // Blynk.email("Asunto: Button Logger", "Acabas de pulsar el botón...");
  }
}

Está tomado del código de ejemplo de Blynk, y usa una interrupción para comprobar el botón. Esto podría usarse por el paciente para alertar al cuidador en cualquier emergencia, como una caída no detectada por el algoritmo de detección de caídas. Puedes obtener el código de ejemplo completo aquí, que envía un email una vez se pulsa un botón.

El zumbador podría usarse para producir tonos (usando el comando tone() de Arduino - más info aquí), para recordar al paciente una tarea como medicación o ejercicio.

La Pantalla:-

Una parte importante del proyecto, que el usuario realmente mira, es la pantalla. Las pantallas Nokia 5110 son comúnmente disponibles, fáciles de configurar y baratas, pero no son tan vistosas, especialmente en un sistema así. Las pantallas OLED con mayor resolución serán una muy buena alternativa, y puedes modificar fácilmente el código para que funcione con una porque usé la librería u8g2 (github aquí). Elige cualquiera de los modelos de pantalla aquí, y añádelo al inicio del sketch (quitando la línea de Nokia 5110, ¡por supuesto!). Tendrás que cablearlo según lo que esté en el código y listo. También puedes usar imágenes bitmap con una pantalla de mayor resolución. También puedes cambiar la fuente del texto en la pantalla, selecciona fuentes de la enorme lista aquí y edita el nombre de la fuente en el código.

Nota: Puede que tengas que cambiar las posiciones en píxeles para el texto en el código si usas una pantalla con mayor resolución.

Eso fue solo una breve descripción de la librería usada para hacer funcionar la pantalla. Pero ahora te diré cómo editar el código para que el Asistente de Alzheimer muestre la hora o los datos del Sensor Hub Nano (temperatura, altitud y presión).

Mostrando la hora: Para mostrar la hora, podrías simplemente usar un RTC (o módulo de mantenimiento de hora) pero como estamos conectados a internet, sería mucho más fácil usar internet para sincronizar la hora. Y como usamos Blynk, eso lo hace aún más simple. Solo necesitas el widget RTC en tu proyecto. Ahora con unas líneas de código, puedes recuperar automáticamente la hora del servidor Blynk (Asegúrate de configurar tu zona horaria desde el widget Blynk). El código principal está configurado para mostrar la hora por defecto (no los valores del sensor, discutidos a continuación).

Nota: La hora mostrada en la pantalla podría subir o bajar un minuto, ya que se sincroniza de internet, pero a pesar de eso, la he probado mucho tiempo y la he encontrado muy precisa (solo diferencia de unos segundos).

Mostrando los datos del Sensor Hub Nano: Podríamos mostrar también datos del Sensor Hub Nano en la pantalla. No que beneficie al paciente, pero es bueno para depuración, si lo necesitas. Eso se puede hacer con el siguiente fragmento:

void showSensorValues() {
  // Muestra los valores del sensor en la pantalla
  char bufT[10];
  char bufP[10];
  char bufA[10];
  String(t).toCharArray(bufT, 10);
  String(p).toCharArray(bufP, 10);
  String(a).toCharArray(bufA, 10);
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_6x10_tf );
  // Mostrar temperatura
  u8g2.drawStr(0, 10, "T:");
  u8g2.drawStr(12, 10, bufT);
  u8g2.drawStr(73, 10, "C");
  u8g2.drawCircle(70, 4, 1, U8G2_DRAW_ALL);
  u8g2.drawHLine(0, 12, 85);
  // Mostrar presión
  u8g2.drawStr(0, 26, "P:");
  u8g2.drawStr(12, 26, bufP);
  u8g2.drawStr(60, 26, "mBar");
  u8g2.drawHLine(0, 28, 85);
  // Mostrar altitud
  u8g2.drawStr(0, 42, "A:");
  u8g2.drawStr(12, 42, bufA);
  u8g2.drawStr(72, 42, "m");
  u8g2.drawHLine(0, 44, 85);
  // Enviar valores a la pantalla
  u8g2.sendBuffer();
}

No olvides ejecutar este comando para obtener los datos del sensor abajo:

getSensorValues();

Pero eso no es todo para la pantalla. Como dije al principio, el Asistente de Alzheimer debería poder recordar al paciente las tareas que deben hacerse diariamente, como cuándo tomar medicinas o recordar al paciente que haga ejercicio.

Usando widget Eventor para recordar:

Para eso, usaremos el widget Eventor (ver detalles) en Blynk.

Añade el widget Eventor a tu proyecto (ya está si escaneaste el código QR de arriba), y sigue las capturas para ver cómo configurarlo:

En el ejemplo de arriba, el widget Eventor se usa para configurar una notificación de detección de caída.

Usar el widget Eventor para recordar se hace con este código:

BLYNK_WRITE(vEVENTOR_PIN) {
  // Usa el widget Eventor para comprobar si es hora de hacer una tarea (tomar medicina en este caso)
  int currentValue = param.asInt(); // 0 a 1
  if (currentValue == 1) {
    // Haz aquí lo que quieras cuando sea hora de medicina
    showPillReminder();
    playBuzzerReminder();
    // Esto es solo un tono, no lo he puesto en el código principal, pero puedes si quieres!
  }
  else {
    // Si no es hora de medicina, no hagas nada
  }
}

Y el resultado en la pantalla cuando es hora de medicina:

Lo mismo para ejercicio:

Esto se hace escribiendo:

showExerciseReminder();

En vez de:

showPillReminder();

El widget Eventor podría, como se dijo arriba, usarse para varias cosas. Por ejemplo, podrías configurar que un aumento de temperatura resulte en enviar un email, ¡sin modificación de código!

Usando diferentes modos del Sensor Hub Nano:

Puedes probar el uso de diferentes modos para el Sensor Hub Nano. Usando los siguientes comandos:

sendCommand(LOW_ENERGY);
sendCommand(STANDARD_MODE);
sendCommand(HIGH_PRECISION);

Usar Blynk para cambiar modos podría ser más eficiente. Para eso, configura tu app Blynk así:

Como esto no tenía utilidad para mí, no lo añadí en el código principal, pero siempre podrías hacerlo según necesites (los comandos están presentes, solo necesitas añadirlos con un poco de lógica en el sketch principal).

Usando Blynk e IFTTT:

Blynk puede permitir que cualquier proyecto Arduino aproveche fácilmente el poder de IFTTT.

Esto es porque puedes usar Blynk para enviar una petición webhook al canal IFTTT Webhooks (antes llamado Maker channel), y podrías crear un applet IFTTT que espere a que el webhook sea disparado (desde el lado Blynk y Arduino) y hacer que dispare cualquier otra cosa en respuesta a eso.

Un ejemplo simple de cómo usar IFTTT y Blynk con webhooks:

El widget webhook de Blynk podría usarse para enviar una petición webhook así:

Este es el canal webhook de IFTTT:

Y usar webhooks para disparar IFTTT no es el único método. IFTTT también puede dispararse usando Blynk para enviar emails y tweets.

Ya has hecho un applet. Hora de probarlo.

Abre "Servicios" en IFTTT y luego selecciona "Webhooks". Ve a "Ajustes" y allí verás una URL. Copia esa y ábrela en una pestaña nueva. Allí, en vez de {event}, escribe el nombre del evento (que configuraste antes). Era "button_pressed" para mí, y así cuando pulso "Test it", este es el resultado tras unos segundos:

Ahora que has confirmado que el Webhook funciona, solo tienes que escribir la URL en los ajustes del webhook de Blynk y obtener una petición GET o POST (a través del widget webhook de Blynk).

Y, en vez de SMS, podrías usar igual de bien llamadas telefónicas, o incluso Twitter y Facebook, si quieres, y es igual de simple. Ese es el poder de IFTTT.

Es lo mismo que mi proyecto de controlador de casa inteligente aquí, y también lo discutí en detalle allí, pero es una cosa genial que no podía dejar de mencionar.

Toques finales

Para ahora, casi toda la parte electrónica del proyecto está completa, pero quedan algunas cosas. Sigue leyendo para ellas, y al final listaré el trabajo futuro que debería hacerse para mejorar este proyecto.

Batería y carga:

El MKR1000 tiene un puerto para batería LiPo, lo que significa que podrías conectar una. Pero no tengo una ahora así que no entraré en eso, pero deberías revisar la web del Arduino MKR1000 si necesitas info sobre eso.

Para cargar, tienes dos opciones, usando el puerto USB del MKR1000 directamente, y la otra es usar carga inalámbrica, si la tienes. Yo usaré la carga inalámbrica. Esto es porque ya tengo un receptor y transmisor de carga inalámbrica hechos por Futara Elettronica.

Para usar el receptor y transmisor, es solo cuestión de dar el voltaje especificado al transmisor. Eso será el 'dock', donde puedes colocar el Asistente de Alzheimer para cargar. En el lado del receptor, solo tendrás que cortar y conectar un cable USB micro B de repuesto (que va al puerto USB del MKR1000) y conectar el otro lado a VCC y ground mirando el pinout.

Mira las imágenes de abajo para ver cómo cablearlo:

Y el resultado final:

La Carcasa:

Como en todo proyecto, se requiere una carcasa para este también, y así es como pretendo que se vea el Asistente de Alzheimer:

Nota: No tengo aún el privilegio de una cortadora láser o impresora 3D, así que el archivo STL es solo para mostrar cómo se ve el proyecto final y no está a escala.

Esto concluye la documentación del Asistente de Alzheimer, pero aún me gustaría incluir la sección de trabajo futuro para describir las cosas que muy mucho quería hacer para el proyecto, pero no pude, por una razón u otra.

Trabajo futuro:

Como dije antes, estas son las cosas que quería incluir en el proyecto, que añadiré en el futuro, si consigo el tiempo:

• Hacer una carcasa adecuada. Ahora solo lo pruebo en protoboard pero si consigo acceso a cortadora láser o impresora 3D actualizaré la documentación con eso.
• Usar un módulo Bluetooth 4.0 en vez de este.
• O incluso mejor, usar solo el sensor DPS310 en vez del Sensor Hub Nano. Esto reduciría el coste del proyecto global, al eliminar el uso del Sensor Hub Nano y el módulo Bluetooth; el DPS310 en sí está disponible barato. Es cuestión de editar el código principal para obtener temperatura, presión y altitud del DPS310 solo, el resto está hecho.
• Usar un sensor secundario para trabajar junto con el DPS310 para detección de caídas y detección de localización. Esto reduciría la ocurrencia de tanto falsos positivos como falsos negativos. Probablemente se necesitará un acelerómetro y un detector de movimiento para ambos.
• Añadir un sensor de pulso. No tenía uno, así que no pude añadirlo. Debería ser una gran adición al proyecto.
• Usar una pantalla de mayor resolución, preferiblemente OLED. Con eso, también se podrían incluir gráficos y sería muy chulo.
• Trabajar en mejorar la duración de la batería del proyecto. Esto se puede hacer usando modo deep sleep en el MKR1000, pero no lo he usado en el código aún.

Gracias por leer, y espero que te haya gustado mi proyecto. Siéntete libre de darme tus opiniones e ideas sobre el proyecto.

Código

Comandos AT

// Sketch original del blog de Martyn Currey aquí: // https://www.martyncurrey.com/arduino-with-hc-05-bluetooth-module-at-mode/ //
// Sketch modificado por mí para funcionar con Arduino MKR1000! //
// Sketch Bluetooth básico
// Conecta el módulo HC-05 y comunica usando el monitor serial
//
// El HC-05 por defecto entra en modo comunicación al encenderse.
// Necesita ser puesto en modo AT
// Tras un reset de fábrica el baud rate por defecto para modo comunicación es 38400
char c = ' ';
void setup() {
  // iniciar comunicación serial con el host computer
  Serial.begin(9600);
  Serial.println("Arduino con HC-05 listo");
  // iniciar comunicación con HC-05 usando 38400
  Serial1.begin(38400);
  Serial.println("Serial1 iniciado a 38400");
}
void loop() {
  // Leer de HC-05 y enviar a Monitor Serial Arduino
  if (Serial1.available()) {
    c = Serial1.read();
    Serial.write(c);
  }
  // Leer de Monitor Serial Arduino y enviar a HC-05
  if (Serial.available()) {
    c = Serial.read();
    // espejar comandos de vuelta al monitor serial
    // facilita seguir los comandos
    Serial.write(c);
    Serial1.write(c);
  }
}

Asistente de Alzheimer

// Incluyendo librerías requeridas
#include <BlynkSimpleMKR1000.h>
#include <WidgetRTC.h>
#include <WiFi101.h>
#include <Arduino.h>
#include <U8g2lib.h>
#include <SPI.h>

// Deberías obtener Auth Token en la app Blynk.
// Ve a Ajustes del Proyecto (icono tuerca).
char auth[] = ""; // Introduce tu token auth Blynk aquí
// Tus credenciales WiFi.
// Pon password a "" para redes abiertas.
char ssid[] = "";
char pass[] = "";

// Definiendo comandos de la placa Sensor Hub Nano
#define HELLO "$hello id="
#define INFO "$info id="
#define SENSOR_INFO "$sinfo id=1"
#define LOW_ENERGY "$set_mode sid=1;md=mode;val=bg"
#define STANDARD_MODE "$set_mode sid=1;md=prs_osr;val=16"
#define HIGH_PRECISION "$set_mode sid=1;md=prs_mr;val=32"
#define START "$start_sensor id=1"
#define STOP "$stop id="

// Definiendo umbrales de caída y margen
// Puede que necesites cambiarlos, pero yo encontré estos valores buenos
#define FALL 0.7
#define CLEARANCE 0.2

// Definiendo pines virtuales Blynk
#define vTEMPERATURE_PIN V0
#define vPRESSURE_PIN V1
#define vALTITUDE_PIN V2
#define vEVENTOR_PIN V3
#define vFALL_PIN V4

// Declarando variables requeridas
float t, p, a, previousA;
// Booleano que dice si se detecta caída o no
boolean fallState;
// Variables necesarias para algoritmo detección caídas
unsigned long previousMillis = 0;
const long interval = 1000;
// BTconnected es false cuando no conectado y true cuando conectado
boolean BTconnected = false;
// Definiendo pines de estado BT y backlight LCD
int btStatePin = 9;
int backlightPin = 2;

BlynkTimer timer;
WidgetRTC rtc;

// Cableado pantalla Nokia 5110
U8G2_PCD8544_84X48_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 7, /* data=*/ 8, /* cs=*/ 3, /* dc=*/ 5, /* reset=*/ 4);

void setup() {
  // Inicializar ambos puertos seriales:
  Serial.begin(115200);
  Serial1.begin(115200);
  // Configurar funciones temporizadas
  timer.setInterval(1000L, sendSensorValues);
  timer.setInterval(3000L, showTimeAndDate);
  // Configurar entradas y salidas requeridas
  pinMode(btStatePin, INPUT);
  pinMode(backlightPin, OUTPUT);
  digitalWrite(backlightPin, LOW);
  u8g2.begin();
  showStartMessage();
  delay(2000);
  // esperar hasta que el módulo bluetooth haya hecho conexión
  while (!BTconnected) {
    if (digitalRead(btStatePin) == HIGH) {
      BTconnected = true;
    } else {
      showWaitingFor();
    }
  }
  initSensorHub();
  Blynk.begin(auth, ssid, pass);
  rtc.begin();
  setBlynkWidgets();
  showTimeAndDate();
  sendCommand(START);
}

void loop() {
  Blynk.run();
  timer.run();
  getSensorValues();
  checkIfFalling();
}

void sendCommand (String sensorCommand) {
  // Esta función envía comandos a través del módulo bluetooth en el puerto serial hardware al Sensor Hub Nano
  // Por ejemplo: "sendCommand(START);", inicia el flujo de datos del sensor
  // La lista completa de comandos que conozco están definidos al inicio del sketch
  Serial1.println(sensorCommand);
}

void initSensorHub() {
  // Inicializar el Sensor Hub Nano, y dar error si hay algún problema
  String junkVal;
  sendCommand(INFO);
  while (Serial1.find("IFX_NanoHub") == false) {
    sendCommand(INFO);
    Serial.println("ERROR");
    showErrorMessage();
  }
  junkVal = Serial1.readStringUntil('\n');
  junkVal = "";
  showConnectedMessage();
  delay(1500);
}

void getSensorValues() {
  // Recupera los valores del sensor del Sensor Hub Nano a través del puerto Serial1
  String junkVal;
  if (Serial1.available()) {
    junkVal = Serial1.readStringUntil('\n');
    junkVal = Serial1.readStringUntil('t');
    t = Serial1.parseFloat();
    junkVal = Serial1.readStringUntil('p');
    p = Serial1.parseFloat();
    junkVal = Serial1.readStringUntil('a');
    a = Serial1.parseFloat();
    junkVal = Serial1.readStringUntil('\n');
  }
}

void sendSensorValues() {
  // Enviar valores del sensor al servidor Blynk
  Blynk.virtualWrite(vTEMPERATURE_PIN, t);
  Blynk.virtualWrite(vPRESSURE_PIN, p);
  Blynk.virtualWrite(vALTITUDE_PIN, a);
}

void checkIfFalling() {
  // Algoritmo para comprobar si el paciente se está cayendo
  unsigned long currentMillis = millis();
  if ((currentMillis - previousMillis) >= interval) {
    float diff = previousA - a;
    if ((diff >= (FALL - CLEARANCE)) && (diff <= (FALL + CLEARANCE))) {
      fallState = true;
      // Aquí inserta lo que necesites hacer si se detecta caída, como enviar notificación o email con Blynk
      // O también podrías usar IFTTT para llamar o enviar sms para alertar al cuidador (más info en la documentación del proyecto)
      Serial.println("Cayendo");
      showFallMessage();
      // En este ejemplo, vFALL_PIN (pin virtual 4) se pone a 255 si se detecta caída
      Blynk.virtualWrite(vFALL_PIN, 255);
      // ¡Puedes enviar una notificación usando solo el widget notificación!
      // Blynk.notify("DPS310 detectó una caída!");
    }
    previousA = a;
    previousMillis = currentMillis;
    fallState = false;
    // Poner vFALL_PIN a 0 si no se detecta caída
    Blynk.virtualWrite(vFALL_PIN, 0);
  }
}

void showStartMessage() {
  // Muestra mensaje de inicio
  u8g2.clearBuffer();
  u8g2.drawRFrame(3, 7, 75, 31, 7);
  u8g2.setFont(u8g2_font_prospero_bold_nbp_tf);
  u8g2.drawStr(8, 19, "Alzheimer's");
  u8g2.drawStr(12, 35, "Assistant");
  u8g2.sendBuffer();
}

void showWaitingFor() {
  // Muestra mensaje esperando Sensor Hub Nano
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_prospero_bold_nbp_tf);
  u8g2.drawStr(9, 15, "Waiting for");
  u8g2.drawStr(8, 28, "Sensor Hub");
  u8g2.drawStr(22, 41, "Nano !!!");
  u8g2.sendBuffer();
}

void showConnectedMessage() {
  // Muestra mensaje conectado
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_7x13B_tf);
  u8g2.drawStr(0, 10, "Connected to");
  u8g2.drawStr(8, 22, "Infineon's");
  u8g2.drawStr(7, 34, "Sensor Hub");
  u8g2.drawStr(29, 46, "Nano");
  u8g2.sendBuffer();
}

void showErrorMessage() {
  // Muestra mensaje error
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_fub14_tf);
  u8g2.drawStr(9, 30, "ERROR");
  u8g2.sendBuffer();
}

void showSensorValues() {
  // Muestra los valores del sensor en la pantalla
  char bufT[10];
  char bufP[10];
  char bufA[10];
  String(t).toCharArray(bufT, 10);
  String(p).toCharArray(bufP, 10);
  String(a).toCharArray(bufA, 10);
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_6x10_tf );
  // Mostrar temperatura
  u8g2.drawStr(0, 10, "T:");
  u8g2.drawStr(12, 10, bufT);
  u8g2.drawStr(73, 10, "C");
  u8g2.drawCircle(70, 4, 1, U8G2_DRAW_ALL);
  u8g2.drawHLine(0, 12, 85);
  // Mostrar presión
  u8g2.drawStr(0, 26, "P:");
  u8g2.drawStr(12, 26, bufP);
  u8g2.drawStr(60, 26, "mBar");
  u8g2.drawHLine(0, 28, 85);
  // Mostrar altitud
  u8g2.drawStr(0, 42, "A:");
  u8g2.drawStr(12, 42, bufA);
  u8g2.drawStr(72, 42, "m");
  u8g2.drawHLine(0, 44, 85);
  // Enviar valores a la pantalla
  u8g2.sendBuffer();
}

void showFallMessage() {
  // Muestra mensaje caída detectada
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_7x13B_tf);
  u8g2.drawStr(27, 20, "Fall");
  u8g2.drawStr(13, 32, "Detected!");
  u8g2.sendBuffer();
  delay(1000);
}

void showPillReminder() {
  // Muestra mensaje recordatorio pastillas
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_7x13B_tf);
  u8g2.drawStr(0, 20, "Time to take");
  u8g2.drawStr(5, 32, "your pills!");
  u8g2.sendBuffer();
}

void showExerciseReminder() {
  // Muestra mensaje recordatorio ejercicio
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_7x13B_tf);
  u8g2.drawStr(16, 20, "Time to");
  u8g2.drawStr(12, 32, "exercise!");
  u8g2.sendBuffer();
}

void showTimeAndDate() {
  // Muestra la hora y fecha del widget RTC en Blynk en formato 24 horas
  if (year() == 1970) {
    // Serial.println("Hora no sincronizada aún");
  } else if (year() != 1970) {
    char bufHours[3];
    char bufColon[2];
    char bufMinutes[3];
    char bufDate[11];
    String currentHours = String(hour());
    String colon = ":";
    String currentMinutes = String(minute());
    String currentDate = String(day()) + "/" + month() + "/" + year();
    String(currentHours).toCharArray(bufHours, 3);
    String(colon).toCharArray(bufColon, 2);
    String(currentMinutes).toCharArray(bufMinutes, 3);
    String(currentDate).toCharArray(bufDate, 11);
    u8g2.clearBuffer();
    u8g2.setFont(u8g2_font_inr33_mf);
    u8g2.drawStr(30, 30, bufColon);
    u8g2.setFont(u8g2_font_logisoso32_tn);
    u8g2.drawStr(0, 32, bufHours);
    u8g2.drawStr(45, 32, bufMinutes);
    u8g2.setFont(u8g2_font_saikyosansbold8_8n);
    u8g2.drawHLine(0, 35, 85);
    u8g2.drawStr(0, 46, bufDate);
    u8g2.sendBuffer();
  }
}

BLYNK_WRITE(vEVENTOR_PIN) {
  // Usa el widget Eventor para comprobar si es hora de hacer una tarea (tomar medicina en este caso)
  int currentValue = param.asInt(); // 0 a 1
  if (currentValue == 1) {
    showPillReminder();
    // Serial.println("Hora de tomar tus pastillas");
  } else {
    // Serial.println("No es hora de tomar pastillas");
  }
}

void setBlynkWidgets() {
  // Esto establece el color de cada widget en la app Blynk
  // Puedes quitar esto del sketch si quieres configurar colores manualmente en la app Blynk
  // También podrías especificar el valor hex de cada color que necesites
  // Poner color widget temperatura a blanco
  Blynk.setProperty(vTEMPERATURE_PIN, "color", "#FFFFFF");
  // Poner color widget presión a azul
  Blynk.setProperty(vPRESSURE_PIN, "color", "#00BBFF");
  // Poner color widget altitud a amarillo
  Blynk.setProperty(vALTITUDE_PIN, "color", "#FFFF00");
}

BLYNK_CONNECTED() {
  // Sincronizar hora al conectar, si se cae la conexión
  rtc.begin();
}

Partes personalizadas y carcasas

Esto es solo para mostrar cómo pretendo que se vea la carcasa. ¡No está en absoluto a escala!

Esquemáticos

Este diagrama se usa al poner tu HC-05 en modo AT y configurarlo, usando el Arduino MKR1000.

Diagrama Fritzing para que el proyecto básico funcione.

Documento listando comandos AT para el HC-05.