mirror of
https://github.com/espressif/esp-idf.git
synced 2024-10-05 20:47:46 -04:00
uart: format driver code by astyle
This commit is contained in:
morris
SalimTerryLi
parent
de3d75605f
commit
89990bcbf5
@ -45,7 +45,7 @@
|
||||
#define XOFF (0x13)
|
||||
#define XON (0x11)
|
||||
|
||||
static const char* UART_TAG = "uart";
|
||||
static const char *UART_TAG = "uart";
|
||||
#define UART_CHECK(a, str, ret_val) \
|
||||
if (!(a)) { \
|
||||
ESP_LOGE(UART_TAG,"%s(%d): %s", __FUNCTION__, __LINE__, str); \
|
||||
@ -94,7 +94,7 @@ typedef struct {
|
||||
int wr;
|
||||
int rd;
|
||||
int len;
|
||||
int* data;
|
||||
int *data;
|
||||
} uart_pat_rb_t;
|
||||
|
||||
typedef struct {
|
||||
@ -113,8 +113,8 @@ typedef struct {
|
||||
RingbufHandle_t rx_ring_buf; /*!< RX ring buffer handler*/
|
||||
bool rx_buffer_full_flg; /*!< RX ring buffer full flag. */
|
||||
int rx_cur_remain; /*!< Data number that waiting to be read out in ring buffer item*/
|
||||
uint8_t* rx_ptr; /*!< pointer to the current data in ring buffer*/
|
||||
uint8_t* rx_head_ptr; /*!< pointer to the head of RX item*/
|
||||
uint8_t *rx_ptr; /*!< pointer to the current data in ring buffer*/
|
||||
uint8_t *rx_head_ptr; /*!< pointer to the head of RX item*/
|
||||
uint8_t rx_data_buf[UART_FIFO_LEN]; /*!< Data buffer to stash FIFO data*/
|
||||
uint8_t rx_stash_len; /*!< stashed data length.(When using flow control, after reading out FIFO data, if we fail to push to buffer, we can just stash them.) */
|
||||
uart_pat_rb_t rx_pattern_pos;
|
||||
@ -127,8 +127,8 @@ typedef struct {
|
||||
int tx_buf_size; /*!< TX ring buffer size */
|
||||
RingbufHandle_t tx_ring_buf; /*!< TX ring buffer handler*/
|
||||
bool tx_waiting_fifo; /*!< this flag indicates that some task is waiting for FIFO empty interrupt, used to send all data without any data buffer*/
|
||||
uint8_t* tx_ptr; /*!< TX data pointer to push to FIFO in TX buffer mode*/
|
||||
uart_tx_data_t* tx_head; /*!< TX data pointer to head of the current buffer in TX ring buffer*/
|
||||
uint8_t *tx_ptr; /*!< TX data pointer to push to FIFO in TX buffer mode*/
|
||||
uart_tx_data_t *tx_head; /*!< TX data pointer to head of the current buffer in TX ring buffer*/
|
||||
uint32_t tx_len_tot; /*!< Total length of current item in ring buffer*/
|
||||
uint32_t tx_len_cur;
|
||||
uint8_t tx_brk_flg; /*!< Flag to indicate to send a break signal in the end of the item sending procedure */
|
||||
@ -190,7 +190,7 @@ esp_err_t uart_set_word_length(uart_port_t uart_num, uart_word_length_t data_bit
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
esp_err_t uart_get_word_length(uart_port_t uart_num, uart_word_length_t* data_bit)
|
||||
esp_err_t uart_get_word_length(uart_port_t uart_num, uart_word_length_t *data_bit)
|
||||
{
|
||||
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);
|
||||
uart_hal_get_data_bit_num(&(uart_context[uart_num].hal), data_bit);
|
||||
@ -207,7 +207,7 @@ esp_err_t uart_set_stop_bits(uart_port_t uart_num, uart_stop_bits_t stop_bit)
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
esp_err_t uart_get_stop_bits(uart_port_t uart_num, uart_stop_bits_t* stop_bit)
|
||||
esp_err_t uart_get_stop_bits(uart_port_t uart_num, uart_stop_bits_t *stop_bit)
|
||||
{
|
||||
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);
|
||||
UART_ENTER_CRITICAL(&(uart_context[uart_num].spinlock));
|
||||
@ -225,7 +225,7 @@ esp_err_t uart_set_parity(uart_port_t uart_num, uart_parity_t parity_mode)
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
esp_err_t uart_get_parity(uart_port_t uart_num, uart_parity_t* parity_mode)
|
||||
esp_err_t uart_get_parity(uart_port_t uart_num, uart_parity_t *parity_mode)
|
||||
{
|
||||
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);
|
||||
UART_ENTER_CRITICAL(&(uart_context[uart_num].spinlock));
|
||||
@ -291,7 +291,7 @@ esp_err_t uart_set_hw_flow_ctrl(uart_port_t uart_num, uart_hw_flowcontrol_t flow
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
esp_err_t uart_get_hw_flow_ctrl(uart_port_t uart_num, uart_hw_flowcontrol_t* flow_ctrl)
|
||||
esp_err_t uart_get_hw_flow_ctrl(uart_port_t uart_num, uart_hw_flowcontrol_t *flow_ctrl)
|
||||
{
|
||||
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL)
|
||||
UART_ENTER_CRITICAL(&(uart_context[uart_num].spinlock));
|
||||
@ -343,7 +343,7 @@ static esp_err_t uart_pattern_link_free(uart_port_t uart_num)
|
||||
static esp_err_t UART_ISR_ATTR uart_pattern_enqueue(uart_port_t uart_num, int pos)
|
||||
{
|
||||
esp_err_t ret = ESP_OK;
|
||||
uart_pat_rb_t* p_pos = &p_uart_obj[uart_num]->rx_pattern_pos;
|
||||
uart_pat_rb_t *p_pos = &p_uart_obj[uart_num]->rx_pattern_pos;
|
||||
int next = p_pos->wr + 1;
|
||||
if (next >= p_pos->len) {
|
||||
next = 0;
|
||||
@ -361,11 +361,11 @@ static esp_err_t UART_ISR_ATTR uart_pattern_enqueue(uart_port_t uart_num, int po
|
||||
|
||||
static esp_err_t uart_pattern_dequeue(uart_port_t uart_num)
|
||||
{
|
||||
if(p_uart_obj[uart_num]->rx_pattern_pos.data == NULL) {
|
||||
if (p_uart_obj[uart_num]->rx_pattern_pos.data == NULL) {
|
||||
return ESP_ERR_INVALID_STATE;
|
||||
} else {
|
||||
esp_err_t ret = ESP_OK;
|
||||
uart_pat_rb_t* p_pos = &p_uart_obj[uart_num]->rx_pattern_pos;
|
||||
uart_pat_rb_t *p_pos = &p_uart_obj[uart_num]->rx_pattern_pos;
|
||||
if (p_pos->rd == p_pos->wr) {
|
||||
ret = ESP_FAIL;
|
||||
} else {
|
||||
@ -380,9 +380,9 @@ static esp_err_t uart_pattern_dequeue(uart_port_t uart_num)
|
||||
|
||||
static esp_err_t uart_pattern_queue_update(uart_port_t uart_num, int diff_len)
|
||||
{
|
||||
uart_pat_rb_t* p_pos = &p_uart_obj[uart_num]->rx_pattern_pos;
|
||||
uart_pat_rb_t *p_pos = &p_uart_obj[uart_num]->rx_pattern_pos;
|
||||
int rd = p_pos->rd;
|
||||
while(rd != p_pos->wr) {
|
||||
while (rd != p_pos->wr) {
|
||||
p_pos->data[rd] -= diff_len;
|
||||
int rd_rec = rd;
|
||||
rd ++;
|
||||
@ -400,7 +400,7 @@ int uart_pattern_pop_pos(uart_port_t uart_num)
|
||||
{
|
||||
UART_CHECK((p_uart_obj[uart_num]), "uart driver error", (-1));
|
||||
UART_ENTER_CRITICAL(&(uart_context[uart_num].spinlock));
|
||||
uart_pat_rb_t* pat_pos = &p_uart_obj[uart_num]->rx_pattern_pos;
|
||||
uart_pat_rb_t *pat_pos = &p_uart_obj[uart_num]->rx_pattern_pos;
|
||||
int pos = -1;
|
||||
if (pat_pos != NULL && pat_pos->rd != pat_pos->wr) {
|
||||
pos = pat_pos->data[pat_pos->rd];
|
||||
@ -414,7 +414,7 @@ int uart_pattern_get_pos(uart_port_t uart_num)
|
||||
{
|
||||
UART_CHECK((p_uart_obj[uart_num]), "uart driver error", (-1));
|
||||
UART_ENTER_CRITICAL(&(uart_context[uart_num].spinlock));
|
||||
uart_pat_rb_t* pat_pos = &p_uart_obj[uart_num]->rx_pattern_pos;
|
||||
uart_pat_rb_t *pat_pos = &p_uart_obj[uart_num]->rx_pattern_pos;
|
||||
int pos = -1;
|
||||
if (pat_pos != NULL && pat_pos->rd != pat_pos->wr) {
|
||||
pos = pat_pos->data[pat_pos->rd];
|
||||
@ -428,12 +428,12 @@ esp_err_t uart_pattern_queue_reset(uart_port_t uart_num, int queue_length)
|
||||
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);
|
||||
UART_CHECK((p_uart_obj[uart_num]), "uart driver error", ESP_ERR_INVALID_STATE);
|
||||
|
||||
int* pdata = (int*) malloc(queue_length * sizeof(int));
|
||||
if(pdata == NULL) {
|
||||
int *pdata = (int *) malloc(queue_length * sizeof(int));
|
||||
if (pdata == NULL) {
|
||||
return ESP_ERR_NO_MEM;
|
||||
}
|
||||
UART_ENTER_CRITICAL(&(uart_context[uart_num].spinlock));
|
||||
int* ptmp = p_uart_obj[uart_num]->rx_pattern_pos.data;
|
||||
int *ptmp = p_uart_obj[uart_num]->rx_pattern_pos.data;
|
||||
p_uart_obj[uart_num]->rx_pattern_pos.data = pdata;
|
||||
p_uart_obj[uart_num]->rx_pattern_pos.len = queue_length;
|
||||
p_uart_obj[uart_num]->rx_pattern_pos.rd = 0;
|
||||
@ -507,12 +507,12 @@ esp_err_t uart_disable_pattern_det_intr(uart_port_t uart_num)
|
||||
|
||||
esp_err_t uart_enable_rx_intr(uart_port_t uart_num)
|
||||
{
|
||||
return uart_enable_intr_mask(uart_num, UART_INTR_RXFIFO_FULL|UART_INTR_RXFIFO_TOUT);
|
||||
return uart_enable_intr_mask(uart_num, UART_INTR_RXFIFO_FULL | UART_INTR_RXFIFO_TOUT);
|
||||
}
|
||||
|
||||
esp_err_t uart_disable_rx_intr(uart_port_t uart_num)
|
||||
{
|
||||
return uart_disable_intr_mask(uart_num, UART_INTR_RXFIFO_FULL|UART_INTR_RXFIFO_TOUT);
|
||||
return uart_disable_intr_mask(uart_num, UART_INTR_RXFIFO_FULL | UART_INTR_RXFIFO_TOUT);
|
||||
}
|
||||
|
||||
esp_err_t uart_disable_tx_intr(uart_port_t uart_num)
|
||||
@ -532,12 +532,12 @@ esp_err_t uart_enable_tx_intr(uart_port_t uart_num, int enable, int thresh)
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
esp_err_t uart_isr_register(uart_port_t uart_num, void (*fn)(void*), void * arg, int intr_alloc_flags, uart_isr_handle_t *handle)
|
||||
esp_err_t uart_isr_register(uart_port_t uart_num, void (*fn)(void *), void *arg, int intr_alloc_flags, uart_isr_handle_t *handle)
|
||||
{
|
||||
int ret;
|
||||
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);
|
||||
UART_ENTER_CRITICAL(&(uart_context[uart_num].spinlock));
|
||||
ret=esp_intr_alloc(uart_periph_signal[uart_num].irq, intr_alloc_flags, fn, arg, handle);
|
||||
ret = esp_intr_alloc(uart_periph_signal[uart_num].irq, intr_alloc_flags, fn, arg, handle);
|
||||
UART_EXIT_CRITICAL(&(uart_context[uart_num].spinlock));
|
||||
return ret;
|
||||
}
|
||||
@ -549,8 +549,8 @@ esp_err_t uart_isr_free(uart_port_t uart_num)
|
||||
UART_CHECK((p_uart_obj[uart_num]), "uart driver error", ESP_FAIL);
|
||||
UART_CHECK((p_uart_obj[uart_num]->intr_handle != NULL), "uart driver error", ESP_ERR_INVALID_ARG);
|
||||
UART_ENTER_CRITICAL(&(uart_context[uart_num].spinlock));
|
||||
ret=esp_intr_free(p_uart_obj[uart_num]->intr_handle);
|
||||
p_uart_obj[uart_num]->intr_handle=NULL;
|
||||
ret = esp_intr_free(p_uart_obj[uart_num]->intr_handle);
|
||||
p_uart_obj[uart_num]->intr_handle = NULL;
|
||||
UART_EXIT_CRITICAL(&(uart_context[uart_num].spinlock));
|
||||
return ret;
|
||||
}
|
||||
@ -646,16 +646,16 @@ esp_err_t uart_intr_config(uart_port_t uart_num, const uart_intr_config_t *intr_
|
||||
UART_CHECK((intr_conf), "param null", ESP_FAIL);
|
||||
uart_hal_clr_intsts_mask(&(uart_context[uart_num].hal), UART_INTR_MASK);
|
||||
UART_ENTER_CRITICAL(&(uart_context[uart_num].spinlock));
|
||||
if(intr_conf->intr_enable_mask & UART_INTR_RXFIFO_TOUT) {
|
||||
if (intr_conf->intr_enable_mask & UART_INTR_RXFIFO_TOUT) {
|
||||
uart_hal_set_rx_timeout(&(uart_context[uart_num].hal), intr_conf->rx_timeout_thresh);
|
||||
} else {
|
||||
//Disable rx_tout intr
|
||||
uart_hal_set_rx_timeout(&(uart_context[uart_num].hal), 0);
|
||||
}
|
||||
if(intr_conf->intr_enable_mask & UART_INTR_RXFIFO_FULL) {
|
||||
if (intr_conf->intr_enable_mask & UART_INTR_RXFIFO_FULL) {
|
||||
uart_hal_set_rxfifo_full_thr(&(uart_context[uart_num].hal), intr_conf->rxfifo_full_thresh);
|
||||
}
|
||||
if(intr_conf->intr_enable_mask & UART_INTR_TXFIFO_EMPTY) {
|
||||
if (intr_conf->intr_enable_mask & UART_INTR_TXFIFO_EMPTY) {
|
||||
uart_hal_set_txfifo_empty_thr(&(uart_context[uart_num].hal), intr_conf->txfifo_empty_intr_thresh);
|
||||
}
|
||||
uart_hal_ena_intr_mask(&(uart_context[uart_num].hal), intr_conf->intr_enable_mask);
|
||||
@ -663,7 +663,7 @@ esp_err_t uart_intr_config(uart_port_t uart_num, const uart_intr_config_t *intr_
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
static int UART_ISR_ATTR uart_find_pattern_from_last(uint8_t* buf, int length, uint8_t pat_chr, uint8_t pat_num)
|
||||
static int UART_ISR_ATTR uart_find_pattern_from_last(uint8_t *buf, int length, uint8_t pat_chr, uint8_t pat_num)
|
||||
{
|
||||
int cnt = 0;
|
||||
int len = length;
|
||||
@ -684,37 +684,37 @@ static int UART_ISR_ATTR uart_find_pattern_from_last(uint8_t* buf, int length, u
|
||||
//internal isr handler for default driver code.
|
||||
static void UART_ISR_ATTR uart_rx_intr_handler_default(void *param)
|
||||
{
|
||||
uart_obj_t *p_uart = (uart_obj_t*) param;
|
||||
uart_obj_t *p_uart = (uart_obj_t *) param;
|
||||
uint8_t uart_num = p_uart->uart_num;
|
||||
int rx_fifo_len = 0;
|
||||
uint32_t uart_intr_status = 0;
|
||||
uart_event_t uart_event;
|
||||
portBASE_TYPE HPTaskAwoken = 0;
|
||||
static uint8_t pat_flg = 0;
|
||||
while(1) {
|
||||
while (1) {
|
||||
// The `continue statement` may cause the interrupt to loop infinitely
|
||||
// we exit the interrupt here
|
||||
uart_intr_status = uart_hal_get_intsts_mask(&(uart_context[uart_num].hal));
|
||||
//Exit form while loop
|
||||
if(uart_intr_status == 0){
|
||||
if (uart_intr_status == 0) {
|
||||
break;
|
||||
}
|
||||
uart_event.type = UART_EVENT_MAX;
|
||||
if(uart_intr_status & UART_INTR_TXFIFO_EMPTY) {
|
||||
if (uart_intr_status & UART_INTR_TXFIFO_EMPTY) {
|
||||
UART_ENTER_CRITICAL_ISR(&(uart_context[uart_num].spinlock));
|
||||
uart_hal_disable_intr_mask(&(uart_context[uart_num].hal), UART_INTR_TXFIFO_EMPTY);
|
||||
UART_EXIT_CRITICAL_ISR(&(uart_context[uart_num].spinlock));
|
||||
uart_hal_clr_intsts_mask(&(uart_context[uart_num].hal), UART_INTR_TXFIFO_EMPTY);
|
||||
if(p_uart->tx_waiting_brk) {
|
||||
if (p_uart->tx_waiting_brk) {
|
||||
continue;
|
||||
}
|
||||
//TX semaphore will only be used when tx_buf_size is zero.
|
||||
if(p_uart->tx_waiting_fifo == true && p_uart->tx_buf_size == 0) {
|
||||
if (p_uart->tx_waiting_fifo == true && p_uart->tx_buf_size == 0) {
|
||||
p_uart->tx_waiting_fifo = false;
|
||||
xSemaphoreGiveFromISR(p_uart->tx_fifo_sem, &HPTaskAwoken);
|
||||
} else {
|
||||
//We don't use TX ring buffer, because the size is zero.
|
||||
if(p_uart->tx_buf_size == 0) {
|
||||
if (p_uart->tx_buf_size == 0) {
|
||||
continue;
|
||||
}
|
||||
bool en_tx_flg = false;
|
||||
@ -722,25 +722,25 @@ static void UART_ISR_ATTR uart_rx_intr_handler_default(void *param)
|
||||
//We need to put a loop here, in case all the buffer items are very short.
|
||||
//That would cause a watch_dog reset because empty interrupt happens so often.
|
||||
//Although this is a loop in ISR, this loop will execute at most 128 turns.
|
||||
while(tx_fifo_rem) {
|
||||
if(p_uart->tx_len_tot == 0 || p_uart->tx_ptr == NULL || p_uart->tx_len_cur == 0) {
|
||||
while (tx_fifo_rem) {
|
||||
if (p_uart->tx_len_tot == 0 || p_uart->tx_ptr == NULL || p_uart->tx_len_cur == 0) {
|
||||
size_t size;
|
||||
p_uart->tx_head = (uart_tx_data_t*) xRingbufferReceiveFromISR(p_uart->tx_ring_buf, &size);
|
||||
if(p_uart->tx_head) {
|
||||
p_uart->tx_head = (uart_tx_data_t *) xRingbufferReceiveFromISR(p_uart->tx_ring_buf, &size);
|
||||
if (p_uart->tx_head) {
|
||||
//The first item is the data description
|
||||
//Get the first item to get the data information
|
||||
if(p_uart->tx_len_tot == 0) {
|
||||
if (p_uart->tx_len_tot == 0) {
|
||||
p_uart->tx_ptr = NULL;
|
||||
p_uart->tx_len_tot = p_uart->tx_head->tx_data.size;
|
||||
if(p_uart->tx_head->type == UART_DATA_BREAK) {
|
||||
if (p_uart->tx_head->type == UART_DATA_BREAK) {
|
||||
p_uart->tx_brk_flg = 1;
|
||||
p_uart->tx_brk_len = p_uart->tx_head->tx_data.brk_len;
|
||||
}
|
||||
//We have saved the data description from the 1st item, return buffer.
|
||||
vRingbufferReturnItemFromISR(p_uart->tx_ring_buf, p_uart->tx_head, &HPTaskAwoken);
|
||||
} else if(p_uart->tx_ptr == NULL) {
|
||||
} else if (p_uart->tx_ptr == NULL) {
|
||||
//Update the TX item pointer, we will need this to return item to buffer.
|
||||
p_uart->tx_ptr = (uint8_t*)p_uart->tx_head;
|
||||
p_uart->tx_ptr = (uint8_t *)p_uart->tx_head;
|
||||
en_tx_flg = true;
|
||||
p_uart->tx_len_cur = size;
|
||||
}
|
||||
@ -774,7 +774,7 @@ static void UART_ISR_ATTR uart_rx_intr_handler_default(void *param)
|
||||
p_uart->tx_ptr = NULL;
|
||||
//Sending item done, now we need to send break if there is a record.
|
||||
//Set TX break signal after FIFO is empty
|
||||
if(p_uart->tx_len_tot == 0 && p_uart->tx_brk_flg == 1) {
|
||||
if (p_uart->tx_len_tot == 0 && p_uart->tx_brk_flg == 1) {
|
||||
uart_hal_clr_intsts_mask(&(uart_context[uart_num].hal), UART_INTR_TX_BRK_DONE);
|
||||
UART_ENTER_CRITICAL_ISR(&(uart_context[uart_num].spinlock));
|
||||
uart_hal_tx_break(&(uart_context[uart_num].hal), p_uart->tx_brk_len);
|
||||
@ -800,12 +800,11 @@ static void UART_ISR_ATTR uart_rx_intr_handler_default(void *param)
|
||||
UART_EXIT_CRITICAL_ISR(&(uart_context[uart_num].spinlock));
|
||||
}
|
||||
}
|
||||
}
|
||||
else if ((uart_intr_status & UART_INTR_RXFIFO_TOUT)
|
||||
|| (uart_intr_status & UART_INTR_RXFIFO_FULL)
|
||||
|| (uart_intr_status & UART_INTR_CMD_CHAR_DET)
|
||||
) {
|
||||
if(pat_flg == 1) {
|
||||
} else if ((uart_intr_status & UART_INTR_RXFIFO_TOUT)
|
||||
|| (uart_intr_status & UART_INTR_RXFIFO_FULL)
|
||||
|| (uart_intr_status & UART_INTR_CMD_CHAR_DET)
|
||||
) {
|
||||
if (pat_flg == 1) {
|
||||
uart_intr_status |= UART_INTR_CMD_CHAR_DET;
|
||||
pat_flg = 0;
|
||||
}
|
||||
@ -841,7 +840,7 @@ static void UART_ISR_ATTR uart_rx_intr_handler_default(void *param)
|
||||
p_uart->rx_stash_len = rx_fifo_len;
|
||||
//If we fail to push data to ring buffer, we will have to stash the data, and send next time.
|
||||
//Mainly for applications that uses flow control or small ring buffer.
|
||||
if(pdFALSE == xRingbufferSendFromISR(p_uart->rx_ring_buf, p_uart->rx_data_buf, p_uart->rx_stash_len, &HPTaskAwoken)) {
|
||||
if (pdFALSE == xRingbufferSendFromISR(p_uart->rx_ring_buf, p_uart->rx_data_buf, p_uart->rx_stash_len, &HPTaskAwoken)) {
|
||||
p_uart->rx_buffer_full_flg = true;
|
||||
UART_ENTER_CRITICAL_ISR(&(uart_context[uart_num].spinlock));
|
||||
uart_hal_disable_intr_mask(&(uart_context[uart_num].hal), UART_INTR_RXFIFO_TOUT | UART_INTR_RXFIFO_FULL);
|
||||
@ -853,11 +852,11 @@ static void UART_ISR_ATTR uart_rx_intr_handler_default(void *param)
|
||||
uart_pattern_enqueue(uart_num, p_uart->rx_buffered_len - (pat_num - rx_fifo_len));
|
||||
} else {
|
||||
uart_pattern_enqueue(uart_num,
|
||||
pat_idx <= -1 ?
|
||||
//can not find the pattern in buffer,
|
||||
p_uart->rx_buffered_len + p_uart->rx_stash_len :
|
||||
// find the pattern in buffer
|
||||
p_uart->rx_buffered_len + pat_idx);
|
||||
pat_idx <= -1 ?
|
||||
//can not find the pattern in buffer,
|
||||
p_uart->rx_buffered_len + p_uart->rx_stash_len :
|
||||
// find the pattern in buffer
|
||||
p_uart->rx_buffered_len + pat_idx);
|
||||
}
|
||||
UART_EXIT_CRITICAL_ISR(&(uart_context[uart_num].spinlock));
|
||||
if ((p_uart->xQueueUart != NULL) && (pdFALSE == xQueueSendFromISR(p_uart->xQueueUart, (void * )&uart_event, &HPTaskAwoken))) {
|
||||
@ -871,7 +870,7 @@ static void UART_ISR_ATTR uart_rx_intr_handler_default(void *param)
|
||||
if (rx_fifo_len < pat_num) {
|
||||
//some of the characters are read out in last interrupt
|
||||
uart_pattern_enqueue(uart_num, p_uart->rx_buffered_len - (pat_num - rx_fifo_len));
|
||||
} else if(pat_idx >= 0) {
|
||||
} else if (pat_idx >= 0) {
|
||||
// find the pattern in stash buffer.
|
||||
uart_pattern_enqueue(uart_num, p_uart->rx_buffered_len + pat_idx);
|
||||
}
|
||||
@ -884,14 +883,14 @@ static void UART_ISR_ATTR uart_rx_intr_handler_default(void *param)
|
||||
uart_hal_disable_intr_mask(&(uart_context[uart_num].hal), UART_INTR_RXFIFO_FULL | UART_INTR_RXFIFO_TOUT);
|
||||
UART_EXIT_CRITICAL_ISR(&(uart_context[uart_num].spinlock));
|
||||
uart_hal_clr_intsts_mask(&(uart_context[uart_num].hal), UART_INTR_RXFIFO_FULL | UART_INTR_RXFIFO_TOUT);
|
||||
if(uart_intr_status & UART_INTR_CMD_CHAR_DET) {
|
||||
if (uart_intr_status & UART_INTR_CMD_CHAR_DET) {
|
||||
uart_hal_clr_intsts_mask(&(uart_context[uart_num].hal), UART_INTR_CMD_CHAR_DET);
|
||||
uart_event.type = UART_PATTERN_DET;
|
||||
uart_event.size = rx_fifo_len;
|
||||
pat_flg = 1;
|
||||
}
|
||||
}
|
||||
} else if(uart_intr_status & UART_INTR_RXFIFO_OVF) {
|
||||
} else if (uart_intr_status & UART_INTR_RXFIFO_OVF) {
|
||||
// When fifo overflows, we reset the fifo.
|
||||
UART_ENTER_CRITICAL_ISR(&(uart_context[uart_num].spinlock));
|
||||
uart_hal_rxfifo_rst(&(uart_context[uart_num].hal));
|
||||
@ -903,10 +902,10 @@ static void UART_ISR_ATTR uart_rx_intr_handler_default(void *param)
|
||||
UART_EXIT_CRITICAL_ISR(&uart_selectlock);
|
||||
uart_hal_clr_intsts_mask(&(uart_context[uart_num].hal), UART_INTR_RXFIFO_OVF);
|
||||
uart_event.type = UART_FIFO_OVF;
|
||||
} else if(uart_intr_status & UART_INTR_BRK_DET) {
|
||||
} else if (uart_intr_status & UART_INTR_BRK_DET) {
|
||||
uart_hal_clr_intsts_mask(&(uart_context[uart_num].hal), UART_INTR_BRK_DET);
|
||||
uart_event.type = UART_BREAK;
|
||||
} else if(uart_intr_status & UART_INTR_FRAM_ERR) {
|
||||
} else if (uart_intr_status & UART_INTR_FRAM_ERR) {
|
||||
UART_ENTER_CRITICAL_ISR(&uart_selectlock);
|
||||
if (p_uart->uart_select_notif_callback) {
|
||||
p_uart->uart_select_notif_callback(uart_num, UART_SELECT_ERROR_NOTIF, &HPTaskAwoken);
|
||||
@ -914,7 +913,7 @@ static void UART_ISR_ATTR uart_rx_intr_handler_default(void *param)
|
||||
UART_EXIT_CRITICAL_ISR(&uart_selectlock);
|
||||
uart_hal_clr_intsts_mask(&(uart_context[uart_num].hal), UART_INTR_FRAM_ERR);
|
||||
uart_event.type = UART_FRAME_ERR;
|
||||
} else if(uart_intr_status & UART_INTR_PARITY_ERR) {
|
||||
} else if (uart_intr_status & UART_INTR_PARITY_ERR) {
|
||||
UART_ENTER_CRITICAL_ISR(&uart_selectlock);
|
||||
if (p_uart->uart_select_notif_callback) {
|
||||
p_uart->uart_select_notif_callback(uart_num, UART_SELECT_ERROR_NOTIF, &HPTaskAwoken);
|
||||
@ -922,32 +921,32 @@ static void UART_ISR_ATTR uart_rx_intr_handler_default(void *param)
|
||||
UART_EXIT_CRITICAL_ISR(&uart_selectlock);
|
||||
uart_hal_clr_intsts_mask(&(uart_context[uart_num].hal), UART_INTR_PARITY_ERR);
|
||||
uart_event.type = UART_PARITY_ERR;
|
||||
} else if(uart_intr_status & UART_INTR_TX_BRK_DONE) {
|
||||
} else if (uart_intr_status & UART_INTR_TX_BRK_DONE) {
|
||||
UART_ENTER_CRITICAL_ISR(&(uart_context[uart_num].spinlock));
|
||||
uart_hal_tx_break(&(uart_context[uart_num].hal), 0);
|
||||
uart_hal_disable_intr_mask(&(uart_context[uart_num].hal), UART_INTR_TX_BRK_DONE);
|
||||
if(p_uart->tx_brk_flg == 1) {
|
||||
if (p_uart->tx_brk_flg == 1) {
|
||||
uart_hal_ena_intr_mask(&(uart_context[uart_num].hal), UART_INTR_TXFIFO_EMPTY);
|
||||
}
|
||||
UART_EXIT_CRITICAL_ISR(&(uart_context[uart_num].spinlock));
|
||||
uart_hal_clr_intsts_mask(&(uart_context[uart_num].hal), UART_INTR_TX_BRK_DONE);
|
||||
if(p_uart->tx_brk_flg == 1) {
|
||||
if (p_uart->tx_brk_flg == 1) {
|
||||
p_uart->tx_brk_flg = 0;
|
||||
p_uart->tx_waiting_brk = 0;
|
||||
} else {
|
||||
xSemaphoreGiveFromISR(p_uart->tx_brk_sem, &HPTaskAwoken);
|
||||
}
|
||||
} else if(uart_intr_status & UART_INTR_TX_BRK_IDLE) {
|
||||
} else if (uart_intr_status & UART_INTR_TX_BRK_IDLE) {
|
||||
UART_ENTER_CRITICAL_ISR(&(uart_context[uart_num].spinlock));
|
||||
uart_hal_disable_intr_mask(&(uart_context[uart_num].hal), UART_INTR_TX_BRK_IDLE);
|
||||
UART_EXIT_CRITICAL_ISR(&(uart_context[uart_num].spinlock));
|
||||
uart_hal_clr_intsts_mask(&(uart_context[uart_num].hal), UART_INTR_TX_BRK_IDLE);
|
||||
} else if(uart_intr_status & UART_INTR_CMD_CHAR_DET) {
|
||||
} else if (uart_intr_status & UART_INTR_CMD_CHAR_DET) {
|
||||
uart_hal_clr_intsts_mask(&(uart_context[uart_num].hal), UART_INTR_CMD_CHAR_DET);
|
||||
uart_event.type = UART_PATTERN_DET;
|
||||
} else if ((uart_intr_status & UART_INTR_RS485_PARITY_ERR)
|
||||
|| (uart_intr_status & UART_INTR_RS485_FRM_ERR)
|
||||
|| (uart_intr_status & UART_INTR_RS485_CLASH)) {
|
||||
|| (uart_intr_status & UART_INTR_RS485_FRM_ERR)
|
||||
|| (uart_intr_status & UART_INTR_RS485_CLASH)) {
|
||||
// RS485 collision or frame error interrupt triggered
|
||||
UART_ENTER_CRITICAL_ISR(&(uart_context[uart_num].spinlock));
|
||||
uart_hal_rxfifo_rst(&(uart_context[uart_num].hal));
|
||||
@ -956,7 +955,7 @@ static void UART_ISR_ATTR uart_rx_intr_handler_default(void *param)
|
||||
UART_EXIT_CRITICAL_ISR(&(uart_context[uart_num].spinlock));
|
||||
uart_hal_clr_intsts_mask(&(uart_context[uart_num].hal), UART_INTR_RS485_CLASH | UART_INTR_RS485_FRM_ERR | UART_INTR_RS485_PARITY_ERR);
|
||||
uart_event.type = UART_EVENT_MAX;
|
||||
} else if(uart_intr_status & UART_INTR_TX_DONE) {
|
||||
} else if (uart_intr_status & UART_INTR_TX_DONE) {
|
||||
if (UART_IS_MODE_SET(uart_num, UART_MODE_RS485_HALF_DUPLEX) && uart_hal_is_tx_idle(&(uart_context[uart_num].hal)) != true) {
|
||||
// The TX_DONE interrupt is triggered but transmit is active
|
||||
// then postpone interrupt processing for next interrupt
|
||||
@ -980,13 +979,13 @@ static void UART_ISR_ATTR uart_rx_intr_handler_default(void *param)
|
||||
uart_event.type = UART_EVENT_MAX;
|
||||
}
|
||||
|
||||
if(uart_event.type != UART_EVENT_MAX && p_uart->xQueueUart) {
|
||||
if (uart_event.type != UART_EVENT_MAX && p_uart->xQueueUart) {
|
||||
if (pdFALSE == xQueueSendFromISR(p_uart->xQueueUart, (void * )&uart_event, &HPTaskAwoken)) {
|
||||
ESP_EARLY_LOGV(UART_TAG, "UART event queue full");
|
||||
}
|
||||
}
|
||||
}
|
||||
if(HPTaskAwoken == pdTRUE) {
|
||||
if (HPTaskAwoken == pdTRUE) {
|
||||
portYIELD_FROM_ISR();
|
||||
}
|
||||
}
|
||||
@ -1000,11 +999,11 @@ esp_err_t uart_wait_tx_done(uart_port_t uart_num, TickType_t ticks_to_wait)
|
||||
portTickType ticks_start = xTaskGetTickCount();
|
||||
//Take tx_mux
|
||||
res = xSemaphoreTake(p_uart_obj[uart_num]->tx_mux, (portTickType)ticks_to_wait);
|
||||
if(res == pdFALSE) {
|
||||
if (res == pdFALSE) {
|
||||
return ESP_ERR_TIMEOUT;
|
||||
}
|
||||
xSemaphoreTake(p_uart_obj[uart_num]->tx_done_sem, 0);
|
||||
if(uart_hal_is_tx_idle(&(uart_context[uart_num].hal))) {
|
||||
if (uart_hal_is_tx_idle(&(uart_context[uart_num].hal))) {
|
||||
xSemaphoreGive(p_uart_obj[uart_num]->tx_mux);
|
||||
return ESP_OK;
|
||||
}
|
||||
@ -1021,7 +1020,7 @@ esp_err_t uart_wait_tx_done(uart_port_t uart_num, TickType_t ticks_to_wait)
|
||||
}
|
||||
//take 2nd tx_done_sem, wait given from ISR
|
||||
res = xSemaphoreTake(p_uart_obj[uart_num]->tx_done_sem, (portTickType)ticks_to_wait);
|
||||
if(res == pdFALSE) {
|
||||
if (res == pdFALSE) {
|
||||
UART_ENTER_CRITICAL(&(uart_context[uart_num].spinlock));
|
||||
uart_hal_disable_intr_mask(&(uart_context[uart_num].hal), UART_INTR_TX_DONE);
|
||||
UART_EXIT_CRITICAL(&(uart_context[uart_num].spinlock));
|
||||
@ -1032,12 +1031,12 @@ esp_err_t uart_wait_tx_done(uart_port_t uart_num, TickType_t ticks_to_wait)
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
int uart_tx_chars(uart_port_t uart_num, const char* buffer, uint32_t len)
|
||||
int uart_tx_chars(uart_port_t uart_num, const char *buffer, uint32_t len)
|
||||
{
|
||||
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", (-1));
|
||||
UART_CHECK((p_uart_obj[uart_num]), "uart driver error", (-1));
|
||||
UART_CHECK(buffer, "buffer null", (-1));
|
||||
if(len == 0) {
|
||||
if (len == 0) {
|
||||
return 0;
|
||||
}
|
||||
int tx_len = 0;
|
||||
@ -1048,14 +1047,14 @@ int uart_tx_chars(uart_port_t uart_num, const char* buffer, uint32_t len)
|
||||
uart_hal_ena_intr_mask(&(uart_context[uart_num].hal), UART_INTR_TX_DONE);
|
||||
UART_EXIT_CRITICAL(&(uart_context[uart_num].spinlock));
|
||||
}
|
||||
uart_hal_write_txfifo(&(uart_context[uart_num].hal), (const uint8_t*) buffer, len, (uint32_t *)&tx_len);
|
||||
uart_hal_write_txfifo(&(uart_context[uart_num].hal), (const uint8_t *) buffer, len, (uint32_t *)&tx_len);
|
||||
xSemaphoreGive(p_uart_obj[uart_num]->tx_mux);
|
||||
return tx_len;
|
||||
}
|
||||
|
||||
static int uart_tx_all(uart_port_t uart_num, const char* src, size_t size, bool brk_en, int brk_len)
|
||||
static int uart_tx_all(uart_port_t uart_num, const char *src, size_t size, bool brk_en, int brk_len)
|
||||
{
|
||||
if(size == 0) {
|
||||
if (size == 0) {
|
||||
return 0;
|
||||
}
|
||||
size_t original_size = size;
|
||||
@ -1063,29 +1062,29 @@ static int uart_tx_all(uart_port_t uart_num, const char* src, size_t size, bool
|
||||
//lock for uart_tx
|
||||
xSemaphoreTake(p_uart_obj[uart_num]->tx_mux, (portTickType)portMAX_DELAY);
|
||||
p_uart_obj[uart_num]->coll_det_flg = false;
|
||||
if(p_uart_obj[uart_num]->tx_buf_size > 0) {
|
||||
if (p_uart_obj[uart_num]->tx_buf_size > 0) {
|
||||
int max_size = xRingbufferGetMaxItemSize(p_uart_obj[uart_num]->tx_ring_buf);
|
||||
int offset = 0;
|
||||
uart_tx_data_t evt;
|
||||
evt.tx_data.size = size;
|
||||
evt.tx_data.brk_len = brk_len;
|
||||
if(brk_en) {
|
||||
if (brk_en) {
|
||||
evt.type = UART_DATA_BREAK;
|
||||
} else {
|
||||
evt.type = UART_DATA;
|
||||
}
|
||||
xRingbufferSend(p_uart_obj[uart_num]->tx_ring_buf, (void*) &evt, sizeof(uart_tx_data_t), portMAX_DELAY);
|
||||
while(size > 0) {
|
||||
while (size > 0) {
|
||||
int send_size = size > max_size / 2 ? max_size / 2 : size;
|
||||
xRingbufferSend(p_uart_obj[uart_num]->tx_ring_buf, (void*) (src + offset), send_size, portMAX_DELAY);
|
||||
xRingbufferSend(p_uart_obj[uart_num]->tx_ring_buf, (void *) (src + offset), send_size, portMAX_DELAY);
|
||||
size -= send_size;
|
||||
offset += send_size;
|
||||
uart_enable_tx_intr(uart_num, 1, UART_EMPTY_THRESH_DEFAULT);
|
||||
}
|
||||
} else {
|
||||
while(size) {
|
||||
while (size) {
|
||||
//semaphore for tx_fifo available
|
||||
if(pdTRUE == xSemaphoreTake(p_uart_obj[uart_num]->tx_fifo_sem, (portTickType)portMAX_DELAY)) {
|
||||
if (pdTRUE == xSemaphoreTake(p_uart_obj[uart_num]->tx_fifo_sem, (portTickType)portMAX_DELAY)) {
|
||||
uint32_t sent = 0;
|
||||
if (UART_IS_MODE_SET(uart_num, UART_MODE_RS485_HALF_DUPLEX)) {
|
||||
UART_ENTER_CRITICAL(&(uart_context[uart_num].spinlock));
|
||||
@ -1093,8 +1092,8 @@ static int uart_tx_all(uart_port_t uart_num, const char* src, size_t size, bool
|
||||
uart_hal_ena_intr_mask(&(uart_context[uart_num].hal), UART_INTR_TX_DONE);
|
||||
UART_EXIT_CRITICAL(&(uart_context[uart_num].spinlock));
|
||||
}
|
||||
uart_hal_write_txfifo(&(uart_context[uart_num].hal), (const uint8_t*)src, size, &sent);
|
||||
if(sent < size) {
|
||||
uart_hal_write_txfifo(&(uart_context[uart_num].hal), (const uint8_t *)src, size, &sent);
|
||||
if (sent < size) {
|
||||
p_uart_obj[uart_num]->tx_waiting_fifo = true;
|
||||
uart_enable_tx_intr(uart_num, 1, UART_EMPTY_THRESH_DEFAULT);
|
||||
}
|
||||
@ -1102,7 +1101,7 @@ static int uart_tx_all(uart_port_t uart_num, const char* src, size_t size, bool
|
||||
src += sent;
|
||||
}
|
||||
}
|
||||
if(brk_en) {
|
||||
if (brk_en) {
|
||||
uart_hal_clr_intsts_mask(&(uart_context[uart_num].hal), UART_INTR_TX_BRK_DONE);
|
||||
UART_ENTER_CRITICAL(&(uart_context[uart_num].spinlock));
|
||||
uart_hal_tx_break(&(uart_context[uart_num].hal), brk_len);
|
||||
@ -1116,7 +1115,7 @@ static int uart_tx_all(uart_port_t uart_num, const char* src, size_t size, bool
|
||||
return original_size;
|
||||
}
|
||||
|
||||
int uart_write_bytes(uart_port_t uart_num, const char* src, size_t size)
|
||||
int uart_write_bytes(uart_port_t uart_num, const char *src, size_t size)
|
||||
{
|
||||
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", (-1));
|
||||
UART_CHECK((p_uart_obj[uart_num] != NULL), "uart driver error", (-1));
|
||||
@ -1124,7 +1123,7 @@ int uart_write_bytes(uart_port_t uart_num, const char* src, size_t size)
|
||||
return uart_tx_all(uart_num, src, size, 0, 0);
|
||||
}
|
||||
|
||||
int uart_write_bytes_with_break(uart_port_t uart_num, const char* src, size_t size, int brk_len)
|
||||
int uart_write_bytes_with_break(uart_port_t uart_num, const char *src, size_t size, int brk_len)
|
||||
{
|
||||
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", (-1));
|
||||
UART_CHECK((p_uart_obj[uart_num]), "uart driver error", (-1));
|
||||
@ -1136,9 +1135,9 @@ int uart_write_bytes_with_break(uart_port_t uart_num, const char* src, size_t si
|
||||
|
||||
static bool uart_check_buf_full(uart_port_t uart_num)
|
||||
{
|
||||
if(p_uart_obj[uart_num]->rx_buffer_full_flg) {
|
||||
if (p_uart_obj[uart_num]->rx_buffer_full_flg) {
|
||||
BaseType_t res = xRingbufferSend(p_uart_obj[uart_num]->rx_ring_buf, p_uart_obj[uart_num]->rx_data_buf, p_uart_obj[uart_num]->rx_stash_len, 1);
|
||||
if(res == pdTRUE) {
|
||||
if (res == pdTRUE) {
|
||||
UART_ENTER_CRITICAL(&(uart_context[uart_num].spinlock));
|
||||
p_uart_obj[uart_num]->rx_buffered_len += p_uart_obj[uart_num]->rx_stash_len;
|
||||
p_uart_obj[uart_num]->rx_buffer_full_flg = false;
|
||||
@ -1150,22 +1149,22 @@ static bool uart_check_buf_full(uart_port_t uart_num)
|
||||
return false;
|
||||
}
|
||||
|
||||
int uart_read_bytes(uart_port_t uart_num, uint8_t* buf, uint32_t length, TickType_t ticks_to_wait)
|
||||
int uart_read_bytes(uart_port_t uart_num, uint8_t *buf, uint32_t length, TickType_t ticks_to_wait)
|
||||
{
|
||||
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", (-1));
|
||||
UART_CHECK((buf), "uart data null", (-1));
|
||||
UART_CHECK((p_uart_obj[uart_num]), "uart driver error", (-1));
|
||||
uint8_t* data = NULL;
|
||||
uint8_t *data = NULL;
|
||||
size_t size;
|
||||
size_t copy_len = 0;
|
||||
int len_tmp;
|
||||
if(xSemaphoreTake(p_uart_obj[uart_num]->rx_mux,(portTickType)ticks_to_wait) != pdTRUE) {
|
||||
if (xSemaphoreTake(p_uart_obj[uart_num]->rx_mux, (portTickType)ticks_to_wait) != pdTRUE) {
|
||||
return -1;
|
||||
}
|
||||
while(length) {
|
||||
if(p_uart_obj[uart_num]->rx_cur_remain == 0) {
|
||||
data = (uint8_t*) xRingbufferReceive(p_uart_obj[uart_num]->rx_ring_buf, &size, (portTickType) ticks_to_wait);
|
||||
if(data) {
|
||||
while (length) {
|
||||
if (p_uart_obj[uart_num]->rx_cur_remain == 0) {
|
||||
data = (uint8_t *) xRingbufferReceive(p_uart_obj[uart_num]->rx_ring_buf, &size, (portTickType) ticks_to_wait);
|
||||
if (data) {
|
||||
p_uart_obj[uart_num]->rx_head_ptr = data;
|
||||
p_uart_obj[uart_num]->rx_ptr = data;
|
||||
p_uart_obj[uart_num]->rx_cur_remain = size;
|
||||
@ -1173,7 +1172,7 @@ int uart_read_bytes(uart_port_t uart_num, uint8_t* buf, uint32_t length, TickTyp
|
||||
//When using dual cores, `rx_buffer_full_flg` may read and write on different cores at same time,
|
||||
//which may lose synchronization. So we also need to call `uart_check_buf_full` once when ringbuffer is empty
|
||||
//to solve the possible asynchronous issues.
|
||||
if(uart_check_buf_full(uart_num)) {
|
||||
if (uart_check_buf_full(uart_num)) {
|
||||
//This condition will never be true if `uart_read_bytes`
|
||||
//and `uart_rx_intr_handler_default` are scheduled on the same core.
|
||||
continue;
|
||||
@ -1183,7 +1182,7 @@ int uart_read_bytes(uart_port_t uart_num, uint8_t* buf, uint32_t length, TickTyp
|
||||
}
|
||||
}
|
||||
}
|
||||
if(p_uart_obj[uart_num]->rx_cur_remain > length) {
|
||||
if (p_uart_obj[uart_num]->rx_cur_remain > length) {
|
||||
len_tmp = length;
|
||||
} else {
|
||||
len_tmp = p_uart_obj[uart_num]->rx_cur_remain;
|
||||
@ -1197,7 +1196,7 @@ int uart_read_bytes(uart_port_t uart_num, uint8_t* buf, uint32_t length, TickTyp
|
||||
p_uart_obj[uart_num]->rx_cur_remain -= len_tmp;
|
||||
copy_len += len_tmp;
|
||||
length -= len_tmp;
|
||||
if(p_uart_obj[uart_num]->rx_cur_remain == 0) {
|
||||
if (p_uart_obj[uart_num]->rx_cur_remain == 0) {
|
||||
vRingbufferReturnItem(p_uart_obj[uart_num]->rx_ring_buf, p_uart_obj[uart_num]->rx_head_ptr);
|
||||
p_uart_obj[uart_num]->rx_head_ptr = NULL;
|
||||
p_uart_obj[uart_num]->rx_ptr = NULL;
|
||||
@ -1209,7 +1208,7 @@ int uart_read_bytes(uart_port_t uart_num, uint8_t* buf, uint32_t length, TickTyp
|
||||
return copy_len;
|
||||
}
|
||||
|
||||
esp_err_t uart_get_buffered_data_len(uart_port_t uart_num, size_t* size)
|
||||
esp_err_t uart_get_buffered_data_len(uart_port_t uart_num, size_t *size)
|
||||
{
|
||||
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);
|
||||
UART_CHECK((p_uart_obj[uart_num]), "uart driver error", ESP_FAIL);
|
||||
@ -1225,15 +1224,15 @@ esp_err_t uart_flush_input(uart_port_t uart_num)
|
||||
{
|
||||
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);
|
||||
UART_CHECK((p_uart_obj[uart_num]), "uart driver error", ESP_FAIL);
|
||||
uart_obj_t* p_uart = p_uart_obj[uart_num];
|
||||
uint8_t* data;
|
||||
uart_obj_t *p_uart = p_uart_obj[uart_num];
|
||||
uint8_t *data;
|
||||
size_t size;
|
||||
|
||||
//rx sem protect the ring buffer read related functions
|
||||
xSemaphoreTake(p_uart->rx_mux, (portTickType)portMAX_DELAY);
|
||||
uart_disable_rx_intr(p_uart_obj[uart_num]->uart_num);
|
||||
while(true) {
|
||||
if(p_uart->rx_head_ptr) {
|
||||
while (true) {
|
||||
if (p_uart->rx_head_ptr) {
|
||||
vRingbufferReturnItem(p_uart->rx_ring_buf, p_uart->rx_head_ptr);
|
||||
UART_ENTER_CRITICAL(&(uart_context[uart_num].spinlock));
|
||||
p_uart_obj[uart_num]->rx_buffered_len -= p_uart->rx_cur_remain;
|
||||
@ -1244,10 +1243,10 @@ esp_err_t uart_flush_input(uart_port_t uart_num)
|
||||
p_uart->rx_head_ptr = NULL;
|
||||
}
|
||||
data = (uint8_t*) xRingbufferReceive(p_uart->rx_ring_buf, &size, (portTickType) 0);
|
||||
if(data == NULL) {
|
||||
if (data == NULL) {
|
||||
bool error = false;
|
||||
UART_ENTER_CRITICAL(&(uart_context[uart_num].spinlock));
|
||||
if( p_uart_obj[uart_num]->rx_buffered_len != 0 ) {
|
||||
if ( p_uart_obj[uart_num]->rx_buffered_len != 0 ) {
|
||||
p_uart_obj[uart_num]->rx_buffered_len = 0;
|
||||
error = true;
|
||||
}
|
||||
@ -1265,9 +1264,9 @@ esp_err_t uart_flush_input(uart_port_t uart_num)
|
||||
uart_pattern_queue_update(uart_num, size);
|
||||
UART_EXIT_CRITICAL(&(uart_context[uart_num].spinlock));
|
||||
vRingbufferReturnItem(p_uart->rx_ring_buf, data);
|
||||
if(p_uart_obj[uart_num]->rx_buffer_full_flg) {
|
||||
if (p_uart_obj[uart_num]->rx_buffer_full_flg) {
|
||||
BaseType_t res = xRingbufferSend(p_uart_obj[uart_num]->rx_ring_buf, p_uart_obj[uart_num]->rx_data_buf, p_uart_obj[uart_num]->rx_stash_len, 1);
|
||||
if(res == pdTRUE) {
|
||||
if (res == pdTRUE) {
|
||||
UART_ENTER_CRITICAL(&(uart_context[uart_num].spinlock));
|
||||
p_uart_obj[uart_num]->rx_buffered_len += p_uart_obj[uart_num]->rx_stash_len;
|
||||
p_uart_obj[uart_num]->rx_buffer_full_flg = false;
|
||||
@ -1302,9 +1301,9 @@ esp_err_t uart_driver_install(uart_port_t uart_num, int rx_buffer_size, int tx_b
|
||||
}
|
||||
#endif
|
||||
|
||||
if(p_uart_obj[uart_num] == NULL) {
|
||||
p_uart_obj[uart_num] = (uart_obj_t*) heap_caps_calloc(1, sizeof(uart_obj_t), MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
|
||||
if(p_uart_obj[uart_num] == NULL) {
|
||||
if (p_uart_obj[uart_num] == NULL) {
|
||||
p_uart_obj[uart_num] = (uart_obj_t *) heap_caps_calloc(1, sizeof(uart_obj_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
|
||||
if (p_uart_obj[uart_num] == NULL) {
|
||||
ESP_LOGE(UART_TAG, "UART driver malloc error");
|
||||
return ESP_FAIL;
|
||||
}
|
||||
@ -1328,7 +1327,7 @@ esp_err_t uart_driver_install(uart_port_t uart_num, int rx_buffer_size, int tx_b
|
||||
p_uart_obj[uart_num]->rx_buffered_len = 0;
|
||||
uart_pattern_queue_reset(uart_num, UART_PATTERN_DET_QLEN_DEFAULT);
|
||||
|
||||
if(uart_queue) {
|
||||
if (uart_queue) {
|
||||
p_uart_obj[uart_num]->xQueueUart = xQueueCreate(queue_size, sizeof(uart_event_t));
|
||||
*uart_queue = p_uart_obj[uart_num]->xQueueUart;
|
||||
ESP_LOGI(UART_TAG, "queue free spaces: %d", uxQueueSpacesAvailable(p_uart_obj[uart_num]->xQueueUart));
|
||||
@ -1341,7 +1340,7 @@ esp_err_t uart_driver_install(uart_port_t uart_num, int rx_buffer_size, int tx_b
|
||||
p_uart_obj[uart_num]->rx_cur_remain = 0;
|
||||
p_uart_obj[uart_num]->rx_head_ptr = NULL;
|
||||
p_uart_obj[uart_num]->rx_ring_buf = xRingbufferCreate(rx_buffer_size, RINGBUF_TYPE_BYTEBUF);
|
||||
if(tx_buffer_size > 0) {
|
||||
if (tx_buffer_size > 0) {
|
||||
p_uart_obj[uart_num]->tx_ring_buf = xRingbufferCreate(tx_buffer_size, RINGBUF_TYPE_NOSPLIT);
|
||||
p_uart_obj[uart_num]->tx_buf_size = tx_buffer_size;
|
||||
} else {
|
||||
@ -1363,10 +1362,14 @@ esp_err_t uart_driver_install(uart_port_t uart_num, int rx_buffer_size, int tx_b
|
||||
uart_module_enable(uart_num);
|
||||
uart_hal_disable_intr_mask(&(uart_context[uart_num].hal), UART_INTR_MASK);
|
||||
uart_hal_clr_intsts_mask(&(uart_context[uart_num].hal), UART_INTR_MASK);
|
||||
r=uart_isr_register(uart_num, uart_rx_intr_handler_default, p_uart_obj[uart_num], intr_alloc_flags, &p_uart_obj[uart_num]->intr_handle);
|
||||
if (r!=ESP_OK) goto err;
|
||||
r=uart_intr_config(uart_num, &uart_intr);
|
||||
if (r!=ESP_OK) goto err;
|
||||
r = uart_isr_register(uart_num, uart_rx_intr_handler_default, p_uart_obj[uart_num], intr_alloc_flags, &p_uart_obj[uart_num]->intr_handle);
|
||||
if (r != ESP_OK) {
|
||||
goto err;
|
||||
}
|
||||
r = uart_intr_config(uart_num, &uart_intr);
|
||||
if (r != ESP_OK) {
|
||||
goto err;
|
||||
}
|
||||
return r;
|
||||
|
||||
err:
|
||||
@ -1378,7 +1381,7 @@ err:
|
||||
esp_err_t uart_driver_delete(uart_port_t uart_num)
|
||||
{
|
||||
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);
|
||||
if(p_uart_obj[uart_num] == NULL) {
|
||||
if (p_uart_obj[uart_num] == NULL) {
|
||||
ESP_LOGI(UART_TAG, "ALREADY NULL");
|
||||
return ESP_OK;
|
||||
}
|
||||
@ -1387,35 +1390,35 @@ esp_err_t uart_driver_delete(uart_port_t uart_num)
|
||||
uart_disable_tx_intr(uart_num);
|
||||
uart_pattern_link_free(uart_num);
|
||||
|
||||
if(p_uart_obj[uart_num]->tx_fifo_sem) {
|
||||
if (p_uart_obj[uart_num]->tx_fifo_sem) {
|
||||
vSemaphoreDelete(p_uart_obj[uart_num]->tx_fifo_sem);
|
||||
p_uart_obj[uart_num]->tx_fifo_sem = NULL;
|
||||
}
|
||||
if(p_uart_obj[uart_num]->tx_done_sem) {
|
||||
if (p_uart_obj[uart_num]->tx_done_sem) {
|
||||
vSemaphoreDelete(p_uart_obj[uart_num]->tx_done_sem);
|
||||
p_uart_obj[uart_num]->tx_done_sem = NULL;
|
||||
}
|
||||
if(p_uart_obj[uart_num]->tx_brk_sem) {
|
||||
if (p_uart_obj[uart_num]->tx_brk_sem) {
|
||||
vSemaphoreDelete(p_uart_obj[uart_num]->tx_brk_sem);
|
||||
p_uart_obj[uart_num]->tx_brk_sem = NULL;
|
||||
}
|
||||
if(p_uart_obj[uart_num]->tx_mux) {
|
||||
if (p_uart_obj[uart_num]->tx_mux) {
|
||||
vSemaphoreDelete(p_uart_obj[uart_num]->tx_mux);
|
||||
p_uart_obj[uart_num]->tx_mux = NULL;
|
||||
}
|
||||
if(p_uart_obj[uart_num]->rx_mux) {
|
||||
if (p_uart_obj[uart_num]->rx_mux) {
|
||||
vSemaphoreDelete(p_uart_obj[uart_num]->rx_mux);
|
||||
p_uart_obj[uart_num]->rx_mux = NULL;
|
||||
}
|
||||
if(p_uart_obj[uart_num]->xQueueUart) {
|
||||
if (p_uart_obj[uart_num]->xQueueUart) {
|
||||
vQueueDelete(p_uart_obj[uart_num]->xQueueUart);
|
||||
p_uart_obj[uart_num]->xQueueUart = NULL;
|
||||
}
|
||||
if(p_uart_obj[uart_num]->rx_ring_buf) {
|
||||
if (p_uart_obj[uart_num]->rx_ring_buf) {
|
||||
vRingbufferDelete(p_uart_obj[uart_num]->rx_ring_buf);
|
||||
p_uart_obj[uart_num]->rx_ring_buf = NULL;
|
||||
}
|
||||
if(p_uart_obj[uart_num]->tx_ring_buf) {
|
||||
if (p_uart_obj[uart_num]->tx_ring_buf) {
|
||||
vRingbufferDelete(p_uart_obj[uart_num]->tx_ring_buf);
|
||||
p_uart_obj[uart_num]->tx_ring_buf = NULL;
|
||||
}
|
||||
@ -1452,19 +1455,19 @@ esp_err_t uart_set_mode(uart_port_t uart_num, uart_mode_t mode)
|
||||
if ((mode == UART_MODE_RS485_COLLISION_DETECT) || (mode == UART_MODE_RS485_APP_CTRL)
|
||||
|| (mode == UART_MODE_RS485_HALF_DUPLEX)) {
|
||||
UART_CHECK((!uart_hal_is_hw_rts_en(&(uart_context[uart_num].hal))),
|
||||
"disable hw flowctrl before using RS485 mode", ESP_ERR_INVALID_ARG);
|
||||
"disable hw flowctrl before using RS485 mode", ESP_ERR_INVALID_ARG);
|
||||
}
|
||||
UART_ENTER_CRITICAL(&(uart_context[uart_num].spinlock));
|
||||
uart_hal_set_mode(&(uart_context[uart_num].hal), mode);
|
||||
if(mode == UART_MODE_RS485_COLLISION_DETECT) {
|
||||
if (mode == UART_MODE_RS485_COLLISION_DETECT) {
|
||||
// This mode allows read while transmitting that allows collision detection
|
||||
p_uart_obj[uart_num]->coll_det_flg = false;
|
||||
// Enable collision detection interrupts
|
||||
uart_hal_ena_intr_mask(&(uart_context[uart_num].hal), UART_INTR_RXFIFO_TOUT
|
||||
| UART_INTR_RXFIFO_FULL
|
||||
| UART_INTR_RS485_CLASH
|
||||
| UART_INTR_RS485_FRM_ERR
|
||||
| UART_INTR_RS485_PARITY_ERR);
|
||||
| UART_INTR_RXFIFO_FULL
|
||||
| UART_INTR_RS485_CLASH
|
||||
| UART_INTR_RS485_FRM_ERR
|
||||
| UART_INTR_RS485_PARITY_ERR);
|
||||
}
|
||||
p_uart_obj[uart_num]->uart_mode = mode;
|
||||
UART_EXIT_CRITICAL(&(uart_context[uart_num].spinlock));
|
||||
@ -1475,7 +1478,7 @@ esp_err_t uart_set_rx_full_threshold(uart_port_t uart_num, int threshold)
|
||||
{
|
||||
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_ERR_INVALID_ARG);
|
||||
UART_CHECK((threshold < UART_RXFIFO_FULL_THRHD_V) && (threshold > 0),
|
||||
"rx fifo full threshold value error", ESP_ERR_INVALID_ARG);
|
||||
"rx fifo full threshold value error", ESP_ERR_INVALID_ARG);
|
||||
if (p_uart_obj[uart_num] == NULL) {
|
||||
ESP_LOGE(UART_TAG, "call uart_driver_install API first");
|
||||
return ESP_ERR_INVALID_STATE;
|
||||
@ -1492,7 +1495,7 @@ esp_err_t uart_set_tx_empty_threshold(uart_port_t uart_num, int threshold)
|
||||
{
|
||||
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_ERR_INVALID_ARG);
|
||||
UART_CHECK((threshold < UART_TXFIFO_EMPTY_THRHD_V) && (threshold > 0),
|
||||
"tx fifo empty threshold value error", ESP_ERR_INVALID_ARG);
|
||||
"tx fifo empty threshold value error", ESP_ERR_INVALID_ARG);
|
||||
if (p_uart_obj[uart_num] == NULL) {
|
||||
ESP_LOGE(UART_TAG, "call uart_driver_install API first");
|
||||
return ESP_ERR_INVALID_STATE;
|
||||
@ -1520,14 +1523,14 @@ esp_err_t uart_set_rx_timeout(uart_port_t uart_num, const uint8_t tout_thresh)
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
esp_err_t uart_get_collision_flag(uart_port_t uart_num, bool* collision_flag)
|
||||
esp_err_t uart_get_collision_flag(uart_port_t uart_num, bool *collision_flag)
|
||||
{
|
||||
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_ERR_INVALID_ARG);
|
||||
UART_CHECK((p_uart_obj[uart_num]), "uart driver error", ESP_FAIL);
|
||||
UART_CHECK((collision_flag != NULL), "wrong parameter pointer", ESP_ERR_INVALID_ARG);
|
||||
UART_CHECK((UART_IS_MODE_SET(uart_num, UART_MODE_RS485_HALF_DUPLEX)
|
||||
|| UART_IS_MODE_SET(uart_num, UART_MODE_RS485_COLLISION_DETECT)),
|
||||
"wrong mode", ESP_ERR_INVALID_ARG);
|
||||
|| UART_IS_MODE_SET(uart_num, UART_MODE_RS485_COLLISION_DETECT)),
|
||||
"wrong mode", ESP_ERR_INVALID_ARG);
|
||||
*collision_flag = p_uart_obj[uart_num]->coll_det_flg;
|
||||
return ESP_OK;
|
||||
}
|
||||
@ -1536,15 +1539,15 @@ esp_err_t uart_set_wakeup_threshold(uart_port_t uart_num, int wakeup_threshold)
|
||||
{
|
||||
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_ERR_INVALID_ARG);
|
||||
UART_CHECK((wakeup_threshold <= UART_ACTIVE_THRESHOLD_V &&
|
||||
wakeup_threshold > UART_MIN_WAKEUP_THRESH),
|
||||
"wakeup_threshold out of bounds", ESP_ERR_INVALID_ARG);
|
||||
wakeup_threshold > UART_MIN_WAKEUP_THRESH),
|
||||
"wakeup_threshold out of bounds", ESP_ERR_INVALID_ARG);
|
||||
UART_ENTER_CRITICAL(&(uart_context[uart_num].spinlock));
|
||||
uart_hal_set_wakeup_thrd(&(uart_context[uart_num].hal), wakeup_threshold);
|
||||
UART_EXIT_CRITICAL(&(uart_context[uart_num].spinlock));
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
esp_err_t uart_get_wakeup_threshold(uart_port_t uart_num, int* out_wakeup_threshold)
|
||||
esp_err_t uart_get_wakeup_threshold(uart_port_t uart_num, int *out_wakeup_threshold)
|
||||
{
|
||||
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_ERR_INVALID_ARG);
|
||||
UART_CHECK((out_wakeup_threshold != NULL), "argument is NULL", ESP_ERR_INVALID_ARG);
|
||||
@ -1555,7 +1558,7 @@ esp_err_t uart_get_wakeup_threshold(uart_port_t uart_num, int* out_wakeup_thresh
|
||||
esp_err_t uart_wait_tx_idle_polling(uart_port_t uart_num)
|
||||
{
|
||||
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_ERR_INVALID_ARG);
|
||||
while(!uart_hal_is_tx_idle(&(uart_context[uart_num].hal)));
|
||||
while (!uart_hal_is_tx_idle(&(uart_context[uart_num].hal)));
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user