Introdução
A epilepsia é uma condição neurológica que provoca alterações temporárias e reversíveis no funcionamento do cérebro, sem estar relacionada à febre, uso de substâncias ou distúrbios metabólicos. Durante uma crise, por alguns segundos ou minutos, determinadas regiões cerebrais emitem sinais incorretos, que podem permanecer localizados ou se espalhar por outras áreas. Muitas vezes, as causas da epilepsia são desconhecidas. Segundo a Organização Mundial da Saúde (OMS), a epilepsia afeta cerca de 2% da população brasileira e aproximadamente 50 milhões de pessoas no mundo.
A forma mais comum é a crise convulsiva, chamada de “ataque epiléptico”. Nesse tipo de crise, o indivíduo pode sofrer quedas, apresentar contrações musculares generalizadas, mordedura de língua, salivação excessiva e respiração ofegante. Este projeto é uma prova de conceito com o objetivo identificar esse tipo de crise por meio de uma pulseira equipada com acelerômetro, capaz de detectar os padrões de movimento característicos das convulsões e emitir um alerta para um contato de emergência.
Material necessário
- 1 Franzininho Wifi
- 1 Acelerômetro LIS3DH
- Jumpers
Ao conectar o acelerômetro tente usar jumpers maiores para que você consiga prender no pulso.
Leitura de Aceleração e Cálculo de Ângulos
O código abaixo realiza a leitura da aceleração em três eixos (X, Y e Z) usando o acelerômetro LIS3DH, e, com base nesses valores, calcula os ângulos de inclinação. A ideia de enviar tanto os dados de aceleração quanto os ângulos ao Edge Impulse para aumentar a quantidade e diversidade de informações fornecidas ao modelo de machine learning, o que pode ajudar a identificar padrões mais precisos e confiáveis durante crises epilépticas.
Os Melhores Treinamentos sobre Sistemas embarcados e IoT
Cursos com professores qualificados para acelerar sua carreira e projetos
#include <Wire.h>
#include <SPI.h>
#include <Adafruit_LIS3DH.h>
#include <Adafruit_Sensor.h>
#include <math.h> // Biblioteca para funções matemáticas
#define FREQUENCY_HZ 50
#define INTERVAL_MS 1000/(FREQUENCY_HZ+1)
static unsigned long last_interval_ms = 0;
#define LIS3DH_CLK 36
#define LIS3DH_MISO 37
#define LIS3DH_MOSI 35
#define LIS3DH_CS 34
// software SPI
Adafruit_LIS3DH lis = Adafruit_LIS3DH(LIS3DH_CS, LIS3DH_MOSI, LIS3DH_MISO, LIS3DH_CLK);
void setup(void) {
Serial.begin(115200);
if (!lis.begin(0x18)) { // change this to 0x19 for alternative i2c address
Serial.println("Couldn't start");
while (1) yield();
}
lis.setRange(LIS3DH_RANGE_2_G); // 2, 4, 8 ou 16 G
lis.setPerformanceMode(LIS3DH_MODE_NORMAL);
lis.setDataRate(LIS3DH_DATARATE_50_HZ);
}
void loop() {
// Obter as acelerações em X, Y e Z em m/s^2
sensors_event_t event;
lis.getEvent(&event);
// Calcular o ângulo em relação aos eixos X (roll), Y (pitch) e Z (yaw)
float roll = (atan2(event.acceleration.y, event.acceleration.z) * 180 / M_PI)*0.1;
float pitch = (atan2(-event.acceleration.x, sqrt(event.acceleration.y * event.acceleration.y + event.acceleration.z * event.acceleration.z)) * 180 / M_PI)*0.1;
// Aproximação do ângulo yaw (rotação em torno do eixo Z) usando atan2 com X e Y
float yaw = (atan2(event.acceleration.y, event.acceleration.x) * 180 / M_PI)*0.1;
// Imprimir os dados de roll, pitch, yaw e acelerações
if (millis() > last_interval_ms + INTERVAL_MS) {
last_interval_ms = millis();
Serial.print(roll);
Serial.print(",");
Serial.print(pitch);
Serial.print(",");
Serial.print(yaw);
Serial.print(",");
Serial.print(event.acceleration.x);
Serial.print(",");
Serial.print(event.acceleration.y);
Serial.print(",");
Serial.println(event.acceleration.z);
}
}
Este código utiliza a biblioteca “Adafruit_LIS3DH” para comunicação com um acelerômetro LIS3DH via SPI, portanto certifique-se de instalar essa biblioteca na sua IDE do Arduino, assim como a biblioteca “Adafruit Unified Sensor”.
No `setup()`, inicializamos a comunicação serial e configuramos o acelerômetro para operar no modo normal, com uma sensibilidade de 2G e taxa de dados de 50Hz.
No `loop()`, realizamos a leitura dos valores de aceleração nos eixos X, Y e Z e calculamos os ângulos de inclinação (roll, pitch e yaw) usando funções trigonométricas. O código garante que os dados sejam enviados à serial a cada intervalo de tempo pré-definido.
Ingestão de Dados no Edge Impulse
Conexão dispositivo na Edge Impulse
Para que o Edge Impulse receba os dados coletados pela sua placa, utilizaremos a ferramenta de ingestão fornecida pela plataforma para conectar o dispositivo ao Edge Impulse. Certifique-se de ter essa ferramenta instalada em sua máquina. Caso ainda não tenha, siga o passo a passo de instalação disponível em edge-impulse-cli.
Após instalado o edge impulse cli, abra o terminal e execute o seguinte comando:
edge-impulse-data-forwarder –device-name “nomeSuaEscolha”
Quando a ferramenta detectar a porta serial e a frequência de comunicação, você será solicitado a nomear os dados que estão sendo lidos. Insira roll, pitch, yaw, ax,ay,az para os eixos do acelerômetro. Em seguida, escolha um nome para o seu dispositivo; por exemplo, “Franzininho”.
Ao abrir a plataforma Edge Impulse você deve ver o dispositivo conectado.
Coleta de dados
Na coleta dos dados para essa prova de conceito, primeiro tentei prender o acelerômetro mais próximo possível do meu pulso. Depois, iniciei a coleta de dados acessando a opção “Data acquisition” e selecionando “Collect data”.
Como não tenho epilepsia, simulei uma crise tremendo o braço e pulso e nomeei essa classe de dados com a label “1”, coletando por 10 segundos em cada repetição. Repeti esse processo várias vezes.
Nesse vídeo é possível ver como os braços ficam em uma crise https://www.youtube.com/watch?v=662Q0uSZfrQ
Para os dados sem crise, realizei atividades cotidianas, como digitar, mexer o braço e pegar objetos, rotulando essas amostras como “0” e também coletando por 10 segundos em cada repetição.
Esses procedimentos foram repetidos tanto para os dados de treino quanto para os dados de teste.
Criação Impulso
Na etapa de criação de impulso, clique em “Impulse design” > “Create Impulse”. Depois adicione um bloco de “processing”, nele vamos escolher “Spectral Analysis”. Em seguida, adicione o bloco de “learning”, nele vamos escolher “Classificação”. Por fim, salve o impulso.
Treinamento Modelo
Primeiro em “Impulse design” > “Spectral features” clique em “Generate Features”. Essa etapa transforma os dados brutos coletados em características (ou features) que podem ser usadas para treinar um modelo de machine learning. As features devem estar bem distribuídas, caso contrário repita o processo de coleta de dados.
Depois de gerar as features (características), vá para “Impulse design” > “Classifier” e clique em “Save & Train”. Aqui vamos treinar o modelo.
Os resultados foram:
Por último, “Impulse design” > “Retrain Model”, clique em “Train Model”. Essa etapa, realiza o re-treino do modelo para ajustar ou melhorar o desempenho do modelo de machine learning com base em novos dados ou alterações na configuração do Impulso.
Teste Modelo
Após o treinamento do modelo vamos testá-lo em “Model Testing”.
Como resultado, o modelo apresentou uma accuracy de 87,5%, o que indica que ele está correto em 87,5% das previsões gerais. Nas classes específicas, o modelo consegue identificar corretamente casos de não epilepsia em 80% das vezes e casos de epilepsia em 95% das vezes.
O F1-score foi de 92%, uma métrica que combina precisão e recall para fornecer uma média harmônica entre essas duas. O recall, que mede a capacidade do modelo de encontrar todos os casos positivos de epilepsia, foi de 93%, enquanto a precisão, que mede a taxa de acerto entre as previsões positivas feitas pelo modelo, também ficou em 93%.
Etapa Deploy
Com o modelo treinado e teste validado podemos implantar o modelo convertendo-o em um arquivo .tflite, que pode ser carregado no microcontrolador. No Edge Impulse, vá até a aba “Deployment”, selecione a plataforma desejada (neste exemplo, Arduino IDE), e clique em “Build” para iniciar o processo de conversão. Após a conclusão, um arquivo .zip contendo o seu modelo será gerado.
Conclusão
Na primeira etapa desta prova de conceito de uma pulseira capaz de identificar crises epilépticas, realizamos a coleta dos dados e o treinamento do modelo de machine learning. Na segunda etapa, utilizaremos o modelo treinado para desenvolver um sistema que, ao detectar uma crise, enviará automaticamente uma mensagem de emergência para um contato previamente cadastrado.
