Detección de caídas y monitorización de la frecuencia cardíaca

Un dispositivo portátil de bajo consumo detecta caídas mediante aprendizaje automático en el borde. También monitoriza la frecuencia cardíaca.

Descripción general

Las caídas pueden causar traumas físicos y psicológicos, especialmente en personas mayores. Para mejorar la calidad de vida de estos pacientes, este proyecto presenta el desarrollo de un sistema de detección de caídas y monitorización de la frecuencia cardíaca. El dispositivo portátil obtiene información del acelerómetro y el sensor de frecuencia cardíaca y la envía a AWS IoT Core. La detección de caídas se realiza sin conexión en el chip mediante un algoritmo de aprendizaje automático.

Entorno de configuración

Descargue MPLAB X IDE desde aquí https://www.microchip.com/en-us/development-tools-tools-and-software/mplab-x-ide.

Clonar AVR IoT Listo para usar la aplicación de ejemplo de nodo de sensor de AWS usando el siguiente comando:

git clone https://github.com/microchip-pic-avr-solutions/avr-iot-aws-sensor-node-mplab.git

Actualizaremos esta base de código del repositorio para adaptarla a la aplicación deseada.

Abrir proyecto MPLAB X IDE > Archivo > Abrir proyectos…

Producción > Proyecto de construcción

Después de una compilación exitosa, podemos flashear el AVR-IOT haciendo clic en el botón Ejecutar proyecto.

Necesitamos configurar el wifi para conectarnos a AWS IoT. Al conectar la placa AVR-IoT al ordenador, aparece como «CURIOSITY» en el explorador de archivos, como se muestra a continuación.

Necesitamos abrir el archivo «CLICK-ME.HTM» que se abre en un navegador de Internet predeterminado

Aquí debemos completar el SSID y las credenciales del wifi y descargar la configuración. Copiamos el archivo de configuración descargado al directorio CURIOSITY y, en pocos segundos, la placa estará conectada a internet.

Como nos gustaría ver los datos en la cuenta privada de AWS Cloud, necesitamos crear una cuenta e iniciar sesión en la consola de AWS y dirigirnos a AWS IoT Core.

Siga este enlace para configurar el dispositivo y enviar los datos a la nube privada de AWS. En AWS IoT > Pruebas, podemos suscribirnos al tema «<node_name>/sensors» y comprobar si los datos llegan como se indica a continuación:

En este punto tenemos una aplicación funcional conectada al AWS IoT.

Para la detección de caídas y la monitorización de la frecuencia cardíaca necesitamos dos sensores:

1. Acelerómetro (ADXL345)

2. Sensor de frecuencia cardíaca (MAX10305)

He adaptado el código de los dos sensores mencionados anteriormente desde las bibliotecas de Arduino para que funcionen con AVR-IoT. Todas las bibliotecas y el código incluidos están disponibles en el repositorio de GitHub.

Además, para tener la función equivalente millis() de Arduino en AVR, he escrito mi propia función.

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/atomic.h>
#include "millis.h"

volatile static uint32_t timerMillis;

// CPU frequency in Hz
#define F_CPU 3333333   // 20MHz/6 (CPU Clock prescalar=6)
//#define PERIOD_VALUE 0xC  // Overflow after 1 ms = 0.001s, (0.001 * F_CPU / 256) - 1, (TCA0 prescalar=256)
#define PERIOD_VALUE 0xD3
// Initializes the use of the timer functions by setting up the TCA timer.
void initTimer()
{
    /* enable overflow interrupt */
    TCA0.SINGLE.INTCTRL = TCA_SINGLE_OVF_bm;

    /* set Normal mode */
    TCA0.SINGLE.CTRLB = TCA_SINGLE_WGMODE_NORMAL_gc;

    /* disable event counting */
    TCA0.SINGLE.EVCTRL &= ~(TCA_SINGLE_CNTEI_bm);

    /* set the period */
    TCA0.SINGLE.PER = PERIOD_VALUE;

    /* set clock source (sys_clk/256) */
    //TCA0.SINGLE.CTRLA = TCA_SINGLE_CLKSEL_DIV256_gc | TCA_SINGLE_ENABLE_bm; 
    TCA0.SINGLE.CTRLA = TCA_SINGLE_CLKSEL_DIV16_gc | TCA_SINGLE_ENABLE_bm; 

}

// TCA overflow handler, called every millisecond.
ISR(TCA0_OVF_vect)
{
    timerMillis++;
    // Clear the interrupt flag (to reset TCA0.CNT)
    TCA0.SINGLE.INTFLAGS = TCA_SINGLE_OVF_bm;
}

// Gets the milliseconds of the current time.
uint32_t millis()
{
    uint32_t m;

    ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
    {
        m = timerMillis;
    }

    return m;
}

Conexión de sensores a la placa AVR-IoT

Los sensores de frecuencia cardíaca y acelerómetro se conectan mediante I₂C. Se utiliza un adaptador Sparkfun Qwiic para conectar los sensores. La disposición de los pines del adaptador Qwiic (GND, 5 V, SDA, SCL) es exactamente la misma (ver más abajo) que en las placas AVR-IOT, por lo que fue muy fácil conectarlos.

Monitoreo de la frecuencia cardíaca

Este es un paso sencillo: el sensor MAX30105 se conecta al AVR-IOT mediante una conexión I2C. El código calcula el promedio de pulsaciones por minuto (BPM) y lo envía a la nube. Podemos monitorizar la frecuencia cardíaca y establecer un umbral; si supera o baja el rango seguro, se emitirá una alerta.

Selección de modelos de aprendizaje automático para detección de caídas

Esto es un poco complicado. No podemos detectar de forma fiable utilizando únicamente las lecturas brutas del acelerómetro. Pero podemos hacerlo mediante aprendizaje automático. Quería utilizar TensorFlow Lite, pero la placa AVR-IOT solo tiene 6 KB de RAM y la aplicación AWS IoT Node utiliza más de 3 KB. Otra opción podría ser utilizar AWS lambda para realizar el trabajo pesado de TensorFlow Lite. Pero siempre quise que lo hiciera en el borde. Por lo tanto, realizar aprendizaje automático basado en redes neuronales no es viable para un dispositivo de memoria tan pequeño, pero podemos hacerlo basado en árboles, por ejemplo, clasificadores de árboles de decisión o de bosque aleatorio. Pero, de nuevo, era un problema. El modelo de aprendizaje automático necesita al menos 2 segundos de datos del acelerómetro de 3 ejes para predecir de forma fiable. Si reducimos la resolución de los datos de punto flotante del acelerómetro de 3 ejes a 64 muestras por segundo, necesitamos 4 x 3 x 64 x 2 = 1536 bytes para mantener los datos de 2 segundos en un búfer de anillo. Además, para usar la instantánea de los datos para extraer características, necesitamos otros 1536 bytes. Por lo tanto, el total es más de 3 KB y no cabría en la RAM. Una forma de solucionar este problema es mantener los datos en un entero con signo de 16 bits (2 bytes) en lugar de 4 bytes de punto flotante y multiplicarlo por 100 para mantener la precisión hasta dos decimales. Al realizar la extracción de características, dividimos los puntos de datos por 100 y volvemos a convertirlos a punto flotante. Con esta estrategia, solo necesitamos 1536 bytes y eso cabría en la RAM disponible. Otro problema fue que el modelo Random Forest mantiene todos los pesos en el código y el espacio disponible en la memoria flash es de solo 8 KB, ya que la aplicación AWS Node usa casi el 93% de la flash. Por lo tanto, el modelo Random Forest no se puede almacenar en la flash. Mientras exploraba modelos de tamaño pequeño, encontré un algoritmo reciente SEFR: Un clasificador rápido de tiempo lineal para dispositivos de potencia ultrabaja que usa solo un peso para cada característica. Lo probé y tiene un diseño tan pequeño que cabe fácilmente en el flash disponible.

Conjunto de datos de entrenamiento para la detección de caídas

Utilicé SisFall: Un conjunto de datos de caídas y movimiento , un conjunto de datos sobre caídas y actividades de la vida diaria (AVD) adquiridos con un acelerómetro. Consta de 19 AVD y 15 tipos de caídas realizadas por 23 adultos jóvenes, 15 tipos de AVD realizadas por 14 participantes sanos e independientes mayores de 62 años, y datos de un participante de 60 años que realizó todas las AVD y las caídas. Utilicé Edge Impulse Studio únicamente para la extracción de características. El entrenamiento se realizó con la característica extraída mediante la biblioteca de Python scikit-learn . El modelo entrenado se adaptó a código C simple mediante la biblioteca de Python micromlgen . El algoritmo SEFR actualmente solo admite la clasificación binaria. Los datos del acelerómetro SisFall, recopilados con el sensor ADXL345, se dividieron en dos clases: «Caída» y «Movimiento», se convirtieron a m/s^² y se cargaron en Edge Impulse Studio. El entrenamiento se realizó con las cuatro características que se enumeran a continuación, calculadas a partir de los datos sin procesar:

• Raíz cuadrada media (RMS)
• desviación estándar
• Oblicuidad
• Curtosis

Podemos ver en el explorador de características de Edge Impulse Studio (abajo) que las clases «Caer» y «Mover» tienen una separación clara usando las características extraídas.

Los scripts para subir los datos a Edge Impulse Studio y entrenar el notebook Jupyter están disponibles en el repositorio de Github (consulte el enlace en la sección de Código). Las características extraídas se descargan de Edge Impulse Studio en formato de matriz numpy y se entrenan con scikit-learn. El algoritmo SEFR ya está portado a la biblioteca de Python EloquentArduino , que puede utilizarse desde scikit-learn.

Solicitud completa

Clonar el repositorio de la aplicación:

git clone https://github.com/metanav/AVRIoT.X.git

Configuración de compilación

Dado que esta aplicación utiliza 2 buffers de datos de sensores y código, debemos cambiar el nivel de optimización de compilación a «s» en Proyecto > Propiedades > Compilador XC8 (como se muestra a continuación) para que la aplicación completa pueda actualizarse sin limitaciones de memoria.

Cree y ejecute la aplicación mientras conecta la placa AVR-IOT. Vaya a AWS IoT > Pruebas y suscríbase al tema MQTT. Podrá ver los datos de frecuencia cardíaca entrantes como BPM y la detección de caídas como 0 (caída detectada) o 1 (sin caída, actividad normal).

{
    "Avg BPM": 58,
    "Fall": 0
}

Demostración de prueba de detección de caídas

Conclusión

Este proyecto presenta un dispositivo de prueba de concepto diseñado específicamente para que las personas mayores monitoricen su salud y bienestar. También demuestra que un algoritmo simple puede utilizarse para resolver problemas complejos y ejecutarse en dispositivos de bajo consumo y recursos limitados.

Esquema

Código