/*
  ############################################################################
  # Código Criado por: MarioParente
  # Data: __/__/2023
  # Detalhes do Projeto: v0.1 - Histórico de temperatura das últimas 24h
  #
  # Atualizações:
  # 20/08/23 - v0.1   - Introduzido suporte para diferentes tipos de sensores: DHT22 e BMP180
  # Set/2024 - v0.2   - Implementado relógio para inicialização da hora
  #          - v0.2.1 - Realizada limpeza e otimização do código para melhor desempenho
  #          - v0.3   - Adicionado loop de tempo para controle contínuo
  #          - v0.3.1 - Melhorada a organização das funções e otimização do código
  #          - v0.3.2 - Desenvolvido termômetro dinâmico para visualização de temperatura
  #          - v0.3.3 - Mais otimizações no código para eficiência
  # Out/2024 - v0.3.4 - Funções de exibição e menu reformuladas e otimizadas
  # Jan/2025 - v0.3.5 - Scarn I²C e Adição do sensor BMP280
  ############################################################################*/

  // Sensores Testados:
  // DHT22  Testado em __/__/____
  // BMP180 Testado em 25/09/2024
  // BMP280 Testado em 11/01/2025
  // RTC (DS3231) Testado em 26/09/2024

/*  anotação
Linha 0: corresponde à coordenada Y = 0.
Linha 1: Y = 8.
Linha 2: Y = 16.
Linha 3: Y = 24.
Linha 4: Y = 32.
Linha 5: Y = 40.
Linha 6: Y = 48.
Linha 7: Y = 56.
Linha 8: Y = 63.

Device found at 0x3C, type = SSD1306, capability bits = 0x100000
Device found at 0x68, type = DS3231 , capability bits = 0x10000
Device found at 0x76, type = BMP280 , capability bits = 0x7
Device found at 0x77, type = BMP180 , capability bits = 0x7
*/

#include <Adafruit_SSD1306.h> // Biblioteca para o display OLED
#include <DHTesp.h>           // Biblioteca para o sensor DHT22
#include <BMP180I2C.h>        // Biblioteca para o sensor BMP180
#include <Adafruit_BMP280.h>  // Biblioteca para o sensor BMP280
#include <RTClib.h>           // Biblioteca para o RTC

//Variáveis globais 
  const int DHT_PIN = 15; // Pino do sensor DHT22

  // Definição de variáveis de estado do sensor
  int Sensor = 0;

  // Definição de variáveis para temperatura e umidade
  int T = 0, H = 0;

  // Variáveis de tempo
  int falhasConsecutivas = 0;  // Contador de falhas consecutivas na leitura do RTC
  int Ano_ini = 0;

  // Definição de variáveis para temperatura e umidade atuais, máximas e mínimas
  int Atual_T = 0, Max_T = 0, Min_T = 0; 
  int Atual_H = 0, Max_H = 0, Min_H = 0; 

  int Menu = 0; // Controle do menu

  // Ponto de tempo e coordenadas para gráfico
  int T_Ponto = -1; // Ponto de tempo para gráfico
  int Ponto_A = 0, Ponto_B = 0; // Coordenadas para o gráfico

// Instância dos sensores e do display
  DHTesp dhtSensor;
  TempAndHumidity data; 
  BMP180I2C bmp180(0x77); // Instância do sensor BMP180
  Adafruit_BMP280 bmp280;
  Adafruit_SSD1306 display(128, 64, &Wire); // Instância do display OLED

  // Instância do RTC
  RTC_DS1307 rtc; 
  //RTC_DS3231 rtc; 
  
//#######################################################

void ini_Sensor() {
  // Scanner I2C para detectar dispositivos conectados
  Serial.println(F("Procurando dispositivos I2C..."));
  
  // Variáveis de status de sensores
  bool rtcEncontrado = false, bmp180Encontrado = false, bmp280Encontrado = false, dht22Encontrado = false;

  for (uint8_t address = 1; address < 127; address++) {
    Wire.beginTransmission(address);
    if (Wire.endTransmission() == 0) {
      Serial.print(F("Dispositivo I2C encontrado no endereço 0x"));
      Serial.println(address, HEX);
      
      // Verificação do RTC DS3231 (endereço 0x68)
      if (address == 0x68) {
         delay(200);
        if (rtc.begin()) {
          rtcEncontrado = true;
          display.setCursor(20, 16);     
          Serial.println(F("RTC DS3231 Encontrado e Inicializado"));
          display.print(F("RTC Encontrado"));
        } else {
          rtcEncontrado = false;
          Serial.println(F("RTC DS3231 Não Inicializado"));
          display.setCursor(20, 16);
          display.print(F("RTC Nao Encontrado"));
        }
        display.display();
      }
      
      // Verificação do BMP280 (endereço 0x76)
      if (address == 0x76) {
        delay(200);
        if (bmp280.begin(0x76)) {
          bmp280Encontrado = true;
          Serial.println(F("BMP280 Encontrado e Inicializado"));
          display.setCursor(0, 24);
          display.print(F("  BMP280 Encontrado "));
          Sensor = 3; // Define BMP280 como ativo
        } else {
          Serial.println(F("BMP280 Não Encontrado"));
          display.setCursor(0, 24);
          display.print(F("BMP280 Nao Encontrado"));
        }
        display.display();
      }
      
      // Verificação do BMP180 (endereço 0x77)
      if (address == 0x77) {
        delay(200);
        if (bmp180.begin()) {
          bmp180Encontrado = true;
          Serial.println(F("BMP180 Encontrado e Inicializado"));
          display.setCursor(0, 32);
          display.print(F("  BMP180 Encontrado "));
          Sensor = 2; // Define BMP180 como ativo
        } else {
          Serial.println(F("BMP180 Não Encontrado"));
          display.setCursor(0, 32);
          display.print(F("BMP180 Nao Encontrado"));
        }
        display.display();
      }      
    }
  }

  // Verificação do DHT22 caso nenhum dos BMPs tenha sido encontrado
  if (Sensor == 0 && !bmp180Encontrado && !bmp280Encontrado) {
    TempAndHumidity data = dhtSensor.getTempAndHumidity();
    delay(200);
    if (!isnan(data.temperature)) {
      dht22Encontrado = true;
      display.setCursor(20, 40);
      Serial.println(F("DHT22 Encontrado"));
      display.print(F("   DHT22 Encontrado  "));
      Sensor = 1; // Define o sensor DHT como ativo
    } else {
      Serial.println(F("DHT22 Não Encontrado"));
      display.setCursor(5, 40);
      display.print(F("DHT22 Nao Encontrado"));
    }
    display.display();
  }

  // Mensagem final indicando o status dos dispositivos
  if (!rtcEncontrado && !bmp180Encontrado && !bmp280Encontrado && !dht22Encontrado) {
    Serial.println(F("Nenhum dispositivo I2C encontrado!"));
  }
  display.display(); // Atualiza o display
}


//#######################################################
void Sensor_DHT22() {
  // Obtém dados de temperatura e umidade do sensor DHT
  TempAndHumidity data = dhtSensor.getTempAndHumidity();  
  // Converte os valores para inteiros  
  if (isnan(data.temperature)) {
    Advertencia(); 
  } else {
    T = constrain(data.temperature, 0, 60);
    H = constrain(data.humidity, 0, 99);
  }
}

void Sensor_BMP180() {
  // Mede a temperatura com o BMP180
  bmp180.measureTemperature();
  delay(100);  // Aguarda a medição ser concluída

  // Verifica se a medição foi realizada com sucesso
  if (bmp180.hasValue()) {
    T = constrain(bmp180.getTemperature(), 0, 60);
  } else {
    Advertencia();  // Chama a função de advertência caso a medição não tenha sido realizada
  }
  // Como o BMP180 não mede umidade, define H como 0
  H = 0;
}

void Sensor_BMP280() {
  // Lê a temperatura do BMP280
  float temp = bmp280.readTemperature();
  delay(100);  // Aguarda a medição ser concluída
  
  // Verifica se a leitura da temperatura é válida
  if (isnan(temp)) {
    Advertencia();  // Chama a função de advertência caso a medição não tenha sido realizada
  } else {
    T = constrain(temp, 0, 60); // Define limite de temperatura aceitável   
  }
  H = 0; // O BMP280 não mede umidade, então define como 0
}


void Tempo() {
  // Obtém a hora e minutos do RTC
  DateTime now = rtc.now();
  
  // Verifica se o RTC está retornando uma data/hora válida
  if (now.year() < Ano_ini) {  // Se o ano lido for menor que o gravado na inicialização consideramos uma falha
    falhasConsecutivas++;
    if (falhasConsecutivas >= 5) {
      //rtcValido = false;
      Advertencia();  // Chama a função de advertência
    }

  } else {
    falhasConsecutivas = 0;
    // Atualiza o display apenas se o RTC estiver funcionando
    int horaAtual = now.hour();
    int minutoAtual = now.minute();
  
    // Calcula o tempo total em blocos de 15 minutos
    int MarcadorAtual = ((horaAtual * 60) + minutoAtual) / 15;

    // Verifica se um novo ponto deve ser gerado
    if (T_Ponto != MarcadorAtual) {
      T_Ponto = MarcadorAtual;
      Ponto(T_Ponto, T); // Chama a função para gerar o ponto
    }   
  }
}

void Alteracao() {
  Menu = (Menu + 1) % 3;  // Alterna o Menu entre 0, 1 e 2
}

void Iniciando() {
  // Inicializa o sensor 
  if (Sensor == 1) {
    Sensor_DHT22();
  } else if (Sensor == 2) {
    Sensor_BMP180();
  } else if (Sensor == 3) {
    Sensor_BMP280();
  }
  // Define valores iniciais de temperatura e umidade
  Atual_T = Max_T = Min_T = T;
  Atual_H = Max_H = Min_H = H;

  // Obtém a hora e minutos do RTC
  DateTime now = rtc.now();
  int totalMinutos = now.hour() * 60 + now.minute(); // Cálculo total de minutos

  // Calcula Ponto_A e Ponto_B
  Ponto_A = (totalMinutos / 15) + 29; // Ponto_A ajustado
  Ponto_B = map(Atual_T, 60, 0, 15, 51); // Mapeia Atual_T para Ponto_B
}

void ExibirDados(int tipo, int x, int n) {
  display.fillRect(33, 0, 80, 8, BLACK);
  //display.drawRect(33, 0, 80, 8, 1);
  switch (tipo) {
    case 0:  // Exibe valores atuais
      display.setCursor(33, 0);
      display.print("Atual:" + String(x) + "C " + String(n) + "%");
      break;
    case 1:  // Exibe valores máximos
      Max_T = max(Max_T, x);  // Atualiza Max_T se x for maior
      Max_H = max(Max_H, n);  // Atualiza Max_H se n for maior
      display.setCursor(33, 0);
      display.print("Max  :" + String(Max_T) + "C " + String(Max_H) + "%");
      break;
    case 2:  // Exibe valores mínimos
      Min_T = min(Min_T, x);  // Atualiza Min_T se x for menor
      Min_H = min(Min_H, n);  // Atualiza Min_H se n for menor
      display.setCursor(33, 0);
      display.print("Min  :" + String(Min_T) + "C " + String(Min_H) + "%");
      break;
  }
}

void Grafico() {
  display.drawLine(27, 53, 126, 53, 1); // linha Horizontal
  display.drawLine(27, 13, 27, 53, 1); // linha Vertical
  // Pontos linha horizontal
  for (int i = 0; i <= 4; i++) {
    display.drawPixel(29 + i * 24, 54, 1);
    display.drawPixel(29 + i * 24, 55, 1);
  }
  // Pontos linha Vertical
  for (int i = 0; i <= 4; i++) {
    display.drawPixel(25, 15 + i * 9, 1);
    display.drawPixel(26, 15 + i * 9, 1);
  } 
}

void Texto_grafico() {
  // Texto horizontal hora
  const char* horas[] = {"0", "6", "12", "18"};
  int posX_horas[] = {27, 51, 72, 96};
  
  for (int i = 0; i < 4; i++) {
    display.setCursor(posX_horas[i], 57);
    display.print(horas[i]);
  }
  // Texto vertical temperatura
  const char* temperaturas[] = {"60", "45", "30", "15", " 0"};
  //const char* temperaturas[] = {40, 30, 20, 10, 0};  // Para futura update
  int posY_temperaturas[] = {12, 21, 30, 39, 48};

  for (int i = 0; i < 5; i++) {
    display.setCursor(13, posY_temperaturas[i]);
    display.print(temperaturas[i]);
  }
  // Legenda
  display.setCursor(0, 0);
  display.print("Temp");
  display.setCursor(0, 57);
  display.print("Hora");
}

void criarTermometro() {
  // Marcação
  display.drawLine(9, 15, 10, 15, WHITE);  // Marcação na altura 14
  display.drawLine(9, 24, 10, 24, WHITE);  // Marcação na altura 23
  display.drawLine(9, 33, 10, 33, WHITE);  // Marcação na altura 32
  display.drawLine(9, 42, 10, 42, WHITE);  // Marcação na altura 41
  display.drawPixel(10, 51, WHITE);  // Marcação na altura 50

  // Termômetro
  display.drawPixel(5, 13, WHITE);  // Topo do tubo
  display.drawPixel(4, 14, WHITE);  // Canto superior esquerdo
  display.drawPixel(6, 14, WHITE);  // Canto superior direito
  display.drawLine(3, 15, 3, 54, WHITE);  // Linha esquerda do tubo
  display.drawLine(7, 15, 7, 54, WHITE);  // Linha direita do tubo
  display.drawLine(4, 49, 6, 49, WHITE);  // Divisão entre tubo e bulbo
  display.drawLine(2, 51, 2, 53, WHITE);  // Linha esquerda do bulbo
  display.drawLine(8, 51, 8, 53, WHITE);  // Linha direita do bulbo    
  display.drawLine(4, 55, 6, 55, WHITE);  // Base do bulbo
  display.drawRect(3, 51, 5, 3, BLACK);  // Espaço no meio do bulbo
  display.drawPixel(5, 49, BLACK);  // Espaço no meio    
  display.fillCircle(5, 52, 1, WHITE);  // Bulbo
}

void Ponto(int x, int y) {
  // Ajuste para o eixo x
  x += 29;

  // Limita o valor de y entre 0 e 60
  y = constrain(y, 0, 60);
  
  // Mapeia o valor de y para as coordenadas da tela
  y = map(y, 60, 0, 15, 51);

  // Desenha uma linha a partir do último ponto até o ponto atual
  if (Ponto_A == 124) {  //Verifica se estamos no final do gráfico (23:45) para desenhar até 24:00 (x = 125)
    display.drawLine(Ponto_A, Ponto_B, 125, y, 1); // Desenha até 24:00
   
    // Reinicia o gráfico no novo dia
    Ponto_A = 29;
    Ponto_B = y;
    display.drawLine(Ponto_A, Ponto_B, Ponto_A, Ponto_B, 1); // Desenha também o novo 00:00

  } else {
    // Desenha o ponto normalmente
    display.drawLine(Ponto_A, Ponto_B, x, y, 1);

    // Atualiza Ponto_A e Ponto_B para o próximo ponto
    Ponto_A = x;
    Ponto_B = y;
  }
}

void Mercurio(int a){
  a = constrain(a, 0, 60);
  a = map(a, 0, 60, 51, 15);
  a = constrain(a, 15, 47);
  display.drawLine(5, 47, 5, 14, BLACK); // Apaga o antigo  
  display.drawLine(5, 47, 5, a, WHITE); // Desenha o novo nível do mercúrio
}

void Advertencia() { // Exibi um logo na tela informando que conteve uma falha.
  // Desenhar linha vertical
  display.drawLine(122, 3, 122, 6, WHITE);  // Ponto inicial (118, 3) até (118, 6)
  
  // Desenhar pixel
  display.drawPixel(122, 8, WHITE);         // Pixel em (118, 8)

  // Desenhar triângulo
  display.drawTriangle(122, 0, 117, 9, 127, 9, WHITE);  // Vértices (118, 0), (113, 9), (123, 9)
}

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, LOW);
  delay(100);
  Serial.begin(115200);
  delay(100);
  Serial.println("###  Iniciando  ###");
  delay(100);

  // Inicializa o display
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C); 
  display.clearDisplay();

  // Exibe a mensagem inicial
  display.setTextColor(WHITE, BLACK);
  display.setTextSize(1);
  display.setCursor(20, 0);
  display.print(F("Auto-Dedetecao"));
  display.display();
    
  // Configura o sensor DHT
  dhtSensor.setup(DHT_PIN, DHTesp::DHT22);  
  // Ajusta o contraste do display
  display.ssd1306_command(SSD1306_SETCONTRAST);
  display.ssd1306_command(25); // Define o nível de brilho para 10% (aumenta a vida util do display)
  
  // Inicializa os sensores e outros componentes
  ini_Sensor();
  display.display();
  delay(1000);
  if (Sensor == 0) { 
    display.setCursor(0, 32);
    display.println(F("    Nenhum sensor    "));
    display.println(F("      detectado      "));
    display.println(F("    Verifique as     "));
    display.println(F("      conexoes       "));
    display.display();
    delay(100);  // Aguarda 5 segundos para a mensagem ser visível
    while (1) {
      for (int pwmValue = 0; pwmValue <= 1023; pwmValue += 10) {
        analogWrite(LED_BUILTIN, pwmValue);
        delay(10);
      }
      for (int pwmValue = 1023; pwmValue >= 0; pwmValue -= 10) {
        analogWrite(LED_BUILTIN, pwmValue);
        delay(10);
      }
    }
  // Fica travado no loop infinito
  }
  // Pausa para a visualização da mensagem
  delay(1500);
  display.clearDisplay();
  
  // Chama funções para configurar o gráfico e iniciar a exibição
  Texto_grafico();
  Grafico();
  criarTermometro();
  Iniciando();
  display.display();
}

void loop() {
  analogWrite(LED_BUILTIN, Menu == 0 ? 200 : 254);  // altere os valores 200 : 250 para o seu hardware
  // Seleção do sensor e obtenção dos dados
  if (Sensor == 1) {
    Sensor_DHT22(); // Lê os dados do sensor DHT
  } else if (Sensor == 2) {
    Sensor_BMP180(); // Lê os dados do sensor BMP
  } else if (Sensor == 3) {
    Sensor_BMP280();
  }

  // Exibe as informações no display de acordo com o menu atual
  ExibirDados(Menu, T, H);
  Tempo(); 
  Alteracao();
  Mercurio(T);
  display.display();
  delay(1000);
}