LAB - ECG

ECG

O sinal ECG gerado no pino PB13 possui a forma de onda a seguir:

E se analisarmos o espectro do sinal via transformada de fourier, obtemos a seguinte composição espectral:

60 Hz

Notamos claramente que existe um sinal centrada em 60Hz, isso é muito comum quando trabalhamos com eletrônica e reflete o 60Hz da rede elétrica que é propagada de diversas formas para o transdutor responsável em amostrar o dado do pulso elétrico do corpo humano, causando um ruído no sinal não desejável.

Para tararmos o dado corretamente teremos que filtra o ruído. Lembre que em alguns países a frequência da rede elétrica é de 50Hz e não de 60Hz como no Brasil.

Task process

Vamos criar uma tarefa no RTOS que será responsável por processar os dados do ECG, iremos chamar a tarefa de task_process. Essa tarefa irá receber os dados da conversão analógica, processar e extrair informações e retornar enviar os dados para a task_main.

Leitura analógica

Para começarmos precisamos ler o valor do ECG que está sendo gerado no pino PB13, para isso iremos configurar a leitura analógica no AFEC1 canal 6. A leitura anlógica deve ser executada a 250 Hz, para garantirmos que estaremos lendo a uma taxa de amostragem fixa, vamos configurar um TC para fazer a conversão do sinal. O valor convertido deve ser colocado em uma fila para processamento futuro, como indicado a seguir:

Retransmitindo o dado

Uma boa prática é atualizar o LCD apenas em uma tarefa, o LVGL não é thread-safe by default, como o site indica na página página:

• https://docs.lvgl.io/latest/en/html/porting/os.html

Isso significa que não podemos chamar uma função do LVGL enquanto a anterior não tenha terminado de executar, e caso implementemos o acesso ao LCD em várias partes do nosso programa corremos grande risco disso acontecer (lembrem que o RTOS interrompe uma tarefa para permitir que outra execute, e isso pode ser no meio da função por exemplo de mudar o valor do label).

Para não termos que usar mutex, vamos atualizar o LCD apenas em uma das tasks, eu sugiro fazermos isso na task_main.

Por conta disso iremos retransmitir o dado da fila do ECG para a task_main por outra fila: xQueueEcgInfo que será do uma struct contendo dois inteiros: ecg e bpm.

A ideia aqui é que a task_process irá pegar os dados do ECG, processar e extrair o valor da frequência cardiaca (em batimentos por minuto) e retransmitir para a task_main exibir no LCD.

Exibindo gráfico

Agora que já temos o caminho do dado pronto vamos exibir no LCD usando o widget lv_chart. O site explica vários modos de fazer isso, eu irei sugerir um que fiz e funcionou bem.

Primeiro teremos que criar um vetor global (int ser1_data[250]) que irá armazenar os pontos do gráfico, o vetor precisa ter o tamanho da quantidade de pontos que queremos exibir. Vamos começar com 250, depois vocês podem ajustar até encontrarem um valor adequado.

Depois precisamos criar o ponteiro para o gráfico (lv_obj_t * chart;) e para a série do (ser1) também global (assim como fazermos para os labels e botões). E então inicializar o gráfico. Aqui eu irei fazer na função lv_screen_chart que deve ser chamada no começo da task_LCD, como demonstrado a seguir:

// globais
#define CHAR_DATA_LEN 250
int ser1_data[CHAR_DATA_LEN];
lv_obj_t * chart;
lv_chart_series_t * ser1;

// Desenha gráfico no LCD
void lv_screen_chart(void) {
chart = lv_chart_create(lv_scr_act(), NULL);
lv_obj_set_size(chart, 300, 250);
lv_obj_align(chart, NULL, LV_ALIGN_IN_BOTTOM_MID, 0, 0);
lv_chart_set_type(chart, LV_CHART_TYPE_LINE);   
lv_chart_set_range(chart, 0, 4095);
lv_chart_set_point_count(chart, CHAR_DATA_LEN);
lv_chart_set_div_line_count(chart, 0, 0);
lv_chart_set_update_mode(chart, LV_CHART_UPDATE_MODE_SHIFT);

ser1 = lv_chart_add_series(chart, LV_COLOR_BLUE);
lv_chart_set_ext_array(chart, ser1, ser1_data, CHAR_DATA_LEN);
lv_obj_set_style_local_line_width(chart, LV_CHART_PART_SERIES, LV_STATE_DEFAULT, 1);
}

static void task_lcd(void *pvParameters) {
+ lv_screen_chart();

for (;;)  {
    lv_tick_inc(50);
    lv_task_handler();
    vTaskDelay(50);
}
}

Agora temos que modificar a função task_main para toda hora que receber um novo valor na fila xQueueEcgInfo ela atualizar o gráfico. Para isso iremos usar a função lv_chart_set_next(chart, ser1, value), após termos atualizado a série precisamos indicar ao LVGL que é para atualizar o gráfico, isso é feito pela função lv_chart_refresh(chart).

• Mais informções na página do widget: https://docs.lvgl.io/latest/en/html/widgets/chart.html#overview

Com isso vocês devem obter algo como:

//                    novo valor | 
//                               v
lv_chart_set_next(chart, ser1, value);
lv_chart_refresh(chart);

Frequência cardiaca

Agora vamos modificar a task_process para detectar a frequência cardiaca, na literatura existem várias maneiras (bem mais correta da qual eu irei propor) o artigo a seguir explora algumas das maneiras:

• Parák, Jakub, and Jan Havlík. "ECG signal processing and heart rate frequency detection methods." Proceedings of Technical Computing Prague 8 (2011): 2011.

A ideia principal é detectar o intervalo de tempo entre cada pico:

A implementação que iremos fazer aqui envolve aplicar um threshold no valor e esperar até o próximo pico, calculando o tempo entre os dois sinais.

RTT

Para calcularmos o dT iremos usar o periférico RTT, que ficará gerando pulsos e depois iremos verificar quantos pulsos aconteceram no intervalo entre um pico e outro e então estimar o valor do dT. O RTT será configurado para operar a uma taxa de 1000Hz, ou seja, 1000 pulsos por segundo, isso nos dará uma boa resolução.

Neste caso não iremos usar a interrupção do RTT de alarme, mas sim a de tempo (que vai ocorrer 1000x por segundo). Sempre que ela ocorrer, iremos incrementar um contador global que será nosso dT. Esse contador será zerado a cada pulso.

Threshold

Iremos aplicar o threshold e procurar por valores que nos ajudem a encontra o pico, isso será feito sempre que um novo dado chegar na fila xQueueEcg.

if (xQueueReceive( xQueueAdc, &adc, 50 )) {
    // ...
    // ...
    if (adc > 3280 ){
        printf("%d: %d ms\n", adc, g_dT);
        // começamos a contar novamente
        g_dT = 0;
    }
}

Melhorando

A implementação anterior não funciona muito bem, as vezes encontramos mais de um valor no mesmo pico dentro do range estipulado:

Calculando bpm

Agora com o dT correto conseguimos converter a informação para bpm.

Exibindo

Agora que temos o valor do bpm, vamos enviar essa informação junto com o ecg para a task_main via a fila xQueueEcgInfo (lembra que criamos uma struct?). Com a informação na tarefa que atualiza o LCD, conseguimos criar um label e exibir o valor na tela junto com o gráfico.

O resultado esperado é algo como:

B/A

• Adicionar beep com o buzzer, conforme frequência.
• Procurar pico usando a energia do sinal do sinal no lugar do valor no tempo.