ADIVINADOR

OBJETIVO

Desarrollar un programa que aleatoriamente conteste a preguntas que el usuario cuestione a través de una comunicación UART (Universal Asíncrono Recepción y Transmisión)     que es una simple y útil interfaz de comunicación serial.

DESCRIPCIÓN DEL PROGRAMA

Se definen las librerías y se etiquetan los parámetros para el puerto UART0, se establecen las variables que se utilizaran como mensajes y un arreglo que las contendrá, la variable “n” es el índice del contador que se incrementa a la velocidad del microcontrolador.

En main() n se incrementa, si n es mayor a 5 se inicializa la variable de contador.

En la interrupción por UART, si esta la bandera de estatus lo que se lee del puerto pasa a la variable data, si el dato es una salto de carro (‘\r’) con la sentencia UART_WriteBlocking se mostrará en la pantalla de la terminal (CoolTerm) el mensaje aleatorio.

CÓDIGO

#include "board.h"

#include "fsl_uart.h"

#include "pin_mux.h"

#include "clock_config.h"

/*******************************************************************************

 * Definitions

 ******************************************************************************/

/* UART instance and clock */

#define DEMO_UART UART0

#define DEMO_UART_CLKSRC UART0_CLK_SRC

#define DEMO_UART_IRQn UART0_RX_TX_IRQn

#define DEMO_UART_IRQHandler UART0_RX_TX_IRQHandler

/*! @brief Ring buffer size (Unit: Byte). */

#define DEMO_RING_BUFFER_SIZE 16

/*! @brief Ring buffer to save received data. */

/*******************************************************************************

 * Prototypes

 ******************************************************************************/

/*******************************************************************************

 * Variables

 ******************************************************************************/

uint8_t g_tipString[] =

    "DESTINO FINAL\r\nHAS TU PREGUNTA\r\n";

/*

  Ring buffer for data input and output, in this example, input data are saved

  to ring buffer in IRQ handler. The main function polls the ring buffer status,

  if there are new data, then send them out.

  Ring buffer full: (((rxIndex + 1) % DEMO_RING_BUFFER_SIZE) == txIndex)

  Ring buffer empty: (rxIndex == txIndex)

*/

char rp0[]="Si";

char rp1[]="Tal Vez";

char rp2[]="A lo mejor";

char rp3[]="Siempre";

char rp4[]="Nunca";

char rp5[]="No";

char *arr_msg[6]={rp0,rp1,rp2,rp3,rp4,rp5};

uint8_t n;

uint8_t demoRingBuffer[DEMO_RING_BUFFER_SIZE];

volatile uint16_t txIndex; /* Index of the data to send out. */

volatile uint16_t rxIndex; /* Index of the memory to save new arrived data. */

/*******************************************************************************

 * Code

 ******************************************************************************/

/*!

 * @brief Main function

 */

int main(void)

{

    uart_config_t config;

// char ch=0;

    BOARD_InitPins();

    BOARD_BootClockRUN();

    /*

     * config.baudRate_Bps = 115200U;

     * config.parityMode = kUART_ParityDisabled;

     * config.stopBitCount = kUART_OneStopBit;

     * config.txFifoWatermark = 0;

     * config.rxFifoWatermark = 1;

     * config.enableTx = false;

     * config.enableRx = false;

     */

    UART_GetDefaultConfig(&config);

    config.baudRate_Bps = BOARD_DEBUG_UART_BAUDRATE;

    config.enableTx = true;

    config.enableRx = true;

    UART_Init(DEMO_UART, &config, CLOCK_GetFreq(DEMO_UART_CLKSRC));

    /* Send g_tipString out. */

    UART_WriteBlocking(DEMO_UART, g_tipString, sizeof(g_tipString) / sizeof(g_tipString[0]));

    /* Enable RX interrupt. */

    UART_EnableInterrupts(DEMO_UART, kUART_RxDataRegFullInterruptEnable | kUART_RxOverrunInterruptEnable);

    EnableIRQ(DEMO_UART_IRQn);

    while (1)

    {

    n++;

     if(n>5)

             n=0;

        /* Send data only when UART TX register is empty and ring buffer has data to send out. */

   /*     while ((kUART_TxDataRegEmptyFlag & UART_GetStatusFlags(DEMO_UART)) && (rxIndex != txIndex))

        {

            UART_WriteByte(DEMO_UART, demoRingBuffer[txIndex]);

                 txIndex++;

            txIndex %= DEMO_RING_BUFFER_SIZE;

        }*/

    }

}

void DEMO_UART_IRQHandler(void)

{

    uint8_t data;

    /* If new data arrived. */

    if ((kUART_RxDataRegFullFlag | kUART_RxOverrunFlag) & UART_GetStatusFlags(DEMO_UART))

    {

        data = UART_ReadByte(DEMO_UART);

        if(data=='\r'){

        UART_WriteBlocking(DEMO_UART,arr_msg[n],strlen(arr_msg[n]));

        }

        /* If ring buffer is not full, add data to ring buffer. */

        if (((rxIndex + 1) % DEMO_RING_BUFFER_SIZE) != txIndex)

        {

            demoRingBuffer[rxIndex] = data;

            rxIndex++;

            rxIndex %= DEMO_RING_BUFFER_SIZE;

        }

        UART_WriteByte(DEMO_UART, demoRingBuffer[txIndex]);

                      txIndex++;

                 txIndex %= DEMO_RING_BUFFER_SIZE;

    }

}