Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Manufacturing Technology >> Processo de manufatura

Construção DIY de Sensor Oxímetro Preciso – IR, Arduino, LCD e Guia de Componentes

Componentes e Materiais

Emissor Infravermelho, 18° Comprimento de onda entre 805nm e 1000nm 1
Fotodiodo LPT80A Fotodiodo de ampla faixa, capaz de receber sinais vermelhos (600nm) e infravermelhos (940nm) 1
LED 5mm: Vermelho Comprimento de onda próximo a 600nm 1
Resistor 10k ohm 1
Resistor 330 ohm 2
Módulo Display LCD I2C 16x2 DFRobot para Arduino Ou outro display LCD para mostrar valores 1
Arduino UNO 1
Jumpers (genéricos) 1
LED de Alta Luminosidade, Branco Terceiro LED opcional, ver seção de melhorias 1

Ferramentas Necessárias

Aplicativos e Serviços Online

Sobre o Projeto

Neste período de isolamento, construí um oxímetro com peças que já tinha em casa. Afinal, um oxímetro é composto basicamente por dois LEDs e um fotodiodo.

Não sou especialista em conhecimentos médicos e, neste estágio do projeto, não tenho certeza se este trabalho tem valor diagnóstico, mas é um bom projeto educacional para estudar como funciona, e provavelmente com alguns ajustes poderia se tornar uma ferramenta médica caseira.

Saturação de Oxigênio e COVID-19

Neste período incrível de nossas vidas, aprendemos muito sobre vírus, pulmões, máscaras cirúrgicas, sabão e lavagem das mãos. Todos leem sobre sintomas como tosse, febre e dificuldade respiratória. Também descobrimos que uma forma de medir a dificuldade respiratória é ler a quantidade de oxigênio no sangue.

Esta medida pode ser lida indiretamente com um dispositivo médico chamado Oxímetro. Você provavelmente já viu um: é um dispositivo não invasivo que é colocado no dedo com luzes pulsantes que fazem o trabalho.

Normalmente, quando você está bem, tem uma porcentagem de saturação de oxigênio (SpO2) próxima ou maior que 95%. Quando a saturação cai abaixo de 90% e você tem tosse e febre, é um problema.

Se qualquer maker pudesse construir um oxímetro, descobrir uma infecção seria mais fácil e poderia ajudar as pessoas a decidirem ir ao hospital quando o problema realmente existe e não por um ataque de pânico.

Primeiro, Entenda Como Funciona o Sensor de Batimentos Cardíacos

Comecei este projeto brincando com um sensor de batimentos cardíacos KY-039 que encontrei em um kit de sensores que muitos de nós temos em casa. Como você pode ver no circuito abaixo, é apenas um LED infravermelho que ilumina um fotodiodo. Há também dois resistores para proteger o LED e ler o pequeno sinal do sensor.

Se você não tem um sensor KY-039, pode construir seu próprio sensor com poucos componentes.

Construção DIY de Sensor Oxímetro Preciso – IR, Arduino, LCD e Guia de Componentes

O dedo é colocado entre o sensor e o fotodiodo como na foto abaixo (originalmente tirada de outro site e modificada):

Construção DIY de Sensor Oxímetro Preciso – IR, Arduino, LCD e Guia de Componentes

A luz emitida pelo LED infravermelho é parcialmente absorvida pela unha, pele e todas as outras partes do dedo, mas não é constante porque muda seguindo as alterações do sangue correndo nas veias. Quando o coração bate, o sangue é empurrado nas veias e a absorção de luz muda. Podemos medir a corrente gerada pelo fotodiodo iluminado pela luz infravermelha que o atinge.

O sensor KY-039 tem um pino S (sinal) para ler esse valor variável.

Podemos Medir a Frequência Cardíaca Contando Picos do Sinal

Ler um valor de um sinal variável de um sensor não é tão fácil, porque há muito ruído, o sinal é muito baixo, e precisamos fazer alguns cálculos para encontrar os bons valores para plotar.

Agradeço a este post útil de Johan Ha, que explica como calcular a média do sinal e também como remover o ruído feito por uma lâmpada doméstica (essa luz é ruído!).

O truque é fazer um array no qual inserimos um valor e removemos um valor para fazer a média dos últimos X valores lidos do sensor. Ele também descreve uma forma de encontrar a subida do sinal, contando N valores crescentes. Ou seja, quando um valor é maior que o valor anterior por N vezes, é um pico.

Usando a ferramenta Serial Plot do Arduino ou outra ferramenta serial para analisar valores impressos na porta COM (como SerialPlot), e testando diferentes valores, podemos definir um número N correto (constante rise_threshold no código). Se você definir um número muito grande ou muito pequeno, pode perder algumas batidas ou contar um dicrotic notch como uma batida.

Uma vez que você entende como encontrar os picos, basta contá-los, ou calcular o tempo entre uma pequena série de batidas para determinar sua taxa de BPM (Beats Per Minute).

Construindo o Oxímetro (Modificando o Sensor KY-039) para Encontrar a Saturação de Oxigênio

Nosso sangue absorve luz de maneira diferente com a mudança do comprimento de onda da luz. A luz vermelha (~600nm) é absorvida melhor pelo sangue que contém mais oxigênio, então podemos comparar as medidas feitas com LED infravermelho (~950nm) com as feitas com LED vermelho e encontrar a porcentagem de oxigênio no sangue. Esse valor é chamado de Sp02% (saturação periférica de oxigênio capilar).

Como eu tinha um sensor KY-039, decidi modificá-lo. Ele tem apenas um LED infravermelho, então adicionei um LED VERMELHO, desconectei o LED IR do Vcc e conectei com um resistor de 330 ohm os dois LEDs a dois pinos diferentes do Arduino.

(Se você não tem um sensor KY-039 para modificar, pode construí-lo: é apenas um par de LEDs, um fotodiodo e 3 resistores, e o esquema é realmente simples!)

Aqui está o esquema do sensor modificado:

Construção DIY de Sensor Oxímetro Preciso – IR, Arduino, LCD e Guia de Componentes

Dessa forma, podemos ligar o LED IR e ler o valor do pino S do KY-039, depois desligar o LED IR e ligar o LED VERMELHO, e ler o valor do pino S do KY-039.

Construção DIY de Sensor Oxímetro Preciso – IR, Arduino, LCD e Guia de Componentes

Se você plotar os dois sinais, verá que os valores IR são sempre menores que os valores do vermelho.

Construção DIY de Sensor Oxímetro Preciso – IR, Arduino, LCD e Guia de Componentes

Para obter um bom sinal, lembre-se de posicionar a ponta do dedo corretamente no fotodiodo e os LEDs devem tocar a unha. Quando encontrar uma posição confortável com boa leitura no plot, não a mude.

Como os sinais são baixos e o ruído é muito problemático, para obter medidas úteis percebi que uma boa luz ambiente é sempre necessária. Portanto, não mova o dedo durante a medição e não mude a luz; apenas uma sombra no sensor pode mudar tudo.

Como é Medida a Saturação SpO2%

O nível de saturação de oxigênio (SpO2) é a fração de hemoglobina saturada com oxigênio relativa à hemoglobina total e é uma função de um parâmetro chamado R (encontrei esta informação em um artigo acadêmico do Politécnico de Milão), que é calculado usando valores mínimos e máximos dos dois sinais:

R = ( (REDmax-REDmin) / REDmin ) / ((IRmax-IRmin) / IRmin)

Cada instrumento tem seu próprio R e é necessária calibração para encontrar a curva (a função) que conecta R com SpO2%.

Contamos o número de picos, mas agora precisamos encontrar os valores máx e mín das duas curvas (LED VERMELHO e LED IR).

Para realizar este trabalho, avaliamos o "período" do batimento cardíaco (ou seja, quantos milissegundos dura uma batida) e dividimos pela taxa de amostragem para determinar quantas amostras compõem um período. A taxa de amostragem no nosso caso é de 40 milissegundos porque lemos o LED IR por 20 milissegundos e depois o LED vermelho por outros 20 milissegundos.

O período da batida é o tempo que passa entre duas curvas ascendentes no sinal.

Assim, posso analisar as últimas L amostras (onde L = período / 40), que salvei em um array, para encontrar os valores REDmax, REDmin, IRmax e IRmin.

Com os valores máximo e mínimo, posso calcular R.

R, L e período são calculados a cada batida, então o cálculo de R também é feito para cada batida.

De R para SpO2%: Como Calibrar o Oxímetro?

A função que liga R com SpO2 pode ser simplificada com uma linha reta:

SpO2 = K * R + M

Precisamos de dois pontos (dois pares de valores de SpO2 e R) para determinar K e M. A única forma de encontrar esses 2 pontos é usando outro oxímetro e lendo os valores do seu display.

O novo oxímetro será a referência: lemos o valor de SpO2 enquanto medimos os valores de R do nosso oxímetro caseiro.

Primeiro respire normalmente e leia o valor de SpO2 e R. Anote.

Então tente prender a respiração e após 10-20 segundos você verá o SpO2 no novo oxímetro diminuindo; você também deve ver o parâmetro R do seu oxímetro aumentando. Antes de desmaiar, anote os valores de SpO2 atingidos e o valor do seu parâmetro R.

Resolva a equação de 2º grau e encontre K e M para seu oxímetro.

Agora é possível calcular tanto bpm quanto SpO2 para cada medida de R.

Também adicionei um display para mostrar todos os números. Mostro valores apenas se encontrei pelo menos 5 medidas de períodos que não mudam muito (±10% do comprimento do período). Dessa forma, removo valores que mudam muito e que dependem dos componentes pobres ou mudança de luz ambiente ou movimento do dedo.

O valor c indica que os valores mostrados são calculados com c medidas estáveis.

Melhoria do Projeto: Remover a Variabilidade da Luz Ambiente

Após alguns dias brincando com meu projeto, encontrei uma forma de melhorá-lo.

Percebi que com esses componentes de baixo custo (estamos usando apenas LEDs e um fotodiodo!) as medidas dependem demais da luz ambiente e isso não é bom se quisermos ler dados adequadamente em um ambiente de trabalho real. Como notei que em um dia ensolarado os resultados são melhores do que com luz nublada ou à noite quando uso uma lâmpada elétrica, decidi adicionar um terceiro LED, que fica sempre ligado e fornece apenas luz no dedo.

Construção DIY de Sensor Oxímetro Preciso – IR, Arduino, LCD e Guia de Componentes

Com este sensor de 3 LEDs, as medidas também são tomadas sob um pano preto para excluir a luz ambiente que pode sempre mudar.

Construção DIY de Sensor Oxímetro Preciso – IR, Arduino, LCD e Guia de Componentes

Agora, os resultados são melhores e não dependem mais da luz ambiente.

Também precisei recalibrar o oxímetro, como você pode ver no vídeo, após alguns segundos ele encontra corretamente bpm e SpO2%.

Código

oximeter-diy-ver-0.92.ino Arduino

Este é o código fonte do Oxímetro DIY, feito com poucos componentes que um maker poderia ter em casa.

/* 
 * um oxímetro diy. v.0.92 (pequenas correções) 
 * hackeando um sensor de batimentos ky-039 ou usando um led infravermelho 
 * um led vermelho e um fotodiodo. 
 * https://hackaday.io/project/170752-oximeter-do-it-yourself 
 */
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#define maxperiod_siz 80 // max número de amostras em um período
#define measures 10 // número de períodos armazenados
#define samp_siz 4 // número de amostras para média
#define rise_threshold 3 // número de medidas crescentes para determinar um pico
// um display de cristal líquido mostra BPM
LiquidCrystal_I2C lcd(0x3F, 16, 2);
int T = 20; // slot milissegundos para ler um valor do sensor
int sensorPin = A1;
int REDLed = 3;
int IRLed = 4;
byte sym[3][8] = {
 { B00000, B01010, B11111, B11111, B01110, B00100, B00000, B00000 },
 { B00000, B00000, B00000, B11000, B00100, B01000, B10000, B11100 },
 { B00000, B00100, B01010, B00010, B00100, B00100, B00000, B00100 } 
};
void setup() {
 Serial.begin(9600);
 Serial.flush();
 pinMode(sensorPin,INPUT);
 pinMode(REDLed,OUTPUT);
 pinMode(IRLed,OUTPUT);
 // inicializa o LCD
 lcd.init();
 lcd.backlight();
 // desliga leds
 digitalWrite(REDLed,LOW);
 digitalWrite(IRLed,LOW);
 for(int i=0;i<8;i++) lcd.createChar(i, sym[i]);
}
void loop () {
 bool finger_status = true;
 float readsIR[samp_siz], sumIR,lastIR, reader, start;
 float readsRED[samp_siz], sumRED,lastRED;
 int period, samples;
 period=0;
 samples=0;
 int samplesCounter = 0;
 float readsIRMM[maxperiod_siz],readsREDMM[maxperiod_siz];
 int ptrMM =0;
 for (int i = 0; i < maxperiod_siz; i++) {
 readsIRMM[i] = 0;readsREDMM[i]=0;}
 float IRmax=0; float IRmin=0; float REDmax=0; float REDmin=0;
 double R=0; float measuresR[measures]; int measuresPeriods[measures]; int m = 0;
 for (int i = 0; i < measures; i++) { measuresPeriods[i]=0; measuresR[i]=0; }
 int ptr; float beforeIR; bool rising; int rise_count; int n; long int last_beat;
 for (int i = 0; i < samp_siz; i++) { readsIR[i] = 0; readsRED[i]=0; }
 sumIR = 0; sumRED=0; ptr = 0;
 while(1) {
 // liga LED IR
 digitalWrite(REDLed,LOW); digitalWrite(IRLed,HIGH);
 // calcula média do sensor durante 20 ms (T) 
 // (isso elimina ruído de 50 Hz causado por luz elétrica)
 n = 0; start = millis(); reader = 0.;
 do { reader += analogRead (sensorPin); n++; } while (millis() < start + T);
 reader /= n; // obtemos uma média
 // Adiciona a medição mais nova a um array e subtrai a mais antiga
 sumIR -= readsIR[ptr]; sumIR += reader; readsIR[ptr] = reader;
 lastIR = sumIR / samp_siz;
 // LIGA LED VERMELHO e faz o mesmo
 digitalWrite(REDLed,HIGH); digitalWrite(IRLed,LOW);
 n = 0; start = millis(); reader = 0.;
 do { reader += analogRead (sensorPin); n++; } while (millis() < start + T);
 reader /= n;
 sumRED -= readsRED[ptr]; sumRED += reader; readsRED[ptr] = reader;
 lastRED = sumRED / samp_siz;
 // CÁLCULO DE R
 // salva todas as amostras de um período tanto para IR quanto para RED
 readsIRMM[ptrMM]=lastIR; readsREDMM[ptrMM]=lastRED; ptrMM++; ptrMM %= maxperiod_siz;
 samplesCounter++;
 // se salvei todas as amostras de um período, procuro max e min e calculo R
 if(samplesCounter>=samples){
 samplesCounter =0; IRmax = 0; IRmin=1023; REDmax = 0; REDmin=1023;
 for(int i=0;i<maxperiod_siz;i++) {
 if( readsIRMM[i]> IRmax) IRmax = readsIRMM[i];
 if( readsIRMM[i]>0 && readsIRMM[i]< IRmin ) IRmin = readsIRMM[i]; readsIRMM[i] =0;
 if( readsREDMM[i]> REDmax) REDmax = readsREDMM[i];
 if( readsREDMM[i]>0 && readsREDMM[i]< REDmin ) REDmin = readsREDMM[i]; readsREDMM[i] =0;
 }
 R = ( (REDmax-REDmin) / REDmin) / ( (IRmax-IRmin) / IRmin ) ;
 }
 // verifica se o dedo está no sensor. Se o dedo faltar, curva RED fica sob IR.
 if (lastRED < lastIR) {
 if(finger_status==true) { finger_status = false; lcd.clear(); lcd.setCursor(0,0); lcd.print("No finger?"); }
 } else {
 if(finger_status==false) { lcd.clear(); finger_status = true; lcd.setCursor(10,0); lcd.print("c="); lcd.setCursor(0,0); lcd.print("bpm"); lcd.setCursor(0,1); lcd.print("SpO"); lcd.write(1); lcd.setCursor(10,1); lcd.print("R="); }
 }
 float avR = 0; int avBPM=0;
 if (finger_status==true){
 // lastIR mantém a média dos valores no array
 // verifica curva ascendente (= batida cardíaca)
 if (lastIR > beforeIR) { rise_count++;
 if (!rising && rise_count > rise_threshold) {
 lcd.setCursor(3,0); lcd.write( 0 ); // <3
 // Detectamos curva ascendente, implica batida cardíaca.
 // Registra tempo desde última batida, mantém últimas 10 picos para média.
 rising = true; measuresR[m] = R; measuresPeriods[m] = millis() - last_beat; last_beat = millis();
 int period = 0; for(int i =0; i<measures; i++) period += measuresPeriods[i];
 period = period / measures; samples = period / (2*T);
 int avPeriod = 0; int c = 0;
 for(int i =1; i<measures; i++) {
 if ( (measuresPeriods[i] < measuresPeriods[i-1] * 1.1) && (measuresPeriods[i] > measuresPeriods[i-1] / 1.1) ) {
 c++; avPeriod += measuresPeriods[i]; avR += measuresR[i]; }
 }
 m++; m %= measures; lcd.setCursor(12,0); lcd.print(String(c)+" ");
 avBPM = 60000 / ( avPeriod / c) ; avR = avR / c ;
 lcd.setCursor(12,1); if(c==0) lcd.print(" "); else lcd.print(String(avR) + " ");
 if(c > 4) {
 int SpO2 = -19 * R + 112; // CALIBRAÇÃO: Y = k*x + m
 lcd.setCursor(4,0); if(avBPM > 40 && avBPM <220) lcd.print(String(avBPM)+" ");
 lcd.setCursor(4,1); if(SpO2 > 70 && SpO2 <150) lcd.print( " " + String(SpO2) +"% ");
 } else {
 if(c <3) { lcd.setCursor(3,0); lcd.write( 2 ); lcd.setCursor(4,1); lcd.write( 2 ); }
 }
 } else { rising = false; rise_count = 0; lcd.setCursor(3,0);lcd.print(" "); }
 beforeIR = lastIR;
 }
 // PLOT tudo
 Serial.print(lastIR); Serial.print(","); Serial.print(lastRED); Serial.println();
 ptr++; ptr %= samp_siz;
 }
}

Esquemáticos

No meu projeto modifiquei um KY-039, mas esse sensor não está disponível na biblioteca Fritzing, então o construí com os poucos componentes dos quais é feito, mas não encontrei um fotodiodo adequado na biblioteca Fritzing.

Construção DIY de Sensor Oxímetro Preciso – IR, Arduino, LCD e Guia de Componentes

Um oxímetro simples para ler oxigênio no sangue pode ser feito hackeando o sensor KY-039, ou construindo um sensor do zero.

Processo de manufatura

  1. Circuito Economizador de Energia com Sensor PIR: Projeto, Operação e Aplicações
  2. Qual Comprimento de Onda LiDAR Dominará Aplicações Automotivas?
  3. Construa um Sensor de Movimento Infravermelho DIY para Raspberry Pi – Guia Passo a Passo
  4. Controle um LED com Sensor de Movimento PIR no Raspberry Pi
  5. Construa um Sensor de Umidade do Solo de Baixo Custo para Irrigação Inteligente com Raspberry Pi
  6. Testando o Sensor de Temperatura DS18B20 no Raspberry Pi
  7. Construa Monitor de Temperatura Doméstico com Raspberry Pi, MCP9808, InfluxDB e Grafana
  8. Sensor Telemetry 2.0.1 – Monitoramento Avançado de Temperatura com Azure IoT Hub
  9. Sensor de Emoção & EEG: Hardware de Baixo Custo para Detecção de Emoções em Tempo Real
  10. Detecção de Temperatura Infravermelha de Precisão para Processos Sensíveis a Cor