#include <stdint.h>
#include <stdbool.h>
#include "stm32f103_hal.h"
#include "lcd.h"

#define NUM_DIENTES 180

volatile uint32_t contador_pulsos = 0;
volatile uint32_t rpm = 0;
volatile bool actualizar_lcd = false;
volatile uint32_t temperatura = 20; 
volatile uint32_t t_motor_us = 0;
volatile uint32_t delta_t_us = 0;


void delay_ms(uint16_t ms) {
    volatile unsigned long t = 0;
    for(uint16_t i = 0; i < ms; i++) {
        for(t = 0; t < 800; t++);
    }
}
void delay_us(uint16_t us) {
    for (volatile unsigned int cycles = 0; cycles < us; cycles++);
}


void SysTick_Handler(void) 
{
    rpm = (contador_pulsos * 600) / NUM_DIENTES;
    contador_pulsos = 0;
    actualizar_lcd = true;
}


void EXTI9_5_IRQHandler(void) 
{
    if (EXTI->PR & (1 << 8)) 
    {
        EXTI->PR = (1 << 8); 
        contador_pulsos++;   
    }
}


void EXTI1_IRQHandler(void)
{
    if (EXTI->PR & (1 << 1)) 
    {
        EXTI->PR = (1 << 1); 

        if (rpm > 0) 
        {
            t_motor_us = 60000000 / rpm;
            uint16_t ticks_tdc = t_motor_us / 40; 
            
            TIM3->ARR = ticks_tdc;
            TIM3->CNT = 0;
            timer_start(TIM3, TIMER_ONESHOT);
        }
    }
}


void TIM3_IRQHandler(void)
{
    if (TIM3->SR & TIM_SR_UIF)
    {
        TIM3->SR &= ~TIM_SR_UIF; 

        delta_t_us = (t_motor_us * (130 - temperatura)) / 120;

        if (delta_t_us > (t_motor_us / 2)) 
        {
            delta_t_us = t_motor_us / 2;
        }
        else if (delta_t_us < (t_motor_us / 4)) 
        {
            delta_t_us = t_motor_us / 4;
        }

        TIM2->ARR = delta_t_us / 10;
        TIM2->CNT = 0;
        timer_start(TIM2, TIMER_ONESHOT); 
    }
}


void TIM2_IRQHandler(void)
{
    if (TIM2->SR & TIM_SR_UIF)
    {
        TIM2->SR &= ~TIM_SR_UIF;

        // Disparo de inyector a 100kHz
        TIM4->CNT = 0;
        timer_start(TIM4, TIMER_ONESHOT);
    }
}

int main(void)
{

    rcc_clock_enable(RCC_GPIOA);
    rcc_clock_enable(RCC_GPIOB);
    rcc_clock_enable(RCC_AFIO); 
    rcc_clock_enable(RCC_ADC1);
    rcc_clock_enable(RCC_TIM2); 
    rcc_clock_enable(RCC_TIM3); 
    rcc_clock_enable(RCC_TIM4); 

    gpio_set_input(GPIOA, 0, GPIO_INPUT_ANALOG); 
    gpio_set_input(GPIOA, 8, GPIO_INPUT_PU);     
    gpio_set_input(GPIOA, 1, GPIO_INPUT_PU);     
    
    LCD_Init();
    adc_init(ADC1, ADC_MODE_SINGLE, ADC_TRIG_SOFTWARE, ADC_ALIGN_RIGHT);
    adc_set_channel(ADC1, ADC_CHANNEL_0, ADC_SMP_239_5);

    exti_set_interrupt(PA8, EXTI_IRQ_RISING); 
    nvic_enable_irq(EXTI9_5_IRQn);            
    exti_set_interrupt(PA1, EXTI_IRQ_RISING); 
    nvic_enable_irq(EXTI1_IRQn);              

    systick_config(800000, SYSTICK_CLKSRC_AHB); 

    timer_init(TIM3, TIMER_MODE_UP, 0, 79); 
    timer_set_interrupt(TIM3, TIMER_IRQ_UPDATE, IRQ_ENABLE);
    nvic_enable_irq(TIM3_IRQn);

    timer_init(TIM2, TIMER_MODE_UP, 0, 79); 
    timer_set_interrupt(TIM2, TIMER_IRQ_UPDATE, IRQ_ENABLE);
    nvic_enable_irq(TIM2_IRQn);

    timer_init(TIM4, TIMER_MODE_UP, 79, 0); 
    timer_set_oc_channel(TIM4, TIMER_CHANNEL_1, TIMER_OC_PWM2, TIMER_OC_POLARITY_HIGH, 64, true);
    
    nvic_enable(); 

    uint32_t valor_adc = 0;

    while (1)
    {
        if (actualizar_lcd)
        {
            actualizar_lcd = false; 

            adc_start(ADC1);
            valor_adc = adc_read(ADC1);
            temperatura = (valor_adc * 500) / 4095;

            LCD_SetCursor(0, 0);
            LCD_Print("RPM:");
            LCD_Print_Int(rpm);
            LCD_SetCursor(8, 0);
            LCD_Print("dt:");
            LCD_Print_Int(delta_t_us / 1000);
            LCD_Print("ms ");

            LCD_SetCursor(0, 1);
            LCD_Print("Temp:");
            LCD_Print_Int(temperatura);
            LCD_Print(" C    ");
        }
    }
}