Crash_Override/OVMS3-idf
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Update UART driver

Browse source 
1. Use esp_log API for LEDC and GPIO code.
2. Modify some API return value.
3. Add ledc_set_pin() for LEDC
4. Modify typo in uart.h

Questions: In uart driver ISR handler, I used xxxFromISR , like xSemaphoreGiveFromISR, do those FromISR functions need to be put in IRAM?
This commit is contained in:
Wangjialin 2016-10-24 15:57:23 +08:00
parent 9098e64398
commit 74aff2b9d2
6 changed files with 169 additions and 323 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

123
components/driver/gpio.c
View file

@ -18,34 +18,13 @@
#include "freertos/xtensa_api.h" #include "freertos/xtensa_api.h"
#include "driver/gpio.h" #include "driver/gpio.h"
#include "soc/soc.h" #include "soc/soc.h"
#include "esp_log.h"
//TODO: move debug options to menuconfig const char* GPIO_TAG = "GPIO";
#define GPIO_DBG_ENABLE (0) #define GPIO_CHECK(a, str, ret_val) if (!(a)) { \
#define GPIO_WARNING_ENABLE (0) ESP_LOGE(GPIO_TAG,"%s:%d (%s):%s\n", __FILE__, __LINE__, __FUNCTION__, str); \
#define GPIO_ERROR_ENABLE (0) return (ret_val); \
#define GPIO_INFO_ENABLE (0) }
//DBG INFOR
#if GPIO_INFO_ENABLE
#define GPIO_INFO ets_printf
#else
#define GPIO_INFO(...)
#endif
#if GPIO_WARNING_ENABLE
#define GPIO_WARNING(format,...) do{\
ets_printf("[waring][%s#%u]",__FUNCTION__,__LINE__);\
ets_printf(format,##__VA_ARGS__);\
}while(0)
#else
#define GPIO_WARNING(...)
#endif
#if GPIO_ERROR_ENABLE
#define GPIO_ERROR(format,...) do{\
ets_printf("[error][%s#%u]",__FUNCTION__,__LINE__);\
ets_printf(format,##__VA_ARGS__);\
}while(0)
#else
#define GPIO_ERROR(...)
#endif
const uint32_t GPIO_PIN_MUX_REG[GPIO_PIN_COUNT] = { const uint32_t GPIO_PIN_MUX_REG[GPIO_PIN_COUNT] = {
GPIO_PIN_REG_0, GPIO_PIN_REG_0,
@ -90,33 +69,17 @@ const uint32_t GPIO_PIN_MUX_REG[GPIO_PIN_COUNT] = {
GPIO_PIN_REG_39 GPIO_PIN_REG_39
}; };
static int is_valid_gpio(int gpio_num)
{
if(gpio_num >= GPIO_PIN_COUNT || GPIO_PIN_MUX_REG[gpio_num] == 0) {
GPIO_ERROR("GPIO io_num=%d does not exist\n",gpio_num);
return 0;
}
return 1;
}
esp_err_t gpio_set_intr_type(gpio_num_t gpio_num, gpio_int_type_t intr_type) esp_err_t gpio_set_intr_type(gpio_num_t gpio_num, gpio_int_type_t intr_type)
{ {
if(!is_valid_gpio(gpio_num)) { GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error\n", ESP_ERR_INVALID_ARG);
return ESP_ERR_INVALID_ARG; GPIO_CHECK(intr_type < GPIO_INTR_MAX, "GPIO interrupt type error\n", ESP_ERR_INVALID_ARG);
}
if(intr_type >= GPIO_INTR_MAX) {
GPIO_ERROR("Unknown GPIO intr:%u\n",intr_type);
return ESP_ERR_INVALID_ARG;
}
GPIO.pin[gpio_num].int_type = intr_type; GPIO.pin[gpio_num].int_type = intr_type;
return ESP_OK; return ESP_OK;
} }
esp_err_t gpio_intr_enable(gpio_num_t gpio_num) esp_err_t gpio_intr_enable(gpio_num_t gpio_num)
{ {
if(!is_valid_gpio(gpio_num)) { GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error\n", ESP_ERR_INVALID_ARG);
return ESP_ERR_INVALID_ARG;
}
if(xPortGetCoreID() == 0) { if(xPortGetCoreID() == 0) {
GPIO.pin[gpio_num].int_ena = GPIO_PRO_CPU_INTR_ENA; //enable pro cpu intr GPIO.pin[gpio_num].int_ena = GPIO_PRO_CPU_INTR_ENA; //enable pro cpu intr
} else { } else {
@ -127,18 +90,14 @@ esp_err_t gpio_intr_enable(gpio_num_t gpio_num)
esp_err_t gpio_intr_disable(gpio_num_t gpio_num) esp_err_t gpio_intr_disable(gpio_num_t gpio_num)
{ {
if(!is_valid_gpio(gpio_num)) { GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error\n", ESP_ERR_INVALID_ARG);
return ESP_ERR_INVALID_ARG;
}
GPIO.pin[gpio_num].int_ena = 0; //disable GPIO intr GPIO.pin[gpio_num].int_ena = 0; //disable GPIO intr
return ESP_OK; return ESP_OK;
} }
static esp_err_t gpio_output_disable(gpio_num_t gpio_num) static esp_err_t gpio_output_disable(gpio_num_t gpio_num)
{ {
if(!is_valid_gpio(gpio_num)) { GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error\n", ESP_ERR_INVALID_ARG);
return ESP_ERR_INVALID_ARG;
}
if(gpio_num < 32) { if(gpio_num < 32) {
GPIO.enable_w1tc = (0x1 << gpio_num); GPIO.enable_w1tc = (0x1 << gpio_num);
} else { } else {
@ -149,13 +108,7 @@ static esp_err_t gpio_output_disable(gpio_num_t gpio_num)
static esp_err_t gpio_output_enable(gpio_num_t gpio_num) static esp_err_t gpio_output_enable(gpio_num_t gpio_num)
{ {
if(gpio_num >= 34) { GPIO_CHECK(GPIO_IS_VALID_OUTPUT_GPIO(gpio_num), "GPIO output gpio_num error\n", ESP_ERR_INVALID_ARG);
GPIO_ERROR("io_num=%d can only be input\n",gpio_num);
return ESP_ERR_INVALID_ARG;
}
if(!is_valid_gpio(gpio_num)) {
return ESP_ERR_INVALID_ARG;
}
if(gpio_num < 32) { if(gpio_num < 32) {
GPIO.enable_w1ts = (0x1 << gpio_num); GPIO.enable_w1ts = (0x1 << gpio_num);
} else { } else {
@ -166,9 +119,7 @@ static esp_err_t gpio_output_enable(gpio_num_t gpio_num)
esp_err_t gpio_set_level(gpio_num_t gpio_num, uint32_t level) esp_err_t gpio_set_level(gpio_num_t gpio_num, uint32_t level)
{ {
if(!GPIO_IS_VALID_GPIO(gpio_num)) { GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error\n", ESP_ERR_INVALID_ARG);
return ESP_ERR_INVALID_ARG;
}
if(level) { if(level) {
if(gpio_num < 32) { if(gpio_num < 32) {
GPIO.out_w1ts = (1 << gpio_num); GPIO.out_w1ts = (1 << gpio_num);
@ -196,9 +147,8 @@ int gpio_get_level(gpio_num_t gpio_num)
esp_err_t gpio_set_pull_mode(gpio_num_t gpio_num, gpio_pull_mode_t pull) esp_err_t gpio_set_pull_mode(gpio_num_t gpio_num, gpio_pull_mode_t pull)
{ {
if(!is_valid_gpio(gpio_num)) { GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error\n", ESP_ERR_INVALID_ARG);
return ESP_ERR_INVALID_ARG; GPIO_CHECK(pull <= GPIO_FLOATING, "GPIO pull mode error\n", ESP_ERR_INVALID_ARG);
}
esp_err_t ret = ESP_OK; esp_err_t ret = ESP_OK;
switch(pull) { switch(pull) {
case GPIO_PULLUP_ONLY: case GPIO_PULLUP_ONLY:
@ -218,7 +168,7 @@ esp_err_t gpio_set_pull_mode(gpio_num_t gpio_num, gpio_pull_mode_t pull)
PIN_PULLDWN_DIS(GPIO_PIN_MUX_REG[gpio_num]); PIN_PULLDWN_DIS(GPIO_PIN_MUX_REG[gpio_num]);
break; break;
default: default:
GPIO_ERROR("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\n",gpio_num,pull);
ret = ESP_ERR_INVALID_ARG; ret = ESP_ERR_INVALID_ARG;
break; break;
} }
@ -227,11 +177,9 @@ esp_err_t gpio_set_pull_mode(gpio_num_t gpio_num, gpio_pull_mode_t pull)
esp_err_t gpio_set_direction(gpio_num_t gpio_num, gpio_mode_t mode) esp_err_t gpio_set_direction(gpio_num_t gpio_num, gpio_mode_t mode)
{ {
if(!is_valid_gpio(gpio_num)) { GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error\n", ESP_ERR_INVALID_ARG);
return ESP_ERR_INVALID_ARG;
}
if(gpio_num >= 34 && (mode & (GPIO_MODE_DEF_OUTPUT))) { if(gpio_num >= 34 && (mode & (GPIO_MODE_DEF_OUTPUT))) {
GPIO_ERROR("io_num=%d can only be input\n",gpio_num); ESP_LOGE(GPIO_TAG, "io_num=%d can only be input\n",gpio_num);
return ESP_ERR_INVALID_ARG; return ESP_ERR_INVALID_ARG;
} }
esp_err_t ret = ESP_OK; esp_err_t ret = ESP_OK;
@ -268,52 +216,51 @@ esp_err_t gpio_config(gpio_config_t *pGPIOConfig)
uint32_t io_num = 0; uint32_t io_num = 0;
uint64_t bit_valid = 0; uint64_t bit_valid = 0;
if(pGPIOConfig->pin_bit_mask == 0 || pGPIOConfig->pin_bit_mask >= (((uint64_t) 1) << GPIO_PIN_COUNT)) { if(pGPIOConfig->pin_bit_mask == 0 || pGPIOConfig->pin_bit_mask >= (((uint64_t) 1) << GPIO_PIN_COUNT)) {
GPIO_ERROR("GPIO_PIN mask error \n"); ESP_LOGE(GPIO_TAG, "GPIO_PIN mask error \n");
return ESP_ERR_INVALID_ARG; return ESP_ERR_INVALID_ARG;
} }
if((pGPIOConfig->mode) & (GPIO_MODE_DEF_OUTPUT)) { if((pGPIOConfig->mode) & (GPIO_MODE_DEF_OUTPUT)) {
//GPIO 34/35/36/37/38/39 can only be used as input mode; //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))) { if((gpio_pin_mask & ( GPIO_SEL_34 | GPIO_SEL_35 | GPIO_SEL_36 | GPIO_SEL_37 | GPIO_SEL_38 | GPIO_SEL_39))) {
GPIO_ERROR("GPIO34-39 can only be used as input mode\n"); ESP_LOGE(GPIO_TAG, "GPIO34-39 can only be used as input mode\n");
return ESP_ERR_INVALID_ARG; return ESP_ERR_INVALID_ARG;
} }
} }
do { do {
io_reg = GPIO_PIN_MUX_REG[io_num]; io_reg = GPIO_PIN_MUX_REG[io_num];
if(((gpio_pin_mask >> io_num) & BIT(0)) && io_reg) { if(((gpio_pin_mask >> io_num) & BIT(0)) && io_reg) {
GPIO_INFO("Gpio%02d |Mode:",io_num); ESP_LOGI(GPIO_TAG, "Gpio%02d |Mode:",io_num);
if((pGPIOConfig->mode) & GPIO_MODE_DEF_INPUT) { if((pGPIOConfig->mode) & GPIO_MODE_DEF_INPUT) {
GPIO_INFO("INPUT "); ESP_LOGI(GPIO_TAG, "INPUT ");
PIN_INPUT_ENABLE(GPIO_PIN_MUX_REG[io_num]); PIN_INPUT_ENABLE(GPIO_PIN_MUX_REG[io_num]);
} else { } else {
PIN_INPUT_DISABLE(GPIO_PIN_MUX_REG[io_num]); PIN_INPUT_DISABLE(GPIO_PIN_MUX_REG[io_num]);
} }
if((pGPIOConfig->mode) & GPIO_MODE_DEF_OD) { if((pGPIOConfig->mode) & GPIO_MODE_DEF_OD) {
GPIO_INFO("OD "); ESP_LOGI(GPIO_TAG, "OD ");
GPIO.pin[io_num].pad_driver = 1; /*0x01 Open-drain */ GPIO.pin[io_num].pad_driver = 1; /*0x01 Open-drain */
} else { } else {
GPIO.pin[io_num].pad_driver = 0; /*0x00 Normal gpio output */ GPIO.pin[io_num].pad_driver = 0; /*0x00 Normal gpio output */
} }
if((pGPIOConfig->mode) & GPIO_MODE_DEF_OUTPUT) { if((pGPIOConfig->mode) & GPIO_MODE_DEF_OUTPUT) {
GPIO_INFO("OUTPUT "); ESP_LOGI(GPIO_TAG, "OUTPUT ");
gpio_output_enable(io_num); gpio_output_enable(io_num);
} else { } else {
gpio_output_disable(io_num); gpio_output_disable(io_num);
} }
GPIO_INFO("|");
if(pGPIOConfig->pull_up_en) { if(pGPIOConfig->pull_up_en) {
GPIO_INFO("PU "); ESP_LOGI(GPIO_TAG, "PU ");
PIN_PULLUP_EN(io_reg); PIN_PULLUP_EN(io_reg);
} else { } else {
PIN_PULLUP_DIS(io_reg); PIN_PULLUP_DIS(io_reg);
} }
if(pGPIOConfig->pull_down_en) { if(pGPIOConfig->pull_down_en) {
GPIO_INFO("PD "); ESP_LOGI(GPIO_TAG, "PD ");
PIN_PULLDWN_EN(io_reg); PIN_PULLDWN_EN(io_reg);
} else { } else {
PIN_PULLDWN_DIS(io_reg); PIN_PULLDWN_DIS(io_reg);
} }
GPIO_INFO("Intr:%d |\n",pGPIOConfig->intr_type); ESP_LOGI(GPIO_TAG, "Intr:%d |\n",pGPIOConfig->intr_type);
gpio_set_intr_type(io_num, pGPIOConfig->intr_type); gpio_set_intr_type(io_num, pGPIOConfig->intr_type);
if(pGPIOConfig->intr_type) { if(pGPIOConfig->intr_type) {
gpio_intr_enable(io_num); gpio_intr_enable(io_num);
@ -322,7 +269,7 @@ esp_err_t gpio_config(gpio_config_t *pGPIOConfig)
} }
PIN_FUNC_SELECT(io_reg, PIN_FUNC_GPIO); /*function number 2 is GPIO_FUNC for each pin */ PIN_FUNC_SELECT(io_reg, PIN_FUNC_GPIO); /*function number 2 is GPIO_FUNC for each pin */
} else if(bit_valid && (io_reg == 0)) { } else if(bit_valid && (io_reg == 0)) {
GPIO_WARNING("io_num=%d does not exist\n",io_num); ESP_LOGW(GPIO_TAG, "io_num=%d does not exist\n",io_num);
} }
io_num++; io_num++;
} while(io_num < GPIO_PIN_COUNT); } while(io_num < GPIO_PIN_COUNT);
@ -331,9 +278,7 @@ esp_err_t gpio_config(gpio_config_t *pGPIOConfig)
esp_err_t gpio_isr_register(uint32_t gpio_intr_num, void (*fn)(void*), void * arg) esp_err_t gpio_isr_register(uint32_t gpio_intr_num, void (*fn)(void*), void * arg)
{ {
if(fn == NULL) { GPIO_CHECK(fn, "GPIO ISR null\n", ESP_ERR_INVALID_ARG);
return ESP_ERR_INVALID_ARG;
}
ESP_INTR_DISABLE(gpio_intr_num); ESP_INTR_DISABLE(gpio_intr_num);
intr_matrix_set(xPortGetCoreID(), ETS_GPIO_INTR_SOURCE, gpio_intr_num); intr_matrix_set(xPortGetCoreID(), ETS_GPIO_INTR_SOURCE, gpio_intr_num);
xt_set_interrupt_handler(gpio_intr_num, fn, arg); xt_set_interrupt_handler(gpio_intr_num, fn, arg);
@ -344,15 +289,13 @@ esp_err_t gpio_isr_register(uint32_t gpio_intr_num, void (*fn)(void*), void * ar
/*only level interrupt can be used for wake-up function*/ /*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) esp_err_t gpio_wakeup_enable(gpio_num_t gpio_num, gpio_int_type_t intr_type)
{ {
if(!is_valid_gpio(gpio_num)) { GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error\n", ESP_ERR_INVALID_ARG);
return ESP_ERR_INVALID_ARG;
}
esp_err_t ret = ESP_OK; esp_err_t ret = ESP_OK;
if((intr_type == GPIO_INTR_LOW_LEVEL) || (intr_type == GPIO_INTR_HIGH_LEVEL)) { 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].int_type = intr_type;
GPIO.pin[gpio_num].wakeup_enable = 0x1; GPIO.pin[gpio_num].wakeup_enable = 0x1;
} else { } else {
GPIO_ERROR("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\n",gpio_num);
ret = ESP_ERR_INVALID_ARG; ret = ESP_ERR_INVALID_ARG;
} }
return ret; return ret;
@ -360,9 +303,7 @@ esp_err_t gpio_wakeup_enable(gpio_num_t gpio_num, gpio_int_type_t intr_type)
esp_err_t gpio_wakeup_disable(gpio_num_t gpio_num) esp_err_t gpio_wakeup_disable(gpio_num_t gpio_num)
{ {
if(!is_valid_gpio(gpio_num)) { GPIO_CHECK(GPIO_IS_VALID_GPIO(gpio_num), "GPIO number error\n", ESP_ERR_INVALID_ARG);
return ESP_ERR_INVALID_ARG;
}
GPIO.pin[gpio_num].wakeup_enable = 0; GPIO.pin[gpio_num].wakeup_enable = 0;
return ESP_OK; return ESP_OK;
} }

2
components/driver/include/driver/gpio.h
View file

@ -28,6 +28,8 @@
extern "C" { extern "C" {
#endif #endif
extern const char* GPIO_TAG;
#define GPIO_SEL_0 (BIT(0)) /* Pin 0 selected */ #define GPIO_SEL_0 (BIT(0)) /* Pin 0 selected */
#define GPIO_SEL_1 (BIT(1)) /* Pin 1 selected */ #define GPIO_SEL_1 (BIT(1)) /* Pin 1 selected */
#define GPIO_SEL_2 (BIT(2)) /* Pin 2 selected */ #define GPIO_SEL_2 (BIT(2)) /* Pin 2 selected */

33
components/driver/include/driver/ledc.h
View file

@ -26,6 +26,7 @@
extern "C" { extern "C" {
#endif #endif
extern const char* LEDC_TAG;
#define LEDC_APB_CLK_HZ (APB_CLK_FREQ) #define LEDC_APB_CLK_HZ (APB_CLK_FREQ)
#define LEDC_REF_CLK_HZ (1*1000000) #define LEDC_REF_CLK_HZ (1*1000000)
@ -338,6 +339,22 @@ esp_err_t ledc_timer_resume(ledc_mode_t speed_mode, uint32_t timer_sel);
*/ */
esp_err_t ledc_bind_channel_timer(ledc_mode_t speed_mode, uint32_t channel, uint32_t timer_idx); esp_err_t ledc_bind_channel_timer(ledc_mode_t speed_mode, uint32_t channel, uint32_t timer_idx);
/**
* @brief Set LEDC output signal to GPIO
*
* @param[in] gpio_num : GPIO number for LEDC signal output
*
* @param[in] speed_mode : select the LEDC speed_mode, high-speed mode and low-speed mode, now we only support high-speed mode. We will access low-speed mode in next version
*
* @param[in] channel : LEDC channel index(0-7), select from ledc_channel_t
*
*
* @return ESP_ERR_INVALID_ARG: parameter error
* ESP_OK: success
*
*/
esp_err_t ledc_set_pin(int gpio_num,ledc_mode_t speed_mode, ledc_channel_t ledc_channel);
/***************************EXAMPLE********************************** /***************************EXAMPLE**********************************
* *
* *
@ -349,21 +366,21 @@ esp_err_t ledc_bind_channel_timer(ledc_mode_t speed_mode, uint32_t channel, uint
* ledc_timer_config_t timer_conf = { * ledc_timer_config_t timer_conf = {
* .bit_num = LEDC_TIMER_12_BIT, //set timer counter bit number * .bit_num = LEDC_TIMER_12_BIT, //set timer counter bit number
* .freq_hz = 1000, //set frequency of pwm, here, 1000Hz * .freq_hz = 1000, //set frequency of pwm, here, 1000Hz
* .speed_mode = LEDC_HIGH_SPEED_MODE //timer mode, * .speed_mode = LEDC_HIGH_SPEED_MODE, //timer mode,
* .timer_num = LEDC_TIMER_0, //timer number * .timer_num = LEDC_TIMER_0, //timer number
* }; * };
* ledc_timer_config(&timer_conf); //setup timer. * ledc_timer_config(&timer_conf); //setup timer.
* *
* //3. set LEDC channel * //3. set LEDC channel
* ledc_channel_config_t ledc_conf = { * ledc_channel_config_t ledc_conf = {
* .channel = LEDC_CHANNEL_0; //set LEDC channel 0 * .channel = LEDC_CHANNEL_0, //set LEDC channel 0
* .duty = 1000; //set the duty for initialization.(duty range is 0 ~ ((2**bit_num)-1) * .duty = 1000, //set the duty for initialization.(duty range is 0 ~ ((2**bit_num)-1)
* .gpio_num = 16; //GPIO number * .gpio_num = 16, //GPIO number
* .intr_type = LEDC_INTR_FADE_END; //GPIO INTR TYPE, as an example, we enable fade_end interrupt here. * .intr_type = LEDC_INTR_FADE_END, //GPIO INTR TYPE, as an example, we enable fade_end interrupt here.
* .speed_mode = LEDC_HIGH_SPEED_MODE; //set LEDC mode, from ledc_mode_t * .speed_mode = LEDC_HIGH_SPEED_MODE, //set LEDC mode, from ledc_mode_t
* .timer_sel = LEDC_TIMER_0; //set LEDC timer source, if different channel use one timer, the frequency and bit_num of these channels should be the same * .timer_sel = LEDC_TIMER_0, //set LEDC timer source, if different channel use one timer, the frequency and bit_num of these channels should be the same
* } * }
* ledc_channel_config(&ledc_conf); //setup the configuration * ledc_channel_config(&ledc_conf); //setup the configuration
* *
* ----------------EXAMPLE OF SETTING DUTY --- ----------------- * ----------------EXAMPLE OF SETTING DUTY --- -----------------
* uint32_t ledc_channel = LEDC_CHANNEL_0; //LEDC channel(0-73) * uint32_t ledc_channel = LEDC_CHANNEL_0; //LEDC channel(0-73)

71
components/driver/include/driver/uart.h
View file

@ -27,7 +27,7 @@ extern "C" {
#include <esp_types.h> #include <esp_types.h>
extern const char* UART_TAG; extern const char* UART_TAG;
#define UART_FIFO_LEN (128) //Do Not Change it #define UART_FIFO_LEN (128) //Do not change this, this value describes the length of the gardware FIFO in the ESP32
#define UART_INTR_MASK 0x1ff #define UART_INTR_MASK 0x1ff
#define UART_LINE_INV_MASK (0x3f << 19) #define UART_LINE_INV_MASK (0x3f << 19)
@ -150,13 +150,10 @@ esp_err_t uart_set_word_length(uart_port_t uart_num, uart_word_length_t data_bit
* *
* @param uart_port_t uart_no: UART_NUM_0, UART_NUM_1 or UART_NUM_2 * @param uart_port_t uart_no: UART_NUM_0, UART_NUM_1 or UART_NUM_2
* *
* @return ESP_FAIL (-1) : Parameter error * @return ESP_FAIL : Parameter error
* UART_DATA_5_BITS (0): UART word length: 5 bits. * ESP_OK : Success, result will be put in (*data_bit)
* UART_DATA_6_BITS (1): UART word length: 6 bits.
* UART_DATA_7_BITS (2): UART word length: 7 bits.
* UART_DATA_8_BITS (3): UART word length: 8 bits.
*/ */
int uart_get_word_length(uart_port_t uart_num); esp_err_t uart_get_word_length(uart_port_t uart_num, uart_word_length_t* data_bit);
/** /**
* @brief Set UART stop bits. * @brief Set UART stop bits.
@ -174,12 +171,10 @@ esp_err_t uart_set_stop_bits(uart_port_t uart_no, uart_stop_bits_t bit_num);
* *
* @param uart_port_t uart_no: UART_NUM_0, UART_NUM_1 or UART_NUM_2 * @param uart_port_t uart_no: UART_NUM_0, UART_NUM_1 or UART_NUM_2
* *
* @return ESP_FAIL (-1): Parameter error * @return ESP_FAIL : Parameter error
* UART_STOP_BITS_1 (1): 1 stop bit * ESP_OK : Success, result will be put in (*stop_bit)
* UART_STOP_BITS_1_5 (2): 1.5 stop bits
* UART_STOP_BITS_1 (3): 2 stop bits
*/ */
int uart_get_stop_bits(uart_port_t uart_num); esp_err_t uart_get_stop_bits(uart_port_t uart_num, uart_stop_bits_t* stop_bit);
/** /**
* @brief Set UART parity. * @brief Set UART parity.
@ -196,13 +191,11 @@ esp_err_t uart_set_parity(uart_port_t uart_no, uart_parity_t parity_mode);
* *
* @param uart_port_t uart_no: UART_NUM_0, UART_NUM_1 or UART_NUM_2 * @param uart_port_t uart_no: UART_NUM_0, UART_NUM_1 or UART_NUM_2
* *
* @return ESP_FAIL (-1): Parameter error * @return ESP_FAIL : Parameter error
* UART_PARITY_ODD (0x11): Odd parity check mode * ESP_OK : Success, result will be put in (*parity_mode)
* UART_PARITY_EVEN (0x10): Even parity check mode
* UART_PARITY_DISABLE(0x0) : parity check disabled
* *
*/ */
int uart_get_parity(uart_port_t uart_num); esp_err_t uart_get_parity(uart_port_t uart_num, uart_parity_t* parity_mode);
/** /**
* @brief Set UART baud rate. * @brief Set UART baud rate.
@ -219,11 +212,11 @@ esp_err_t uart_set_baudrate(uart_port_t uart_no, uint32_t baud_rate);
* *
* @param uart_port_t uart_no: UART_NUM_0, UART_NUM_1 or UART_NUM_2 * @param uart_port_t uart_no: UART_NUM_0, UART_NUM_1 or UART_NUM_2
* *
* @return ESP_FAIL(-1): Parameter error * @return ESP_FAIL : Parameter error
* Others (>0): UART baud-rate * ESP_OK : Success, result will be put in (*baudrate)
* *
*/ */
int uart_get_baudrate(uart_port_t uart_num); esp_err_t uart_get_baudrate(uart_port_t uart_num, uint32_t* baudrate);
/** /**
* @brief Set UART line inverse mode * @brief Set UART line inverse mode
@ -253,13 +246,10 @@ esp_err_t uart_set_hw_flow_ctrl(uart_port_t uart_no, uart_hw_flowcontrol_t flow_
* @brief Get hardware flow control mode * @brief Get hardware flow control mode
* @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2
* *
* @return ESP_FAIL (-1): Parameter error * @return ESP_FAIL : Parameter error
* UART_HW_FLOWCTRL_DISABLE (0): UART hw flow control disabled * ESP_OK : Success, result will be put in (*flow_ctrl)
* UART_HW_FLOWCTRL_RTS (1): UART RX flow control enabled
* UART_HW_FLOWCTRL_CTS (2): UART TX flow control enabled
* UART_HW_FLOWCTRL_CTS_RTS (3): UART TX/RX flow control enabled
*/ */
int uart_get_hw_flow_ctrl(uart_port_t uart_num); esp_err_t uart_get_hw_flow_ctrl(uart_port_t uart_num, uart_hw_flowcontrol_t* flow_ctrl);
/** /**
* @brief Clear UART interrupt status * @brief Clear UART interrupt status
@ -453,6 +443,7 @@ esp_err_t uart_driver_delete(uart_port_t uart_num);
* @param TickType_t ticks_to_wait: Timeout, count in RTOS ticks * @param TickType_t ticks_to_wait: Timeout, count in RTOS ticks
* *
* @return ESP_OK : Success * @return ESP_OK : Success
* ESP_FAIL : Parameter error
* ESP_ERR_TIMEOUT: Timeout * ESP_ERR_TIMEOUT: Timeout
*/ */
esp_err_t uart_wait_tx_fifo_empty(uart_port_t uart_num, TickType_t ticks_to_wait); esp_err_t uart_wait_tx_fifo_empty(uart_port_t uart_num, TickType_t ticks_to_wait);
@ -465,7 +456,8 @@ esp_err_t uart_wait_tx_fifo_empty(uart_port_t uart_num, TickType_t ticks_to_wait
* @param char* buffer : data buffer address * @param char* buffer : data buffer address
* @param uint32_t len : data length to send * @param uint32_t len : data length to send
* *
* @return The number of data that pushed to the TX FIFO * @return -1 : Parameter error
* OTHERS(>=0): The number of data that pushed to the TX FIFO
*/ */
int uart_tx_chars(uart_port_t uart_no, char* buffer, uint32_t len); int uart_tx_chars(uart_port_t uart_no, char* buffer, uint32_t len);
@ -477,7 +469,8 @@ int uart_tx_chars(uart_port_t uart_no, char* buffer, uint32_t len);
* @param char* src : data buffer address * @param char* src : data buffer address
* @param size_t size : data length to send * @param size_t size : data length to send
* *
* @return The number of data that sent out. * @return -1 : Parameter error
* OTHERS(>=0): The number of data that pushed to the TX FIFO
*/ */
int uart_tx_all_chars(uart_port_t uart_num, const char* src, size_t size); int uart_tx_all_chars(uart_port_t uart_num, const char* src, size_t size);
@ -490,7 +483,8 @@ int uart_tx_all_chars(uart_port_t uart_num, const char* src, size_t size);
* @param size_t size : data length to send * @param size_t size : data length to send
* @param int brk_len : break signal length (unit: one bit's time@current_baudrate) * @param int brk_len : break signal length (unit: one bit's time@current_baudrate)
* *
* @return The number of data that sent out. * @return -1 : Parameter error
* OTHERS(>=0): The number of data that pushed to the TX FIFO
*/ */
int uart_tx_all_chars_with_break(uart_port_t uart_num, const char* src, size_t size, int brk_len); int uart_tx_all_chars_with_break(uart_port_t uart_num, const char* src, size_t size, int brk_len);
@ -498,20 +492,20 @@ int uart_tx_all_chars_with_break(uart_port_t uart_num, const char* src, size_t s
* @brief UART read one char * @brief UART read one char
* *
* @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2
* @param TickType_t ticks_to_wait : ticks to wait. * @param TickType_t ticks_to_wait : Timeout, count in RTOS ticks
* *
* @return -1 : Error * @return -1 : Error
* Others : return a char data from uart fifo. * Others : return a char data from UART.
*/ */
int uart_read_char(uart_port_t uart_num, TickType_t ticks_to_wait); int uart_read_char(uart_port_t uart_num, TickType_t ticks_to_wait);
/** /**
* @brief UART read bytes from UART buffer * @brief UART read bytes from UART buffer
* *
* @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 * @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2
* @param uint8_t* buf : pointer to the buffer. * @param uint8_t* buf : pointer to the buffer.
* @param uint32_t length : data length * @param uint32_t length : data length
* @param TickType_t ticks_to_wait: timeout time( FreeRTOS ti c * @param TickType_t ticks_to_wait: Timeout, count in RTOS ticks
* *
* @return -1 : Error * @return -1 : Error
* Others : return a char data from uart fifo. * Others : return a char data from uart fifo.
@ -542,9 +536,9 @@ esp_err_t uart_set_print_port(uart_port_t uart_no);
* @brief Get the current serial port for ets_printf function * @brief Get the current serial port for ets_printf function
* *
* *
* @param uart_port_t uart_no : UART_NUM_0, UART_NUM_1 or UART_NUM_2 * @return current print port: 0: UART0;
* * 1: UART1;
* @return null * 2: UART2;
*/ */
int uart_get_print_port(); int uart_get_print_port();
@ -637,7 +631,6 @@ int uart_get_print_port();
* break; * break;
* case UART_FIFO_OVF: //Event of HW FIFO overflow detected * case UART_FIFO_OVF: //Event of HW FIFO overflow detected
* ESP_LOGI(UART_TAG, "hw fifo overflow\n"); * ESP_LOGI(UART_TAG, "hw fifo overflow\n");
* while(1);
* break; * break;
* case UART_BUFFER_FULL: //Event of UART ring buffer full * case UART_BUFFER_FULL: //Event of UART ring buffer full
* ESP_LOGI(UART_TAG, "ring buffer full\n"); * ESP_LOGI(UART_TAG, "ring buffer full\n");

223
components/driver/ledc.c
View file

@ -18,86 +18,19 @@
#include "freertos/xtensa_api.h" #include "freertos/xtensa_api.h"
#include "soc/gpio_sig_map.h" #include "soc/gpio_sig_map.h"
#include "driver/ledc.h" #include "driver/ledc.h"
#include "esp_log.h"
//TODO: to use APIs in esp_log.h. const char* LEDC_TAG = "LEDC";
#define LEDC_DBG_WARING_ENABLE (0)
#define LEDC_DBG_ERROR_ENABLE (0)
#define LEDC_INFO_ENABLE (0)
#define LEDC_DBG_ENABLE (0)
//DBG INFOR
#if LEDC_DBG_ENABLE
#define LEDC_DBG(format,...) do{\
ets_printf("[dbg][%s#%u]",__FUNCTION__,__LINE__);\
ets_printf(format,##__VA_ARGS__);\
}while(0)
#else
#define LEDC_DBG(...)
#endif
#if LEDC_INFO_ENABLE
#define LEDC_INFO(format,...) do{\
ets_printf("[info][%s#%u]",__FUNCTION__,__LINE__);\
ets_printf(format,##__VA_ARGS__);\
}while(0)
#else
#define LEDC_INFO(...)
#endif
#if LEDC_DBG_WARING_ENABLE
#define LEDC_WARING(format,...) do{\
ets_printf("[waring][%s#%u]",__FUNCTION__,__LINE__);\
ets_printf(format,##__VA_ARGS__);\
}while(0)
#else
#define LEDC_WARING(...)
#endif
#if LEDC_DBG_ERROR_ENABLE
#define LEDC_ERROR(format,...) do{\
ets_printf("[error][%s#%u]",__FUNCTION__,__LINE__);\
ets_printf(format,##__VA_ARGS__);\
}while(0)
#else
#define LEDC_ERROR(...)
#endif
static portMUX_TYPE ledc_spinlock = portMUX_INITIALIZER_UNLOCKED; static portMUX_TYPE ledc_spinlock = portMUX_INITIALIZER_UNLOCKED;
#define LEDC_CHECK(a, str, ret_val) if (!(a)) { \
static bool ledc_is_valid_channel(uint32_t channel) ESP_LOGE(LEDC_TAG,"%s:%d (%s):%s\n", __FILE__, __LINE__, __FUNCTION__, str); \
{ return (ret_val); \
if(channel > LEDC_CHANNEL_7) { }
LEDC_ERROR("LEDC CHANNEL ERR: %d\n",channel);
return false;
}
return true;
}
static bool ledc_is_valid_mode(uint32_t mode)
{
if(mode >= LEDC_SPEED_MODE_MAX) {
LEDC_ERROR("LEDC MODE ERR: %d\n",mode);
return false;
}
return true;
}
static bool ledc_is_valid_timer(int timer)
{
if(timer > LEDC_TIMER_3) {
LEDC_ERROR("LEDC TIMER ERR: %d\n", timer);
return false;
}
return true;
}
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) 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)
{ {
if(!ledc_is_valid_mode(speed_mode)) { LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
return ESP_ERR_INVALID_ARG; LEDC_CHECK(timer_sel <= LEDC_TIMER_3, "ledc timer error\n", ESP_ERR_INVALID_ARG);
}
if(!ledc_is_valid_timer(timer_sel)) {
return ESP_ERR_INVALID_ARG;
}
portENTER_CRITICAL(&ledc_spinlock); 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.div_num = div_num;
LEDC.timer_group[speed_mode].timer[timer_sel].conf.tick_sel = clk_src; LEDC.timer_group[speed_mode].timer[timer_sel].conf.tick_sel = clk_src;
@ -125,12 +58,8 @@ static esp_err_t ledc_duty_config(ledc_mode_t speed_mode, uint32_t channel_num,
esp_err_t ledc_bind_channel_timer(ledc_mode_t speed_mode, uint32_t channel, uint32_t timer_idx) esp_err_t ledc_bind_channel_timer(ledc_mode_t speed_mode, uint32_t channel, uint32_t timer_idx)
{ {
if(!ledc_is_valid_mode(speed_mode)) { LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
return ESP_ERR_INVALID_ARG; LEDC_CHECK(timer_idx <= LEDC_TIMER_3, "ledc timer error\n", ESP_ERR_INVALID_ARG);
}
if(!ledc_is_valid_timer(timer_idx)) {
return ESP_ERR_INVALID_ARG;
}
portENTER_CRITICAL(&ledc_spinlock); portENTER_CRITICAL(&ledc_spinlock);
LEDC.channel_group[speed_mode].channel[channel].conf0.timer_sel = timer_idx; LEDC.channel_group[speed_mode].channel[channel].conf0.timer_sel = timer_idx;
portEXIT_CRITICAL(&ledc_spinlock); portEXIT_CRITICAL(&ledc_spinlock);
@ -139,12 +68,8 @@ esp_err_t ledc_bind_channel_timer(ledc_mode_t speed_mode, uint32_t channel, uint
esp_err_t ledc_timer_rst(ledc_mode_t speed_mode, uint32_t timer_sel) esp_err_t ledc_timer_rst(ledc_mode_t speed_mode, uint32_t timer_sel)
{ {
if(!ledc_is_valid_mode(speed_mode)) { LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
return ESP_ERR_INVALID_ARG; LEDC_CHECK(timer_sel <= LEDC_TIMER_3, "ledc timer error\n", ESP_ERR_INVALID_ARG);
}
if(!ledc_is_valid_timer(timer_sel)) {
return ESP_ERR_INVALID_ARG;
}
portENTER_CRITICAL(&ledc_spinlock); 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 = 1;
LEDC.timer_group[speed_mode].timer[timer_sel].conf.rst = 0; LEDC.timer_group[speed_mode].timer[timer_sel].conf.rst = 0;
@ -154,12 +79,8 @@ esp_err_t ledc_timer_rst(ledc_mode_t speed_mode, uint32_t timer_sel)
esp_err_t ledc_timer_pause(ledc_mode_t speed_mode, uint32_t timer_sel) esp_err_t ledc_timer_pause(ledc_mode_t speed_mode, uint32_t timer_sel)
{ {
if(!ledc_is_valid_mode(speed_mode)) { LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
return ESP_ERR_INVALID_ARG; LEDC_CHECK(timer_sel <= LEDC_TIMER_3, "ledc timer error\n", ESP_ERR_INVALID_ARG);
}
if(!ledc_is_valid_timer(timer_sel)) {
return ESP_ERR_INVALID_ARG;
}
portENTER_CRITICAL(&ledc_spinlock); portENTER_CRITICAL(&ledc_spinlock);
LEDC.timer_group[speed_mode].timer[timer_sel].conf.pause = 1; LEDC.timer_group[speed_mode].timer[timer_sel].conf.pause = 1;
portEXIT_CRITICAL(&ledc_spinlock); portEXIT_CRITICAL(&ledc_spinlock);
@ -168,12 +89,8 @@ esp_err_t ledc_timer_pause(ledc_mode_t speed_mode, uint32_t timer_sel)
esp_err_t ledc_timer_resume(ledc_mode_t speed_mode, uint32_t timer_sel) esp_err_t ledc_timer_resume(ledc_mode_t speed_mode, uint32_t timer_sel)
{ {
if(!ledc_is_valid_mode(speed_mode)) { LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
return ESP_ERR_INVALID_ARG; LEDC_CHECK(timer_sel <= LEDC_TIMER_3, "ledc timer error\n", ESP_ERR_INVALID_ARG);
}
if(!ledc_is_valid_timer(timer_sel)) {
return ESP_ERR_INVALID_ARG;
}
portENTER_CRITICAL(&ledc_spinlock); portENTER_CRITICAL(&ledc_spinlock);
LEDC.timer_group[speed_mode].timer[timer_sel].conf.pause = 0; LEDC.timer_group[speed_mode].timer[timer_sel].conf.pause = 0;
portEXIT_CRITICAL(&ledc_spinlock); portEXIT_CRITICAL(&ledc_spinlock);
@ -182,9 +99,7 @@ esp_err_t ledc_timer_resume(ledc_mode_t speed_mode, uint32_t timer_sel)
static esp_err_t ledc_enable_intr_type(ledc_mode_t speed_mode, uint32_t channel, ledc_intr_type_t type) static esp_err_t ledc_enable_intr_type(ledc_mode_t speed_mode, uint32_t channel, ledc_intr_type_t type)
{ {
if(!ledc_is_valid_mode(speed_mode)) { LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
return ESP_ERR_INVALID_ARG;
}
uint32_t value; uint32_t value;
uint32_t intr_type = type; uint32_t intr_type = type;
portENTER_CRITICAL(&ledc_spinlock); portENTER_CRITICAL(&ledc_spinlock);
@ -200,9 +115,7 @@ static esp_err_t ledc_enable_intr_type(ledc_mode_t speed_mode, uint32_t channel,
esp_err_t ledc_isr_register(uint32_t ledc_intr_num, void (*fn)(void*), void * arg) esp_err_t ledc_isr_register(uint32_t ledc_intr_num, void (*fn)(void*), void * arg)
{ {
if(fn == NULL) { LEDC_CHECK(fn, "ledc isr null\n", ESP_ERR_INVALID_ARG);
return ESP_ERR_INVALID_ARG;
}
portENTER_CRITICAL(&ledc_spinlock); portENTER_CRITICAL(&ledc_spinlock);
ESP_INTR_DISABLE(ledc_intr_num); ESP_INTR_DISABLE(ledc_intr_num);
intr_matrix_set(xPortGetCoreID(), ETS_LEDC_INTR_SOURCE, ledc_intr_num); intr_matrix_set(xPortGetCoreID(), ETS_LEDC_INTR_SOURCE, ledc_intr_num);
@ -218,16 +131,13 @@ esp_err_t ledc_timer_config(ledc_timer_config_t* timer_conf)
int bit_num = timer_conf->bit_num; int bit_num = timer_conf->bit_num;
int timer_num = timer_conf->timer_num; int timer_num = timer_conf->timer_num;
int speed_mode = timer_conf->speed_mode; int speed_mode = timer_conf->speed_mode;
LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
if(!ledc_is_valid_mode(speed_mode)) {
return ESP_ERR_INVALID_ARG;
}
if(freq_hz == 0 || bit_num == 0 || bit_num > LEDC_TIMER_15_BIT) { if(freq_hz == 0 || bit_num == 0 || bit_num > LEDC_TIMER_15_BIT) {
LEDC_ERROR("freq_hz=%u bit_num=%u\n", freq_hz, bit_num); ESP_LOGE(LEDC_TAG, "freq_hz=%u bit_num=%u\n", freq_hz, bit_num);
return ESP_ERR_INVALID_ARG; return ESP_ERR_INVALID_ARG;
} }
if(timer_num > LEDC_TIMER_3) { if(timer_num > LEDC_TIMER_3) {
LEDC_ERROR("Time Select %u\n", timer_num); ESP_LOGE(LEDC_TAG, "Time Select %u\n", timer_num);
return ESP_ERR_INVALID_ARG; return ESP_ERR_INVALID_ARG;
} }
esp_err_t ret = ESP_OK; esp_err_t ret = ESP_OK;
@ -239,7 +149,7 @@ esp_err_t ledc_timer_config(ledc_timer_config_t* timer_conf)
/*Selet the reference tick*/ /*Selet the reference tick*/
div_param = ((uint64_t) LEDC_REF_CLK_HZ << 8) / freq_hz / precision; div_param = ((uint64_t) LEDC_REF_CLK_HZ << 8) / freq_hz / precision;
if(div_param <= 256 || div_param > LEDC_DIV_NUM_HSTIMER0_V) { if(div_param <= 256 || div_param > LEDC_DIV_NUM_HSTIMER0_V) {
LEDC_ERROR("div param err,div_param=%u\n", div_param); ESP_LOGE(LEDC_TAG, "div param err,div_param=%u\n", (uint32_t)div_param);
ret = ESP_FAIL; ret = ESP_FAIL;
} }
timer_clk_src = LEDC_REF_TICK; timer_clk_src = LEDC_REF_TICK;
@ -254,6 +164,21 @@ esp_err_t ledc_timer_config(ledc_timer_config_t* timer_conf)
return ret; return ret;
} }
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);
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) {
gpio_matrix_out(gpio_num, LEDC_HS_SIG_OUT0_IDX + ledc_channel, 0, 0);
} else {
}
return ESP_OK;
}
esp_err_t ledc_channel_config(ledc_channel_config_t* ledc_conf) esp_err_t ledc_channel_config(ledc_channel_config_t* ledc_conf)
{ {
uint32_t speed_mode = ledc_conf->speed_mode; uint32_t speed_mode = ledc_conf->speed_mode;
@ -262,21 +187,10 @@ esp_err_t ledc_channel_config(ledc_channel_config_t* ledc_conf)
uint32_t timer_select = ledc_conf->timer_sel; uint32_t timer_select = ledc_conf->timer_sel;
uint32_t intr_type = ledc_conf->intr_type; uint32_t intr_type = ledc_conf->intr_type;
uint32_t duty = ledc_conf->duty; uint32_t duty = ledc_conf->duty;
LEDC_CHECK(ledc_channel <= LEDC_CHANNEL_7, "ledc channel error\n", ESP_ERR_INVALID_ARG);
if(!ledc_is_valid_channel(ledc_channel)) { LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
return 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);
if(!ledc_is_valid_mode(speed_mode)) {
return ESP_ERR_INVALID_ARG;
}
if(!GPIO_IS_VALID_OUTPUT_GPIO(gpio_num)) {
LEDC_ERROR("GPIO number error: IO%d\n ", gpio_num);
return ESP_ERR_INVALID_ARG;
}
if(timer_select > LEDC_TIMER_3) {
LEDC_ERROR("Time Select %u\n", timer_select);
return ESP_ERR_INVALID_ARG;
}
esp_err_t ret = ESP_OK; esp_err_t ret = ESP_OK;
/*set channel parameters*/ /*set channel parameters*/
/* channel parameters decide how the waveform looks like in one period*/ /* channel parameters decide how the waveform looks like in one period*/
@ -288,7 +202,7 @@ esp_err_t ledc_channel_config(ledc_channel_config_t* ledc_conf)
ledc_bind_channel_timer(speed_mode, ledc_channel, timer_select); ledc_bind_channel_timer(speed_mode, ledc_channel, timer_select);
/*set interrupt type*/ /*set interrupt type*/
ledc_enable_intr_type(speed_mode, ledc_channel, intr_type); ledc_enable_intr_type(speed_mode, ledc_channel, intr_type);
LEDC_INFO("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\n",
ledc_channel, gpio_num, duty, timer_select ledc_channel, gpio_num, duty, timer_select
); );
/*set LEDC signal in gpio matrix*/ /*set LEDC signal in gpio matrix*/
@ -300,12 +214,8 @@ esp_err_t ledc_channel_config(ledc_channel_config_t* ledc_conf)
esp_err_t ledc_update_duty(ledc_mode_t speed_mode, ledc_channel_t channel) esp_err_t ledc_update_duty(ledc_mode_t speed_mode, ledc_channel_t channel)
{ {
if(!ledc_is_valid_mode(speed_mode)) { LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
return ESP_ERR_INVALID_ARG; LEDC_CHECK(channel <= LEDC_CHANNEL_7, "ledc channel error\n", ESP_ERR_INVALID_ARG);
}
if(!ledc_is_valid_channel(channel)) {
return ESP_ERR_INVALID_ARG;
}
portENTER_CRITICAL(&ledc_spinlock); portENTER_CRITICAL(&ledc_spinlock);
LEDC.channel_group[speed_mode].channel[channel].conf0.sig_out_en = 1; LEDC.channel_group[speed_mode].channel[channel].conf0.sig_out_en = 1;
LEDC.channel_group[speed_mode].channel[channel].conf1.duty_start = 1; LEDC.channel_group[speed_mode].channel[channel].conf1.duty_start = 1;
@ -315,12 +225,8 @@ esp_err_t ledc_update_duty(ledc_mode_t speed_mode, ledc_channel_t channel)
esp_err_t ledc_stop(ledc_mode_t speed_mode, ledc_channel_t channel, uint32_t idle_level) esp_err_t ledc_stop(ledc_mode_t speed_mode, ledc_channel_t channel, uint32_t idle_level)
{ {
if(!ledc_is_valid_mode(speed_mode)) { LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
return ESP_ERR_INVALID_ARG; LEDC_CHECK(channel <= LEDC_CHANNEL_7, "ledc channel error\n", ESP_ERR_INVALID_ARG);
}
if(!ledc_is_valid_channel(channel)) {
return ESP_ERR_INVALID_ARG;
}
portENTER_CRITICAL(&ledc_spinlock); 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.idle_lv = idle_level & 0x1;
LEDC.channel_group[speed_mode].channel[channel].conf0.sig_out_en = 0; LEDC.channel_group[speed_mode].channel[channel].conf0.sig_out_en = 0;
@ -331,18 +237,11 @@ esp_err_t ledc_stop(ledc_mode_t speed_mode, ledc_channel_t channel, uint32_t idl
esp_err_t ledc_set_fade(ledc_mode_t speed_mode, uint32_t channel, uint32_t duty, ledc_duty_direction_t fade_direction, 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) uint32_t step_num, uint32_t duty_cyle_num, uint32_t duty_scale)
{ {
if(!ledc_is_valid_mode(speed_mode)) { LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
return 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);
if(!ledc_is_valid_channel(channel)) {
return ESP_ERR_INVALID_ARG;
}
if(fade_direction > LEDC_DUTY_DIR_INCREASE) {
LEDC_ERROR("Duty direction err\n");
return 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) { if(step_num > LEDC_DUTY_NUM_HSCH0_V || duty_cyle_num > LEDC_DUTY_CYCLE_HSCH0_V || duty_scale > LEDC_DUTY_SCALE_HSCH0_V) {
LEDC_ERROR("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\n", step_num, duty_cyle_num, duty_scale);
return ESP_ERR_INVALID_ARG; return ESP_ERR_INVALID_ARG;
} }
ledc_duty_config(speed_mode, ledc_duty_config(speed_mode,
@ -359,12 +258,8 @@ esp_err_t ledc_set_fade(ledc_mode_t speed_mode, uint32_t channel, uint32_t duty,
esp_err_t ledc_set_duty(ledc_mode_t speed_mode, ledc_channel_t channel, uint32_t duty) esp_err_t ledc_set_duty(ledc_mode_t speed_mode, ledc_channel_t channel, uint32_t duty)
{ {
if(!ledc_is_valid_mode(speed_mode)) { LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
return ESP_ERR_INVALID_ARG; LEDC_CHECK(channel <= LEDC_CHANNEL_7, "ledc channel error\n", ESP_ERR_INVALID_ARG);
}
if(!ledc_is_valid_channel(channel)) {
return ESP_ERR_INVALID_ARG;
}
ledc_duty_config(speed_mode, ledc_duty_config(speed_mode,
channel, //uint32_t chan_num, channel, //uint32_t chan_num,
0, //uint32_t hpoint_val, 0, //uint32_t hpoint_val,
@ -379,18 +274,14 @@ esp_err_t ledc_set_duty(ledc_mode_t speed_mode, ledc_channel_t channel, uint32_t
int ledc_get_duty(ledc_mode_t speed_mode, ledc_channel_t channel) int ledc_get_duty(ledc_mode_t speed_mode, ledc_channel_t channel)
{ {
if(!ledc_is_valid_mode(speed_mode)) { LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", (-1));
return -1;
}
uint32_t duty = (LEDC.channel_group[speed_mode].channel[channel].duty_rd.duty_read >> 4); uint32_t duty = (LEDC.channel_group[speed_mode].channel[channel].duty_rd.duty_read >> 4);
return duty; return duty;
} }
esp_err_t ledc_set_freq(ledc_mode_t speed_mode, ledc_timer_t timer_num, uint32_t freq_hz) esp_err_t ledc_set_freq(ledc_mode_t speed_mode, ledc_timer_t timer_num, uint32_t freq_hz)
{ {
if(!ledc_is_valid_mode(speed_mode)) { LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", ESP_ERR_INVALID_ARG);
return ESP_ERR_INVALID_ARG;
}
portENTER_CRITICAL(&ledc_spinlock); portENTER_CRITICAL(&ledc_spinlock);
esp_err_t ret = ESP_OK; esp_err_t ret = ESP_OK;
uint32_t div_num = 0; uint32_t div_num = 0;
@ -403,7 +294,7 @@ esp_err_t ledc_set_freq(ledc_mode_t speed_mode, ledc_timer_t timer_num, uint32_t
div_num = ((uint64_t) LEDC_REF_CLK_HZ << 8) / freq_hz / precision; div_num = ((uint64_t) LEDC_REF_CLK_HZ << 8) / freq_hz / precision;
} }
if(div_num <= 256 || div_num > LEDC_DIV_NUM_HSTIMER0) { if(div_num <= 256 || div_num > LEDC_DIV_NUM_HSTIMER0) {
LEDC_ERROR("div param err,div_param=%u\n", div_num); ESP_LOGE(LEDC_TAG, "div param err,div_param=%u\n", div_num);
ret = ESP_FAIL; ret = ESP_FAIL;
} }
LEDC.timer_group[speed_mode].timer[timer_num].conf.div_num = div_num; LEDC.timer_group[speed_mode].timer[timer_num].conf.div_num = div_num;
@ -413,9 +304,7 @@ esp_err_t ledc_set_freq(ledc_mode_t speed_mode, ledc_timer_t timer_num, uint32_t
uint32_t ledc_get_freq(ledc_mode_t speed_mode, ledc_timer_t timer_num) uint32_t ledc_get_freq(ledc_mode_t speed_mode, ledc_timer_t timer_num)
{ {
if(!ledc_is_valid_mode(speed_mode)) { LEDC_CHECK(speed_mode < LEDC_SPEED_MODE_MAX, "ledc mode error\n", (0));
return 0;
}
portENTER_CRITICAL(&ledc_spinlock); portENTER_CRITICAL(&ledc_spinlock);
uint32_t freq = 0; uint32_t freq = 0;
uint32_t timer_source_clk = LEDC.timer_group[speed_mode].timer[timer_num].conf.tick_sel; uint32_t timer_source_clk = LEDC.timer_group[speed_mode].timer[timer_num].conf.tick_sel;

40
components/driver/uart.c
View file

@ -90,10 +90,11 @@ esp_err_t uart_set_word_length(uart_port_t uart_num, uart_word_length_t data_bit
return ESP_OK; return ESP_OK;
} }
int uart_get_word_length(uart_port_t uart_num) 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"); UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error");
return UART[uart_num]->conf0.bit_num; *(data_bit) = UART[uart_num]->conf0.bit_num;
return ESP_OK;
} }
esp_err_t uart_set_stop_bits(uart_port_t uart_num, uart_stop_bits_t stop_bit) esp_err_t uart_set_stop_bits(uart_port_t uart_num, uart_stop_bits_t stop_bit)
@ -106,10 +107,11 @@ esp_err_t uart_set_stop_bits(uart_port_t uart_num, uart_stop_bits_t stop_bit)
return ESP_OK; return ESP_OK;
} }
int uart_get_stop_bits(uart_port_t uart_num) 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"); UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error");
return UART[uart_num]->conf0.stop_bit_num; (*stop_bit) = UART[uart_num]->conf0.stop_bit_num;
return ESP_OK;
} }
esp_err_t uart_set_parity(uart_port_t uart_num, uart_parity_t parity_mode) esp_err_t uart_set_parity(uart_port_t uart_num, uart_parity_t parity_mode)
@ -122,19 +124,20 @@ esp_err_t uart_set_parity(uart_port_t uart_num, uart_parity_t parity_mode)
return ESP_OK; return ESP_OK;
} }
int uart_get_parity(uart_port_t uart_num) 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"); UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error");
int val = UART[uart_num]->conf0.val; int val = UART[uart_num]->conf0.val;
if(val & UART_PARITY_EN_M) { if(val & UART_PARITY_EN_M) {
if(val & UART_PARITY_M) { if(val & UART_PARITY_M) {
return UART_PARITY_ODD; (*parity_mode) = UART_PARITY_ODD;
} else { } else {
return UART_PARITY_EVEN; (*parity_mode) = UART_PARITY_EVEN;
} }
} else { } else {
return UART_PARITY_DISABLE; (*parity_mode) = UART_PARITY_DISABLE;
} }
return ESP_OK;
} }
esp_err_t uart_set_baudrate(uart_port_t uart_num, uint32_t baud_rate) esp_err_t uart_set_baudrate(uart_port_t uart_num, uint32_t baud_rate)
@ -149,14 +152,14 @@ esp_err_t uart_set_baudrate(uart_port_t uart_num, uint32_t baud_rate)
return ESP_OK; return ESP_OK;
} }
int uart_get_baudrate(uart_port_t uart_num) esp_err_t uart_get_baudrate(uart_port_t uart_num, uint32_t* baudrate)
{ {
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error"); UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error");
UART_ENTER_CRITICAL(&uart_spinlock[uart_num]); UART_ENTER_CRITICAL(&uart_spinlock[uart_num]);
uint32_t clk_div = (UART[uart_num]->clk_div.div_int << 4) | UART[uart_num]->clk_div.div_frag; uint32_t clk_div = (UART[uart_num]->clk_div.div_int << 4) | UART[uart_num]->clk_div.div_frag;
UART_EXIT_CRITICAL(&uart_spinlock[uart_num]); UART_EXIT_CRITICAL(&uart_spinlock[uart_num]);
uint32_t baudrate = ((UART_CLK_FREQ) << 4) / clk_div; (*baudrate) = ((UART_CLK_FREQ) << 4) / clk_div;
return baudrate; return ESP_OK;
} }
esp_err_t uart_set_line_inverse(uart_port_t uart_num, uint32_t inverse_mask) esp_err_t uart_set_line_inverse(uart_port_t uart_num, uint32_t inverse_mask)
@ -192,7 +195,7 @@ esp_err_t uart_set_hw_flow_ctrl(uart_port_t uart_num, uart_hw_flowcontrol_t flow
return ESP_OK; return ESP_OK;
} }
int uart_get_hw_flow_ctrl(uart_port_t uart_num) 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"); UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error");
uart_hw_flowcontrol_t val = UART_HW_FLOWCTRL_DISABLE; uart_hw_flowcontrol_t val = UART_HW_FLOWCTRL_DISABLE;
@ -202,7 +205,8 @@ int uart_get_hw_flow_ctrl(uart_port_t uart_num)
if(UART[uart_num]->conf0.tx_flow_en) { if(UART[uart_num]->conf0.tx_flow_en) {
val |= UART_HW_FLOWCTRL_CTS; val |= UART_HW_FLOWCTRL_CTS;
} }
return val; (*flow_ctrl) = val;
return ESP_OK;
} }
static esp_err_t uart_reset_fifo(uart_port_t uart_num) static esp_err_t uart_reset_fifo(uart_port_t uart_num)
@ -311,11 +315,11 @@ esp_err_t uart_isr_register(uart_port_t uart_num, uint8_t uart_intr_num, void (*
//only one GPIO pad can connect with input signal //only one GPIO pad can connect with input signal
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_pin(uart_port_t uart_num, int tx_io_num, int rx_io_num, int rts_io_num, int cts_io_num)
{ {
UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error"); // UART_CHECK((uart_num < UART_NUM_MAX), "uart_num error");
UART_CHECK((tx_io_num < 0 || (GPIO_IS_VALID_OUTPUT_GPIO(tx_io_num))), "tx_io_num error"); // UART_CHECK((tx_io_num < 0 || (GPIO_IS_VALID_OUTPUT_GPIO(tx_io_num))), "tx_io_num error");
UART_CHECK((rx_io_num < 0 || (GPIO_IS_VALID_GPIO(rx_io_num))), "rx_io_num error"); // UART_CHECK((rx_io_num < 0 || (GPIO_IS_VALID_GPIO(rx_io_num))), "rx_io_num error");
UART_CHECK((rts_io_num < 0 || (GPIO_IS_VALID_OUTPUT_GPIO(rts_io_num))), "rts_io_num error"); // UART_CHECK((rts_io_num < 0 || (GPIO_IS_VALID_OUTPUT_GPIO(rts_io_num))), "rts_io_num error");
UART_CHECK((cts_io_num < 0 || (GPIO_IS_VALID_GPIO(cts_io_num))), "cts_io_num error"); // UART_CHECK((cts_io_num < 0 || (GPIO_IS_VALID_GPIO(cts_io_num))), "cts_io_num error");
int tx_sig, rx_sig, rts_sig, cts_sig; int tx_sig, rx_sig, rts_sig, cts_sig;
switch(uart_num) { switch(uart_num) {