#include <stdio.h>  // Inclui a biblioteca padrão de entrada e saída.
#include "pico/stdlib.h"  // Inclui as funções padrão da plataforma Raspberry Pi Pico.
#include "hardware/uart.h"  // Inclui as funções de hardware para controle de UART.
#include "hardware/irq.h"  // Inclui as funções para controle de interrupções (IRQ).

// Define os pinos GPIO para os pinos TX (transmissão) e RX (recepção) do UART0.
#define UART0_TX_PIN 0
#define UART0_RX_PIN 1

// Define os pinos GPIO para os pinos TX e RX do UART1.
#define UART1_TX_PIN 4
#define UART1_RX_PIN 5

// Função de callback chamada quando há dados recebidos no UART0.
void on_uart0_rx() {
    // Enquanto houver dados disponíveis para leitura no UART0...
    while (uart_is_readable(uart0)) {
        // Lê um byte de dados do UART0.
        uint8_t ch = uart_getc(uart0);
        // Se o UART0 estiver pronto para transmitir...
        if (uart_is_writable(uart0)) {
            // Envia o byte lido de volta ao UART0 (eco).
            uart_putc(uart0, ch);
        }
    }
}

// Função de callback chamada quando há dados recebidos no UART1.
void on_uart1_rx() {
    // Enquanto houver dados disponíveis para leitura no UART1...
    while (uart_is_readable(uart1)) {
        // Lê um byte de dados do UART1.
        uint8_t ch = uart_getc(uart1);
        // Se o UART1 estiver pronto para transmitir...
        if (uart_is_writable(uart1)) {
            // Envia o byte lido de volta ao UART1 (eco).
            uart_putc(uart1, ch);
        }
    }
}

// Função principal do programa.
int main() {
    // Inicializa o sistema de E/S padrão para permitir printf no monitor serial.
    stdio_init_all();

    // Inicializa o UART0 com uma taxa de transmissão de 9600 bps.
    uart_init(uart0, 9600);
    // Inicializa o UART1 com uma taxa de transmissão de 9600 bps.
    uart_init(uart1, 9600);

    // Limpa a tela do monitor serial antes de exibir a mensagem.
    printf("\033[2J\033[H");
    sleep_ms(500); // Aguarde 100 ms antes de enviar qualquer mensagem
    printf(" \n");
    printf("Sistema inicializado!\n");
    printf("Digite algo para testar:\n");
     fflush(stdout);

    // Configura os pinos TX e RX do UART0 como pinos de função UART.
    gpio_set_function(UART0_TX_PIN, GPIO_FUNC_UART);
    gpio_set_function(UART0_RX_PIN, GPIO_FUNC_UART);
    // Configura os pinos TX e RX do UART1 como pinos de função UART.
    gpio_set_function(UART1_TX_PIN, GPIO_FUNC_UART);
    gpio_set_function(UART1_RX_PIN, GPIO_FUNC_UART);

    // Associa a interrupção do UART0 à função de callback on_uart0_rx.
    irq_set_exclusive_handler(UART0_IRQ, on_uart0_rx);
    // Associa a interrupção do UART1 à função de callback on_uart1_rx.
    irq_set_exclusive_handler(UART1_IRQ, on_uart1_rx);

    // Habilita a interrupção do UART0.
    irq_set_enabled(UART0_IRQ, true);
    // Habilita a interrupção do UART1.
    irq_set_enabled(UART1_IRQ, true);

    // Habilita as interrupções de recepção no UART0.
    uart_set_irq_enables(uart0, true, false);
    // Habilita as interrupções de recepção no UART1.
    uart_set_irq_enables(uart1, true, false);

    // Retorna 0 para indicar o término do programa (esta linha nunca será alcançada devido ao loop abaixo).
    return 0;

    // Loop infinito para manter o programa ativo (se fosse usado, evitaria o encerramento do programa).
    while (1)
        tight_loop_contents();  // Executa operações básicas enquanto aguarda.
}