/*******************************************************************************
 * 
 * Exemplo de monitor multiparamétrico usando Arduino Uno.
 * Este exemplo utiliza:
 *  - display OLED com controlador SSD1306 para gráficos e informações;
 *  - módulo de oximetria MAX30102 (comunicação I2C (pinos A4 e A5));
 *  - módulo de ECG AD8232 (pino A0);
 *  - monitoramento da bateria (pino A1).
 * 
 * Criado por: Erick León, 2023
 * 
 ********************************************************************************/

// Bibliotecas utilizadas:
#include <Wire.h>                  // comuicação I2C (OLED e Oxímetro)
#include <Adafruit_SSD1306.h>      // comunicação com o display OLED

// Configuração do display OLED. Parâmetros:
//    - largura_do_display: 128 pixels
//    - altura_do_display: 64 pixels
//    - biblioteca de comunicação I2C utilizada
//    - pino de Reset do display (-1 em caso de não ter)
Adafruit_SSD1306 display(128, 64, &Wire, -1);

const byte NUM_PONTOS_GRAF = 55;   // Número de pontos dos gráficos
unsigned long tempoAnterior = millis(); // para medir taxa de medição dos dados
float freqAquisicao;                    // taxa de medição dos dados

// Outras bibliotecas com as funções utilizadas:
#include "ecg.h"                   // funções do ECG AD8232
#include "oximetro.h"              // funções do sensor MAX30102
#include "tela.h"                  // funções do display OLED

/////////////////////////////////////////////////////////////////////
// esta função só roda uma vez, no início
void setup() {
    Wire.begin();                  // inicia a comunicação I2C
    delay(500);                    // aguarda 500ms

    configuraAdcEcg();
    inicializaDisplay();
    inicializaOximetro();
}

/////////////////////////////////////////////////////////////////////
// esta função se repete indefinidamente
void loop() {
    // mede a taxa de medição dos dados
    freqAquisicao = 1000.0/(millis()-(float)tempoAnterior);
    tempoAnterior = millis();
    
    medeOximetro(); // dispara leitura do oxímetro e do ECG
    desenhaTela();  // atualiza tela
}

/*******************************************************************************
 * Funções usadas com o sensor AD8232 (ECG).
 * 
 * Criado por: Erick León, 2023
 ********************************************************************************/

const byte NUM_PONTOS_ECG = NUM_PONTOS_GRAF; // Número de pontos do gráfico do ECG

int ecg_vec[NUM_PONTOS_ECG]; // vetor com as medidas atuais
bool lendo_bateria=false; // variável que verifica se é uma leitura de bateria
int tensao_bateria=0;

////////////////////////////////////////////////////////////////
// 'Anda' com o vetor de medidas do ADC, e guarda a nova medida
// na última posição.
// Esta interrupção roda assim que o ADC termina uma medida.
ISR (ADC_vect){
    if(lendo_bateria){
        tensao_bateria = ADC;  // lê valor do ADC (tensão na bateria)
        ADMUX = bit (REFS0) | (0 & 7);      // volta para canal do ECG (A0)
        lendo_bateria = false;
    }
    else{ // lendo ECG
        // 'anda' com os dados do gráfico para a esquerda e guarda nova medida
        for (int idx=0; idx<NUM_PONTOS_ECG-1;idx++) ecg_vec[idx] = ecg_vec[idx+1];
        ecg_vec[NUM_PONTOS_ECG-1] = ADC;  // lê valor do ADC (sinal de ECG)
    }
}

////////////////////////////////////////////////////////////////
// Configura o ADC com prescaler de 128, leitura única no pino
// A0, disparando interrupção (ADC_vect) ao final da medição.
// Esta função só roda quando chamada.
void configuraAdcEcg(){
    // configuração do ADC usado para medir o sinal de ECG
    ADCSRA =  bit (ADEN) | bit (ADIE) | bit (ADIF);     // liga o ADC e interrupção (ADC_vect)
    ADCSRA |= bit (ADPS0) |  bit (ADPS1) | bit (ADPS2); // Prescaler de 128
    ADMUX = bit (REFS0) | (0 & 7);      // leitura do canal 0 (A0)
}

////////////////////////////////////////////////////////////////
// Inicia uma conversão (medida de tensão na bateria) do ADC.
// Esta função só roda quando chamada.
void disparaLeituraBateria(){
    lendo_bateria=true; // avisa a interrupção do ADC que não é leitura de ECG
    ADMUX = bit (REFS0) | (1 & 7);      // leitura do canal 1 (A1)
    bitSet (ADCSRA, ADSC);  // inicia uma medida no ADC
}

////////////////////////////////////////////////////////////////
// Inicia uma conversão (medida de ECG) do ADC.
// Esta função só roda quando chamada.
void disparaLeituraEcg(){
    bitSet (ADCSRA, ADSC);  // inicia uma medida no ADC
}

/*******************************************************************************
 * Funções usadas com o sensor MAX30102 (oxímetro).
 * 
 * Criado por: Erick León, 2023
 ********************************************************************************/

#include "MAX30105.h"            // comunicação com sensor MAX30102

#define PONTOS_PICO_FREQ 5       // nro de pontos para verificar se ocorreu pico
const byte NUM_PONTOS_OX = NUM_PONTOS_GRAF;   // Número de pontos do gráfico do Oxim

MAX30105 meuOximetro;            // declaração do sensor MAX30102

const byte NUM_PONTOS_FREQ = 4;  // Número de medidas usadas na média
byte freqs_vec[NUM_PONTOS_FREQ]; // Vetor de medidas de frequência
byte posFreq = 0;                // guarda a posição atual do vetor
float batidasPorMinuto;          // frequência (batidas por minuto)
int freqMedia;                   // média da frequência
long valorIR;                    // valor lido pelo sensor
int valorIR_vec[NUM_PONTOS_OX]; // vetor com valores lidos (IR)
long maximoOxim;                 // valor máximo do gráfico do oxímetro
long minimoOxim;                 // valor mínimo do gráfico do oxímetro
long amplitudeOxim;              // amplitude do gráfico do oxímetro
unsigned long ultimaBatida = millis(); // instante da última batida
int contadorTemperatura = 0;     // contador da última medida da temperatura
int contadorBatida = 100;        // contador da última batida detectada
float temperatura;               // valor da temperatura
long media = 0;                  // média dos valores lidos

// para o cálculo do SpO2:
int16_t spo2 = 0;                // guarda o valor de SpO2
#include "spo2.h"                // biblioteca modificada p/ cálculo do SpO2

/////////////////////////////////////////////////////////////////////
// Inicializa a comunicação com o módulo de oximetria MAX30102.
// Esta função só roda quando chamada.
void inicializaOximetro(){
    display.clearDisplay(); // limpa o buffer da tela
    display.setCursor(0,0); // coloca o cursor de texto no canto superior esquerdo do buffer da tela
    
    // Initializa o sensor MAX30102, usando a porta I2C padrão, velocidade de 400kHz
    if (!meuOximetro.begin(Wire, I2C_SPEED_FAST)) // se não encontrou
    {
        display.print(F("Sensor nao encontrado"));  // coloca mensagem de erro no buffer
        display.display();  // atualiza a tela com as informações do buffer
        while (1); // Se não encontra o sensor, fica parado aqui em um loop infinito
    }
    display.println(F("Coloque o dedo no sensor"));  // coloca mensagem no buffer
    display.display();      // atualiza a tela com as informações do buffer
    delay(1000);            // aguarda 1 segundo
    
    // Configura o sensor MAX30102
    meuOximetro.setup();
    temperatura = meuOximetro.readTemperature(); // mede temperatura inicial
}

/////////////////////////////////////////////////////////////////////
// Encontra os valores máximo e mínimo e a amplitude dos dados do
// oxímetro.
// Esta função só roda quando chamada.
void encontraMaxMinOxim(){
    //encontra máximos e mínimos dos valores lidos
    maximoOxim = -2000000;
    minimoOxim = 2000000;
    for (int idx=0; idx<NUM_PONTOS_OX;idx++){
        if (valorIR_vec[idx] > maximoOxim) maximoOxim = valorIR_vec[idx];
        if (valorIR_vec[idx] < minimoOxim) minimoOxim = valorIR_vec[idx];
    }
    amplitudeOxim = maximoOxim-minimoOxim;
}

/////////////////////////////////////////////////////////////////////
// Verifica se ocorreu uma batida cardíaca procurando por um pico
// no sinal do oxímetro.
// Esta função só roda quando chamada.
void verificaBatidaOximetro(){
    encontraMaxMinOxim(); // encontra amplitude dos dados do oxímetro
    //verifica se ocorreu um pico
    int distancia = PONTOS_PICO_FREQ; // distância entre pontos para verificar um pico
    long variacao = (float)amplitudeOxim/5.0; // variação mínima para considerar pico
    unsigned long tempoAtual = millis();
    // condição 1: ponto candidato acima do ponto à frente
    bool condicao1 = valorIR_vec[NUM_PONTOS_OX-distancia-1]-valorIR_vec[NUM_PONTOS_OX-1]>variacao;
    // condição 2: ponto candidato acima do ponto atrás
    bool condicao2 = valorIR_vec[NUM_PONTOS_OX-distancia-1]-valorIR_vec[NUM_PONTOS_OX-2*distancia-1]>variacao;
    // condição 3: frequencia < 200bpm (tempo entre batidas > 300ms)
    bool condicao3 = tempoAtual-ultimaBatida > 300;
    // condição 4: dedo no sensor
    bool condicao4 = valorIR > 50000;
    if ( condicao1 && condicao2 && condicao3 && condicao4 ){
        contadorBatida = 0; // zera contador para mostrar indicador de batida na tela

        // calcula a frequência em batidas por minuto
        batidasPorMinuto = 60 / ((tempoAtual-ultimaBatida) / 1000.0);
        ultimaBatida = tempoAtual;

        if ( batidasPorMinuto>20 && batidasPorMinuto<200 ){ // se valor é válido
            freqs_vec[posFreq++] = (byte)batidasPorMinuto; // Armazena a leitura no vetor
            posFreq %= NUM_PONTOS_FREQ; // se chegou no final, volta para o início
            
            // Calcula a média das leituras, eliminando maior e menor valores
            freqMedia = 0;
            int freqMax=0;
            int freqMin=999;
            for (byte x = 0 ; x < NUM_PONTOS_FREQ ; x++){
                    if (freqs_vec[x]>freqMax) freqMax = freqs_vec[x];
                    if (freqs_vec[x]<freqMin) freqMin = freqs_vec[x];
                    freqMedia += freqs_vec[x];
            }
            freqMedia = freqMedia - freqMax - freqMin;
            freqMedia /= (NUM_PONTOS_FREQ-2);
        }
    }
}

/////////////////////////////////////////////////////////////////////
// Realiza leitura do módulo oxímetro MAX30102 e dispara a leitura
// do ECG, para as medidas ficarem sincronizadas.
// Esta função só roda quando chamada.
void medeOximetro(){
    disparaLeituraEcg();           // para leituras ficarem sincronizadas...
    valorIR = meuOximetro.getIR(); // mede valor do led IR do MAX30102
    adicionaMedidaIR(valorIR);               // para cálculo do SpO2
    adicionaMedidaRed(meuOximetro.getRed()); // para cálculo do SpO2

    // encontra a média exponencial dos últimos valores lidos
    media = 0.8*media + 0.2*valorIR;

    // 'anda' com os dados do gráfico para a esquerda
    for (int idx=0; idx<NUM_PONTOS_OX-1;idx++) valorIR_vec[idx] = valorIR_vec[idx+1];

    // acrescenta o novo valor no final, subtraindo o valor médio
    valorIR_vec[NUM_PONTOS_OX-1] = valorIR - media;

    verificaBatidaOximetro(); // verifica se ocorreu uma batida cardíaca
}

/*******************************************************************************
 * Funções usadas com o display OLED com controlador SSD1306, usado para 
 * gráficos e apresentação de informações diversas.
 * 
 * Criado por: Erick León, 2023
 ********************************************************************************/

#include <Adafruit_GFX.h>          // construção de gráficos


/////////////////////////////////////////////////////////////////////
// Iniciliza o display OLED.
// Esta função só roda quando chamada.
void inicializaDisplay(){
    // inicializa a comunicação com o display, no endereço I2C 0x3C
    if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
        while (1);   // Se não conseguiu inicializar o display, fica aqui parado
    }
    display.setTextSize(1);        // escolhe o tamanho da letra
    display.setTextColor(WHITE);   // escolhe a cor da letra
}

/////////////////////////////////////////////////////////////////////
// Desenha uma curva (gráfico) no buffer do display OLED,
// acrescentando um retângulo ao redor da curva.
// Esta função só roda quando chamada.
void desenhaCurva(int posicao_inferior, int altura, int n_pontos, int *vec){
    long maximo = -99999;
    long minimo = 99999;
    long amplitude;
    for (int idx=0; idx<n_pontos-1;idx++){ // encontra maximo e minimo
        if (vec[idx] > maximo) maximo = vec[idx];
        if (vec[idx] < minimo) minimo = vec[idx];
    }
    amplitude = maximo - minimo;
    if (amplitude==0) amplitude = 1;
    for (int idx=0; idx<n_pontos-1;idx++){ // desenha curva
        // normaliza de 0 a 1
        float valorNorm = ((float)vec[idx+1]-(float)minimo)/((float)amplitude);
        float valorNorm_anterior = ((float)vec[idx]-(float)minimo)/((float)amplitude);
        // encontra posição no display
        int ponto = (float)posicao_inferior-(float)(altura-1)*valorNorm;
        int ponto_anterior = (float)posicao_inferior-(float)(altura-1)*valorNorm_anterior;
        display.drawLine(idx+1, ponto_anterior, idx+2, ponto, SSD1306_WHITE);
    }

    // desenha retângulo em volta do gráfico
    display.drawRect(0, posicao_inferior-altura-1, n_pontos+2, altura+2, SSD1306_WHITE);
}

/////////////////////////////////////////////////////////////////////
// Desenha todos os elementos da tela.
// Esta função só roda quando chamada.
void desenhaTela(){
    byte posXTexto = 70; // posição X do texto na tela
    byte altura_linha = 11; // latura da linha de texto, em pixels
    // soma 1 nos contadores
    contadorTemperatura++;
    contadorBatida++;
    
    display.clearDisplay();   // limpa o buffer da tela
    
    // Dados do oxímetro
    display.setCursor(0,0);   // posiciona cursor de texto
    display.print(F("Oximetro:")); // mostra mensagem
    display.setCursor(posXTexto,altura_linha*1); // posiciona cursor de texto
    display.print(freqMedia); // mostra no buffer da tela frequência cardíaca medida
    display.print(F(" bpm")); // mostra no buffer da tela a unidade de tempo do intervalo
    if (valorIR < 50000){
        display.setCursor(posXTexto,altura_linha*4); // posiciona cursor de texto
        display.print(F("sem dedo?")); // mostra mensagem
        spo2 = 0;
    }
    
    desenhaCurva(30,20,NUM_PONTOS_OX,valorIR_vec); // desenha curva do oxímetro no buffer

    // se ocorreu uma batida a menos de 3 atualizações, mostra círculo
    if (contadorBatida < 3) display.fillCircle(122, 5, 5, SSD1306_WHITE);

    //a cada 20 atualizações (aprox. 2 segundos), mede temperatura e SpO2
    if ( contadorTemperatura > 20 ) {
        temperatura = meuOximetro.readTemperature();
        contadorTemperatura = 0;
        int16_t spo2_temp = medeSpO2();
        if (spo2_temp>0) spo2 = spo2_temp;
    }

    display.setCursor(posXTexto,altura_linha*2); // posiciona cursor de texto
    display.print(F("SpO2:")); // mostra mensagem no buffer
    display.print(spo2);      // mostra no buffer da tela SpO2
    
    display.setCursor(posXTexto,altura_linha*3); // posiciona cursor de texto
    display.print(temperatura); // mostra no buffer da tela frequência cardíaca medida
    display.cp437(true);      // usa código de caracteres 'Code page 437' para símbolo de grau
    display.print((char)248); // símbolo de grau
    display.print(F("C"));    // mostra no buffer da tela a unidade da temperatura
    
    // Dados do ECG
    display.setCursor(0,33);  // posiciona cursor de texto
    display.print(F("ECG:")); // mostra mensagem

    desenhaCurva(62,20,NUM_PONTOS_ECG,ecg_vec); // desenha curva do ECG no buffer

    // mostra frequência de aquisição na tela:
    display.setCursor(posXTexto,0); // posiciona cursor de texto
    if (freqAquisicao<10.0) display.print(F(" ")); // para alinhar valores
    display.print(freqAquisicao);
    display.print(F("Hz"));

    // atualiza valor da tensão da bateria:
    display.setCursor(posXTexto,altura_linha*5); // posiciona cursor de texto
    display.print(F("Vin:"));
    disparaLeituraBateria();
    display.print(tensao_bateria*5.0*2.0/1024.0);
    display.print(F("V"));
    
    display.display();        // atualiza a tela com as informações do buffer
 
}