mirror of
https://github.com/espressif/esp-idf.git
synced 2024-10-05 20:47:46 -04:00
fc80d3e568
MCPWM group clock pre scale was originally fixed to 2, which is inconvenient. Set group clock prescale dynamically. Now the maximum resolution of the MCPWM timer is up to 160MHz(when the prescale set to 1). And add a resulotion config for MCPWM capture.
171 lines
6.5 KiB
C
171 lines
6.5 KiB
C
/*
|
|
* 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));
|
|
}
|
|
|
|
TEST_CASE("mcpwm_group_set_prescale_dynamically", "[mcpwm]")
|
|
{
|
|
mcpwm_timer_config_t timer_config = {
|
|
.clk_src = MCPWM_TIMER_CLK_SRC_DEFAULT,
|
|
.resolution_hz = 100 * 1000, // 100kHz
|
|
.period_ticks = 400,
|
|
.count_mode = MCPWM_TIMER_COUNT_MODE_UP_DOWN,
|
|
.group_id = 0,
|
|
};
|
|
|
|
mcpwm_timer_handle_t timer = NULL;
|
|
printf("create mcpwm timer\r\n");
|
|
TEST_ESP_OK(mcpwm_new_timer(&timer_config, &timer));
|
|
|
|
mcpwm_operator_config_t operator_config = {
|
|
.group_id = 0,
|
|
};
|
|
mcpwm_oper_handle_t oper = NULL;
|
|
TEST_ESP_OK(mcpwm_new_operator(&operator_config, &oper));
|
|
|
|
mcpwm_generator_config_t generator_config = {
|
|
.gen_gpio_num = 0,
|
|
};
|
|
mcpwm_gen_handle_t generator = NULL;
|
|
TEST_ESP_OK(mcpwm_new_generator(oper, &generator_config, &generator));
|
|
|
|
printf("add carrier to PWM wave\r\n");
|
|
mcpwm_carrier_config_t carrier_config = {
|
|
.clk_src = MCPWM_CARRIER_CLK_SRC_DEFAULT,
|
|
.frequency_hz = 100000, // 100KHz carrier need higher group prescale
|
|
.duty_cycle = 0.5,
|
|
.first_pulse_duration_us = 10,
|
|
};
|
|
|
|
TEST_ESP_ERR(ESP_ERR_INVALID_STATE, mcpwm_operator_apply_carrier(oper, &carrier_config));
|
|
carrier_config.frequency_hz = 2000000; // 2MHz carrier
|
|
carrier_config.first_pulse_duration_us = 5;
|
|
TEST_ESP_OK(mcpwm_operator_apply_carrier(oper, &carrier_config));
|
|
|
|
|
|
TEST_ESP_OK(mcpwm_del_generator(generator));
|
|
TEST_ESP_OK(mcpwm_del_operator(oper));
|
|
TEST_ESP_OK(mcpwm_del_timer(timer));
|
|
}
|