Medição de Frequência Cardíaca com Arduino + KY-039

E aí gente! Tudo certo com vocês? Esse aqui, tecnicamente, é o primeiro post de verdade pois o outro foi apenas um post introdutório e também pare que o blog não ficasse sem publicação nenhuma. 

Nessa nossa nova postagem vamos falar um pouquinho sobre medições de frequência cardíaca (batimentos cardíacos) utilizando arduino e um sensor. No meu caso eu vou utilizar um Garagino, que infelizmente não é mais vendido, mas ele é igual o arduino, ele também conta com um microcontrolador ATMEGA328P, então o que for ser feito aqui, será feito no arduino sem nenhuma diferença.

Garagino. Foto: Diigiit/Reprodução.

E o sensor que vamos utilizar é um sensor de batimentos cardíacos por infravermelho. Em alguns lugares ele aparece com o nome KY-039. Mas antes de entrarmos no código em si, eu gostaria de falar algumas coisas sobre esse sensor.

Sensor KY-039. Foto: Rgeoeyef/Reprodução

Vocês conseguem ver que existem dois componentes aqui, um emissor e um receptor de infravermelho, e existem também dois resistores aqui na placa de circuito impresso. E basicamente é isso. Sendo bem sincero pra vocês, esse sensor não é muito legal não. E as expectativas para esse sensor estavam muito altas, pois ele se define como um sensor de batimentos cardíacos e tem um baixo custo, porém não é bem assim que ele funciona não.

Vocês devem estar falando "mas, Adriano, por que ele não muito legal?".

Como falei, ele se define como uma coisa, mas o que ele faz é outra! A saída que a gente vai ter no arduino vai ser uma leitura de quanto infravermelho está saindo do emissor e alcançando o receptor. Quando colocamos o dedo criamos uma barreira para o raio passar, mas nossos batimentos cardíacos dilatam os vasos sanguíneos nos nossos dedos e isso faz com que haja uma mudança na resistência para a passagem do infravermelho. Em outras palavras, fica mais difícil do raio atravessar, então conseguimos visualizar essa dificuldade aumentando e diminuindo de acordo com os batimentos cardíacos. Quanto maior a resistência, maior o valor, e a faixa de valores lidas pelo arduino vai ser de 0 a 1023.

Então se puderem escolher um outro sensor, será melhor, muitos já tem bibliotecas prontas e até mais funções! Mas se vocês estiverem na mesma situação que eu e só tiverem esse sensor disponível, então vamos utilizar esse mesmo.

IMPORTANTE: Vale lembrar que o infravermelho é uma radiação não ionizante, isto é, ela não é capaz de provocar ionização dos os materiais com o qual interagir, então podem ficar tranquilos para colocar o dedo nesse sensor que não vai faz mal algum.

Quanto à montagem, na parte de trás da minha placa (em alguns fica na parte de cima, como visto na imagem do sensor que coloquei antes no post), posso identificar um sinal de menos e uma letra 's', e um pino entre eles. No pino do sinal de menos eu liguei ele no GND do arduino utilizando um jumper macho-fêmea (amarelo), o pino do meio (que é o pino sem identificação) liguei no Vcc onde teremos o +5V (branco), e o pino com a letra 's' foi ligado ao A0 do arduino (azul). Mas peço que confirmem na placa de vocês e no datasheet por onde compraram (se tiver), pois quando entrei em contato com o site onde esse sensor foi comprado, eles nem tinham datasheet para passar.

Agora vamos para o código do arduino. Eu gostaria de deixar um agradecimento ao usuário Johan_Ha, pois quando eu estava desenvolvendo o código para usar com esse sensor eu me deparei com o código dele e vi que estamos desenvolvendo algo parecido, então me baseei no código dele para poder fazer esse sensor funcionar corretamente. Clique aqui para ver o código e considerações originais desse usuário.

Primeiro vamos dar uma olhada em como é a saída direto do nosso sensor. Então apenas imprimir na tela o valor lido.

int sensorPin = 0;

void setup() {
	Serial.begin(9600);
}

void loop(){
	Serial.println(analogRead(sensorPin));
}

Gráfico do sinal não processado. Autoria Própria

Olha só como o sinal é poluído, com um monte de coisa atrapalhando pra ver. Então vamos fazer uma coisa pra deixar ele mais limpo, vamos criar uma janela móvel e imprimir apenas o valor da média nessa janela.

#define SAMP_SIZE 20

int sensorPin = 0;
float readings[SAMP_SIZE];
float readingsSum, currentReading, sensorValue;
long int readingsIndex;

void setup() {
	Serial.begin(9600);
	for(int i = 0; i < SAMP_SIZE; i++)
		readings[i] = 0;
	readingsSum = 0;
	readingsIndex = 0;
}

void loop(){
	sensorValue = analogRead(sensorPin);
	readingsSum -= readings[readingsIndex];
	readingsSum += sensorValue;
	readings[readingsIndex] = sensorValue;
	
	currentReading = readingsSum / SAMP_SIZE;
	Serial.print(currentReading);
	Serial.print("\n");

	readingsIndex++;
	readingsIndex %= SAMP_SIZE;
}

Gráfico após a janela de média móvel. Autoria Própria

Ainda temos um pouco de ruído! Existe um ruído muito comum que é causado pela nossa própria rede elétrica, que tem uma frequência de 60Hz, então para isso, vamos pegar o período desse ruído que é 1/60 e resulta em 16.66666ms. Vamos fazer uma média dos valores nesse período para atenuar esse ruído. Se você mora em um país que a rede elétrica é de 50Hz, use 20ms.

#define SAMP_SIZE 20

int sensorPin = 0;
float readings[SAMP_SIZE];
float readingsSum, currentReading, sensorValue;
long int readingsIndex, currentTime, startTime;
int n;

void setup() {
	Serial.begin(9600);
	for(int i = 0; i < SAMP_SIZE; i++)
		readings[i] = 0;
	readingsSum = 0;
	readingsIndex = 0;
}

void loop(){
	n = 0;
	startTime = millis();
	sensorValue = 0;
	do{
		sensorValue += analogRead(sensorPin);
		n++;
		currentTime = millis();
	}while(currentTime - startTime < 16.6667);  
	sensorValue /= n;

	readingsSum -= readings[readingsIndex];
	readingsSum += sensorValue;
	readings[readingsIndex] = sensorValue;
	
	currentReading = readingsSum / SAMP_SIZE;
	Serial.print(currentReading);
	Serial.print("\n");

	readingsIndex++;
	readingsIndex %= SAMP_SIZE;
}

Gráfico do sinal após filtrar os ruídos de 60Hz. Autoria Própria

Depois basta fazermos o sistema de detecção de borda! Para isso precisamos procurar quando o valor anterior é menor que o valor atual. Também definimos o o mínimo de vezes que devemos encontrar uma subida para que se considere como uma batida. Além disso vamos calcular uma média dos bpm's medidos. (Para mais informações, assista ao vídeo no final do post)

#include <float.h>

#define SAMP_SIZE 20
#define RISE_THRESHOLD 10
#define RISE_LIMIT 10
#define BEATS_SIZE 15
#define BPM_AVG_SIZE 4

int sensorPin = 0;
float readings[SAMP_SIZE], beats[BEATS_SIZE], bpmList[BPM_AVG_SIZE];
float readingsSum, bpmListSum, currentReading, sensorValue, startTime, lastReading, printValue, bpm;
long int currentTime, readingsIndex, bpmListIndex, lastBeat;
int riseCount, n;
bool rising;

void setup() {
	Serial.begin(9600);
	for(int i = 0; i < SAMP_SIZE; i++)
		readings[i] = 0;
	for(int i = 0; i < BPM_AVG_SIZE; i++)
		bpmList[i] = 0;
	for(int i = 0; i < BEATS_SIZE; i++)
		beats[i] = FLT_MAX;
	readingsSum = 0;
	readingsIndex = 0;
	bpmListSum = 0;
	bpmListIndex = 0;
}

void loop(){
	n = 0;
	startTime = millis();
	sensorValue = 0.;
	do{
		sensorValue += analogRead(sensorPin);
		n++;
		currentTime = millis();
	}while(currentTime - startTime < 16.6667);  
	sensorValue /= n;
	
	readingsSum -= readings[readingsIndex];
	readingsSum += sensorValue;
	readings[readingsIndex] = sensorValue;
	
	currentReading = readingsSum / SAMP_SIZE;
	
	if (currentReading > lastReading && currentReading-lastReading < RISE_LIMIT){
		riseCount++;
		if (!rising && riseCount > RISE_THRESHOLD){
			rising = true;
			beats[0] = millis() - lastBeat;
			lastBeat = millis();

			float beatsSum = 0;
			for(int i = 0; i < BEATS_SIZE; i++) beatsSum += beats[i];
			bpm = BEATS_SIZE*60000.0/beatsSum;

			bpmListSum -= bpmList[bpmListIndex];
			bpmListSum += bpm;
			bpmList[bpmListIndex++] = bpm;
			bpmListIndex %= BPM_AVG_SIZE;
			printValue = bpmListSum/BPM_AVG_SIZE;
			
			Serial.print(printValue);
			Serial.print('\n');
			
			for(int i = BEATS_SIZE-1; i>0; i--) beats[i] = beats[i-1];
		}
	}
	else{
		rising = false;
		riseCount = 0;
	}
	lastReading = currentReading;
	readingsIndex++;
	readingsIndex %= SAMP_SIZE;
}

Leitura dos BPMs. Autoria Própria

Quero mostrar uma última imagem comparando todos os sinais juntos, para mostrar o quão importante é fazer o processamento de sinais. Além disso deixarei um vídeo no final do post com explicações mais detalhadas sobre todo esse projeto.

Todos os sinais juntos, mostrando a eficiência do processamento de sinais. Autoria Própria

Video do projeto: