uart.c

Go to the documentation of this file.

#include "user_config.h"

#include "uart.h"
#include "uart_register.h"

#ifdef TELNET_SERIAL
    extern queue_t *bridge_send_queue;
    extern queue_t *bridge_receive_queue;
#endif

#define UARTS 2
#ifdef UART_QUEUED
    #ifdef UART_QUEUED_TX
        queue_t *uart_txq[UARTS]  = { NULL, NULL };
    #endif
    #ifdef UART_QUEUED_RX
        queue_t *uart_rxq[UARTS]  = { NULL, NULL };
    #endif
#endif
int uart_debug_port = 0;

// =================================================================
// @brief low level UART functions
void uart_rx_enable(uint8 uart_no)
{
    SET_PERI_REG_MASK(UART_INT_ENA(uart_no), UART_RXFIFO_FULL_INT_ENA|UART_RXFIFO_TOUT_INT_ENA);
}

void uart_rx_disable(uint8 uart_no)
{
    CLEAR_PERI_REG_MASK(UART_INT_ENA(uart_no), UART_RXFIFO_FULL_INT_ENA|UART_RXFIFO_TOUT_INT_ENA);
}

void uart_tx_enable(uint8_t uart_no)
{
    SET_PERI_REG_MASK(UART_INT_ENA(uart_no), UART_TXFIFO_EMPTY_INT_ENA);
}

void uart_tx_disable(uint8_t uart_no)
{
    CLEAR_PERI_REG_MASK(UART_INT_ENA(uart_no), UART_TXFIFO_EMPTY_INT_ENA);
}

// =================================================================

void tx_fifo_flush(int uart_no)
{
    SET_PERI_REG_MASK(UART_CONF0(uart_no),  UART_TXFIFO_RST);  
    CLEAR_PERI_REG_MASK(UART_CONF0(uart_no), UART_TXFIFO_RST); 
}

void rx_fifo_flush(int uart_no)
{
    SET_PERI_REG_MASK(UART_CONF0(uart_no),  UART_RXFIFO_RST);  
    CLEAR_PERI_REG_MASK(UART_CONF0(uart_no), UART_RXFIFO_RST); 
}

// =================================================================
MEMSPACE
int tx_fifo_used(int uart_no)
{
    int used = (READ_PERI_REG(UART_STATUS(uart_no))>>UART_TXFIFO_CNT_S)&UART_TXFIFO_CNT;
    return(used);
}

MEMSPACE
int tx_fifo_free(int uart_no)
{
    int used = (READ_PERI_REG(UART_STATUS(uart_no))>>UART_TXFIFO_CNT_S)&UART_TXFIFO_CNT;
    int free = UART_FIFO_LEN - used;
    return(free);
}

MEMSPACE
int tx_fifo_empty(int uart_no)
{
    int used = (READ_PERI_REG(UART_STATUS(uart_no))>>UART_TXFIFO_CNT_S)&UART_TXFIFO_CNT;
    return( used ? 0 : 1);
}

MEMSPACE
int rx_fifo_used(int uart_no)
{
    // number of characters in fifo
    int used = (READ_PERI_REG(UART_STATUS(UART0))>>UART_RXFIFO_CNT_S)&UART_RXFIFO_CNT;
    return(used);
}

MEMSPACE
int rx_fifo_free(int uart_no)
{
    // number of characters in fifo
    int used = (READ_PERI_REG(UART_STATUS(UART0))>>UART_RXFIFO_CNT_S)&UART_RXFIFO_CNT;
    int free = UART_FIFO_LEN - used;
    return(used);
}

MEMSPACE
int  rx_fifo_empty(int uart_no)
{
    // number of characters in fifo
    int used = (READ_PERI_REG(UART_STATUS(UART0))>>UART_RXFIFO_CNT_S)&UART_RXFIFO_CNT;
    return( used ? 0 : 1);
}

// =================================================================

MEMSPACE
int tx_fifo_putb(int uart_no, uint8_t c)
{
    if(tx_fifo_free(uart_no) )
    {
        WRITE_PERI_REG(UART_FIFO(uart_no), c);
        uart_tx_enable(uart_no);
        return(c);
    }
    return(-1);
}

MEMSPACE
int rx_fifo_getb(int uart_no)
{
    if( rx_fifo_used(uart_no) )
        return (READ_PERI_REG(UART_FIFO(UART0)) & 0xFF);
    return(-1);
}

// =================================================================
MEMSPACE
int tx_fifo_write(int uart_no, uint8_t *buf, int size)
{
    uint8_t tmp;
    int  sent = 0;
    while(size && tx_fifo_free(uart_no))
    {
        tmp = *buf++;
        WRITE_PERI_REG(UART_FIFO(uart_no) , tmp);
        ++sent;
        --size;
    }
    // FIXME
    uart_tx_enable(uart_no);
    return(sent);
}
    
MEMSPACE
int rx_fifo_read(int uart_no, uint8_t *buf, int size)
{
    uint8_t tmp;
    int  read = 0;
    while(size && rx_fifo_used(uart_no) )
    {
        tmp = READ_PERI_REG(UART_FIFO(UART0)) & 0xFF;
        *buf++ = tmp;
        ++read;
        --size;
    }
    return(read);
}

// =================================================================

LOCAL MEMSPACE
int uart_putb(uint8 uart_no, uint8 data)
{
//FIXME verify free before call to tx_free_putc
    while( !tx_fifo_free(uart_no) )
        optimistic_yield(1000);
    return( tx_fifo_putb(uart_no, data) );
}

LOCAL MEMSPACE
int uart_getb(int uart_no)
{
    uint8_t c;
//FIXME verify empty before call to rx_free_getc
    while( rx_fifo_empty(uart_no) )
        optimistic_yield(1000);
    c = rx_fifo_getb(uart_no);
    return (c);
}

// =================================================================
MEMSPACE
int uart_putc(uint8 uart_no, char c)
{
    if (c == '\r')
        uart_putb(uart_no, '\n');
    return( uart_putb(uart_no, c) );
}

MEMSPACE
int uart_getc(int uart_no)
{
    uint8_t c;
    while(1)
    {
        optimistic_yield(1000);
        c = uart_getb(uart_no);
        if(c == '\n')
            continue;
        break;
    }
    return (c);
}
// =================================================================
MEMSPACE
int uart0_putc(uint8 c)
{
    return( uart_putc(0,c) );
}

MEMSPACE
int  uart0_getc()
{
    return( uart_getc(0) );
}

// =================================================================
MEMSPACE
int uart1_putc(uint8 c)
{
    return( uart_putc(1,c) );
}

MEMSPACE
int uart1_getc()
{
    return( uart_getc(1) );
}

// =================================================================

MEMSPACE
void uart_flush(uint8_t uart_no)
{
#ifdef UART_QUEUED_TX
    while(!queue_empty(uart_txq[uart_no]) && tx_fifo_used(uart_no))
        ;
#else
    while(tx_fifo_used(uart_no))
        ;
#endif
}

// =================================================================
#ifdef UART_QUEUED



#ifdef UART_QUEUED_RX

LOCAL MEMSPACE
int uart_queue_getb(uint8_t uart_no)
{
    uint8_t c;
    while(queue_empty(uart_rxq[uart_no]))
        optimistic_yield(1000);
    c = queue_popc(uart_rxq[uart_no]);
    return (c);
}
MEMSPACE
uint8_t uart_queue_getc(uint8_t uart_no)
{
    uint8_t c;
    while(1)
    {
        c = uart_queue_getb(uart_no);
        if(c == '\r')
            continue;
        break;
    }
    return (c);
}

MEMSPACE
uint8_t uart0_queue_getc()
{
    uint8_t data = uart_queue_getc(0);
}


MEMSPACE
uint8_t uart1_queue_getc()
{
    return(uart_queue_getc(1) );
}
#endif

#ifdef UART_QUEUED_TX
#ifdef UART_TASK

void uart_task(void)
{
    uint8_t data;
    if(tx_fifo_empty(0) )
    { 
        if(!queue_empty(uart_txq[0]) )
        {
            data = queue_popc(uart_txq[0]);
            WRITE_PERI_REG(UART_FIFO(0), data);
            uart_tx_enable(0);
        }
    }
}
#endif

LOCAL MEMSPACE
void uart_queue_putb(uint8 uart_no, uint8 data)
{
    // enable transmit queue to empty existing data
    // uart_tx_enable(uart_no);
    while(queue_full(uart_txq[uart_no]))
      optimistic_yield(1000);
    queue_pushc(uart_txq[uart_no], data);
    // enable transmit queue to empty new data
    uart_tx_enable(uart_no);
}


// =================================================================
MEMSPACE
void uart_queue_putc(uint8_t uart_no, char c)
{
    if (c == '\r')
        uart_queue_putb(uart_no, '\n');
    uart_queue_putb(uart_no, c);
}

MEMSPACE
void uart0_queue_putc(char c)
{
    uart_queue_putc(0,c);
}

MEMSPACE
void uart1_queue_putc(char c)
{
    uart_queue_putc(1,c);
}
#endif

#endif

int kbhiteol(int uart_no)
{
    if(uart_rxq[uart_no]->flags & QUEUE_EOL )
            return(1);
    if(!queue_empty(uart_rxq[uart_no]) )
        return(1);
    return(0);
}
int kbhit(int uart_no)
{
    if(!queue_empty(uart_rxq[uart_no]) )
        return(1);
    return(0);
}


// =================================================================

---

Generated on Wed Jan 31 2018 21:22:16 for ESP8266 ILI9341 display support code with printf sources, wire-frame viewer and custom fonts by   1.8.11