// Temporizador de Hardware para alternar um LED

#include "pico/stdlib.h"   // Biblioteca padrão do Raspberry Pi Pico para controle de GPIO, temporização e comunicação serial.
#include "hardware/timer.h" // Biblioteca para controle e configuração de temporizadores de hardware.
#include <stdio.h>         // Biblioteca padrão de entrada e saída para uso de funções como printf.

// Definição do pino de controle do LED.
const uint LED_PIN = 12; // Constante para representar o pino GPIO 12 ao qual o LED está conectado.

// Função de callback que será chamada a cada intervalo definido pelo temporizador.
// Esta função alterna o estado do LED e imprime uma mensagem na saída serial.
bool repeating_timer_callback(struct repeating_timer *t) {
    // Variável estática que mantém o estado do LED entre chamadas da função.
    // A palavra-chave 'static' faz com que o valor de 'led_on' persista entre as execuções da função.
    static bool led_on = false;

    // Alterna o estado do LED: se estava desligado, liga; se estava ligado, desliga.
    led_on = !led_on;

    // Define o estado do pino do LED com base no valor de 'led_on'.
    // Se 'led_on' for true, o pino será colocado em nível alto (3,3V), ligando o LED.
    // Se for false, o pino será colocado em nível baixo (0V), desligando o LED.
    gpio_put(LED_PIN, led_on);

    // Imprime na saída serial o estado atual do LED ("ligado" ou "desligado").
    printf("LED %s\n", led_on ? "ligado" : "desligado");

    // Retorna true para manter o temporizador repetindo esta função.
    // Se retornasse false, o temporizador pararia de chamar a função de callback.
    return true;
}

int main() {
    // Inicializa a comunicação serial, permitindo o uso de 'printf' para depuração.
    // Isso é necessário para enviar mensagens pela interface USB ou UART.
    stdio_init_all();

    // Inicializa o pino GPIO 12, preparando-o para ser usado como saída digital.
    gpio_init(LED_PIN);

    // Configura a direção do pino 12 como saída.
    // Isso permite controlar o estado do pino (ligado/desligado) para acender ou apagar o LED.
    gpio_set_dir(LED_PIN, GPIO_OUT);

    // Declara uma estrutura para armazenar informações sobre o temporizador repetitivo.
    struct repeating_timer timer;

    // Configura um temporizador repetitivo que chama a função 'repeating_timer_callback' a cada 1 segundo (1000 ms).
    // Parâmetros:
    // 1000: Intervalo de tempo em milissegundos (1 segundo).
    // repeating_timer_callback: Função de callback que será chamada a cada intervalo.
    // NULL: Dados adicionais que podem ser passados para a função de callback (não utilizado aqui).
    // &timer: Ponteiro para a estrutura que armazenará informações sobre o temporizador.
    add_repeating_timer_ms(1000, repeating_timer_callback, NULL, &timer);

    // Loop principal do programa.
    // Como o temporizador está gerenciando o controle do LED, o loop principal fica livre para outras tarefas.
    // Neste exemplo, não há outras tarefas, então o loop fica vazio.
    while (true) {
        // O loop principal pode ser usado para realizar outras tarefas, se necessário.
        // Como o temporizador e a função de callback estão gerenciando o LED, não é necessário adicionar nada aqui.
    }

    // Retorno de 0, que nunca será alcançado devido ao loop infinito.
    // Isso é apenas uma boa prática em programas com um ponto de entrada main().
    return 0;
}