/******************************************************************************
* 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>
/*****************************************************************************/

/******************************************************************************
* 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];
/*****************************************************************************/

/******************************************************************************
* 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);
/*****************************************************************************/

/******************************************************************************
   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; //Ponteiro da função.
  p_vetor_ponteiro[1] = task_dois; 
  p_vetor_ponteiro[2] = task_tres; 
  p_vetor_ponteiro[3] = task_quatro; 
  sleep_ms(2000);

/************************************************************************************/
  while(1)
  {
    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

    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; //Estado inicial do led.

  if(timer_execucao[pos_task_um] == 0x00) //.
  {
    timer_execucao[pos_task_um] = TIMER_1000_MS; //Tempo que determina, o tempo total ligado.
    estado_led_task_um = ~estado_led_task_um; //Inverte o estado do led conforme o tempo determinado.
    gpio_put(LD_1,estado_led_task_um); //Define qual led sera alterado.
    printf("Estado LED um: %d\n",estado_led_task_um); //Informa no terminal o estado da led.
  }
}    

/******************************************************************************
   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(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);
    printf("Estado LED dois: %d\n",estado_led_task_dois);
  }
} 

/******************************************************************************
   Funcao:		void task_tres(void)
   Entrada:		Nenhuma (void)
   Saída:		  Nenhuma (void)
   Descrição:	Implementa tarefa para controlar LED em GPIO1
*****************************************************************************/
void task_tres(void)
{
  static uint8_t estado_led_task_tres = 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);
    printf("Estado LED tres: %d\n",estado_led_task_tres);
  }
} 

/******************************************************************************
   Funcao:		void task_quatro(void)
   Entrada:		Nenhuma (void)
   Saída:		  Nenhuma (void)
   Descrição:	Implementa tarefa para controlar LED em GPIO1
*****************************************************************************/
void task_quatro(void)
{
  static uint8_t estado_led_task_quatro = 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);
    printf("Estado LED quatro: %d\n",estado_led_task_quatro);
  }
}