#include <avr/io.h>
#include <avr/pgmspace.h>
#include <string.h>
#include "usart.h"


#define UNO /**< define a placa de desenvolvimento arduino UNO */
//#define MEGA /**< define a placa de desenvolvimento arduino MEGA */

#ifdef UNO
#define TERMINAL_LED PORTB5 /**<terminal em que está conectado o LED */
#elif defined(MEGA)
#define TERMINAL_LED PORTB7
#endif

const char strHello[] PROGMEM = "ola mundo ...";
const char strLed[] PROGMEM = "\n*** Mudando o estado do led em PB5 ***\r";

char strRam[15]; /**<Uma string que é armazenada na SRAM */


/******************************************************************************/
/**
 * @brief Inicializa o pino da porta ligado ao LED: faz o pino uma saída com o
 *        nível lógico 1.
 *
 */
void inicializa_LED ( void )
/******************************************************************************/
{
    //faz o pino PINO_LED uma saída
    DDRB |= ( 1 << TERMINAL_LED );
    // faz a saída PINO_LED igual a 1
    PORTB |= ( 1 << TERMINAL_LED );
}


/******************************************************************************/
/**
 * @brief envia 20 retornos de carros para limpar todo ou parte do terminal.
 *
 */
void limpa_console ( void )
/******************************************************************************/
{
    uint8_t contador;
    const uint8_t numero_linhas = 20;

    // limpa o console enviando retornos de carro (numero_linhas vezes)
    for ( contador = 0; contador < numero_linhas; contador++ ) {
        USART_transmite_nova_linha();
    }
}


/******************************************************************************/
/**
 * @brief imprime uma string que é armazenada na memória FLASH, junto com o código
 * compilado.
 *
 */
void testa_imprime_string_flash ( void )
/******************************************************************************/
{
    const static char msg_imprime_string_flash[] PROGMEM = \
            "\nImprimindo uma string de uma variavel da memoria FLASH\n\n";
    USART_transmite_string_FLASH ( msg_imprime_string_flash );
    // envia pela USART0 uma string da memória FLASH
    USART_transmite_string_FLASH ( strHello );
    USART_transmite_nova_linha();
}


/******************************************************************************/
/**
 * @brief imprime uma string armazenada na memória SRAM.
 *
 */
void testa_imprime_string_sram ( void )
/******************************************************************************/
{
    const static char msg_imprime_string_ram[] PROGMEM = \
            "\nImprimindo uma string de uma variavel da memoria RAM\n\n";
    // envia pela USART0 uma string da memória SRAM
    // gravamos uma string exemplo
    USART_transmite_string_FLASH ( msg_imprime_string_ram );
    strcpy(strRam, "string RAM");
    USART_transmite_string ( strRam );
    USART_transmite_nova_linha();
}


/******************************************************************************/
/**
 * @brief Inprime em um terminal o valor de uma variável (byte) que é decrementada de
 * 10 a 0. O valor é apresentado como uma string hexadecimal.
 *
 */
void testa_imprime_byte_hexadecimal ( void )
/******************************************************************************/
{
    const static char msg_imprime_byte[] PROGMEM = \
            "\nImprimindo alguns bytes em hexadecimal: 0x0A a 0x00\n\n";
    int8_t contador;
    // envia pela USART0 os valores de 10 a 0 em hexadecimal
    USART_transmite_string_FLASH ( msg_imprime_byte );
    contador = 10;

    do{
        USART_transmite_prefixo_hexadecimal();
        USART_transmite_byte_hexadecimal ( ( uint8_t ) contador );
        USART_transmite_string ( " " );
        contador = contador - 1;
    }while ( contador != -1 );

    USART_transmite_nova_linha();
}


/******************************************************************************/
/**
 * @brief Lê um caractere e envia de volta ao terminal. Repete este procedimento
 * 5 vezes.
 *
 */
void testa_ecooa_caracteres ( void )
/******************************************************************************/
{
    /*     const static char msg_ecooa_caracteres[] PROGMEM = \
             "\nDigite alguns caracteres. Eles serao recebidos pelo\n"\
            " microcontrolador e enviados de volta para o terminal.\n\n"; */
    const char *msg_ecooa_caracteres  = PSTR ( \
                                        "\nDigite alguns caracteres. Eles serao recebidos pelo\n"\
                                        " microcontrolador e enviados de volta para o terminal.\n\n" );
    USART_transmite_string_FLASH ( msg_ecooa_caracteres );
    // ecoa os caracteres recebidos pela USART0
    uint8_t ch;
    uint8_t conta_caracteres;
    const uint8_t numero_maximo_carcateres_recebidos = 5;
    conta_caracteres = 0;

    while ( conta_caracteres < numero_maximo_carcateres_recebidos ) {
        ch = USART_recebe_byte();
        USART_transmite_byte ( '(' );
        USART_transmite_byte ( ch );
        USART_transmite_byte ( ')' );
        conta_caracteres++;
    }
}


/******************************************************************************/
/**
 * @brief Faz a leitura de caracteres pela USART e altera o estado de um LED.
 *
 */
void testa_comanda_LED ( void )
/******************************************************************************/
{
    const static char msg_comanda_LED[] PROGMEM = \
            "\nDigite 0 para apagar o LED, 1 para ligar ou\n"\
            "a letra t para mudar o estado do led\n\n";
    const static char msg_led_ligado[] PROGMEM = "O LED foi ligado ...\n";
    const static char msg_led_desligado[] PROGMEM = "O LED foi desligado ...\n";
    const static char msg_led_troca_estado[] PROGMEM = "O estado do LED foi alterado\n";
    const static char msg_led_nenhuma_acao[] PROGMEM = "Commando não reconhecido\n";

    uint8_t ch; /**< guarda o caracater lido pela interface USART */
    USART_transmite_string_FLASH( msg_comanda_LED );

    do {
        ch = USART_recebe_byte();
        USART_transmite_byte ( ch );
        USART_transmite_string ( ": " );

        switch ( ch ) {
        case '0':
            PORTB &= ~ ( 1 << TERMINAL_LED );
            USART_transmite_string_FLASH ( msg_led_desligado );
            break;

        case '1':
            PORTB |= ( 1 << TERMINAL_LED );
            USART_transmite_string_FLASH ( msg_led_ligado );
            break;

        case 't'|'T':
            PORTB ^= ( 1 << TERMINAL_LED );
            USART_transmite_string_FLASH ( msg_led_troca_estado );
            break;

        default:
            USART_transmite_string_FLASH ( msg_led_nenhuma_acao );
        }
    } while ( 1 );
}


/******************************************************************************/
/**
 * @brief Procedimento principal. Testamos os procedimentos do programa da USART
 *
 * @return retorna um valor indicando se houve ou não problemas na execução do
 * programa. Programas com microcontroladores nunca devem retornar do procedimento
 * main.
 */
int main ( void )
/******************************************************************************/
{
    inicializa_LED();               // incializa o pino PINO_LED
    USART_inicializa(38400, true); // inicializa a interface UART
    limpa_console();                // limpa o console
    testa_imprime_string_flash();   // imprime uma string constante da memória flash
    testa_imprime_string_sram();    // imprime uma string da memória sram
    testa_imprime_byte_hexadecimal(); // imprime um byte como string hexadecimal
    testa_ecooa_caracteres();       // lê um carcater e o retorna ao terminal
    testa_comanda_LED();            // lê caracteres e controla um LED

    while ( 1 ) {};                 // terminamos o programa de teste

    return 0;
}