pioduino/esp-idf
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'feature/mcpwm_interrupt_priority' into 'master'

Browse Source 
feat(MCPWM): Support set interrupt priority

Closes IDF-7952

See merge request espressif/esp-idf!25364
This commit is contained in:
morris
2023-08-23 13:43:24 +08:00
parent 52bca70b1a 713324ff9d
commit 329bc7e5e9
20 changed files with 266 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files
components/driver/test_apps/mcpwm/main/CMakeLists.txt
+1
View File
@@ -6,6 +6,7 @@ set(srcs "test_app_main.c"
"test_mcpwm_oper.c"
"test_mcpwm_sync.c"
"test_mcpwm_timer.c"
"test_mcpwm_common.c"
"test_mcpwm_utils.c")
if(CONFIG_MCPWM_ISR_IRAM_SAFE)
components/driver/test_apps/mcpwm/main/test_mcpwm_common.c
+125
View File
@@ -0,0 +1,125 @@
/*
* SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "unity.h"
#include "esp_private/mcpwm.h"
#include "test_mcpwm_utils.h"
#include "driver/mcpwm_prelude.h"
TEST_CASE("mcpwm_set_interrupt_priority", "[mcpwm]")
{
printf("install timer\r\n");
mcpwm_timer_config_t timer_config = {
.group_id = 0,
.clk_src = MCPWM_TIMER_CLK_SRC_DEFAULT,
.resolution_hz = 1 * 1000 * 1000,
.period_ticks = 20 * 1000,
.count_mode = MCPWM_TIMER_COUNT_MODE_UP,
.intr_priority = 3,
};
mcpwm_timer_handle_t timer = NULL;
TEST_ESP_OK(mcpwm_new_timer(&timer_config, &timer));
printf("register event callbacks\r\n");
mcpwm_timer_event_callbacks_t timer_cbs = {
.on_stop = NULL,
.on_full = NULL,
.on_empty = NULL,
};
TEST_ESP_OK(mcpwm_timer_register_event_callbacks(timer, &timer_cbs, NULL));
timer_config.intr_priority = 1;
mcpwm_timer_handle_t timer2 = NULL;
TEST_ESP_ERR(ESP_ERR_INVALID_STATE, mcpwm_new_timer(&timer_config, &timer2));
TEST_ESP_ERR(ESP_ERR_INVALID_ARG, mcpwm_timer_register_event_callbacks(timer2, &timer_cbs, NULL));
printf("install operator\r\n");
mcpwm_operator_config_t operator_config = {
.group_id = 0,
.intr_priority = 0,
};
mcpwm_oper_handle_t oper = NULL;
TEST_ESP_OK(mcpwm_new_operator(&operator_config, &oper));
printf("register event callbacks\r\n");
mcpwm_operator_event_callbacks_t oper_cbs = {
.on_brake_cbc = NULL,
.on_brake_ost = NULL,
};
TEST_ESP_OK(mcpwm_operator_register_event_callbacks(oper, &oper_cbs, NULL));
operator_config.intr_priority = 1;
mcpwm_oper_handle_t oper2 = NULL;
TEST_ESP_ERR(ESP_ERR_INVALID_STATE, mcpwm_new_operator(&operator_config, &oper2));
TEST_ESP_ERR(ESP_ERR_INVALID_ARG, mcpwm_operator_register_event_callbacks(oper2, &oper_cbs, NULL));
printf("install comparator\r\n");
mcpwm_comparator_config_t comparator_config = {
.intr_priority = 0,
};
mcpwm_cmpr_handle_t comparator = NULL;
TEST_ESP_OK(mcpwm_new_comparator(oper, &comparator_config, &comparator));
TEST_ESP_OK(mcpwm_operator_connect_timer(oper, timer));
printf("register event callback\r\n");
mcpwm_comparator_event_callbacks_t comparator_cbs = {
.on_reach = NULL,
};
TEST_ESP_OK(mcpwm_comparator_register_event_callbacks(comparator, &comparator_cbs, NULL));
comparator_config.intr_priority = 1;
mcpwm_cmpr_handle_t comparator2 = NULL;
TEST_ESP_ERR(ESP_ERR_INVALID_STATE, mcpwm_new_comparator(oper, &comparator_config, &comparator2));
TEST_ESP_ERR(ESP_ERR_INVALID_ARG, mcpwm_comparator_register_event_callbacks(comparator2, &comparator_cbs, NULL));
printf("install gpio fault\r\n");
const int fault_gpio = 0;
mcpwm_fault_handle_t fault = NULL;
mcpwm_gpio_fault_config_t gpio_fault_config = {
.group_id = 0,
.gpio_num = fault_gpio,
.intr_priority = 0,
};
TEST_ESP_OK(mcpwm_new_gpio_fault(&gpio_fault_config, &fault));
printf("register event callback\r\n");
mcpwm_fault_event_callbacks_t fault_cbs = {
.on_fault_enter = NULL,
.on_fault_exit = NULL,
};
TEST_ESP_OK(mcpwm_fault_register_event_callbacks(fault, &fault_cbs, NULL));
gpio_fault_config.intr_priority = 1;
mcpwm_fault_handle_t fault2 = NULL;
TEST_ESP_ERR(ESP_ERR_INVALID_STATE, mcpwm_new_gpio_fault(&gpio_fault_config, &fault2));
TEST_ESP_ERR(ESP_ERR_INVALID_ARG, mcpwm_fault_register_event_callbacks(fault2, &fault_cbs, NULL));
printf("install capture timer\r\n");
mcpwm_cap_timer_handle_t cap_timer = NULL;
mcpwm_capture_timer_config_t cap_timer_config = {
.clk_src = MCPWM_CAPTURE_CLK_SRC_DEFAULT,
.group_id = 0,
};
TEST_ESP_OK(mcpwm_new_capture_timer(&cap_timer_config, &cap_timer));
printf("install capture\r\n");
mcpwm_cap_channel_handle_t cap_channel = NULL;
mcpwm_capture_channel_config_t cap_chan_config = {
.gpio_num = -1,
.prescale = 2,
.intr_priority = 3,
};
TEST_ESP_OK(mcpwm_new_capture_channel(cap_timer, &cap_chan_config, &cap_channel));
printf("register event callback\r\n");
mcpwm_capture_event_callbacks_t cap_cbs = {
.on_cap = NULL,
};
TEST_ESP_OK(mcpwm_capture_channel_register_event_callbacks(cap_channel, &cap_cbs, NULL));
cap_chan_config.intr_priority = 1;
mcpwm_cap_channel_handle_t cap_channel2 = NULL;
TEST_ESP_ERR(ESP_ERR_INVALID_STATE, mcpwm_new_capture_channel(cap_timer, &cap_chan_config, &cap_channel2));
TEST_ESP_ERR(ESP_ERR_INVALID_ARG, mcpwm_capture_channel_register_event_callbacks(cap_channel2, &cap_cbs, NULL));
printf("delete all mcpwm objects\r\n");
TEST_ESP_OK(mcpwm_del_comparator(comparator));
TEST_ESP_OK(mcpwm_del_operator(oper));
TEST_ESP_OK(mcpwm_del_capture_channel(cap_channel));
TEST_ESP_OK(mcpwm_del_capture_timer(cap_timer));
TEST_ESP_OK(mcpwm_del_timer(timer));
TEST_ESP_OK(mcpwm_del_fault(fault));
}
components/driver/test_apps/mcpwm/main/test_mcpwm_gen.c
+14 -14
View File
@@ -767,6 +767,7 @@ TEST_CASE("mcpwm_duty_empty_full", "[mcpwm]")
TEST_CASE("mcpwm_generator_action_on_fault_trigger_event", "[mcpwm]")
{
const int generator_gpio = 0;
const int fault_gpio_num[3] = {2, 4, 5};
printf("create timer and operator\r\n");
mcpwm_operator_config_t oper_config = {
@@ -777,17 +778,16 @@ TEST_CASE("mcpwm_generator_action_on_fault_trigger_event", "[mcpwm]")
printf("install gpio faults trigger\r\n");
mcpwm_fault_handle_t gpio_faults[3];
mcpwm_gpio_fault_config_t gpio_trigger_config[3];
gpio_trigger_config[0].gpio_num = 2;
gpio_trigger_config[1].gpio_num = 4;
gpio_trigger_config[2].gpio_num = 5;
mcpwm_gpio_fault_config_t gpio_trigger_config = {
.group_id = 0,
.flags.active_level = 1,
.flags.pull_down = 1,
.flags.pull_up = 0,
.flags.io_loop_back = 1, // so that we can write the GPIO value by GPIO driver
};
for (int i = 0 ; i < 3; i++) {
gpio_trigger_config[i].group_id = 0;
gpio_trigger_config[i].flags.active_level = 1;
gpio_trigger_config[i].flags.pull_down = 1;
gpio_trigger_config[i].flags.pull_up = 0;
gpio_trigger_config[i].flags.io_loop_back = 1; // so that we can write the GPIO value by GPIO driver
TEST_ESP_OK(mcpwm_new_gpio_fault(&gpio_trigger_config[i], &gpio_faults[i]));
gpio_trigger_config.gpio_num = fault_gpio_num[i];
TEST_ESP_OK(mcpwm_new_gpio_fault(&gpio_trigger_config, &gpio_faults[i]));
}
printf("create generator\r\n");
@@ -808,14 +808,14 @@ TEST_CASE("mcpwm_generator_action_on_fault_trigger_event", "[mcpwm]")
MCPWM_GEN_FAULT_EVENT_ACTION(MCPWM_TIMER_DIRECTION_UP, gpio_faults[2], MCPWM_GEN_ACTION_LOW)));
TEST_ASSERT_EQUAL(0, gpio_get_level(generator_gpio));
gpio_set_level(gpio_trigger_config[0].gpio_num, 1);
gpio_set_level(gpio_trigger_config[0].gpio_num, 0);
gpio_set_level(fault_gpio_num[0], 1);
gpio_set_level(fault_gpio_num[0], 0);
TEST_ASSERT_EQUAL(1, gpio_get_level(generator_gpio));
vTaskDelay(pdMS_TO_TICKS(10));
TEST_ASSERT_EQUAL(1, gpio_get_level(generator_gpio));
gpio_set_level(gpio_trigger_config[1].gpio_num, 1);
gpio_set_level(gpio_trigger_config[1].gpio_num, 0);
gpio_set_level(fault_gpio_num[1], 1);
gpio_set_level(fault_gpio_num[1], 0);
TEST_ASSERT_EQUAL(0, gpio_get_level(generator_gpio));
vTaskDelay(pdMS_TO_TICKS(10));
components/driver/test_apps/mcpwm/main/test_mcpwm_utils.c
+1 -1
View File
@@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/