#define __ATmega2560__
#define __AVR_ATmega2560__
#ifndef F_CPU
#define F_CPU 16000000UL
#endif
#include <stdint.h>
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <stdbool.h>
#include <util/delay.h>
#include <stdlib.h>
#include <avr/interrupt.h>
#include "usart.h"
#include "lcd.h"

#define PI 3.14159
#define BETA 3950 //do sensor de temperatura
#define GAMMA 0.7 //do photoresistor
#define RL10 50 //photoresistor
#define THRESHOLD 853 //crepúsculo
#define FAROL PD7 //faróis
#define ar_ligado PG1 // led que indica se o ar condicionado está ligado
#define ligar_desligar_ar PC0
#define R 16 // Diâmetro do pneu em polegadas
#define MAX_VELOCIDADE 200.0 // Velocidade máxima permitida em km/h 
#define SENSOR_RODA PJ1
#define recirculacao_sinal PG0
#define recirculacao_led PC1

uint8_t recirculando, anterior_recirc, anterior_ar;

volatile uint32_t tick;
volatile uint16_t timer, espera;

volatile float velocidade, speed;

volatile float distancia = 0;
volatile float comprimento = 2 * PI/8 * (0.0254 * R / 2);

const int ac_max = 30;
const int ac_min = 17;
int ar_condicionado = 25;

uint8_t estado_atual_chave_ar;      // o estado da chave: valor da chave sem debounce
uint8_t estado_anterior_chave_ar;   // armazena o estado anterior da chave
uint8_t leitura_atual_chave_ar;     // a leitura atual do valor da chave
uint8_t leitura_anterior_chave_ar;  // a leitura anterior do valor da chave
uint8_t chave_pressionada_ar;       // 1 se é reconhecida uma borda de descida

uint8_t estado_atual_chave_recirc;      // o estado da chave: valor da chave sem debounce
uint8_t estado_anterior_chave_recirc;   // armazena o estado anterior da chave
uint8_t leitura_atual_chave_recirc;     // a leitura atual do valor da chave
uint8_t leitura_anterior_chave_recirc;  // a leitura anterior do valor da chave
uint8_t chave_pressionada_recirc;       // 1 se é reconhecida uma borda de descida

// ISR para interrupção de mudança de pino
// ISR para a interrupção de mudança de pino para o sensor de velocidade
ISR(PCINT1_vect) {
    if ((PINJ&(1<<PINJ1))) {
        velocidade = comprimento * 1000000 / (tick * 512 + OCR1A * 0.5); // divide a distância pelo tempo (tick = 4096us e OCR1A = 4us)
        velocidade = velocidade * 3.6; // transforma m/s para km/h

        tick = 0; // zera a variável que mede o tempo
        TCNT1 = 0x00; // zera o contador que mede o tempo
        distancia += comprimento;
    }
}

// Função para configurar o Timer1
void timer1_config(void) {
    TCCR1A = 0; // Timer mode with no output
    TCCR1B = (1 << CS11) | (1 << CS10); // Prescaler 64
    TCNT1 = 0; // Initialize counter
    OCR1A = 1023;     // valor de TOP = 1023
    TIMSK1 = (1 << TOIE1); // Enable overflow interrupt
}

// Função para configurar a interrupção externa
void external_interrupt_config(void) {
    PCICR |= (1 << PCIE1); // Habilita interrupção do PCINT1
    PCMSK1 |= (1 << PCINT10); // Habilita PCINT9 (PJ1)
    
    EICRA |= (1 << ISC11); // Configura interrupção para borda de descida no INT1
    EIMSK |= (1 << INT1);  // Habilita interrupção externa INT1

    EICRA |= (1 << ISC31); // Configura interrupção para borda de descida no INT3
    EIMSK |= (1 << INT3);  // Habilita interrupção externa INT3
}

// ISR para o Timer1 overflow
ISR(TIMER1_OVF_vect) {
    tick++;
}

void controla_ar_condicionado(void) {
    _delay_ms(10);                                           // esperamos um intervalo de tempo maior que o intervalo de repique da chave
    leitura_anterior_chave_ar = leitura_atual_chave_ar;      // atualizamos a leitura anterior da chave
    leitura_atual_chave_ar = ((PINC & (1 << ligar_desligar_ar)) == 0x01);  // realizamos a leitura de PB0
    estado_anterior_chave_ar = estado_atual_chave_ar;        // atualiza o estado anterior da chave
    if (leitura_atual_chave_ar == leitura_anterior_chave_ar) // se o sinal da chave permanece estável no intervalo
    {
      estado_atual_chave_ar = leitura_atual_chave_ar;        // o estado da chave é igual ao valor da chave
    }

    // verificamos se a chave foi pressionada
    chave_pressionada_ar = (estado_anterior_chave_ar == 0x01) && (estado_atual_chave_ar == 0x00);  // é uma borda de descida?

    // Complementamos o LED quando a chave é pulsada
    if (chave_pressionada_ar) {
        PORTG ^= (1 << ar_ligado); // Comuta o LED que indica se o ar condicionado está ligado
    }
}
//botão de recirculação
void recirculacao(void) {
    _delay_ms(10);                                            // esperamos um intervalo de tempo maior que o intervalo de repique da chave
    leitura_anterior_chave_recirc = leitura_atual_chave_recirc; // atualizamos a leitura anterior da chave
    leitura_atual_chave_recirc = ((PING & (1 << recirculacao_sinal)) == 0x01);  // realizamos a leitura de PG0
    estado_anterior_chave_recirc = estado_atual_chave_recirc;  // atualiza o estado anterior da chave
    if (leitura_atual_chave_recirc == leitura_anterior_chave_recirc) // se o sinal da chave permanece estável no intervalo
    {
      estado_atual_chave_recirc = leitura_atual_chave_recirc; // o estado da chave é igual ao valor da chave
    }

    // verificamos se a chave foi pressionada
    chave_pressionada_recirc = (estado_anterior_chave_recirc == 0x01) && (estado_atual_chave_recirc == 0x00);  // é uma borda de descida?

    // Alteramos o estado de recirculação quando a chave é pulsada
    if (chave_pressionada_recirc) {
        recirculando = !recirculando;
    }

    // Ajustamos o LED de recirculação
    if (recirculando == 1) {
        PORTC |= (1 << recirculacao_led); // Liga o LED de recirculação
    } else {
        PORTC &= ~(1 << recirculacao_led); // Desliga o LED de recirculação
    }
}


// Função para inicializar o ADC
void adc_config(void) {
    // Selecionar a referência de tensão(5V) para AVCC com um capacitor em AREF
    ADMUX = (1 << REFS0);
    // Configurar a prescaler para 128 para uma taxa de amostragem de 125 kHz com um clock de 16 MHz
    ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0);
}

// Função para ler o canal ADC especificado
uint16_t ler_adc(uint8_t canal) {
    // Certifique-se de que o canal está entre 0 e 7
    if (canal > 7) {
        return 0;
    }
    // Configurar o canal (limpando bits de canal, então definindo o canal desejado)
    ADMUX = (ADMUX & 0xF0) | (canal & 0x07);
    // Iniciar a conversão
    ADCSRA |= (1 << ADSC);
    // Esperar a conversão terminar (ADSC será limpo após a conclusão)
    while (ADCSRA & (1 << ADSC));
    // Retornar o valor convertido
    return ADCW; // ADCW é o valor de 16 bits da conversão
}

// Configuração do ADC e da USART
void setup(void) {
    adc_config(); // Configura o ADC para leitura do valor analógico
    USART0_configura(); // Configura a USART para comunicação serial
    LCD_Init(); // inicializa o LCD
    timer1_config(); // Configura o Timer1
    external_interrupt_config(); // Configura a interrupção externa
    
    DDRJ &= ~(1 << DDJ1); // Configura PJ1 como entrada
    PORTJ |= (1 << PORTJ1); // Habilita pull-up em PJ1
    
    DDRD |= (1 << FAROL); // Configura o pino do LED/luz como saída
    // Configurações para a recirculação
    DDRD &= ~(1 << recirculacao_sinal); // Configura PD3 como entrada
    PORTD |= (1 << recirculacao_sinal); // Habilita pull-up em PD3
    DDRC |= (1 << recirculacao_led); // Configura o pino do LED de recirculação como saída
    PORTC &= ~(1 << recirculacao_led);

    DDRG |= (1 << ar_ligado); // Configura o pino do LED de recirculação como saída
    PORTG &= ~(1 << ar_ligado);
    DDRD &= ~(1 << ligar_desligar_ar);  // Configura como entrada
    PORTD |= (1 << ligar_desligar_ar);  // Habilita pull-up

    leitura_atual_chave_ar = ((PINC & (1 << ligar_desligar_ar)) == 0x01);  // lemos o valor da chave
    estado_atual_chave_ar = leitura_atual_chave_ar;               // O estado inicial da chave é o valor da chave

    leitura_atual_chave_recirc = ((PINC & (1 << recirculacao_sinal)) == 0x01);  // lemos o valor da chave
    estado_atual_chave_recirc = leitura_atual_chave_recirc;               // O estado inicial da chave é o valor da chave
}

int main(void) {
    setup();
    char buffer[16];
    while (1) {
       sei();
       recirculacao();
       controla_ar_condicionado();
        // Lendo o sensor de temperatura externa
        uint16_t valor_temperatura_externa = ler_adc(1);
        float temperatura_ex = 1 / (log(1 / (1023.0 / valor_temperatura_externa - 1)) / BETA + 1.0 / 298.15) - 273.15;
        LCD_gotoxy(0, 0);
        LCD_string("T. Ext: ");
        dtostrf(temperatura_ex, 4, 1, buffer);
        LCD_string(buffer);
        LCD_string(" C");

        // Lendo o sensor de temperatura interna
        uint16_t valor_temperatura_interna = ler_adc(5);
        float temperatura_in = 1 / (log(1 / (1023.0 / valor_temperatura_interna - 1)) / BETA + 1.0 / 298.15) - 273.15;
        LCD_gotoxy(1, 0);
        LCD_string("T. Int: ");
        dtostrf(temperatura_in, 4, 1, buffer);
        LCD_string(buffer);
        LCD_string(" C");
      
       _delay_ms(2000); // Delay para exibir os valores no LCD

        // Lendo a temperatura na saída do ar condicionado
        uint16_t valor_temperatura_arcond = ler_adc(7);
        float temperatura_arcond = 1 / (log(1 / (1023.0 / valor_temperatura_arcond - 1)) / BETA + 1.0 / 298.15) - 273.15;
         // Limitar a temperatura do ar condicionado dentro dos limites
        if (ar_condicionado > ac_max) {
            ar_condicionado = ac_max;
        }
        if (ar_condicionado < ac_min) {
            ar_condicionado = ac_min;
        }
        
        LCD_Clear();
        LCD_gotoxy(0, 0);
        LCD_string("AC Temp: ");
        dtostrf(temperatura_arcond, 4, 1, buffer);
        LCD_string(buffer);
        LCD_string(" C");

        // Exibição da temperatura configurada no ar condicionado
        LCD_gotoxy(1, 0);
        LCD_string("AC Set: ");
        dtostrf(ar_condicionado, 4, 1, buffer);
        LCD_string(buffer);
        LCD_string(" C");

        _delay_ms(2000); // Delay para exibir os valores no LCD

        // Lendo o fotoresistor
        uint16_t valor_luminosidade = ler_adc(3); // Leitura do pino A2
        float v_luz = (valor_luminosidade * 5) / 1024.0; // 5V é a tensão de referência
        float resistencia = 2000 * v_luz / (1 - v_luz / 5);
        float lux = pow(RL10 * 1e3 * pow(10, GAMMA) / resistencia, (1 / GAMMA));

        LCD_Clear();
        LCD_gotoxy(0, 0);
        LCD_string("Lum: ");
        dtostrf(lux, 4, 1, buffer);
        LCD_string(buffer);
        LCD_string(" lux");
        if (lux > THRESHOLD) {
            PORTD &= ~(1 << FAROL); // Apaga a luz/LED
            LCD_gotoxy(1, 0);
            LCD_string("Farol desligado");
        } else {
            PORTD |= (1 << FAROL); // Acende a luz/LED
            LCD_gotoxy(1, 0);
            LCD_string("Farol ligado");
        }
        _delay_ms(1000); // Delay para exibir os valores no LCD
        
        LCD_Clear();
        LCD_gotoxy(0, 0);
        if (recirculando) {
            LCD_string("Recirculacao: ON");
        } else {
            LCD_string("Recirculacao: OFF");
        }

        if (velocidade > MAX_VELOCIDADE) { // Limita a velocidade ao valor máximo permitido
            velocidade = MAX_VELOCIDADE;
        }
       _delay_ms(2000); // Delay para exibir os valores no LCD
            // Exibir a velocidade no LCD
            LCD_Clear();
            LCD_gotoxy(0, 0);
            LCD_string("Vel: ");
            dtostrf(velocidade, 4, 1, buffer);
            LCD_string(buffer);
            LCD_string(" km/h");

            // Exibir a distância percorrida no LCD
            LCD_gotoxy(1, 0);
            LCD_string("Dist: ");
            dtostrf(distancia, 4, 2, buffer);
            LCD_string(buffer);
            LCD_string(" km");
             _delay_ms(1000); // Atualiza a cada segundo
        }

        return 0;
    }