#include <Wire.h>                                       // Responsável por conter as funções necessárias para gerenciar
                                                        // a comunicação entre os dispositivos através do protocolo I2C.
#include <LiquidCrystal_I2C.h>                          // Inclui a biblioteca do Display LCD I2C.
#include <DHT.h>                                        // Inclui a biblioteca do sensor DHT.

#define DHTPIN 7                                        // Define o pino digital para o DHT22.
#define DHTTYPE DHT22                                   // Definindo o tipo de sensor DHT.

#define LED_RED 8                                       // Define o LED vermelho que acende se temperatura < 20ºC.
#define LED_BLUE 9                                      // Define o LED azul que acende se temperatura > 40ºC.
#define LED_YELLOW 10                                   // Define o LED amarelo que acende se umidade > 75%.

#define RGB_RED 3                                       // Define o pino PWM para o componente vermelho do LED RGB.
#define RGB_GREEN 5                                     // Define o pino PWM para o componente verde do LED RGB.
#define RGB_BLUE 6                                      // Define o pino PWM para o componente azul do LED RGB.

#define POT_PIN A3                                      // Define o pino analógico do potenciômetro.

DHT dht(DHTPIN, DHTTYPE);
LiquidCrystal_I2C lcd(0x27, 16, 2);                     // Endereço do Display LCD I2C.

unsigned long previousMillisLCD = 0;                    // Variável para armazenar o tempo anterior para o LCD.
unsigned long previousMillisSensor = 0;                 // Variável para armazenar o tempo anterior para a leitura do sensor.
const long intervalLCD = 10000;                         // Intervalo de 10 segundos para alternar entre temperatura e umidade no LCD.
const long intervalSensor = 1000;                       // Intervalo de 1 segundo para leituras de sensores.

bool showTemperature = false;                           // Para alternar entre temperatura e umidade.

void setup() {
  pinMode(LED_RED, OUTPUT);                             // Define o LED vermelho como uma saída.
  pinMode(LED_BLUE, OUTPUT);                            // Define o LED azul como uma saída.
  pinMode(LED_YELLOW, OUTPUT);                          // Define o LED amarelo como uma saída.
  pinMode(RGB_RED, OUTPUT);                             // Define o LED vermelho como uma saída.
  pinMode(RGB_GREEN, OUTPUT);                           // Define o LED verde como uma saída.
  pinMode(RGB_BLUE, OUTPUT);                            // Define o LED azul como uma saída.

  lcd.begin(16, 2);                                     // Display LCD I2C 16x2.
  lcd.backlight();

  dht.begin();                                        

  Serial.begin(9600);                                   // Para depuração, se necessário.
}

void loop() {
  unsigned long currentMillis = millis();               // Obtém o tempo atual em milissegundos desde que o programa começou.

                                                        // Controle de leituras de sensores usando millis().
                                                        // Verifica se 1 segundo (1000 milissegundos) se passou desde a última leitura.
  if (currentMillis - previousMillisSensor >= intervalSensor) {
    previousMillisSensor = currentMillis;               // Atualiza o tempo anterior de leitura do sensor.

                                                        // Leitura dos valores de temperatura e umidade.
    float temperature = dht.readTemperature();
    float humidity = dht.readHumidity();
    int potValue = analogRead(POT_PIN);
    int angle = map(potValue, 0, 1023, 0, 270);         // Mapeia o valor do potenciômetro para 0-270 graus.

                                                        // Controle do LED RGB.
    if (angle >= 0 && angle < 90) {
      analogWrite(RGB_RED, 255);
      analogWrite(RGB_GREEN, 0);
      analogWrite(RGB_BLUE, 0);
    } else if (angle >= 90 && angle < 180) {
      analogWrite(RGB_RED, 0);
      analogWrite(RGB_GREEN, 255);
      analogWrite(RGB_BLUE, 0);
    } else if (angle >= 180 && angle <= 270) {
      analogWrite(RGB_RED, 0);
      analogWrite(RGB_GREEN, 0);
      analogWrite(RGB_BLUE, 255);
    }

                                                          // Controle do LED que indica temperatura < 20ºC.
    if (temperature < 20) {
      int brightness = map(temperature, 10, 20, 255, 0);  // Aumenta a luminosidade quando a temperatura se aproxima de 20ºC.
      brightness = constrain(brightness, 0, 255);
      analogWrite(LED_RED, brightness);
    } else {
      digitalWrite(LED_RED, LOW);
    }

                                                          // Controle do LED que indica temperatura > 40ºC.
    if (temperature > 40) {
      digitalWrite(LED_BLUE, HIGH);
    } else {
      digitalWrite(LED_BLUE, LOW);
    }

                                                          // Controle do LED que indica umidade > 75%.
                                                          
    if (humidity > 75) {
      digitalWrite(LED_YELLOW, HIGH);
    } else {
      digitalWrite(LED_YELLOW, LOW);
    }
  }

                                                          // Alterna entre exibir umidade e temperatura no LCD a cada 10 segundos.
                                                          // Verifica se 10 segundos (10000 milissegundos) se passaram desde a última atualização do LCD.
  if (currentMillis - previousMillisLCD >= intervalLCD) {
    previousMillisLCD = currentMillis;                    // Atualiza o tempo anterior para o LCD.

    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("SEM2");

    if (showTemperature) {
      lcd.setCursor(0, 1);
      lcd.print("Temp: ");
      lcd.print(dht.readTemperature());
      lcd.print(" C");
    } else {
      lcd.setCursor(0, 1);
      lcd.print("Umid: ");
      lcd.print(dht.readHumidity());
      lcd.print(" %");
    }
    showTemperature = !showTemperature;                   // Alterna para a próxima exibição.
  }
  //A função millis() é uma função comum em ambientes de programação de microcontroladores, como o Arduino. 
  //Ela retorna o número de milissegundos que se passaram desde que o programa começou a ser executado. 
  //Essa contagem é iniciada quando a placa é ligada ou quando o programa é reiniciado.
  // Isso permite que o código realize outras tarefas em paralelo sem ficar bloqueado em uma espera,
  // ao contrário do uso de delay(), que pausaria a execução completamente.
}