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

GPIO: fix unit test issue on ESP32-S2

Browse source 
Also rename some test variables.
This commit is contained in:
michael 2020-02-25 17:41:50 +08:00
parent 7a3f21636f
commit f1a4c84e57
1 changed files with 172 additions and 184 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

356
components/driver/test/test_gpio.c
View file

@ -21,16 +21,24 @@
#endif #endif
#define WAKE_UP_IGNORE 1 // gpio_wakeup function development is not completed yet, set it deprecated. #define WAKE_UP_IGNORE 1 // gpio_wakeup function development is not completed yet, set it deprecated.
#if CONFIG_IDF_TARGET_ESP32 #if CONFIG_IDF_TARGET_ESP32
#define GPIO_OUTPUT_IO 18 // default output GPIO #define TEST_GPIO_EXT_OUT_IO 18 // default output GPIO
#define GPIO_INPUT_IO 19 // default input GPIO #define TEST_GPIO_EXT_IN_IO 19 // default input GPIO
#define GPIO_OUTPUT_MAX GPIO_NUM_34 #define TEST_GPIO_OUTPUT_PIN 23
#define TEST_GPIO_INPUT_ONLY_PIN 34
#define TEST_GPIO_OUTPUT_MAX GPIO_NUM_34
#elif CONFIG_IDF_TARGET_ESP32S2 #elif CONFIG_IDF_TARGET_ESP32S2
// ESP32_S2 DEVKIC uses IO19 and IO20 as USB functions, so it is necessary to avoid using IO19, otherwise GPIO io pull up/down function cannot pass // ESP32_S2 DEVKIC uses IO19 and IO20 as USB functions, so it is necessary to avoid using IO19, otherwise GPIO io pull up/down function cannot pass
#define GPIO_OUTPUT_IO 18 // default output GPIO // Also the first version of ESP32-S2-Saola has pullup issue on GPIO18, which is tied to 3V3 on the
#define GPIO_INPUT_IO 21 // default input GPIO // runner. Also avoid using GPIO18.
#define GPIO_OUTPUT_MAX GPIO_NUM_46 #define TEST_GPIO_EXT_OUT_IO 17 // default output GPIO
#define TEST_GPIO_EXT_IN_IO 21 // default input GPIO
#define TEST_GPIO_OUTPUT_PIN 26
#define TEST_GPIO_INPUT_ONLY_PIN 46
#define TEST_GPIO_OUTPUT_MAX GPIO_NUM_46
#endif #endif
static volatile int disable_intr_times = 0; // use this to calculate how many times it go into interrupt static volatile int disable_intr_times = 0; // use this to calculate how many times it go into interrupt
static volatile int level_intr_times = 0; // use this to get how many times the level interrupt happened static volatile int level_intr_times = 0; // use this to get how many times the level interrupt happened
static volatile int edge_intr_times = 0; // use this to get how many times the edge interrupt happened static volatile int edge_intr_times = 0; // use this to get how many times the edge interrupt happened
@ -38,6 +46,7 @@ static volatile int edge_intr_times = 0; // use this to get how many times the
static bool wake_up_result = false; // use this to judge the wake up event happen or not static bool wake_up_result = false; // use this to judge the wake up event happen or not
#endif #endif
/** /**
* do some initialization operation in this function * do some initialization operation in this function
* @param num: it is the destination GPIO wanted to be initialized * @param num: it is the destination GPIO wanted to be initialized
@ -45,7 +54,7 @@ static bool wake_up_result = false; // use this to judge the wake up event happ
*/ */
static gpio_config_t init_io(gpio_num_t num) static gpio_config_t init_io(gpio_num_t num)
{ {
TEST_ASSERT(num < GPIO_OUTPUT_MAX); TEST_ASSERT(num < TEST_GPIO_OUTPUT_MAX);
gpio_config_t io_conf; gpio_config_t io_conf;
io_conf.intr_type = GPIO_PIN_INTR_DISABLE; io_conf.intr_type = GPIO_PIN_INTR_DISABLE;
io_conf.mode = GPIO_MODE_OUTPUT; io_conf.mode = GPIO_MODE_OUTPUT;
@ -81,11 +90,11 @@ static void gpio_isr_level_handler2(void* arg)
level_intr_times++; level_intr_times++;
ets_printf("GPIO[%d] intr, val: %d\n", gpio_num, gpio_get_level(gpio_num)); ets_printf("GPIO[%d] intr, val: %d\n", gpio_num, gpio_get_level(gpio_num));
if(gpio_get_level(gpio_num)) { if(gpio_get_level(gpio_num)) {
gpio_set_level(GPIO_OUTPUT_IO, 0); gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0);
}else{ }else{
gpio_set_level(GPIO_OUTPUT_IO, 1); gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1);
} }
ets_printf("GPIO[%d] intr, val: %d, level_intr_times = %d\n", GPIO_OUTPUT_IO, gpio_get_level(GPIO_OUTPUT_IO), level_intr_times); ets_printf("GPIO[%d] intr, val: %d, level_intr_times = %d\n", TEST_GPIO_EXT_OUT_IO, gpio_get_level(TEST_GPIO_EXT_OUT_IO), level_intr_times);
ets_printf("GPIO[%d] intr, val: %d, level_intr_times = %d\n", gpio_num, gpio_get_level(gpio_num), level_intr_times); ets_printf("GPIO[%d] intr, val: %d, level_intr_times = %d\n", gpio_num, gpio_get_level(gpio_num), level_intr_times);
} }
#endif #endif
@ -94,10 +103,10 @@ static void gpio_isr_level_handler2(void* arg)
// get result of waking up or not // get result of waking up or not
static void sleep_wake_up(void *arg) static void sleep_wake_up(void *arg)
{ {
gpio_config_t io_config = init_io(GPIO_INPUT_IO); gpio_config_t io_config = init_io(TEST_GPIO_EXT_IN_IO);
io_config.mode = GPIO_MODE_INPUT; io_config.mode = GPIO_MODE_INPUT;
gpio_config(&io_config); gpio_config(&io_config);
TEST_ESP_OK(gpio_wakeup_enable(GPIO_INPUT_IO, GPIO_INTR_HIGH_LEVEL)); TEST_ESP_OK(gpio_wakeup_enable(TEST_GPIO_EXT_IN_IO, GPIO_INTR_HIGH_LEVEL));
esp_light_sleep_start(); esp_light_sleep_start();
wake_up_result = true; wake_up_result = true;
} }
@ -105,12 +114,12 @@ static void sleep_wake_up(void *arg)
// wake up light sleep event // wake up light sleep event
static void trigger_wake_up(void *arg) static void trigger_wake_up(void *arg)
{ {
gpio_config_t io_config = init_io(GPIO_OUTPUT_IO); gpio_config_t io_config = init_io(TEST_GPIO_EXT_OUT_IO);
gpio_config(&io_config); gpio_config(&io_config);
gpio_set_level(GPIO_OUTPUT_IO, 0); gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0);
gpio_install_isr_service(0); gpio_install_isr_service(0);
gpio_isr_handler_add(GPIO_OUTPUT_IO, gpio_isr_level_handler, (void*) GPIO_INPUT_IO); gpio_isr_handler_add(TEST_GPIO_EXT_OUT_IO, gpio_isr_level_handler, (void*) TEST_GPIO_EXT_IN_IO);
gpio_set_level(GPIO_OUTPUT_IO, 1); gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1);
vTaskDelay(100 / portTICK_RATE_MS); vTaskDelay(100 / portTICK_RATE_MS);
} }
#endif #endif
@ -159,27 +168,15 @@ TEST_CASE("GPIO config parameters test", "[gpio]")
io_config.pin_bit_mask = ((uint64_t)1<<GPIO_NUM_MAX); io_config.pin_bit_mask = ((uint64_t)1<<GPIO_NUM_MAX);
TEST_ASSERT(gpio_config(&io_config) == ESP_ERR_INVALID_ARG); TEST_ASSERT(gpio_config(&io_config) == ESP_ERR_INVALID_ARG);
#if CONFIG_IDF_TARGET_ESP32 io_config.pin_bit_mask = ((uint64_t)1<<TEST_GPIO_OUTPUT_PIN);
io_config.pin_bit_mask = (uint64_t)1<<23;
TEST_ESP_OK(gpio_config(&io_config)); TEST_ESP_OK(gpio_config(&io_config));
io_config.pin_bit_mask = ((uint64_t)1 << 34); io_config.pin_bit_mask = ((uint64_t)1 << TEST_GPIO_INPUT_ONLY_PIN);
io_config.mode = GPIO_MODE_INPUT; io_config.mode = GPIO_MODE_INPUT;
TEST_ESP_OK(gpio_config(&io_config)); TEST_ESP_OK(gpio_config(&io_config));
io_config.mode = GPIO_MODE_OUTPUT; io_config.mode = GPIO_MODE_OUTPUT;
// ESP32 34-39 input only, once set as output should log something // The pin is input only, once set as output should log something
TEST_ASSERT(gpio_config(&io_config) == ESP_ERR_INVALID_ARG); TEST_ASSERT(gpio_config(&io_config) == ESP_ERR_INVALID_ARG);
#elif CONFIG_IDF_TARGET_ESP32S2
io_config.pin_bit_mask = (uint64_t)1<<26;
TEST_ESP_OK(gpio_config(&io_config));
io_config.pin_bit_mask = ((uint64_t)1 << 46);
io_config.mode = GPIO_MODE_INPUT;
TEST_ESP_OK(gpio_config(&io_config));
io_config.mode = GPIO_MODE_OUTPUT;
// ESP32-S2 46 input only, once set as output should log something
TEST_ASSERT(gpio_config(&io_config) == ESP_ERR_INVALID_ARG);
#endif
} }
@ -189,69 +186,69 @@ TEST_CASE("GPIO rising edge interrupt test", "[gpio][test_env=UT_T1_GPIO]")
{ {
edge_intr_times = 0; // set it as 0 prepare to test edge_intr_times = 0; // set it as 0 prepare to test
//init input and output gpio //init input and output gpio
gpio_config_t output_io = init_io(GPIO_OUTPUT_IO); gpio_config_t output_io = init_io(TEST_GPIO_EXT_OUT_IO);
gpio_config_t input_io = init_io(GPIO_INPUT_IO); gpio_config_t input_io = init_io(TEST_GPIO_EXT_IN_IO);
input_io.intr_type = GPIO_INTR_POSEDGE; input_io.intr_type = GPIO_INTR_POSEDGE;
input_io.mode = GPIO_MODE_INPUT; input_io.mode = GPIO_MODE_INPUT;
input_io.pull_up_en = 1; input_io.pull_up_en = 1;
TEST_ESP_OK(gpio_config(&output_io)); TEST_ESP_OK(gpio_config(&output_io));
TEST_ESP_OK(gpio_config(&input_io)); TEST_ESP_OK(gpio_config(&input_io));
TEST_ESP_OK(gpio_set_level(GPIO_OUTPUT_IO, 0)); TEST_ESP_OK(gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0));
//rising edge intr //rising edge intr
TEST_ESP_OK(gpio_set_intr_type(GPIO_INPUT_IO, GPIO_INTR_POSEDGE)); TEST_ESP_OK(gpio_set_intr_type(TEST_GPIO_EXT_IN_IO, GPIO_INTR_POSEDGE));
TEST_ESP_OK(gpio_install_isr_service(0)); TEST_ESP_OK(gpio_install_isr_service(0));
gpio_isr_handler_add(GPIO_INPUT_IO, gpio_isr_edge_handler, (void*)GPIO_INPUT_IO); gpio_isr_handler_add(TEST_GPIO_EXT_IN_IO, gpio_isr_edge_handler, (void*)TEST_GPIO_EXT_IN_IO);
TEST_ESP_OK(gpio_set_level(GPIO_OUTPUT_IO, 1)); TEST_ESP_OK(gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1));
TEST_ASSERT_EQUAL_INT(edge_intr_times, 1); TEST_ASSERT_EQUAL_INT(edge_intr_times, 1);
vTaskDelay(100 / portTICK_RATE_MS); vTaskDelay(100 / portTICK_RATE_MS);
gpio_isr_handler_remove(GPIO_INPUT_IO); gpio_isr_handler_remove(TEST_GPIO_EXT_IN_IO);
gpio_uninstall_isr_service(); gpio_uninstall_isr_service();
} }
TEST_CASE("GPIO falling edge interrupt test", "[gpio][test_env=UT_T1_GPIO]") TEST_CASE("GPIO falling edge interrupt test", "[gpio][test_env=UT_T1_GPIO]")
{ {
edge_intr_times = 0; edge_intr_times = 0;
gpio_config_t output_io = init_io(GPIO_OUTPUT_IO); gpio_config_t output_io = init_io(TEST_GPIO_EXT_OUT_IO);
gpio_config_t input_io = init_io(GPIO_INPUT_IO); gpio_config_t input_io = init_io(TEST_GPIO_EXT_IN_IO);
input_io.intr_type = GPIO_INTR_POSEDGE; input_io.intr_type = GPIO_INTR_POSEDGE;
input_io.mode = GPIO_MODE_INPUT; input_io.mode = GPIO_MODE_INPUT;
input_io.pull_up_en = 1; input_io.pull_up_en = 1;
TEST_ESP_OK(gpio_config(&output_io)); TEST_ESP_OK(gpio_config(&output_io));
TEST_ESP_OK(gpio_config(&input_io)); TEST_ESP_OK(gpio_config(&input_io));
TEST_ESP_OK(gpio_set_level(GPIO_OUTPUT_IO, 1)); TEST_ESP_OK(gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1));
gpio_set_intr_type(GPIO_INPUT_IO, GPIO_INTR_NEGEDGE); gpio_set_intr_type(TEST_GPIO_EXT_IN_IO, GPIO_INTR_NEGEDGE);
gpio_install_isr_service(0); gpio_install_isr_service(0);
gpio_isr_handler_add(GPIO_INPUT_IO, gpio_isr_edge_handler, (void*) GPIO_INPUT_IO); gpio_isr_handler_add(TEST_GPIO_EXT_IN_IO, gpio_isr_edge_handler, (void*) TEST_GPIO_EXT_IN_IO);
gpio_set_level(GPIO_OUTPUT_IO, 0); gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0);
vTaskDelay(100 / portTICK_RATE_MS); vTaskDelay(100 / portTICK_RATE_MS);
TEST_ASSERT_EQUAL_INT(edge_intr_times, 1); TEST_ASSERT_EQUAL_INT(edge_intr_times, 1);
vTaskDelay(100 / portTICK_RATE_MS); vTaskDelay(100 / portTICK_RATE_MS);
gpio_isr_handler_remove(GPIO_INPUT_IO); gpio_isr_handler_remove(TEST_GPIO_EXT_IN_IO);
gpio_uninstall_isr_service(); gpio_uninstall_isr_service();
} }
TEST_CASE("GPIO both rising and falling edge interrupt test", "[gpio][test_env=UT_T1_GPIO]") TEST_CASE("GPIO both rising and falling edge interrupt test", "[gpio][test_env=UT_T1_GPIO]")
{ {
edge_intr_times = 0; edge_intr_times = 0;
gpio_config_t output_io = init_io(GPIO_OUTPUT_IO); gpio_config_t output_io = init_io(TEST_GPIO_EXT_OUT_IO);
gpio_config_t input_io = init_io(GPIO_INPUT_IO); gpio_config_t input_io = init_io(TEST_GPIO_EXT_IN_IO);
input_io.intr_type = GPIO_INTR_POSEDGE; input_io.intr_type = GPIO_INTR_POSEDGE;
input_io.mode = GPIO_MODE_INPUT; input_io.mode = GPIO_MODE_INPUT;
input_io.pull_up_en = 1; input_io.pull_up_en = 1;
TEST_ESP_OK(gpio_config(&output_io)); TEST_ESP_OK(gpio_config(&output_io));
TEST_ESP_OK(gpio_config(&input_io)); TEST_ESP_OK(gpio_config(&input_io));
TEST_ESP_OK(gpio_set_level(GPIO_OUTPUT_IO, 0)); TEST_ESP_OK(gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0));
int level = 0; int level = 0;
gpio_set_intr_type(GPIO_INPUT_IO, GPIO_INTR_ANYEDGE); gpio_set_intr_type(TEST_GPIO_EXT_IN_IO, GPIO_INTR_ANYEDGE);
gpio_install_isr_service(0); gpio_install_isr_service(0);
gpio_isr_handler_add(GPIO_INPUT_IO, gpio_isr_edge_handler, (void*) GPIO_INPUT_IO); gpio_isr_handler_add(TEST_GPIO_EXT_IN_IO, gpio_isr_edge_handler, (void*) TEST_GPIO_EXT_IN_IO);
// for rising edge in GPIO_INTR_ANYEDGE // for rising edge in GPIO_INTR_ANYEDGE
while(1) { while(1) {
level = level + 1; level = level + 1;
gpio_set_level(GPIO_OUTPUT_IO, level*0.2); gpio_set_level(TEST_GPIO_EXT_OUT_IO, level*0.2);
if(level > 10) { if(level > 10) {
break; break;
} }
@ -261,7 +258,7 @@ TEST_CASE("GPIO both rising and falling edge interrupt test", "[gpio][test_env=U
// for falling rdge in GPIO_INTR_ANYEDGE // for falling rdge in GPIO_INTR_ANYEDGE
while(1) { while(1) {
level = level - 1; level = level - 1;
gpio_set_level(GPIO_OUTPUT_IO, level/5); gpio_set_level(TEST_GPIO_EXT_OUT_IO, level/5);
if(level < 0) { if(level < 0) {
break; break;
} }
@ -270,29 +267,29 @@ TEST_CASE("GPIO both rising and falling edge interrupt test", "[gpio][test_env=U
vTaskDelay(100 / portTICK_RATE_MS); vTaskDelay(100 / portTICK_RATE_MS);
TEST_ASSERT_EQUAL_INT(edge_intr_times, 2); TEST_ASSERT_EQUAL_INT(edge_intr_times, 2);
vTaskDelay(100 / portTICK_RATE_MS); vTaskDelay(100 / portTICK_RATE_MS);
gpio_isr_handler_remove(GPIO_INPUT_IO); gpio_isr_handler_remove(TEST_GPIO_EXT_IN_IO);
gpio_uninstall_isr_service(); gpio_uninstall_isr_service();
} }
TEST_CASE("GPIO input high level trigger, cut the interrupt source exit interrupt test", "[gpio][test_env=UT_T1_GPIO]") TEST_CASE("GPIO input high level trigger, cut the interrupt source exit interrupt test", "[gpio][test_env=UT_T1_GPIO]")
{ {
level_intr_times=0; level_intr_times=0;
gpio_config_t output_io = init_io(GPIO_OUTPUT_IO); gpio_config_t output_io = init_io(TEST_GPIO_EXT_OUT_IO);
gpio_config_t input_io = init_io(GPIO_INPUT_IO); gpio_config_t input_io = init_io(TEST_GPIO_EXT_IN_IO);
input_io.intr_type = GPIO_INTR_POSEDGE; input_io.intr_type = GPIO_INTR_POSEDGE;
input_io.mode = GPIO_MODE_INPUT; input_io.mode = GPIO_MODE_INPUT;
input_io.pull_up_en = 1; input_io.pull_up_en = 1;
TEST_ESP_OK(gpio_config(&output_io)); TEST_ESP_OK(gpio_config(&output_io));
TEST_ESP_OK(gpio_config(&input_io)); TEST_ESP_OK(gpio_config(&input_io));
TEST_ESP_OK(gpio_set_level(GPIO_OUTPUT_IO, 0)); TEST_ESP_OK(gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0));
gpio_set_intr_type(GPIO_INPUT_IO, GPIO_INTR_HIGH_LEVEL); gpio_set_intr_type(TEST_GPIO_EXT_IN_IO, GPIO_INTR_HIGH_LEVEL);
gpio_install_isr_service(0); gpio_install_isr_service(0);
gpio_isr_handler_add(GPIO_INPUT_IO, gpio_isr_level_handler2, (void*) GPIO_INPUT_IO); gpio_isr_handler_add(TEST_GPIO_EXT_IN_IO, gpio_isr_level_handler2, (void*) TEST_GPIO_EXT_IN_IO);
gpio_set_level(GPIO_OUTPUT_IO, 1); gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1);
vTaskDelay(100 / portTICK_RATE_MS); vTaskDelay(100 / portTICK_RATE_MS);
TEST_ASSERT_EQUAL_INT_MESSAGE(level_intr_times, 1, "go into high-level interrupt more than once with cur interrupt source way"); TEST_ASSERT_EQUAL_INT_MESSAGE(level_intr_times, 1, "go into high-level interrupt more than once with cur interrupt source way");
gpio_isr_handler_remove(GPIO_INPUT_IO); gpio_isr_handler_remove(TEST_GPIO_EXT_IN_IO);
gpio_uninstall_isr_service(); gpio_uninstall_isr_service();
} }
@ -300,80 +297,80 @@ TEST_CASE("GPIO input high level trigger, cut the interrupt source exit interrup
TEST_CASE("GPIO low level interrupt test", "[gpio][test_env=UT_T1_GPIO]") TEST_CASE("GPIO low level interrupt test", "[gpio][test_env=UT_T1_GPIO]")
{ {
disable_intr_times=0; disable_intr_times=0;
gpio_config_t output_io = init_io(GPIO_OUTPUT_IO); gpio_config_t output_io = init_io(TEST_GPIO_EXT_OUT_IO);
gpio_config_t input_io = init_io(GPIO_INPUT_IO); gpio_config_t input_io = init_io(TEST_GPIO_EXT_IN_IO);
input_io.intr_type = GPIO_INTR_POSEDGE; input_io.intr_type = GPIO_INTR_POSEDGE;
input_io.mode = GPIO_MODE_INPUT; input_io.mode = GPIO_MODE_INPUT;
input_io.pull_up_en = 1; input_io.pull_up_en = 1;
TEST_ESP_OK(gpio_config(&output_io)); TEST_ESP_OK(gpio_config(&output_io));
TEST_ESP_OK(gpio_config(&input_io)); TEST_ESP_OK(gpio_config(&input_io));
TEST_ESP_OK(gpio_set_level(GPIO_OUTPUT_IO, 1)); TEST_ESP_OK(gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1));
gpio_set_intr_type(GPIO_INPUT_IO, GPIO_INTR_LOW_LEVEL); gpio_set_intr_type(TEST_GPIO_EXT_IN_IO, GPIO_INTR_LOW_LEVEL);
gpio_install_isr_service(0); gpio_install_isr_service(0);
gpio_isr_handler_add(GPIO_INPUT_IO, gpio_isr_level_handler, (void*) GPIO_INPUT_IO); gpio_isr_handler_add(TEST_GPIO_EXT_IN_IO, gpio_isr_level_handler, (void*) TEST_GPIO_EXT_IN_IO);
gpio_set_level(GPIO_OUTPUT_IO, 0); gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0);
printf("get level:%d\n",gpio_get_level(GPIO_INPUT_IO)); printf("get level:%d\n",gpio_get_level(TEST_GPIO_EXT_IN_IO));
vTaskDelay(100 / portTICK_RATE_MS); vTaskDelay(100 / portTICK_RATE_MS);
TEST_ASSERT_EQUAL_INT_MESSAGE(disable_intr_times, 1, "go into low-level interrupt more than once with disable way"); TEST_ASSERT_EQUAL_INT_MESSAGE(disable_intr_times, 1, "go into low-level interrupt more than once with disable way");
gpio_isr_handler_remove(GPIO_INPUT_IO); gpio_isr_handler_remove(TEST_GPIO_EXT_IN_IO);
gpio_uninstall_isr_service(); gpio_uninstall_isr_service();
} }
TEST_CASE("GPIO multi-level interrupt test, to cut the interrupt source exit interrupt ", "[gpio][test_env=UT_T1_GPIO]") TEST_CASE("GPIO multi-level interrupt test, to cut the interrupt source exit interrupt ", "[gpio][test_env=UT_T1_GPIO]")
{ {
level_intr_times=0; level_intr_times=0;
gpio_config_t output_io = init_io(GPIO_OUTPUT_IO); gpio_config_t output_io = init_io(TEST_GPIO_EXT_OUT_IO);
gpio_config_t input_io = init_io(GPIO_INPUT_IO); gpio_config_t input_io = init_io(TEST_GPIO_EXT_IN_IO);
input_io.intr_type = GPIO_INTR_POSEDGE; input_io.intr_type = GPIO_INTR_POSEDGE;
input_io.mode = GPIO_MODE_INPUT; input_io.mode = GPIO_MODE_INPUT;
input_io.pull_up_en = 1; input_io.pull_up_en = 1;
TEST_ESP_OK(gpio_config(&output_io)); TEST_ESP_OK(gpio_config(&output_io));
TEST_ESP_OK(gpio_config(&input_io)); TEST_ESP_OK(gpio_config(&input_io));
TEST_ESP_OK(gpio_set_level(GPIO_OUTPUT_IO, 0)); TEST_ESP_OK(gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0));
gpio_set_intr_type(GPIO_INPUT_IO, GPIO_INTR_HIGH_LEVEL); gpio_set_intr_type(TEST_GPIO_EXT_IN_IO, GPIO_INTR_HIGH_LEVEL);
gpio_install_isr_service(0); gpio_install_isr_service(0);
gpio_isr_handler_add(GPIO_INPUT_IO, gpio_isr_level_handler2, (void*) GPIO_INPUT_IO); gpio_isr_handler_add(TEST_GPIO_EXT_IN_IO, gpio_isr_level_handler2, (void*) TEST_GPIO_EXT_IN_IO);
gpio_set_level(GPIO_OUTPUT_IO, 1); gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1);
vTaskDelay(100 / portTICK_RATE_MS); vTaskDelay(100 / portTICK_RATE_MS);
TEST_ASSERT_EQUAL_INT_MESSAGE(level_intr_times, 1, "go into high-level interrupt more than once with cur interrupt source way"); TEST_ASSERT_EQUAL_INT_MESSAGE(level_intr_times, 1, "go into high-level interrupt more than once with cur interrupt source way");
gpio_set_level(GPIO_OUTPUT_IO, 1); gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1);
vTaskDelay(200 / portTICK_RATE_MS); vTaskDelay(200 / portTICK_RATE_MS);
TEST_ASSERT_EQUAL_INT_MESSAGE(level_intr_times, 2, "go into high-level interrupt more than once with cur interrupt source way"); TEST_ASSERT_EQUAL_INT_MESSAGE(level_intr_times, 2, "go into high-level interrupt more than once with cur interrupt source way");
gpio_isr_handler_remove(GPIO_INPUT_IO); gpio_isr_handler_remove(TEST_GPIO_EXT_IN_IO);
gpio_uninstall_isr_service(); gpio_uninstall_isr_service();
} }
TEST_CASE("GPIO enable and disable interrupt test", "[gpio][test_env=UT_T1_GPIO]") TEST_CASE("GPIO enable and disable interrupt test", "[gpio][test_env=UT_T1_GPIO]")
{ {
disable_intr_times = 0; disable_intr_times = 0;
gpio_config_t output_io = init_io(GPIO_OUTPUT_IO); gpio_config_t output_io = init_io(TEST_GPIO_EXT_OUT_IO);
gpio_config_t input_io = init_io(GPIO_INPUT_IO); gpio_config_t input_io = init_io(TEST_GPIO_EXT_IN_IO);
input_io.intr_type = GPIO_INTR_POSEDGE; input_io.intr_type = GPIO_INTR_POSEDGE;
input_io.mode = GPIO_MODE_INPUT; input_io.mode = GPIO_MODE_INPUT;
input_io.pull_up_en = 1; input_io.pull_up_en = 1;
TEST_ESP_OK(gpio_config(&output_io)); TEST_ESP_OK(gpio_config(&output_io));
TEST_ESP_OK(gpio_config(&input_io)); TEST_ESP_OK(gpio_config(&input_io));
TEST_ESP_OK(gpio_set_level(GPIO_OUTPUT_IO, 0)); // Because of GPIO_INTR_HIGH_LEVEL interrupt, 0 must be set first TEST_ESP_OK(gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0)); // Because of GPIO_INTR_HIGH_LEVEL interrupt, 0 must be set first
TEST_ESP_OK(gpio_set_intr_type(GPIO_INPUT_IO, GPIO_INTR_HIGH_LEVEL)); TEST_ESP_OK(gpio_set_intr_type(TEST_GPIO_EXT_IN_IO, GPIO_INTR_HIGH_LEVEL));
TEST_ESP_OK(gpio_install_isr_service(0)); TEST_ESP_OK(gpio_install_isr_service(0));
TEST_ESP_OK(gpio_isr_handler_add(GPIO_INPUT_IO, gpio_isr_level_handler, (void*) GPIO_INPUT_IO)); TEST_ESP_OK(gpio_isr_handler_add(TEST_GPIO_EXT_IN_IO, gpio_isr_level_handler, (void*) TEST_GPIO_EXT_IN_IO));
TEST_ESP_OK(gpio_set_level(GPIO_OUTPUT_IO, 1)); TEST_ESP_OK(gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1));
TEST_ESP_OK(gpio_isr_handler_remove(GPIO_INPUT_IO)); TEST_ESP_OK(gpio_isr_handler_remove(TEST_GPIO_EXT_IN_IO));
TEST_ESP_OK(gpio_set_level(GPIO_OUTPUT_IO, 0)); TEST_ESP_OK(gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0));
TEST_ASSERT_EQUAL_INT_MESSAGE(disable_intr_times, 1, "go into high-level interrupt more than once with disable way"); TEST_ASSERT_EQUAL_INT_MESSAGE(disable_intr_times, 1, "go into high-level interrupt more than once with disable way");
// not install service now // not install service now
vTaskDelay(100 / portTICK_RATE_MS); vTaskDelay(100 / portTICK_RATE_MS);
TEST_ESP_OK(gpio_intr_disable(GPIO_INPUT_IO)); TEST_ESP_OK(gpio_intr_disable(TEST_GPIO_EXT_IN_IO));
TEST_ESP_OK(gpio_set_level(GPIO_OUTPUT_IO, 1)); TEST_ESP_OK(gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1));
TEST_ASSERT_EQUAL_INT_MESSAGE(disable_intr_times, 1, "disable interrupt does not work, still go into interrupt!"); TEST_ASSERT_EQUAL_INT_MESSAGE(disable_intr_times, 1, "disable interrupt does not work, still go into interrupt!");
gpio_uninstall_isr_service(); //uninstall the service gpio_uninstall_isr_service(); //uninstall the service
TEST_ASSERT(gpio_isr_handler_add(GPIO_INPUT_IO, gpio_isr_level_handler, (void*) GPIO_INPUT_IO) == ESP_ERR_INVALID_STATE); TEST_ASSERT(gpio_isr_handler_add(TEST_GPIO_EXT_IN_IO, gpio_isr_level_handler, (void*) TEST_GPIO_EXT_IN_IO) == ESP_ERR_INVALID_STATE);
TEST_ASSERT(gpio_isr_handler_remove(GPIO_INPUT_IO) == ESP_ERR_INVALID_STATE); TEST_ASSERT(gpio_isr_handler_remove(TEST_GPIO_EXT_IN_IO) == ESP_ERR_INVALID_STATE);
} }
#endif //DISABLED_FOR_TARGETS(ESP32S2) #endif //DISABLED_FOR_TARGETS(ESP32S2)
@ -384,37 +381,28 @@ TEST_CASE("GPIO set gpio output level test", "[gpio][ignore]")
gpio_config_t io_conf; gpio_config_t io_conf;
io_conf.intr_type = GPIO_PIN_INTR_DISABLE; io_conf.intr_type = GPIO_PIN_INTR_DISABLE;
io_conf.mode = GPIO_MODE_OUTPUT; io_conf.mode = GPIO_MODE_OUTPUT;
io_conf.pin_bit_mask = (1<<GPIO_OUTPUT_IO); io_conf.pin_bit_mask = (1<<TEST_GPIO_EXT_OUT_IO);
io_conf.pull_down_en = 0; io_conf.pull_down_en = 0;
io_conf.pull_up_en = 0; io_conf.pull_up_en = 0;
gpio_config(&io_conf); gpio_config(&io_conf);
io_conf.pin_bit_mask = (1<<GPIO_INPUT_IO); io_conf.pin_bit_mask = (1<<TEST_GPIO_EXT_IN_IO);
io_conf.mode = GPIO_MODE_INPUT; io_conf.mode = GPIO_MODE_INPUT;
gpio_config(&io_conf); gpio_config(&io_conf);
gpio_set_level(GPIO_OUTPUT_IO, 0); gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0);
// tested voltage is around 0v // tested voltage is around 0v
TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), 0, "get level error! the level should be low!"); TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), 0, "get level error! the level should be low!");
vTaskDelay(1000 / portTICK_RATE_MS); vTaskDelay(1000 / portTICK_RATE_MS);
gpio_set_level(GPIO_OUTPUT_IO, 1); gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1);
// tested voltage is around 3.3v // tested voltage is around 3.3v
TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), 1, "get level error! the level should be high!"); TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), 1, "get level error! the level should be high!");
//This IO is just used for input
#if CONFIG_IDF_TARGET_ESP32 io_conf.pin_bit_mask = ((uint64_t)1<<TEST_GPIO_INPUT_ONLY_PIN);
//ESP32 IO34-39 are just used for input
io_conf.pin_bit_mask = ((uint64_t)1<<34);
io_conf.mode = GPIO_MODE_OUTPUT; io_conf.mode = GPIO_MODE_OUTPUT;
gpio_config(&io_conf); gpio_config(&io_conf);
TEST_ASSERT(gpio_config(&io_conf) == ESP_ERR_INVALID_ARG); TEST_ASSERT(gpio_config(&io_conf) == ESP_ERR_INVALID_ARG);
#elif CONFIG_IDF_TARGET_ESP32S2
//ESP32-S2 IO46 are just used for input
io_conf.pin_bit_mask = ((uint64_t)1<<46);
io_conf.mode = GPIO_MODE_OUTPUT;
gpio_config(&io_conf);
TEST_ASSERT(gpio_config(&io_conf) == ESP_ERR_INVALID_ARG);
#endif
} }
// gpio17 connects to 3.3v pin, gpio19 connects to the GND pin // gpio17 connects to 3.3v pin, gpio19 connects to the GND pin
@ -443,24 +431,24 @@ TEST_CASE("GPIO get input level test", "[gpio][ignore]")
TEST_CASE("GPIO io pull up/down function", "[gpio]") TEST_CASE("GPIO io pull up/down function", "[gpio]")
{ {
// First, ensure that the output IO will not affect the level // First, ensure that the output IO will not affect the level
gpio_config_t io_conf = init_io(GPIO_OUTPUT_IO); gpio_config_t io_conf = init_io(TEST_GPIO_EXT_OUT_IO);
gpio_config(&io_conf); gpio_config(&io_conf);
gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_INPUT); gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_INPUT);
io_conf = init_io(GPIO_INPUT_IO); io_conf = init_io(TEST_GPIO_EXT_IN_IO);
gpio_config(&io_conf); gpio_config(&io_conf);
gpio_set_direction(GPIO_INPUT_IO, GPIO_MODE_INPUT); gpio_set_direction(TEST_GPIO_EXT_IN_IO, GPIO_MODE_INPUT);
TEST_ESP_OK(gpio_pullup_en(GPIO_INPUT_IO)); // pull up first TEST_ESP_OK(gpio_pullup_en(TEST_GPIO_EXT_IN_IO)); // pull up first
vTaskDelay(100 / portTICK_RATE_MS); vTaskDelay(100 / portTICK_RATE_MS);
TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), 1, "gpio_pullup_en error, it can't pull up"); TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), 1, "gpio_pullup_en error, it can't pull up");
TEST_ESP_OK(gpio_pulldown_dis(GPIO_INPUT_IO)); //can't be pull down TEST_ESP_OK(gpio_pulldown_dis(TEST_GPIO_EXT_IN_IO)); //can't be pull down
vTaskDelay(100 / portTICK_RATE_MS); vTaskDelay(100 / portTICK_RATE_MS);
TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), 1, "gpio_pulldown_dis error, it can pull down"); TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), 1, "gpio_pulldown_dis error, it can pull down");
TEST_ESP_OK(gpio_pulldown_en(GPIO_INPUT_IO)); // can be pull down now TEST_ESP_OK(gpio_pulldown_en(TEST_GPIO_EXT_IN_IO)); // can be pull down now
vTaskDelay(100 / portTICK_RATE_MS); vTaskDelay(100 / portTICK_RATE_MS);
TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), 0, "gpio_pulldown_en error, it can't pull down"); TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), 0, "gpio_pulldown_en error, it can't pull down");
TEST_ESP_OK(gpio_pullup_dis(GPIO_INPUT_IO)); // can't be pull up TEST_ESP_OK(gpio_pullup_dis(TEST_GPIO_EXT_IN_IO)); // can't be pull up
vTaskDelay(100 / portTICK_RATE_MS); vTaskDelay(100 / portTICK_RATE_MS);
TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), 0, "gpio_pullup_dis error, it can pull up"); TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), 0, "gpio_pullup_dis error, it can pull up");
} }
#if !TEMPORARY_DISABLED_FOR_TARGETS(ESP32S2) #if !TEMPORARY_DISABLED_FOR_TARGETS(ESP32S2)
@ -468,71 +456,71 @@ TEST_CASE("GPIO io pull up/down function", "[gpio]")
TEST_CASE("GPIO output and input mode test", "[gpio][test_env=UT_T1_GPIO]") TEST_CASE("GPIO output and input mode test", "[gpio][test_env=UT_T1_GPIO]")
{ {
//ESP32 connect io18 and io19, ESP32-S2 connect io18 and io21 //ESP32 connect io18 and io19, ESP32-S2 connect io18 and io21
gpio_config_t output_io = init_io(GPIO_OUTPUT_IO); gpio_config_t output_io = init_io(TEST_GPIO_EXT_OUT_IO);
gpio_config_t input_io = init_io(GPIO_INPUT_IO); gpio_config_t input_io = init_io(TEST_GPIO_EXT_IN_IO);
gpio_config(&output_io); gpio_config(&output_io);
gpio_config(&input_io); gpio_config(&input_io);
int level = gpio_get_level(GPIO_INPUT_IO); int level = gpio_get_level(TEST_GPIO_EXT_IN_IO);
//disable mode //disable mode
gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_DISABLE); gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_DISABLE);
gpio_set_direction(GPIO_INPUT_IO, GPIO_MODE_OUTPUT); gpio_set_direction(TEST_GPIO_EXT_IN_IO, GPIO_MODE_OUTPUT);
gpio_set_level(GPIO_OUTPUT_IO, !level); gpio_set_level(TEST_GPIO_EXT_OUT_IO, !level);
TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), level, "direction GPIO_MODE_DISABLE set error, it can output"); TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), level, "direction GPIO_MODE_DISABLE set error, it can output");
//input mode and output mode //input mode and output mode
gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_OUTPUT); gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_OUTPUT);
gpio_set_direction(GPIO_INPUT_IO, GPIO_MODE_INPUT); gpio_set_direction(TEST_GPIO_EXT_IN_IO, GPIO_MODE_INPUT);
gpio_set_level(GPIO_OUTPUT_IO, 1); gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1);
TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), 1, "direction GPIO_MODE_OUTPUT set error, it can't output"); TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), 1, "direction GPIO_MODE_OUTPUT set error, it can't output");
gpio_set_level(GPIO_OUTPUT_IO, 0); gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0);
TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), 0, "direction GPIO_MODE_OUTPUT set error, it can't output"); TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), 0, "direction GPIO_MODE_OUTPUT set error, it can't output");
// open drain mode(output), can just output low level // open drain mode(output), can just output low level
gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_OUTPUT_OD); gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_OUTPUT_OD);
gpio_set_direction(GPIO_INPUT_IO, GPIO_MODE_INPUT); gpio_set_direction(TEST_GPIO_EXT_IN_IO, GPIO_MODE_INPUT);
gpio_set_level(GPIO_OUTPUT_IO, 1); gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1);
TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), 0, "direction GPIO_MODE_OUTPUT set error, it can't output"); TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), 0, "direction GPIO_MODE_OUTPUT set error, it can't output");
gpio_set_level(GPIO_OUTPUT_IO, 0); gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0);
TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), 0, "direction GPIO_MODE_OUTPUT set error, it can't output"); TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), 0, "direction GPIO_MODE_OUTPUT set error, it can't output");
// open drain mode(output and input), can just output low level // open drain mode(output and input), can just output low level
// output test // output test
gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_INPUT_OUTPUT_OD); gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_INPUT_OUTPUT_OD);
gpio_set_direction(GPIO_INPUT_IO, GPIO_MODE_INPUT); gpio_set_direction(TEST_GPIO_EXT_IN_IO, GPIO_MODE_INPUT);
gpio_set_level(GPIO_OUTPUT_IO, 1); gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1);
TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), 0, "direction GPIO_MODE_OUTPUT set error, it can't output"); TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), 0, "direction GPIO_MODE_OUTPUT set error, it can't output");
gpio_set_level(GPIO_OUTPUT_IO, 0); gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0);
TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), 0, "direction GPIO_MODE_OUTPUT set error, it can't output"); TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), 0, "direction GPIO_MODE_OUTPUT set error, it can't output");
// GPIO_MODE_INPUT_OUTPUT mode // GPIO_MODE_INPUT_OUTPUT mode
// output test // output test
level = gpio_get_level(GPIO_INPUT_IO); level = gpio_get_level(TEST_GPIO_EXT_IN_IO);
gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_INPUT_OUTPUT); gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_INPUT_OUTPUT);
gpio_set_direction(GPIO_INPUT_IO, GPIO_MODE_INPUT); gpio_set_direction(TEST_GPIO_EXT_IN_IO, GPIO_MODE_INPUT);
gpio_set_level(GPIO_OUTPUT_IO, !level); gpio_set_level(TEST_GPIO_EXT_OUT_IO, !level);
TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(GPIO_INPUT_IO), !level, "direction set error, it can't output"); TEST_ASSERT_EQUAL_INT_MESSAGE(gpio_get_level(TEST_GPIO_EXT_IN_IO), !level, "direction set error, it can't output");
} }
TEST_CASE("GPIO repeate call service and isr has no memory leak test","[gpio][test_env=UT_T1_GPIO][timeout=90]") TEST_CASE("GPIO repeate call service and isr has no memory leak test","[gpio][test_env=UT_T1_GPIO][timeout=90]")
{ {
gpio_config_t output_io = init_io(GPIO_OUTPUT_IO); gpio_config_t output_io = init_io(TEST_GPIO_EXT_OUT_IO);
gpio_config_t input_io = init_io(GPIO_INPUT_IO); gpio_config_t input_io = init_io(TEST_GPIO_EXT_IN_IO);
input_io.intr_type = GPIO_INTR_POSEDGE; input_io.intr_type = GPIO_INTR_POSEDGE;
input_io.mode = GPIO_MODE_INPUT; input_io.mode = GPIO_MODE_INPUT;
input_io.pull_up_en = 1; input_io.pull_up_en = 1;
TEST_ESP_OK(gpio_config(&output_io)); TEST_ESP_OK(gpio_config(&output_io));
TEST_ESP_OK(gpio_config(&input_io)); TEST_ESP_OK(gpio_config(&input_io));
TEST_ESP_OK(gpio_set_level(GPIO_OUTPUT_IO, 0)); TEST_ESP_OK(gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0));
//rising edge //rising edge
uint32_t size = esp_get_free_heap_size(); uint32_t size = esp_get_free_heap_size();
for(int i=0;i<1000;i++) { for(int i=0;i<1000;i++) {
TEST_ESP_OK(gpio_set_intr_type(GPIO_INPUT_IO, GPIO_INTR_POSEDGE)); TEST_ESP_OK(gpio_set_intr_type(TEST_GPIO_EXT_IN_IO, GPIO_INTR_POSEDGE));
TEST_ESP_OK(gpio_install_isr_service(0)); TEST_ESP_OK(gpio_install_isr_service(0));
TEST_ESP_OK(gpio_isr_handler_add(GPIO_INPUT_IO, gpio_isr_edge_handler, (void*)GPIO_INPUT_IO)); TEST_ESP_OK(gpio_isr_handler_add(TEST_GPIO_EXT_IN_IO, gpio_isr_edge_handler, (void*)TEST_GPIO_EXT_IN_IO));
gpio_set_level(GPIO_OUTPUT_IO, 1); gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1);
TEST_ESP_OK(gpio_isr_handler_remove(GPIO_INPUT_IO)); TEST_ESP_OK(gpio_isr_handler_remove(TEST_GPIO_EXT_IN_IO));
gpio_set_level(GPIO_OUTPUT_IO, 0); gpio_set_level(TEST_GPIO_EXT_OUT_IO, 0);
gpio_uninstall_isr_service(); gpio_uninstall_isr_service();
} }
TEST_ASSERT_INT32_WITHIN(size, esp_get_free_heap_size(), 100); TEST_ASSERT_INT32_WITHIN(size, esp_get_free_heap_size(), 100);
@ -549,8 +537,8 @@ TEST_CASE("GPIO wake up enable and disenable test", "[gpio][ignore]")
TEST_ASSERT_TRUE(wake_up_result); TEST_ASSERT_TRUE(wake_up_result);
wake_up_result = false; wake_up_result = false;
TEST_ESP_OK(gpio_wakeup_disable(GPIO_INPUT_IO)); TEST_ESP_OK(gpio_wakeup_disable(TEST_GPIO_EXT_IN_IO));
gpio_set_level(GPIO_OUTPUT_IO, 1); gpio_set_level(TEST_GPIO_EXT_OUT_IO, 1);
vTaskDelay(100 / portTICK_RATE_MS); vTaskDelay(100 / portTICK_RATE_MS);
TEST_ASSERT_FALSE(wake_up_result); TEST_ASSERT_FALSE(wake_up_result);
} }
@ -560,56 +548,56 @@ TEST_CASE("GPIO wake up enable and disenable test", "[gpio][ignore]")
// ignored because the voltage needs to be tested with multimeter // ignored because the voltage needs to be tested with multimeter
TEST_CASE("GPIO verify only the gpio with input ability can be set pull/down", "[gpio][ignore]") TEST_CASE("GPIO verify only the gpio with input ability can be set pull/down", "[gpio][ignore]")
{ {
gpio_config_t output_io = init_io(GPIO_OUTPUT_IO); gpio_config_t output_io = init_io(TEST_GPIO_EXT_OUT_IO);
gpio_config_t input_io = init_io(GPIO_INPUT_IO); gpio_config_t input_io = init_io(TEST_GPIO_EXT_IN_IO);
gpio_config(&output_io); gpio_config(&output_io);
input_io.mode = GPIO_MODE_INPUT; input_io.mode = GPIO_MODE_INPUT;
gpio_config(&input_io); gpio_config(&input_io);
printf("pull up test!\n"); printf("pull up test!\n");
// pull up test // pull up test
gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_OUTPUT); gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_OUTPUT);
TEST_ESP_OK(gpio_set_pull_mode(GPIO_OUTPUT_IO, GPIO_PULLUP_ONLY)); TEST_ESP_OK(gpio_set_pull_mode(TEST_GPIO_EXT_OUT_IO, GPIO_PULLUP_ONLY));
prompt_to_continue("mode: GPIO_MODE_OUTPUT"); prompt_to_continue("mode: GPIO_MODE_OUTPUT");
gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_OUTPUT_OD); gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_OUTPUT_OD);
TEST_ESP_OK(gpio_set_pull_mode(GPIO_OUTPUT_IO, GPIO_PULLUP_ONLY)); TEST_ESP_OK(gpio_set_pull_mode(TEST_GPIO_EXT_OUT_IO, GPIO_PULLUP_ONLY));
// open drain just can output low level // open drain just can output low level
gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_INPUT_OUTPUT_OD); gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_INPUT_OUTPUT_OD);
TEST_ESP_OK(gpio_set_pull_mode(GPIO_OUTPUT_IO, GPIO_PULLUP_ONLY)); TEST_ESP_OK(gpio_set_pull_mode(TEST_GPIO_EXT_OUT_IO, GPIO_PULLUP_ONLY));
prompt_to_continue("mode: GPIO_MODE_OUTPUT_OD"); prompt_to_continue("mode: GPIO_MODE_OUTPUT_OD");
gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_INPUT_OUTPUT); gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_INPUT_OUTPUT);
TEST_ESP_OK(gpio_set_pull_mode(GPIO_OUTPUT_IO, GPIO_PULLUP_ONLY)); TEST_ESP_OK(gpio_set_pull_mode(TEST_GPIO_EXT_OUT_IO, GPIO_PULLUP_ONLY));
prompt_to_continue("mode: GPIO_MODE_INPUT_OUTPUT"); prompt_to_continue("mode: GPIO_MODE_INPUT_OUTPUT");
gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_INPUT); gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_INPUT);
TEST_ESP_OK(gpio_set_pull_mode(GPIO_OUTPUT_IO, GPIO_PULLUP_ONLY)); TEST_ESP_OK(gpio_set_pull_mode(TEST_GPIO_EXT_OUT_IO, GPIO_PULLUP_ONLY));
prompt_to_continue("mode: GPIO_MODE_INPUT"); prompt_to_continue("mode: GPIO_MODE_INPUT");
// after pull up the level is high now // after pull up the level is high now
// pull down test // pull down test
printf("pull down test!\n"); printf("pull down test!\n");
gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_OUTPUT); gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_OUTPUT);
TEST_ESP_OK(gpio_set_pull_mode(GPIO_OUTPUT_IO, GPIO_PULLDOWN_ONLY)); TEST_ESP_OK(gpio_set_pull_mode(TEST_GPIO_EXT_OUT_IO, GPIO_PULLDOWN_ONLY));
prompt_to_continue("mode: GPIO_MODE_OUTPUT"); prompt_to_continue("mode: GPIO_MODE_OUTPUT");
gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_OUTPUT_OD); gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_OUTPUT_OD);
TEST_ESP_OK(gpio_set_pull_mode(GPIO_OUTPUT_IO, GPIO_PULLDOWN_ONLY)); TEST_ESP_OK(gpio_set_pull_mode(TEST_GPIO_EXT_OUT_IO, GPIO_PULLDOWN_ONLY));
prompt_to_continue("mode: GPIO_MODE_OUTPUT_OD"); prompt_to_continue("mode: GPIO_MODE_OUTPUT_OD");
gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_INPUT_OUTPUT_OD); gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_INPUT_OUTPUT_OD);
TEST_ESP_OK(gpio_set_pull_mode(GPIO_OUTPUT_IO, GPIO_PULLDOWN_ONLY)); TEST_ESP_OK(gpio_set_pull_mode(TEST_GPIO_EXT_OUT_IO, GPIO_PULLDOWN_ONLY));
prompt_to_continue("mode: GPIO_MODE_INPUT_OUTPUT_OD"); prompt_to_continue("mode: GPIO_MODE_INPUT_OUTPUT_OD");
gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_INPUT_OUTPUT); gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_INPUT_OUTPUT);
TEST_ESP_OK(gpio_set_pull_mode(GPIO_OUTPUT_IO, GPIO_PULLDOWN_ONLY)); TEST_ESP_OK(gpio_set_pull_mode(TEST_GPIO_EXT_OUT_IO, GPIO_PULLDOWN_ONLY));
prompt_to_continue("mode: GPIO_MODE_INPUT_OUTPUT"); prompt_to_continue("mode: GPIO_MODE_INPUT_OUTPUT");
gpio_set_direction(GPIO_OUTPUT_IO, GPIO_MODE_INPUT); gpio_set_direction(TEST_GPIO_EXT_OUT_IO, GPIO_MODE_INPUT);
TEST_ESP_OK(gpio_set_pull_mode(GPIO_OUTPUT_IO, GPIO_PULLDOWN_ONLY)); TEST_ESP_OK(gpio_set_pull_mode(TEST_GPIO_EXT_OUT_IO, GPIO_PULLDOWN_ONLY));
prompt_to_continue("mode: GPIO_MODE_INPUT"); prompt_to_continue("mode: GPIO_MODE_INPUT");
} }
@ -642,23 +630,23 @@ TEST_CASE("GPIO verify only the gpio with input ability can be set pull/down", "
TEST_CASE("GPIO drive capability test", "[gpio][ignore]") TEST_CASE("GPIO drive capability test", "[gpio][ignore]")
{ {
printf("weak capability test! please view the current change!\n"); printf("weak capability test! please view the current change!\n");
drive_capability_set_get(GPIO_OUTPUT_IO, GPIO_DRIVE_CAP_0); drive_capability_set_get(TEST_GPIO_EXT_OUT_IO, GPIO_DRIVE_CAP_0);
prompt_to_continue("If this test finishes"); prompt_to_continue("If this test finishes");
printf("stronger capability test! please view the current change!\n"); printf("stronger capability test! please view the current change!\n");
drive_capability_set_get(GPIO_OUTPUT_IO, GPIO_DRIVE_CAP_1); drive_capability_set_get(TEST_GPIO_EXT_OUT_IO, GPIO_DRIVE_CAP_1);
prompt_to_continue("If this test finishes"); prompt_to_continue("If this test finishes");
printf("default capability test! please view the current change!\n"); printf("default capability test! please view the current change!\n");
drive_capability_set_get(GPIO_OUTPUT_IO, GPIO_DRIVE_CAP_2); drive_capability_set_get(TEST_GPIO_EXT_OUT_IO, GPIO_DRIVE_CAP_2);
prompt_to_continue("If this test finishes"); prompt_to_continue("If this test finishes");
printf("default capability2 test! please view the current change!\n"); printf("default capability2 test! please view the current change!\n");
drive_capability_set_get(GPIO_OUTPUT_IO, GPIO_DRIVE_CAP_DEFAULT); drive_capability_set_get(TEST_GPIO_EXT_OUT_IO, GPIO_DRIVE_CAP_DEFAULT);
prompt_to_continue("If this test finishes"); prompt_to_continue("If this test finishes");
printf("strongest capability test! please view the current change!\n"); printf("strongest capability test! please view the current change!\n");
drive_capability_set_get(GPIO_OUTPUT_IO, GPIO_DRIVE_CAP_3); drive_capability_set_get(TEST_GPIO_EXT_OUT_IO, GPIO_DRIVE_CAP_3);
prompt_to_continue("If this test finishes"); prompt_to_continue("If this test finishes");
} }