uart.c 文件参考

#include "ets_sys.h"
#include "osapi.h"
#include "driver/uart.h"
#include "driver/uart_register.h"
#include "mem.h"
#include "os_type.h"
#include "room_info.h"

uart.c 的引用(Include)关系图:

宏定义
#define	uart_recvTaskPrio   0
#define	uart_recvTaskQueueLen   10
#define	DBG
#define	DBG1   uart1_sendStr_no_wait
#define	DBG2   os_printf

函数
void	NB_RxMsgHandler (uint8 *nb_msg)
	NB消息处理函数 更多...
LOCAL void	uart0_rx_intr_handler (void *para)
LOCAL void ICACHE_FLASH_ATTR	uart_config (uint8 uart_no)
STATUS	uart_tx_one_char (uint8 uart, uint8 TxChar)
LOCAL void ICACHE_FLASH_ATTR	uart1_write_char (char c)
LOCAL void ICACHE_FLASH_ATTR	uart0_write_char_no_wait (char c)
void ICACHE_FLASH_ATTR	uart0_tx_buffer (uint8 *buf, uint16 len)
void ICACHE_FLASH_ATTR	uart1_tx_buffer (uint8 *buf, uint16 len)
void ICACHE_FLASH_ATTR	uart0_sendStr (const char *str)
void	at_port_print (const char *str) __attribute__((alias("uart0_sendStr")))
LOCAL void ICACHE_FLASH_ATTR	uart_recvTask (os_event_t *events)
void ICACHE_FLASH_ATTR	uart_init (UartBautRate uart0_br, UartBautRate uart1_br)
void ICACHE_FLASH_ATTR	uart_reattach ()
STATUS	uart_tx_one_char_no_wait (uint8 uart, uint8 TxChar)
STATUS	uart0_tx_one_char_no_wait (uint8 TxChar)
void	uart1_sendStr_no_wait (const char *str)
void	uart_rx_intr_disable (uint8 uart_no)
void	uart_rx_intr_enable (uint8 uart_no)
LOCAL void	uart0_write_char (char c)
void ICACHE_FLASH_ATTR	UART_SetWordLength (uint8 uart_no, UartBitsNum4Char len)
void ICACHE_FLASH_ATTR	UART_SetStopBits (uint8 uart_no, UartStopBitsNum bit_num)
void ICACHE_FLASH_ATTR	UART_SetLineInverse (uint8 uart_no, UART_LineLevelInverse inverse_mask)
void ICACHE_FLASH_ATTR	UART_SetParity (uint8 uart_no, UartParityMode Parity_mode)
void ICACHE_FLASH_ATTR	UART_SetBaudrate (uint8 uart_no, uint32 baud_rate)
void ICACHE_FLASH_ATTR	UART_SetFlowCtrl (uint8 uart_no, UART_HwFlowCtrl flow_ctrl, uint8 rx_thresh)
void ICACHE_FLASH_ATTR	UART_WaitTxFifoEmpty (uint8 uart_no, uint32 time_out_us)
bool ICACHE_FLASH_ATTR	UART_CheckOutputFinished (uint8 uart_no, uint32 time_out_us)
void ICACHE_FLASH_ATTR	UART_ResetFifo (uint8 uart_no)
void ICACHE_FLASH_ATTR	UART_ClearIntrStatus (uint8 uart_no, uint32 clr_mask)
void ICACHE_FLASH_ATTR	UART_SetIntrEna (uint8 uart_no, uint32 ena_mask)
void ICACHE_FLASH_ATTR	UART_SetPrintPort (uint8 uart_no)
void ICACHE_FLASH_ATTR	uart_init_2 (UartBautRate uart0_br, UartBautRate uart1_br)

变量
UartDevice	UartDev
LOCAL struct UartBuffer *	pTxBuffer = NULL
LOCAL struct UartBuffer *	pRxBuffer = NULL
os_event_t	uart_recvTaskQueue [uart_recvTaskQueueLen]

宏定义说明

#define uart_recvTaskPrio   0

#define uart_recvTaskQueueLen   10

#define DBG

#define DBG1   uart1_sendStr_no_wait

#define DBG2   os_printf

函数说明

void NB_RxMsgHandler

(

uint8 *

nb_msg

)

NB消息处理函数

NB消息有以下几种类型：

• 动作指令的执行情况。如“OK”、“ERROR”
• 查询指令的查询结果

云端下发的控制命令。以“+NNMI:”为前缀

当NB发送消息来的时候，我们先判断在接收到这条消息之前有没有发送过指令，即判断响应标志位 response_flag是否被置位，再决定是否去匹配响应消息。

参数

[in]

nb_msg

串口接收到的NB消息

                                     {

    if (response_flag != 0 ) { /* 等待响应匹配 */

        ESP_DEBUG("response_flag = 1");
        
        if (0 != os_strstr(nb_msg, response_msg)) {

            ESP_DEBUG("OK! response message parse!");

            os_memset(response_msg, 0, sizeof(response_msg));
            response_flag = 0;

            NB_Init();

            return;
        } else {

            ESP_DEBUG("ERROR! response message parse failed");

            return;
        }
    } else {

        ESP_DEBUG("response_flag = 0");

        /* 匹配下发消息前缀 */

        /* 命令下发 */

    }

}

函数调用图:

LOCAL void uart0_rx_intr_handler

(

void *

para

)

{
    /* uart0 and uart1 intr combine togther, when interrupt occur, see reg 0x3ff20020, bit2, bit0 represents
    * uart1 and uart0 respectively
    */
    uint8 RcvChar;
    uint8 uart_no = UART0;//UartDev.buff_uart_no;
    uint8 fifo_len = 0;
    uint8 buf_idx = 0;
    uint8 temp,cnt;
    //RcvMsgBuff *pRxBuff = (RcvMsgBuff *)para;
    
        /*ATTENTION:*/
    /*IN NON-OS VERSION SDK, DO NOT USE "ICACHE_FLASH_ATTR" FUNCTIONS IN THE WHOLE HANDLER PROCESS*/
    /*ALL THE FUNCTIONS CALLED IN INTERRUPT HANDLER MUST BE DECLARED IN RAM */
    /*IF NOT , POST AN EVENT AND PROCESS IN SYSTEM TASK */
    if(UART_FRM_ERR_INT_ST == (READ_PERI_REG(UART_INT_ST(uart_no)) & UART_FRM_ERR_INT_ST)){
        DBG1("FRM_ERR\r\n");
        WRITE_PERI_REG(UART_INT_CLR(uart_no), UART_FRM_ERR_INT_CLR);
    }else if(UART_RXFIFO_FULL_INT_ST == (READ_PERI_REG(UART_INT_ST(uart_no)) & UART_RXFIFO_FULL_INT_ST)){
        DBG("f");
        uart_rx_intr_disable(UART0);
        WRITE_PERI_REG(UART_INT_CLR(UART0), UART_RXFIFO_FULL_INT_CLR);
        system_os_post(uart_recvTaskPrio, 0, 0);
    }else if(UART_RXFIFO_TOUT_INT_ST == (READ_PERI_REG(UART_INT_ST(uart_no)) & UART_RXFIFO_TOUT_INT_ST)){
        DBG("t");
        uart_rx_intr_disable(UART0);
        WRITE_PERI_REG(UART_INT_CLR(UART0), UART_RXFIFO_TOUT_INT_CLR);
        system_os_post(uart_recvTaskPrio, 0, 0);
    }else if(UART_TXFIFO_EMPTY_INT_ST == (READ_PERI_REG(UART_INT_ST(uart_no)) & UART_TXFIFO_EMPTY_INT_ST)){
        DBG("e");
    /* to output uart data from uart buffer directly in empty interrupt handler*/
    /*instead of processing in system event, in order not to wait for current task/function to quit */
    /*ATTENTION:*/
    /*IN NON-OS VERSION SDK, DO NOT USE "ICACHE_FLASH_ATTR" FUNCTIONS IN THE WHOLE HANDLER PROCESS*/
    /*ALL THE FUNCTIONS CALLED IN INTERRUPT HANDLER MUST BE DECLARED IN RAM */
    CLEAR_PERI_REG_MASK(UART_INT_ENA(UART0), UART_TXFIFO_EMPTY_INT_ENA);
    #if UART_BUFF_EN
        tx_start_uart_buffer(UART0);
    #endif
        //system_os_post(uart_recvTaskPrio, 1, 0);
        WRITE_PERI_REG(UART_INT_CLR(uart_no), UART_TXFIFO_EMPTY_INT_CLR);
        
    }else if(UART_RXFIFO_OVF_INT_ST  == (READ_PERI_REG(UART_INT_ST(uart_no)) & UART_RXFIFO_OVF_INT_ST)){
        WRITE_PERI_REG(UART_INT_CLR(uart_no), UART_RXFIFO_OVF_INT_CLR);
        DBG1("RX OVF!!\r\n");
    }

}

函数调用图:

这是这个函数的调用关系图:

LOCAL void ICACHE_FLASH_ATTR uart_config

(

uint8

uart_no

)

{
    if (uart_no == UART1){
        PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO2_U, FUNC_U1TXD_BK);
    }else{
        /* rcv_buff size if 0x100 */
        ETS_UART_INTR_ATTACH(uart0_rx_intr_handler,  &(UartDev.rcv_buff));
        PIN_PULLUP_DIS(PERIPHS_IO_MUX_U0TXD_U);
        PIN_FUNC_SELECT(PERIPHS_IO_MUX_U0TXD_U, FUNC_U0TXD);
    #if UART_HW_RTS
        PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDO_U, FUNC_U0RTS);   //HW FLOW CONTROL RTS PIN
        #endif
    #if UART_HW_CTS
        PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTCK_U, FUNC_U0CTS);   //HW FLOW CONTROL CTS PIN
        #endif
    }
    uart_div_modify(uart_no, UART_CLK_FREQ / (UartDev.baut_rate));//SET BAUDRATE
    
    WRITE_PERI_REG(UART_CONF0(uart_no), ((UartDev.exist_parity & UART_PARITY_EN_M)  <<  UART_PARITY_EN_S) //SET BIT AND PARITY MODE
                                                                        | ((UartDev.parity & UART_PARITY_M)  <<UART_PARITY_S )
                                                                        | ((UartDev.stop_bits & UART_STOP_BIT_NUM) << UART_STOP_BIT_NUM_S)
                                                                        | ((UartDev.data_bits & UART_BIT_NUM) << UART_BIT_NUM_S));
    
    //clear rx and tx fifo,not ready
    SET_PERI_REG_MASK(UART_CONF0(uart_no), UART_RXFIFO_RST | UART_TXFIFO_RST);    //RESET FIFO
    CLEAR_PERI_REG_MASK(UART_CONF0(uart_no), UART_RXFIFO_RST | UART_TXFIFO_RST);
    
    if (uart_no == UART0){
        //set rx fifo trigger
        WRITE_PERI_REG(UART_CONF1(uart_no),
        ((100 & UART_RXFIFO_FULL_THRHD) << UART_RXFIFO_FULL_THRHD_S) |
        #if UART_HW_RTS
        ((110 & UART_RX_FLOW_THRHD) << UART_RX_FLOW_THRHD_S) |
        UART_RX_FLOW_EN |   //enbale rx flow control
        #endif
        (0x02 & UART_RX_TOUT_THRHD) << UART_RX_TOUT_THRHD_S |
        UART_RX_TOUT_EN|
        ((0x10 & UART_TXFIFO_EMPTY_THRHD)<<UART_TXFIFO_EMPTY_THRHD_S));//wjl 
        #if UART_HW_CTS
        SET_PERI_REG_MASK( UART_CONF0(uart_no),UART_TX_FLOW_EN);  //add this sentense to add a tx flow control via MTCK( CTS )
        #endif
        SET_PERI_REG_MASK(UART_INT_ENA(uart_no), UART_RXFIFO_TOUT_INT_ENA |UART_FRM_ERR_INT_ENA);
    }else{
        WRITE_PERI_REG(UART_CONF1(uart_no),((UartDev.rcv_buff.TrigLvl & UART_RXFIFO_FULL_THRHD) << UART_RXFIFO_FULL_THRHD_S));//TrigLvl default val == 1
    }
    //clear all interrupt
    WRITE_PERI_REG(UART_INT_CLR(uart_no), 0xffff);
    //enable rx_interrupt
    SET_PERI_REG_MASK(UART_INT_ENA(uart_no), UART_RXFIFO_FULL_INT_ENA|UART_RXFIFO_OVF_INT_ENA);
}

函数调用图:

这是这个函数的调用关系图:

STATUS uart_tx_one_char	(	uint8	uart,
		uint8	TxChar
	)

{
    while (true){
        uint32 fifo_cnt = READ_PERI_REG(UART_STATUS(uart)) & (UART_TXFIFO_CNT<<UART_TXFIFO_CNT_S);
        if ((fifo_cnt >> UART_TXFIFO_CNT_S & UART_TXFIFO_CNT) < 126) {
            break;
        }
    }
    WRITE_PERI_REG(UART_FIFO(uart) , TxChar);
    return OK;
}

这是这个函数的调用关系图:

LOCAL void ICACHE_FLASH_ATTR uart1_write_char

(

char

c

)

{
    if (c == '\n'){
        uart_tx_one_char(UART1, '\r');
        uart_tx_one_char(UART1, '\n');
    }else if (c == '\r'){
    
    }else{
        uart_tx_one_char(UART1, c);
    }
}

函数调用图:

这是这个函数的调用关系图:

LOCAL void ICACHE_FLASH_ATTR uart0_write_char_no_wait

(

char

c

)

{
#if UART_BUFF_EN    //send to uart0 fifo but do not wait 
    uint8 chr;
    if (c == '\n'){
        chr = '\r';
        tx_buff_enq(&chr, 1);
        chr = '\n';
        tx_buff_enq(&chr, 1);
    }else if (c == '\r'){
    
    }else{
        tx_buff_enq(&c,1);
    }
#else //send to uart tx buffer
    if (c == '\n'){
        uart_tx_one_char_no_wait(UART0, '\r');
        uart_tx_one_char_no_wait(UART0, '\n');
    }else if (c == '\r'){
    
    }
    else{
        uart_tx_one_char_no_wait(UART0, c);
    }
#endif
}

函数调用图:

这是这个函数的调用关系图:

void ICACHE_FLASH_ATTR uart0_tx_buffer	(	uint8 *	buf,
		uint16	len
	)

{
    uint16 i;
    for (i = 0; i < len; i++)
    {
        uart_tx_one_char(UART0, buf[i]);
    }
}

函数调用图:

void ICACHE_FLASH_ATTR uart1_tx_buffer	(	uint8 *	buf,
		uint16	len
	)

{
    uint16 i;
    for (i = 0; i < len; i++)
    {
        uart_tx_one_char(UART1, buf[i]);
    }
}

函数调用图:

这是这个函数的调用关系图:

void ICACHE_FLASH_ATTR uart0_sendStr

(

const char *

str

)

{
    while(*str){
        uart_tx_one_char(UART0, *str++);
    }
}

函数调用图:

void at_port_print

(

const char *

str

)

LOCAL void ICACHE_FLASH_ATTR uart_recvTask

(

os_event_t *

events

)

{
    if(events->sig == 0){
    #if  UART_BUFF_EN  
        Uart_rx_buff_enq();
    #else
        uint8 fifo_len = (READ_PERI_REG(UART_STATUS(UART0))>>UART_RXFIFO_CNT_S)&UART_RXFIFO_CNT;
        uint8 d_tmp = 0;
        uint8 idx=0;
        for(idx=0;idx<fifo_len;idx++) {
            d_tmp = READ_PERI_REG(UART_FIFO(UART0)) & 0xFF;
            uart_tx_one_char(UART0, d_tmp);
        }
        WRITE_PERI_REG(UART_INT_CLR(UART0), UART_RXFIFO_FULL_INT_CLR|UART_RXFIFO_TOUT_INT_CLR);
        uart_rx_intr_enable(UART0);
    #endif
    }else if(events->sig == 1){
    #if UART_BUFF_EN
     //already move uart buffer output to uart empty interrupt
        //tx_start_uart_buffer(UART0);
    #else 
    
    #endif
    }
}

函数调用图:

这是这个函数的调用关系图:

void ICACHE_FLASH_ATTR uart_init	(	UartBautRate	uart0_br,
		UartBautRate	uart1_br
	)

{
    /*this is a example to process uart data from task,please change the priority to fit your application task if exists*/
    system_os_task(uart_recvTask, uart_recvTaskPrio, uart_recvTaskQueue, uart_recvTaskQueueLen);  //demo with a task to process the uart data
    
    UartDev.baut_rate = uart0_br;
    uart_config(UART0);
    UartDev.baut_rate = uart1_br;
    uart_config(UART1);
    ETS_UART_INTR_ENABLE();
    
    #if UART_BUFF_EN
    pTxBuffer = Uart_Buf_Init(UART_TX_BUFFER_SIZE);
    pRxBuffer = Uart_Buf_Init(UART_RX_BUFFER_SIZE);
    #endif


    /*option 1: use default print, output from uart0 , will wait some time if fifo is full */
    //do nothing...

    /*option 2: output from uart1,uart1 output will not wait , just for output debug info */
    /*os_printf output uart data via uart1(GPIO2)*/
    //os_install_putc1((void *)uart1_write_char);    //use this one to output debug information via uart1 //

    /*option 3: output from uart0 will skip current byte if fifo is full now... */
    /*see uart0_write_char_no_wait:you can output via a buffer or output directly */
    /*os_printf output uart data via uart0 or uart buffer*/
    //os_install_putc1((void *)uart0_write_char_no_wait);  //use this to print via uart0
    
    #if UART_SELFTEST&UART_BUFF_EN
    os_timer_disarm(&buff_timer_t);
    os_timer_setfn(&buff_timer_t, uart_test_rx , NULL);   //a demo to process the data in uart rx buffer
    os_timer_arm(&buff_timer_t,10,1);
    #endif
}

函数调用图:

这是这个函数的调用关系图:

void ICACHE_FLASH_ATTR uart_reattach

(

)

{
    uart_init(BIT_RATE_115200, BIT_RATE_115200);
}

函数调用图:

STATUS uart_tx_one_char_no_wait	(	uint8	uart,
		uint8	TxChar
	)

{
    uint8 fifo_cnt = (( READ_PERI_REG(UART_STATUS(uart))>>UART_TXFIFO_CNT_S)& UART_TXFIFO_CNT);
    if (fifo_cnt < 126) {
        WRITE_PERI_REG(UART_FIFO(uart) , TxChar);
    }
    return OK;
}

这是这个函数的调用关系图:

STATUS uart0_tx_one_char_no_wait

(

uint8

TxChar

)

{
    uint8 fifo_cnt = (( READ_PERI_REG(UART_STATUS(UART0))>>UART_TXFIFO_CNT_S)& UART_TXFIFO_CNT);
    if (fifo_cnt < 126) {
        WRITE_PERI_REG(UART_FIFO(UART0) , TxChar);
    }
    return OK;
}

void uart1_sendStr_no_wait

(

const char *

str

)

{
    while(*str){
        uart_tx_one_char_no_wait(UART1, *str++);
    }
}

函数调用图:

void uart_rx_intr_disable

(

uint8

uart_no

)

{
#if 1
    CLEAR_PERI_REG_MASK(UART_INT_ENA(uart_no), UART_RXFIFO_FULL_INT_ENA|UART_RXFIFO_TOUT_INT_ENA);
#else
    ETS_UART_INTR_DISABLE();
#endif
}

这是这个函数的调用关系图:

void uart_rx_intr_enable

(

uint8

uart_no

)

{
#if 1
    SET_PERI_REG_MASK(UART_INT_ENA(uart_no), UART_RXFIFO_FULL_INT_ENA|UART_RXFIFO_TOUT_INT_ENA);
#else
    ETS_UART_INTR_ENABLE();
#endif
}

这是这个函数的调用关系图:

LOCAL void uart0_write_char

(

char

c

)

{
    if (c == '\n') {
        uart_tx_one_char(UART0, '\r');
        uart_tx_one_char(UART0, '\n');
    } else if (c == '\r') {
    } else {
        uart_tx_one_char(UART0, c);
    }
}

函数调用图:

这是这个函数的调用关系图:

void ICACHE_FLASH_ATTR UART_SetWordLength	(	uint8	uart_no,
		UartBitsNum4Char	len
	)

{
    SET_PERI_REG_BITS(UART_CONF0(uart_no),UART_BIT_NUM,len,UART_BIT_NUM_S);
}

void ICACHE_FLASH_ATTR UART_SetStopBits	(	uint8	uart_no,
		UartStopBitsNum	bit_num
	)

{
    SET_PERI_REG_BITS(UART_CONF0(uart_no),UART_STOP_BIT_NUM,bit_num,UART_STOP_BIT_NUM_S);
}

void ICACHE_FLASH_ATTR UART_SetLineInverse	(	uint8	uart_no,
		UART_LineLevelInverse	inverse_mask
	)

{
    CLEAR_PERI_REG_MASK(UART_CONF0(uart_no), UART_LINE_INV_MASK);
    SET_PERI_REG_MASK(UART_CONF0(uart_no), inverse_mask);
}

void ICACHE_FLASH_ATTR UART_SetParity	(	uint8	uart_no,
		UartParityMode	Parity_mode
	)

{
    CLEAR_PERI_REG_MASK(UART_CONF0(uart_no), UART_PARITY |UART_PARITY_EN);
    if(Parity_mode==NONE_BITS){
    }else{
        SET_PERI_REG_MASK(UART_CONF0(uart_no), Parity_mode|UART_PARITY_EN);
    }
}

void ICACHE_FLASH_ATTR UART_SetBaudrate	(	uint8	uart_no,
		uint32	baud_rate
	)

{
    uart_div_modify(uart_no, UART_CLK_FREQ /baud_rate);
}

void ICACHE_FLASH_ATTR UART_SetFlowCtrl	(	uint8	uart_no,
		UART_HwFlowCtrl	flow_ctrl,
		uint8	rx_thresh
	)

{
    if(flow_ctrl&USART_HardwareFlowControl_RTS){
        PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDO_U, FUNC_U0RTS);
        SET_PERI_REG_BITS(UART_CONF1(uart_no),UART_RX_FLOW_THRHD,rx_thresh,UART_RX_FLOW_THRHD_S);
        SET_PERI_REG_MASK(UART_CONF1(uart_no), UART_RX_FLOW_EN);
    }else{
        CLEAR_PERI_REG_MASK(UART_CONF1(uart_no), UART_RX_FLOW_EN);
    }
    if(flow_ctrl&USART_HardwareFlowControl_CTS){
        PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTCK_U, FUNC_UART0_CTS);
        SET_PERI_REG_MASK(UART_CONF0(uart_no), UART_TX_FLOW_EN);
    }else{
        CLEAR_PERI_REG_MASK(UART_CONF0(uart_no), UART_TX_FLOW_EN);
    }
}

void ICACHE_FLASH_ATTR UART_WaitTxFifoEmpty	(	uint8	uart_no,
		uint32	time_out_us
	)

{
    uint32 t_s = system_get_time();
    while (READ_PERI_REG(UART_STATUS(uart_no)) & (UART_TXFIFO_CNT << UART_TXFIFO_CNT_S)){
        
        if(( system_get_time() - t_s )> time_out_us){
            break;
        }
    WRITE_PERI_REG(0X60000914, 0X73);//WTD

    }
}

函数调用图:

bool ICACHE_FLASH_ATTR UART_CheckOutputFinished	(	uint8	uart_no,
		uint32	time_out_us
	)

{
    uint32 t_start = system_get_time();
    uint8 tx_fifo_len;
    uint32 tx_buff_len;
    while(1){
        tx_fifo_len =( (READ_PERI_REG(UART_STATUS(uart_no))>>UART_TXFIFO_CNT_S)&UART_TXFIFO_CNT);
        if(pTxBuffer){
            tx_buff_len = ((pTxBuffer->UartBuffSize)-(pTxBuffer->Space));
        }else{
            tx_buff_len = 0;
        }
        
        if( tx_fifo_len==0 && tx_buff_len==0){
            return TRUE;
        }
        if( system_get_time() - t_start > time_out_us){
            return FALSE;
        }
    WRITE_PERI_REG(0X60000914, 0X73);//WTD
    }    
}

函数调用图:

void ICACHE_FLASH_ATTR UART_ResetFifo

(

uint8

uart_no

)

{
    SET_PERI_REG_MASK(UART_CONF0(uart_no), UART_RXFIFO_RST | UART_TXFIFO_RST);
    CLEAR_PERI_REG_MASK(UART_CONF0(uart_no), UART_RXFIFO_RST | UART_TXFIFO_RST);
}

void ICACHE_FLASH_ATTR UART_ClearIntrStatus	(	uint8	uart_no,
		uint32	clr_mask
	)

{
    WRITE_PERI_REG(UART_INT_CLR(uart_no), clr_mask);
}

void ICACHE_FLASH_ATTR UART_SetIntrEna	(	uint8	uart_no,
		uint32	ena_mask
	)

{
    SET_PERI_REG_MASK(UART_INT_ENA(uart_no), ena_mask);
}

void ICACHE_FLASH_ATTR UART_SetPrintPort

(

uint8

uart_no

)

{
    if(uart_no==1){
        os_install_putc1(uart1_write_char);
    }else{
        /*option 1: do not wait if uart fifo is full,drop current character*/
        os_install_putc1(uart0_write_char_no_wait);
    /*option 2: wait for a while if uart fifo is full*/
    os_install_putc1(uart0_write_char);
    }
}

函数调用图:

这是这个函数的调用关系图:

void ICACHE_FLASH_ATTR uart_init_2	(	UartBautRate	uart0_br,
		UartBautRate	uart1_br
	)

{
    // rom use 74880 baut_rate, here reinitialize
    UartDev.baut_rate = uart0_br;
    UartDev.exist_parity = STICK_PARITY_EN;
    UartDev.parity = EVEN_BITS;
    UartDev.stop_bits = ONE_STOP_BIT;
    UartDev.data_bits = EIGHT_BITS;
    
    uart_config(UART0);
    UartDev.baut_rate = uart1_br;
    uart_config(UART1);
    ETS_UART_INTR_ENABLE();

    // install uart1 putc callback
    os_install_putc1((void *)uart1_write_char);//print output at UART1
}

函数调用图:

变量说明

UartDevice UartDev

LOCAL struct UartBuffer* pTxBuffer = NULL

LOCAL struct UartBuffer* pRxBuffer = NULL

os_event_t uart_recvTaskQueue[uart_recvTaskQueueLen]