1. remove "\n" when calling ESP_LOGX APIs.
2. modify uart_event_t for uart rx data.
3. use MICRO for uart inverse value
4. add uart_tx_data_t for internal tx function.
static const char* GPIO_TAG = "GPIO";
#define GPIO_CHECK(a, str, ret_val) if (!(a)) { \
- ESP_LOGE(GPIO_TAG,"%s:%d (%s):%s\n", __FILE__, __LINE__, __FUNCTION__, str); \
+ ESP_LOGE(GPIO_TAG,"%s:%d (%s):%s", __FILE__, __LINE__, __FUNCTION__, str); \
return (ret_val); \
}
esp_err_t gpio_set_intr_type(gpio_num_t gpio_num, gpio_int_type_t intr_type)
{
- GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error\n", ESP_ERR_INVALID_ARG);
- GPIO_CHECK(intr_type < GPIO_INTR_MAX, "GPIO interrupt type error\n", ESP_ERR_INVALID_ARG);
+ GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
+ GPIO_CHECK(intr_type < GPIO_INTR_MAX, "GPIO interrupt type error", ESP_ERR_INVALID_ARG);
GPIO.pin[gpio_num].int_type = intr_type;
return ESP_OK;
}
esp_err_t gpio_intr_enable(gpio_num_t gpio_num)
{
- GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error\n", ESP_ERR_INVALID_ARG);
+ GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
if(xPortGetCoreID() == 0) {
GPIO.pin[gpio_num].int_ena = GPIO_PRO_CPU_INTR_ENA; //enable pro cpu intr
} else {
esp_err_t gpio_intr_disable(gpio_num_t gpio_num)
{
- GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error\n", ESP_ERR_INVALID_ARG);
+ GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
GPIO.pin[gpio_num].int_ena = 0; //disable GPIO intr
return ESP_OK;
}
static esp_err_t gpio_output_disable(gpio_num_t gpio_num)
{
- GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error\n", ESP_ERR_INVALID_ARG);
+ GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
if(gpio_num < 32) {
GPIO.enable_w1tc = (0x1 << gpio_num);
} else {
static esp_err_t gpio_output_enable(gpio_num_t gpio_num)
{
- GPIO_CHECK(GPIO_IS_VALID_OUTPUT_GPIO(gpio_num), "GPIO output gpio_num error\n", ESP_ERR_INVALID_ARG);
+ GPIO_CHECK(GPIO_IS_VALID_OUTPUT_GPIO(gpio_num), "GPIO output gpio_num error", ESP_ERR_INVALID_ARG);
if(gpio_num < 32) {
GPIO.enable_w1ts = (0x1 << gpio_num);
} else {
esp_err_t gpio_set_level(gpio_num_t gpio_num, uint32_t level)
{
- GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error\n", ESP_ERR_INVALID_ARG);
+ GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
if(level) {
if(gpio_num < 32) {
GPIO.out_w1ts = (1 << gpio_num);
esp_err_t gpio_set_pull_mode(gpio_num_t gpio_num, gpio_pull_mode_t pull)
{
- GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error\n", ESP_ERR_INVALID_ARG);
- GPIO_CHECK(pull <= GPIO_FLOATING, "GPIO pull mode error\n", ESP_ERR_INVALID_ARG);
+ GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
+ GPIO_CHECK(pull <= GPIO_FLOATING, "GPIO pull mode error", ESP_ERR_INVALID_ARG);
esp_err_t ret = ESP_OK;
switch(pull) {
case GPIO_PULLUP_ONLY:
PIN_PULLDWN_DIS(GPIO_PIN_MUX_REG[gpio_num]);
break;
default:
- ESP_LOGE(GPIO_TAG, "Unknown pull up/down mode,gpio_num=%u,pull=%u\n",gpio_num,pull);
+ ESP_LOGE(GPIO_TAG, "Unknown pull up/down mode,gpio_num=%u,pull=%u",gpio_num,pull);
ret = ESP_ERR_INVALID_ARG;
break;
}
esp_err_t gpio_set_direction(gpio_num_t gpio_num, gpio_mode_t mode)
{
- GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error\n", ESP_ERR_INVALID_ARG);
+ GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
if(gpio_num >= 34 && (mode & (GPIO_MODE_DEF_OUTPUT))) {
- ESP_LOGE(GPIO_TAG, "io_num=%d can only be input\n",gpio_num);
+ ESP_LOGE(GPIO_TAG, "io_num=%d can only be input",gpio_num);
return ESP_ERR_INVALID_ARG;
}
esp_err_t ret = ESP_OK;
uint64_t gpio_pin_mask = (pGPIOConfig->pin_bit_mask);
uint32_t io_reg = 0;
uint32_t io_num = 0;
- uint64_t bit_valid = 0;
+ uint8_t input_en = 0;
+ uint8_t output_en = 0;
+ uint8_t od_en = 0;
+ uint8_t pu_en = 0;
+ uint8_t pd_en = 0;
if(pGPIOConfig->pin_bit_mask == 0 || pGPIOConfig->pin_bit_mask >= (((uint64_t) 1) << GPIO_PIN_COUNT)) {
- ESP_LOGE(GPIO_TAG, "GPIO_PIN mask error \n");
+ ESP_LOGE(GPIO_TAG, "GPIO_PIN mask error ");
return ESP_ERR_INVALID_ARG;
}
if((pGPIOConfig->mode) & (GPIO_MODE_DEF_OUTPUT)) {
//GPIO 34/35/36/37/38/39 can only be used as input mode;
if((gpio_pin_mask & ( GPIO_SEL_34 | GPIO_SEL_35 | GPIO_SEL_36 | GPIO_SEL_37 | GPIO_SEL_38 | GPIO_SEL_39))) {
- ESP_LOGE(GPIO_TAG, "GPIO34-39 can only be used as input mode\n");
+ ESP_LOGE(GPIO_TAG, "GPIO34-39 can only be used as input mode");
return ESP_ERR_INVALID_ARG;
}
}
do {
io_reg = GPIO_PIN_MUX_REG[io_num];
if(((gpio_pin_mask >> io_num) & BIT(0)) && io_reg) {
- ESP_LOGI(GPIO_TAG, "Gpio%02d |Mode:",io_num);
if((pGPIOConfig->mode) & GPIO_MODE_DEF_INPUT) {
- ESP_LOGI(GPIO_TAG, "INPUT ");
+ input_en = 1;
PIN_INPUT_ENABLE(GPIO_PIN_MUX_REG[io_num]);
} else {
PIN_INPUT_DISABLE(GPIO_PIN_MUX_REG[io_num]);
}
if((pGPIOConfig->mode) & GPIO_MODE_DEF_OD) {
- ESP_LOGI(GPIO_TAG, "OD ");
+ od_en = 1;
GPIO.pin[io_num].pad_driver = 1; /*0x01 Open-drain */
} else {
GPIO.pin[io_num].pad_driver = 0; /*0x00 Normal gpio output */
}
if((pGPIOConfig->mode) & GPIO_MODE_DEF_OUTPUT) {
- ESP_LOGI(GPIO_TAG, "OUTPUT ");
+ output_en = 1;
gpio_output_enable(io_num);
} else {
gpio_output_disable(io_num);
}
if(pGPIOConfig->pull_up_en) {
- ESP_LOGI(GPIO_TAG, "PU ");
+ pu_en = 1;
PIN_PULLUP_EN(io_reg);
} else {
PIN_PULLUP_DIS(io_reg);
}
if(pGPIOConfig->pull_down_en) {
- ESP_LOGI(GPIO_TAG, "PD ");
+ pd_en = 1;
PIN_PULLDWN_EN(io_reg);
} else {
PIN_PULLDWN_DIS(io_reg);
}
- ESP_LOGI(GPIO_TAG, "Intr:%d |\n",pGPIOConfig->intr_type);
+ ESP_LOGI(GPIO_TAG, "GPIO[%d]| InputEn: %d| OutputEn: %d| OpenDrain: %d| Pullup: %d| Pulldown: %d| Intr:%d ", io_num, input_en, output_en, od_en, pu_en, pd_en, pGPIOConfig->intr_type);
gpio_set_intr_type(io_num, pGPIOConfig->intr_type);
if(pGPIOConfig->intr_type) {
gpio_intr_enable(io_num);
gpio_intr_disable(io_num);
}
PIN_FUNC_SELECT(io_reg, PIN_FUNC_GPIO); /*function number 2 is GPIO_FUNC for each pin */
- } else if(bit_valid && (io_reg == 0)) {
- ESP_LOGW(GPIO_TAG, "io_num=%d does not exist\n",io_num);
}
io_num++;
} while(io_num < GPIO_PIN_COUNT);
esp_err_t gpio_isr_register(uint32_t gpio_intr_num, void (*fn)(void*), void * arg)
{
- GPIO_CHECK(fn, "GPIO ISR null\n", ESP_ERR_INVALID_ARG);
+ GPIO_CHECK(fn, "GPIO ISR null", ESP_ERR_INVALID_ARG);
ESP_INTR_DISABLE(gpio_intr_num);
intr_matrix_set(xPortGetCoreID(), ETS_GPIO_INTR_SOURCE, gpio_intr_num);
xt_set_interrupt_handler(gpio_intr_num, fn, arg);
/*only level interrupt can be used for wake-up function*/
esp_err_t gpio_wakeup_enable(gpio_num_t gpio_num, gpio_int_type_t intr_type)
{
- GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error\n", ESP_ERR_INVALID_ARG);
+ GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
esp_err_t ret = ESP_OK;
if((intr_type == GPIO_INTR_LOW_LEVEL) || (intr_type == GPIO_INTR_HIGH_LEVEL)) {
GPIO.pin[gpio_num].int_type = intr_type;
GPIO.pin[gpio_num].wakeup_enable = 0x1;
} else {
- ESP_LOGE(GPIO_TAG, "GPIO wakeup only support Level mode,but edge mode set. gpio_num:%u\n",gpio_num);
+ ESP_LOGE(GPIO_TAG, "GPIO wakeup only support Level mode,but edge mode set. gpio_num:%u",gpio_num);
ret = ESP_ERR_INVALID_ARG;
}
return ret;
esp_err_t gpio_wakeup_disable(gpio_num_t gpio_num)
{
- GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error\n", ESP_ERR_INVALID_ARG);
+ GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error", ESP_ERR_INVALID_ARG);
GPIO.pin[gpio_num].wakeup_enable = 0;
return ESP_OK;
}
#define UART_BITRATE_MAX 5000000\r
#define UART_PIN_NO_CHANGE (-1)\r
\r
+#define UART_INVERSE_DISABLE (0x0) /*!< Disable UART signal inverse*/\r
+#define UART_INVERSE_RXD (UART_RXD_INV_M) /*!< UART RXD input inverse*/\r
+#define UART_INVERSE_CTS (UART_CTS_INV_M) /*!< UART CTS input inverse*/\r
+#define UART_INVERSE_TXD (UART_TXD_INV_M) /*!< UART TXD output inverse*/\r
+#define UART_INVERSE_RTS (UART_RTS_INV_M) /*!< UART RTS output inverse*/\r
+\r
typedef enum {\r
UART_DATA_5_BITS = 0x0, /*!< word length: 5bits*/\r
UART_DATA_6_BITS = 0x1, /*!< word length: 6bits*/\r
UART_DATA_7_BITS = 0x2, /*!< word length: 7bits*/\r
UART_DATA_8_BITS = 0x3, /*!< word length: 8bits*/\r
- UART_DATA_MAX_BITS = 0X4,\r
+ UART_DATA_BITS_MAX = 0X4,\r
} uart_word_length_t;\r
\r
typedef enum {\r
UART_HW_FLOWCTRL_MAX = 0x4,\r
} uart_hw_flowcontrol_t;\r
\r
-typedef enum {\r
- UART_INVERSE_DISABLE = 0x0, /*!< Disable UART wire output inverse*/\r
- UART_INVERSE_RXD = (uint32_t)UART_RXD_INV_M, /*!< UART RXD input inverse*/\r
- UART_INVERSE_CTS = (uint32_t)UART_CTS_INV_M, /*!< UART CTS input inverse*/\r
- UART_INVERSE_TXD = (uint32_t)UART_TXD_INV_M, /*!< UART TXD output inverse*/\r
- UART_INVERSE_RTS = (uint32_t)UART_RTS_INV_M, /*!< UART RTS output inverse*/\r
-} uart_inverse_t;\r
-\r
typedef struct {\r
int baud_rate; /*!< UART baudrate*/\r
uart_word_length_t data_bits; /*!< UART byte size*/\r
} uart_event_type_t;\r
\r
typedef struct {\r
- uart_event_type_t type;\r
- union {\r
- struct {\r
- int brk_len;\r
- size_t size;\r
- uint8_t data[];\r
- } data;\r
- };\r
+ uart_event_type_t type; /*!< UART event type */\r
+ size_t size; /*!< UART data size for UART_DATA event*/\r
} uart_event_t;\r
\r
/**\r
*\r
* @param inverse_mask Choose the wires that need to be inversed.\r
*\r
- * (inverse_mask should be chosen from uart_inverse_t, combine with OR-OPERATION)\r
+ * (inverse_mask should be chosen from UART_INVERSE_RXD/UART_INVERSE_TXD/UART_INVERSE_RTS/UART_INVERSE_CTS, combine with OR-OPERATION)\r
*\r
* @return\r
* - ESP_OK Success\r
* - ESP_FAIL Parameter error\r
*/\r
-esp_err_t uart_set_line_inverse(uart_port_t uart_no, uint32_t inverse_mask) ;\r
-\r
+esp_err_t uart_set_line_inverse(uart_port_t uart_no, uint32_t inverse_mask);\r
\r
/**\r
* @brief Set hardware flow control.\r
* if(xQueueReceive(uart0_queue, (void * )&event, (portTickType)portMAX_DELAY)) {\r
* ESP_LOGI(TAG, "uart[%d] event:", uart_num);\r
* switch(event.type) {\r
+ * memset(dtmp, 0, sizeof(dtmp));\r
* //Event of UART receving data\r
* case UART_DATA:\r
- * ESP_LOGI(TAG,"data, len: %d\n", event.data.size);\r
- * int len = uart_read_bytes(uart_num, dtmp, event.data.size, 10);\r
- * ESP_LOGI(TAG, "uart read: %d\n", len);\r
+ * ESP_LOGI(TAG,"data, len: %d", event.size);\r
+ * int len = uart_read_bytes(uart_num, dtmp, event.size, 10);\r
+ * ESP_LOGI(TAG, "uart read: %d", len);\r
+ uart_write_bytes(uart_num, (const char*)dtmp, len);\r
* break;\r
* //Event of HW FIFO overflow detected\r
* case UART_FIFO_OVF:\r
static const char* LEDC_TAG = "LEDC";
static portMUX_TYPE ledc_spinlock = portMUX_INITIALIZER_UNLOCKED;
#define LEDC_CHECK(a, str, ret_val) if (!(a)) { \
- ESP_LOGE(LEDC_TAG,"%s:%d (%s):%s\n", __FILE__, __LINE__, __FUNCTION__, str); \
+ ESP_LOGE(LEDC_TAG,"%s:%d (%s):%s", __FILE__, __LINE__, __FUNCTION__, str); \
return (ret_val); \
}
esp_err_t ledc_timer_set(ledc_mode_t speed_mode, ledc_timer_t timer_sel, uint32_t div_num, uint32_t bit_num, ledc_clk_src_t clk_src)
{
- LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
- LEDC_CHECK(timer_sel <= LEDC_TIMER_3, "ledc timer error\n", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(timer_sel <= LEDC_TIMER_3, "ledc timer error", ESP_ERR_INVALID_ARG);
portENTER_CRITICAL(&ledc_spinlock);
LEDC.timer_group[speed_mode].timer[timer_sel].conf.div_num = div_num;
LEDC.timer_group[speed_mode].timer[timer_sel].conf.tick_sel = clk_src;
esp_err_t ledc_bind_channel_timer(ledc_mode_t speed_mode, uint32_t channel, uint32_t timer_idx)
{
- LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
- LEDC_CHECK(timer_idx <= LEDC_TIMER_3, "ledc timer error\n", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(timer_idx <= LEDC_TIMER_3, "ledc timer error", ESP_ERR_INVALID_ARG);
portENTER_CRITICAL(&ledc_spinlock);
LEDC.channel_group[speed_mode].channel[channel].conf0.timer_sel = timer_idx;
portEXIT_CRITICAL(&ledc_spinlock);
esp_err_t ledc_timer_rst(ledc_mode_t speed_mode, uint32_t timer_sel)
{
- LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
- LEDC_CHECK(timer_sel <= LEDC_TIMER_3, "ledc timer error\n", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(timer_sel <= LEDC_TIMER_3, "ledc timer error", ESP_ERR_INVALID_ARG);
portENTER_CRITICAL(&ledc_spinlock);
LEDC.timer_group[speed_mode].timer[timer_sel].conf.rst = 1;
LEDC.timer_group[speed_mode].timer[timer_sel].conf.rst = 0;
esp_err_t ledc_timer_pause(ledc_mode_t speed_mode, uint32_t timer_sel)
{
- LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
- LEDC_CHECK(timer_sel <= LEDC_TIMER_3, "ledc timer error\n", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(timer_sel <= LEDC_TIMER_3, "ledc timer error", ESP_ERR_INVALID_ARG);
portENTER_CRITICAL(&ledc_spinlock);
LEDC.timer_group[speed_mode].timer[timer_sel].conf.pause = 1;
portEXIT_CRITICAL(&ledc_spinlock);
esp_err_t ledc_timer_resume(ledc_mode_t speed_mode, uint32_t timer_sel)
{
- LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
- LEDC_CHECK(timer_sel <= LEDC_TIMER_3, "ledc timer error\n", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(timer_sel <= LEDC_TIMER_3, "ledc timer error", ESP_ERR_INVALID_ARG);
portENTER_CRITICAL(&ledc_spinlock);
LEDC.timer_group[speed_mode].timer[timer_sel].conf.pause = 0;
portEXIT_CRITICAL(&ledc_spinlock);
static esp_err_t ledc_enable_intr_type(ledc_mode_t speed_mode, uint32_t channel, ledc_intr_type_t type)
{
- LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error", ESP_ERR_INVALID_ARG);
uint32_t value;
uint32_t intr_type = type;
portENTER_CRITICAL(&ledc_spinlock);
esp_err_t ledc_isr_register(uint32_t ledc_intr_num, void (*fn)(void*), void * arg)
{
- LEDC_CHECK(fn, "ledc isr null\n", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(fn, "ledc isr null", ESP_ERR_INVALID_ARG);
portENTER_CRITICAL(&ledc_spinlock);
ESP_INTR_DISABLE(ledc_intr_num);
intr_matrix_set(xPortGetCoreID(), ETS_LEDC_INTR_SOURCE, ledc_intr_num);
int bit_num = timer_conf->bit_num;
int timer_num = timer_conf->timer_num;
int speed_mode = timer_conf->speed_mode;
- LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error", ESP_ERR_INVALID_ARG);
if(freq_hz == 0 || bit_num == 0 || bit_num > LEDC_TIMER_15_BIT) {
- ESP_LOGE(LEDC_TAG, "freq_hz=%u bit_num=%u\n", freq_hz, bit_num);
+ ESP_LOGE(LEDC_TAG, "freq_hz=%u bit_num=%u", freq_hz, bit_num);
return ESP_ERR_INVALID_ARG;
}
if(timer_num > LEDC_TIMER_3) {
- ESP_LOGE(LEDC_TAG, "Time Select %u\n", timer_num);
+ ESP_LOGE(LEDC_TAG, "Time Select %u", timer_num);
return ESP_ERR_INVALID_ARG;
}
esp_err_t ret = ESP_OK;
/*Selet the reference tick*/
div_param = ((uint64_t) LEDC_REF_CLK_HZ << 8) / freq_hz / precision;
if(div_param <= 256 || div_param > LEDC_DIV_NUM_HSTIMER0_V) {
- ESP_LOGE(LEDC_TAG, "div param err,div_param=%u\n", (uint32_t)div_param);
+ ESP_LOGE(LEDC_TAG, "div param err,div_param=%u", (uint32_t)div_param);
ret = ESP_FAIL;
}
timer_clk_src = LEDC_REF_TICK;
esp_err_t ledc_set_pin(int gpio_num, ledc_mode_t speed_mode, ledc_channel_t ledc_channel)
{
- LEDC_CHECK(ledc_channel <= LEDC_CHANNEL_7, "ledc channel error\n", ESP_ERR_INVALID_ARG);
- LEDC_CHECK(GPIO_IS_VALID_OUTPUT_GPIO(gpio_num), "ledc GPIO output number error\n", ESP_ERR_INVALID_ARG);
- LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(ledc_channel <= LEDC_CHANNEL_7, "ledc channel error", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(GPIO_IS_VALID_OUTPUT_GPIO(gpio_num), "ledc GPIO output number error", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error", ESP_ERR_INVALID_ARG);
PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[gpio_num], PIN_FUNC_GPIO);
gpio_set_direction(gpio_num, GPIO_MODE_OUTPUT);
if(speed_mode == LEDC_HIGH_SPEED_MODE) {
uint32_t timer_select = ledc_conf->timer_sel;
uint32_t intr_type = ledc_conf->intr_type;
uint32_t duty = ledc_conf->duty;
- LEDC_CHECK(ledc_channel <= LEDC_CHANNEL_7, "ledc channel error\n", ESP_ERR_INVALID_ARG);
- LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
- LEDC_CHECK(GPIO_IS_VALID_OUTPUT_GPIO(gpio_num), "ledc GPIO output number error\n", ESP_ERR_INVALID_ARG);
- LEDC_CHECK(timer_select <= LEDC_TIMER_3, "ledc timer error\n", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(ledc_channel <= LEDC_CHANNEL_7, "ledc channel error", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(GPIO_IS_VALID_OUTPUT_GPIO(gpio_num), "ledc GPIO output number error", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(timer_select <= LEDC_TIMER_3, "ledc timer error", ESP_ERR_INVALID_ARG);
esp_err_t ret = ESP_OK;
/*set channel parameters*/
/* channel parameters decide how the waveform looks like in one period*/
ledc_bind_channel_timer(speed_mode, ledc_channel, timer_select);
/*set interrupt type*/
ledc_enable_intr_type(speed_mode, ledc_channel, intr_type);
- ESP_LOGI(LEDC_TAG, "LEDC_PWM CHANNEL %1u|GPIO %02u|Duty %04u|Time %01u\n",
+ ESP_LOGI(LEDC_TAG, "LEDC_PWM CHANNEL %1u|GPIO %02u|Duty %04u|Time %01u",
ledc_channel, gpio_num, duty, timer_select
);
/*set LEDC signal in gpio matrix*/
esp_err_t ledc_update_duty(ledc_mode_t speed_mode, ledc_channel_t channel)
{
- LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
- LEDC_CHECK(channel <= LEDC_CHANNEL_7, "ledc channel error\n", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(channel <= LEDC_CHANNEL_7, "ledc channel error", ESP_ERR_INVALID_ARG);
portENTER_CRITICAL(&ledc_spinlock);
LEDC.channel_group[speed_mode].channel[channel].conf0.sig_out_en = 1;
LEDC.channel_group[speed_mode].channel[channel].conf1.duty_start = 1;
esp_err_t ledc_stop(ledc_mode_t speed_mode, ledc_channel_t channel, uint32_t idle_level)
{
- LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
- LEDC_CHECK(channel <= LEDC_CHANNEL_7, "ledc channel error\n", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(channel <= LEDC_CHANNEL_7, "ledc channel error", ESP_ERR_INVALID_ARG);
portENTER_CRITICAL(&ledc_spinlock);
LEDC.channel_group[speed_mode].channel[channel].conf0.idle_lv = idle_level & 0x1;
LEDC.channel_group[speed_mode].channel[channel].conf0.sig_out_en = 0;
esp_err_t ledc_set_fade(ledc_mode_t speed_mode, uint32_t channel, uint32_t duty, ledc_duty_direction_t fade_direction,
uint32_t step_num, uint32_t duty_cyle_num, uint32_t duty_scale)
{
- LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
- LEDC_CHECK(channel <= LEDC_CHANNEL_7, "ledc channel error\n", ESP_ERR_INVALID_ARG);
- LEDC_CHECK(fade_direction <= LEDC_DUTY_DIR_INCREASE, "ledc fade direction error\n", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(channel <= LEDC_CHANNEL_7, "ledc channel error", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(fade_direction <= LEDC_DUTY_DIR_INCREASE, "ledc fade direction error", ESP_ERR_INVALID_ARG);
if(step_num > LEDC_DUTY_NUM_HSCH0_V || duty_cyle_num > LEDC_DUTY_CYCLE_HSCH0_V || duty_scale > LEDC_DUTY_SCALE_HSCH0_V) {
- ESP_LOGE(LEDC_TAG, "step_num=%u duty_cyle_num=%u duty_scale=%u\n", step_num, duty_cyle_num, duty_scale);
+ ESP_LOGE(LEDC_TAG, "step_num=%u duty_cyle_num=%u duty_scale=%u", step_num, duty_cyle_num, duty_scale);
return ESP_ERR_INVALID_ARG;
}
ledc_duty_config(speed_mode,
esp_err_t ledc_set_duty(ledc_mode_t speed_mode, ledc_channel_t channel, uint32_t duty)
{
- LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
- LEDC_CHECK(channel <= LEDC_CHANNEL_7, "ledc channel error\n", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(channel <= LEDC_CHANNEL_7, "ledc channel error", ESP_ERR_INVALID_ARG);
ledc_duty_config(speed_mode,
channel, //uint32_t chan_num,
0, //uint32_t hpoint_val,
int ledc_get_duty(ledc_mode_t speed_mode, ledc_channel_t channel)
{
- LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", (-1));
+ LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error", (-1));
uint32_t duty = (LEDC.channel_group[speed_mode].channel[channel].duty_rd.duty_read >> 4);
return duty;
}
esp_err_t ledc_set_freq(ledc_mode_t speed_mode, ledc_timer_t timer_num, uint32_t freq_hz)
{
- LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
+ LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error", ESP_ERR_INVALID_ARG);
portENTER_CRITICAL(&ledc_spinlock);
esp_err_t ret = ESP_OK;
uint32_t div_num = 0;
div_num = ((uint64_t) LEDC_REF_CLK_HZ << 8) / freq_hz / precision;
}
if(div_num <= 256 || div_num > LEDC_DIV_NUM_HSTIMER0) {
- ESP_LOGE(LEDC_TAG, "div param err,div_param=%u\n", div_num);
+ ESP_LOGE(LEDC_TAG, "div param err,div_param=%u", div_num);
ret = ESP_FAIL;
}
LEDC.timer_group[speed_mode].timer[timer_num].conf.div_num = div_num;
uint32_t ledc_get_freq(ledc_mode_t speed_mode, ledc_timer_t timer_num)
{
- LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", (0));
+ LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error", (0));
portENTER_CRITICAL(&ledc_spinlock);
uint32_t freq = 0;
uint32_t timer_source_clk = LEDC.timer_group[speed_mode].timer[timer_num].conf.tick_sel;
\r
static const char* UART_TAG = "UART";\r
#define UART_CHECK(a, str, ret) if (!(a)) { \\r
- ESP_LOGE(UART_TAG,"%s:%d (%s):%s\n", __FILE__, __LINE__, __FUNCTION__, str); \\r
+ ESP_LOGE(UART_TAG,"%s:%d (%s):%s", __FILE__, __LINE__, __FUNCTION__, str); \\r
return (ret); \\r
}\r
#define UART_EMPTY_THRESH_DEFAULT (10)\r
#define UART_ENTER_CRITICAL(mux) portENTER_CRITICAL(mux)\r
#define UART_EXIT_CRITICAL(mux) portEXIT_CRITICAL(mux)\r
\r
+typedef struct {\r
+ uart_event_type_t type; /*!< UART TX data type */\r
+ struct {\r
+ int brk_len;\r
+ size_t size;\r
+ uint8_t data[0];\r
+ } tx_data;\r
+} uart_tx_data_t;\r
\r
typedef struct {\r
uart_port_t uart_num; /*!< UART port number*/\r
RingbufHandle_t tx_ring_buf; /*!< TX ring buffer handler*/\r
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*/\r
uint8_t* tx_ptr; /*!< TX data pointer to push to FIFO in TX buffer mode*/\r
- uart_event_t* tx_head; /*!< TX data pointer to head of the current buffer in TX ring buffer*/\r
+ uart_tx_data_t* tx_head; /*!< TX data pointer to head of the current buffer in TX ring buffer*/\r
uint32_t tx_len_tot; /*!< Total length of current item in ring buffer*/\r
uint32_t tx_len_cur;\r
uint8_t tx_brk_flg; /*!< Flag to indicate to send a break signal in the end of the item sending procedure */\r
uint8_t tx_waiting_brk; /*!< Flag to indicate that TX FIFO is ready to send break signal after FIFO is empty, do not push data into TX FIFO right now.*/\r
} uart_obj_t;\r
\r
+\r
+\r
static uart_obj_t *p_uart_obj[UART_NUM_MAX] = {0};\r
static uart_dev_t* UART[UART_NUM_MAX] = {&UART0, &UART1, &UART2};\r
static portMUX_TYPE uart_spinlock[UART_NUM_MAX] = {portMUX_INITIALIZER_UNLOCKED, portMUX_INITIALIZER_UNLOCKED, portMUX_INITIALIZER_UNLOCKED};\r
esp_err_t uart_set_word_length(uart_port_t uart_num, uart_word_length_t data_bit)\r
{\r
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);\r
- UART_CHECK((data_bit < UART_DATA_MAX_BITS), "data bit error", ESP_FAIL);\r
+ UART_CHECK((data_bit < UART_DATA_BITS_MAX), "data bit error", ESP_FAIL);\r
UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);\r
UART[uart_num]->conf0.bit_num = data_bit;\r
UART_EXIT_CRITICAL(&uart_spinlock[uart_num]);\r
esp_err_t uart_set_rts(uart_port_t uart_num, int level)\r
{\r
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);\r
- UART_CHECK((UART[uart_num]->conf1.rx_flow_en != 1), "disable hw flowctrl before using sw control\n", ESP_FAIL);\r
+ UART_CHECK((UART[uart_num]->conf1.rx_flow_en != 1), "disable hw flowctrl before using sw control", ESP_FAIL);\r
UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);\r
UART[uart_num]->conf0.sw_rts = level & 0x1;\r
UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);\r
esp_err_t uart_param_config(uart_port_t uart_num, const uart_config_t *uart_config)\r
{\r
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);\r
- UART_CHECK((uart_config), "param null\n", ESP_FAIL);\r
+ UART_CHECK((uart_config), "param null", ESP_FAIL);\r
if(uart_num == UART_NUM_0) {\r
periph_module_enable(PERIPH_UART0_MODULE);\r
} else if(uart_num == UART_NUM_1) {\r
esp_err_t uart_intr_config(uart_port_t uart_num, const uart_intr_config_t *intr_conf)\r
{\r
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);\r
- UART_CHECK((intr_conf), "param null\n", ESP_FAIL);\r
+ UART_CHECK((intr_conf), "param null", ESP_FAIL);\r
UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);\r
UART[uart_num]->int_clr.val = UART_INTR_MASK;\r
if(intr_conf->intr_enable_mask & UART_RXFIFO_TOUT_INT_ENA_M) {\r
while(tx_fifo_rem) {\r
if(p_uart->tx_len_tot == 0 || p_uart->tx_ptr == NULL || p_uart->tx_len_cur == 0) {\r
size_t size;\r
- p_uart->tx_head = (uart_event_t*) xRingbufferReceiveFromISR(p_uart->tx_ring_buf, &size);\r
+ p_uart->tx_head = (uart_tx_data_t*) xRingbufferReceiveFromISR(p_uart->tx_ring_buf, &size);\r
if(p_uart->tx_head) {\r
//The first item is the data description\r
//Get the first item to get the data information\r
if(p_uart->tx_len_tot == 0) {\r
p_uart->tx_ptr = NULL;\r
- p_uart->tx_len_tot = p_uart->tx_head->data.size;\r
+ p_uart->tx_len_tot = p_uart->tx_head->tx_data.size;\r
if(p_uart->tx_head->type == UART_DATA_BREAK) {\r
- p_uart->tx_len_tot = p_uart->tx_head->data.size;\r
+ p_uart->tx_len_tot = p_uart->tx_head->tx_data.size;\r
p_uart->tx_brk_flg = 1;\r
- p_uart->tx_brk_len = p_uart->tx_head->data.brk_len;\r
+ p_uart->tx_brk_len = p_uart->tx_head->tx_data.brk_len;\r
}\r
//We have saved the data description from the 1st item, return buffer.\r
vRingbufferReturnItemFromISR(p_uart->tx_ring_buf, p_uart->tx_head, &HPTaskAwoken);\r
uart_reg->int_clr.rxfifo_full = 1;\r
UART_EXIT_CRITICAL_ISR(&uart_spinlock[uart_num]);\r
uart_event.type = UART_DATA;\r
- uart_event.data.size = rx_fifo_len;\r
+ uart_event.size = rx_fifo_len;\r
//If we fail to push data to ring buffer, we will have to stash the data, and send next time.\r
//Mainly for applications that uses flow control or small ring buffer.\r
if(pdFALSE == xRingbufferSendFromISR(p_uart->rx_ring_buf, p_uart->rx_data_buf, p_uart->rx_stash_len, &HPTaskAwoken)) {\r
if(p_uart_obj[uart_num]->tx_buf_size > 0) {\r
int max_size = xRingbufferGetMaxItemSize(p_uart_obj[uart_num]->tx_ring_buf);\r
int offset = 0;\r
- uart_event_t evt;\r
- evt.data.size = size;\r
- evt.data.brk_len = brk_len;\r
+ uart_tx_data_t evt;\r
+ evt.tx_data.size = size;\r
+ evt.tx_data.brk_len = brk_len;\r
if(brk_en) {\r
evt.type = UART_DATA_BREAK;\r
} else {\r
esp_err_t uart_driver_install(uart_port_t uart_num, int rx_buffer_size, int tx_buffer_size, int queue_size, int uart_intr_num, void* uart_queue)\r
{\r
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);\r
- UART_CHECK((rx_buffer_size > 0), "uart rx buffer length error\n", ESP_FAIL);\r
+ UART_CHECK((rx_buffer_size > 0), "uart rx buffer length error", ESP_FAIL);\r
if(p_uart_obj[uart_num] == NULL) {\r
ESP_INTR_DISABLE(uart_intr_num);\r
p_uart_obj[uart_num] = (uart_obj_t*) malloc(sizeof(uart_obj_t));\r
if(p_uart_obj[uart_num] == NULL) {\r
- ESP_LOGE(UART_TAG, "UART driver malloc error\n");\r
+ ESP_LOGE(UART_TAG, "UART driver malloc error");\r
return ESP_FAIL;\r
}\r
p_uart_obj[uart_num]->uart_num = uart_num;\r
if(uart_queue) {\r
p_uart_obj[uart_num]->xQueueUart = xQueueCreate(queue_size, sizeof(uart_event_t));\r
*((QueueHandle_t*) uart_queue) = p_uart_obj[uart_num]->xQueueUart;\r
- ESP_LOGI(UART_TAG, "queue free spaces: %d\n", uxQueueSpacesAvailable(p_uart_obj[uart_num]->xQueueUart));\r
+ ESP_LOGI(UART_TAG, "queue free spaces: %d", uxQueueSpacesAvailable(p_uart_obj[uart_num]->xQueueUart));\r
} else {\r
p_uart_obj[uart_num]->xQueueUart = NULL;\r
}\r
p_uart_obj[uart_num]->tx_buf_size = 0;\r
}\r
} else {\r
- ESP_LOGE(UART_TAG, "UART driver already installed\n");\r
+ ESP_LOGE(UART_TAG, "UART driver already installed");\r
return ESP_FAIL;\r
}\r
uart_isr_register(uart_num, uart_intr_num, uart_rx_intr_handler_default, p_uart_obj[uart_num]);\r
{\r
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error", ESP_FAIL);\r
if(p_uart_obj[uart_num] == NULL) {\r
- ESP_LOGI(UART_TAG, "ALREADY NULL\n");\r
+ ESP_LOGI(UART_TAG, "ALREADY NULL");\r
return ESP_OK;\r
}\r
ESP_INTR_DISABLE(p_uart_obj[uart_num]->intr_num);\r
projects / esp-idf / commitdiff