half_duplex_uart.h

Go to the documentation of this file.

// clang-format off
 
// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
 
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#ifndef _RB_HALF_DUPLEX_UART_H_
#define _RB_HALF_DUPLEX_UART_H_
 
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include "soc/uart_reg.h"
#include "soc/uart_struct.h"
#include "esp_err.h"
#include "esp_intr_alloc.h"
#include "driver/periph_ctrl.h"
#include "freertos/FreeRTOS.h"
#include "freertos/semphr.h"
#include "freertos/xtensa_api.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "freertos/ringbuf.h"
#include <esp_types.h>
#include "soc/uart_channel.h"
#include "driver/uart.h"
 
#ifdef __cplusplus
}
#endif
 
namespace rb {
namespace half_duplex {
 
esp_err_t uart_set_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);
 
esp_err_t uart_set_stop_bits(uart_port_t uart_num, uart_stop_bits_t stop_bits);
 
esp_err_t uart_get_stop_bits(uart_port_t uart_num, uart_stop_bits_t* stop_bits);
 
esp_err_t uart_set_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);
 
esp_err_t uart_set_baudrate(uart_port_t uart_num, uint32_t baudrate);
 
esp_err_t uart_get_baudrate(uart_port_t uart_num, uint32_t* baudrate);
 
esp_err_t uart_set_line_inverse(uart_port_t uart_num, uint32_t inverse_mask);
 
esp_err_t uart_set_hw_flow_ctrl(uart_port_t uart_num, uart_hw_flowcontrol_t flow_ctrl, uint8_t rx_thresh);
 
 esp_err_t uart_set_sw_flow_ctrl(uart_port_t uart_num, bool enable, uint8_t rx_thresh_xon,  uint8_t rx_thresh_xoff);
 
esp_err_t uart_get_hw_flow_ctrl(uart_port_t uart_num, uart_hw_flowcontrol_t* flow_ctrl);
 
esp_err_t uart_clear_intr_status(uart_port_t uart_num, uint32_t clr_mask);
 
esp_err_t uart_enable_intr_mask(uart_port_t uart_num, uint32_t enable_mask);
 
esp_err_t uart_disable_intr_mask(uart_port_t uart_num, uint32_t disable_mask);
 
esp_err_t uart_enable_rx_intr(uart_port_t uart_num);
 
esp_err_t uart_disable_rx_intr(uart_port_t uart_num);
 
esp_err_t uart_disable_tx_intr(uart_port_t uart_num);
 
esp_err_t uart_enable_tx_intr(uart_port_t uart_num, int enable, int thresh);
 
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_free(uart_port_t uart_num);
 
esp_err_t uart_set_pin(uart_port_t uart_num, int tx_io_num, int rx_io_num, int rts_io_num, int cts_io_num);
 
esp_err_t uart_set_rts(uart_port_t uart_num, int level);
 
esp_err_t uart_set_dtr(uart_port_t uart_num, int level);
 
esp_err_t uart_set_tx_idle_num(uart_port_t uart_num, uint16_t idle_num);
 
esp_err_t uart_param_config(uart_port_t uart_num, const uart_config_t *uart_config);
 
esp_err_t uart_intr_config(uart_port_t uart_num, const uart_intr_config_t *intr_conf);
 
esp_err_t uart_driver_install(uart_port_t uart_num, int rx_buffer_size, int tx_buffer_size, int queue_size, QueueHandle_t* uart_queue, int intr_alloc_flags);
 
esp_err_t uart_driver_delete(uart_port_t uart_num);
 
esp_err_t uart_wait_tx_done(uart_port_t uart_num, TickType_t ticks_to_wait);
 
int uart_tx_chars(uart_port_t uart_num, const char* buffer, uint32_t len);
 
int uart_write_bytes(uart_port_t uart_num, const char* src, size_t size);
 
int uart_write_bytes_with_break(uart_port_t uart_num, const char* src, size_t size, int brk_len);
 
int uart_read_bytes(uart_port_t uart_num, uint8_t* buf, uint32_t length, TickType_t ticks_to_wait);
 
esp_err_t uart_flush(uart_port_t uart_num);
 
esp_err_t uart_flush_input(uart_port_t uart_num);
 
esp_err_t uart_get_buffered_data_len(uart_port_t uart_num, size_t* size);
 
esp_err_t uart_disable_pattern_det_intr(uart_port_t uart_num);
 
esp_err_t uart_enable_pattern_det_intr(uart_port_t uart_num, char pattern_chr, uint8_t chr_num, int chr_tout, int post_idle, int pre_idle);
 
int uart_pattern_pop_pos(uart_port_t uart_num);
 
int uart_pattern_get_pos(uart_port_t uart_num);
 
esp_err_t uart_pattern_queue_reset(uart_port_t uart_num, int queue_length);
 
esp_err_t uart_set_mode(uart_port_t uart_num, uart_mode_t mode);
 
esp_err_t uart_set_rx_timeout(uart_port_t uart_num, const uint8_t tout_thresh);
 
esp_err_t uart_get_collision_flag(uart_port_t uart_num, bool* collision_flag);
 
esp_err_t uart_set_wakeup_threshold(uart_port_t uart_num, int wakeup_threshold);
 
esp_err_t uart_get_wakeup_threshold(uart_port_t uart_num, int* out_wakeup_threshold);
 
void uart_set_half_duplex_pin(uart_port_t uart_num, gpio_num_t pin);
 
}; // namespace half_duplex
}; // namespace rb
 
#endif /*_RB_HALF_DUPLEX_UART_H_*/