/******************************************************************************
* HEADER-FILES (Somente os arquivos necessarios nesse arquivo)
******************************************************************************/
#include "main.h"
#include "ssd1306.h"
#include "ssd1306_graphic.h"
#include "pico/stdlib.h"
#include "hardware/i2c.h"
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
#include <hardware/sync.h>
#include <stdint.h>
/*****************************************************************************/

/******************************************************************************
* Variaveis Globais
******************************************************************************/
// Buffer de tela global
uint8_t display_buffer[128 * SSD1306_HEIGHT / 8] = {0};
uint8_t estado_ignicao = 0;
uint16_t timer_execucao[NUM_TASKS];

//aqui a task de leitura anota os resultados e as tasks dos leds vem ler
bool estados_chaves [8] = {1,1,1,1,1,1,1,1};
/*****************************************************************************/

/******************************************************************************
* Prototipos das funcoes
******************************************************************************/
void system_init(void);
void alarm_irq(void);
void init_timer_irq(void);
void button_callback(uint gpio);
void task_um(void);
void task_dois(void);
void task_tres(void);
void task_quatro(void);
bool task_chaves_valor();
/*****************************************************************************/

/******************************************************************************
   Funcao:		void main(void) 
   Entrada:		Nenhuma (void)
   Saída:		Nenhuma (void)
   Descrição:	Função principal
 *****************************************************************************/
void main(void) 
{
  void (*p_vetor_ponteiro[NUM_TASKS])();

  stdio_init_all(); 
  system_init(); /* Inicializa hardware do RP2040 */
  SSD1306_init(); /* Inicializa display e pinos de comunicação */

// Limpa o buffer do display

  ssd1306_clear_buffer(display_buffer);
  ssd1306_send_data(display_buffer, 128 * SSD1306_HEIGHT / 8);
  sleep_ms(2000);

  // Escreve texto no buffer
  ssd1306_write_text(display_buffer, 32, 0, "FATEC ");
  ssd1306_write_text(display_buffer, 10, 8, "SANTO ANDRE");
  ssd1306_write_text(display_buffer, 28, 24, "T.A.P.M.");
  ssd1306_send_data(display_buffer, 128 * SSD1306_HEIGHT / 8);


  p_vetor_ponteiro[0] = task_um;
  p_vetor_ponteiro[1] = task_dois;
  p_vetor_ponteiro[2] = task_tres;
  p_vetor_ponteiro[3] = task_quatro;
  
  sleep_ms(2000);

/************************************************************************************/
  while(1)
  {
    //atualiza constantemente o estado das chaves
    task_chaves_valor();
   
   //executa constantemente as funções
    for(uint8_t index = 0; index < NUM_TASKS; index ++)
    {
      (*p_vetor_ponteiro[index])();
    }
    sleep_ms(10);
  }
}


/******************************************************************************
   Funcao:		void system_init(void)
   Entrada:		Nenhuma (void)
   Saída:		Nenhuma (void)
   Descrição:	Inicializa sistema (microcontrolador e periféricos)
 *****************************************************************************/
void system_init(void)
{
    printf("Init Hardware ....\n");
    sleep_ms(10);
    
    gpio_init(BUTTON_PIN);
    gpio_set_dir(BUTTON_PIN, GPIO_IN);
    gpio_pull_up(BUTTON_PIN); // Enable pull-up resistor

  for(int i = 0; i < 8; i++){
    gpio_init(chaves[i]);
    gpio_set_dir(chaves[i], GPIO_IN);
    gpio_pull_up(chaves[i]);

  }
    gpio_set_irq_enabled_with_callback(BUTTON_PIN, GPIO_IRQ_EDGE_FALL, true, (gpio_irq_callback_t)&button_callback);

    gpio_init(LD_1);
    gpio_set_dir(LD_1, GPIO_OUT);
    gpio_put(LD_1,0);

    gpio_init(LD_2);
    gpio_set_dir(LD_2, GPIO_OUT);
    gpio_put(LD_2,0);

    gpio_init(LD_3);
    gpio_set_dir(LD_3, GPIO_OUT);
    gpio_put(LD_3,0);

    gpio_init(LD_4);
    gpio_set_dir(LD_4, GPIO_OUT);
    gpio_put(LD_4,0);

    init_timer_irq();
}

/******************************************************************************
   Funcao:		void alarm_irq(void)
   Entrada:		Nenhuma (void)
   Saída:		Nenhuma (void)
   Descrição:	Função tratamento interrupcao do TIMER_IRQ_0
 *****************************************************************************/
void alarm_irq(void) 
{
    // Clear the alarm irq
    hw_clear_bits(&timer_hw->intr, 1u << ALARM_NUM);

    for(uint8_t cnt = 0; cnt < NUM_TASKS; cnt++)
    {
      if(timer_execucao[cnt])         timer_execucao[cnt]--;
    }

    uint64_t target = timer_hw->timerawl + DELAY;

    // Write the lower 32 bits of the target time to the alarm register, arming it.
    timer_hw->alarm[ALARM_NUM] = (uint32_t) target;

}

/******************************************************************************
   Funcao:		void init_timer_irq(void)
   Entrada:		Nenhuma (void)
   Saída:		Nenhuma (void)
   Descrição:	Função para inicialização do TIMER_IRQ_0 (100ms)
 *****************************************************************************/
void init_timer_irq(void)
{
  // Enable the interrupt for the alarm (we're using Alarm 0)
  hw_set_bits(&timer_hw->inte, 1u << ALARM_NUM) ;
  // Associate an interrupt handler with the ALARM_IRQ
  irq_set_exclusive_handler(ALARM_IRQ, alarm_irq) ;
  // Enable the alarm interrupt
  irq_set_enabled(ALARM_IRQ, true) ;
  
  uint64_t target = timer_hw->timerawl + DELAY;

  // Write the lower 32 bits of the target time to the alarm register, arming it.
  timer_hw->alarm[ALARM_NUM] = (uint32_t) target;
}
/******************************************************************************
   Funcao:		void button_callback(void)
   Entrada:		Nenhuma (void)
   Saída:		Nenhuma (void)
   Descrição:	Função tratamento interrupcao do botao
 *****************************************************************************/
void button_callback(uint gpio) 
{
    //gerar evento para odometro total 
    printf("Mudança no Estado da Ignição!\n");
    estado_ignicao = !estado_ignicao;
}

/******************************************************************************
   Funcao:		void task_um(void)
   Entrada:		Nenhuma (void)
   Saída:		  Nenhuma (void)
   Descrição:	Implementa tarefa para controlar LED em GPIO0
*****************************************************************************/
void task_um(void)
{
  
  static uint8_t estado_led_task_um = 0;
  //checa estados das chaves se for true executa task 1
  if((estados_chaves[0] == 0) && (estados_chaves[1] == 0)){

  if(timer_execucao[pos_task_um] == 0x00)
  {
    timer_execucao[pos_task_um] = TIMER_1000_MS;
    estado_led_task_um = ~estado_led_task_um;
    gpio_put(LD_1,estado_led_task_um);
  }
  } else{
    gpio_put(LD_1,0);
    estado_led_task_um = 0;
  }
}    

/******************************************************************************
   Funcao:		void task_dois(void)
   Entrada:		Nenhuma (void)
   Saída:		  Nenhuma (void)
   Descrição:	Implementa tarefa para controlar LED em GPIO1
*****************************************************************************/
void task_dois(void)
{
  static uint8_t estado_led_task_dois = 0;
  if((estados_chaves[2] == 0)&&(estados_chaves[3] == 0)){

  
  if(timer_execucao[pos_task_dois] == 0x00)
  {
    timer_execucao[pos_task_dois] = TIMER_500_MS;
    estado_led_task_dois = ~estado_led_task_dois;
    gpio_put(LD_2,estado_led_task_dois);
  }
  }else{
    gpio_put(LD_2, 0);
    estado_led_task_dois = 0;
  }
} 

void task_tres(void)
{
  static uint8_t estado_led_task_tres = 0;

if((estados_chaves[4] == 0)&&(estados_chaves[5] == 0)){


  if(timer_execucao[pos_task_tres] == 0x00)
  {
    timer_execucao[pos_task_tres] = TIMER_1500_MS;
    estado_led_task_tres = ~estado_led_task_tres;
    gpio_put(LD_3,estado_led_task_tres);
  }
}else{
   gpio_put(LD_3,0);
   estado_led_task_tres = 0;
}
} 

void task_quatro(void)
{
  static uint8_t estado_led_task_quatro = 0;

  if((estados_chaves[6] == 0)&&(estados_chaves[7] == 0)){

 

  if(timer_execucao[pos_task_quatro] == 0x00)
  {
    timer_execucao[pos_task_quatro] = TIMER_750_MS;
    estado_led_task_quatro = ~estado_led_task_quatro;
    gpio_put(LD_4,estado_led_task_quatro);
  }
   }else{
      gpio_put(LD_4,0);
      estado_led_task_quatro = 0;
   }
} 

bool task_chaves_valor()
{
  //aqui é feito a varredura das 8 chaves
  for(int x = 0; x < 8; x++){

    //aqui é feito a leitura e coleta do estado das chaves e armazenado no vetor bool
    estados_chaves[x] = gpio_get(chaves[x]);
  }

  return true; //pela função ser declarada bool ela retorna para true.
}