espressif/esp-idf
1
0
Fork 1
mirror of https://github.com/espressif/esp-idf.git synced 2025-08-07 22:54:33 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'feature/etm_api_update' into 'master'

Browse Source 
etm: introduce config structure for event/task new functions

See merge request espressif/esp-idf!21483
This commit is contained in:
morris
2022-12-12 13:12:09 +08:00
parent 0443865102 5c06e9cf40
commit 7064b668c6
8 changed files with 95 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
components/driver/gptimer/gptimer_etm.c
View File

@@ -33,19 +33,19 @@ static esp_err_t gptimer_del_etm_task(esp_etm_task_t *task)
return ESP_OK; return ESP_OK;
} }
esp_err_t gptimer_new_etm_event(gptimer_handle_t timer, gptimer_etm_event_type_t event_type, esp_etm_event_handle_t *out_event) esp_err_t gptimer_new_etm_event(gptimer_handle_t timer, const gptimer_etm_event_config_t *config, esp_etm_event_handle_t *out_event)
{ {
esp_etm_event_t *event = NULL; esp_etm_event_t *event = NULL;
esp_err_t ret = ESP_OK; esp_err_t ret = ESP_OK;
ESP_GOTO_ON_FALSE(timer && out_event, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument"); ESP_GOTO_ON_FALSE(timer && config && out_event, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
ESP_GOTO_ON_FALSE(event_type < GPTIMER_ETM_EVENT_MAX, ESP_ERR_INVALID_ARG, err, TAG, "invalid event type"); ESP_GOTO_ON_FALSE(config->event_type < GPTIMER_ETM_EVENT_MAX, ESP_ERR_INVALID_ARG, err, TAG, "invalid event type");
event = heap_caps_calloc(1, sizeof(esp_etm_event_t), ETM_MEM_ALLOC_CAPS); event = heap_caps_calloc(1, sizeof(esp_etm_event_t), ETM_MEM_ALLOC_CAPS);
ESP_GOTO_ON_FALSE(event, ESP_ERR_NO_MEM, err, TAG, "no memory for ETM event"); ESP_GOTO_ON_FALSE(event, ESP_ERR_NO_MEM, err, TAG, "no memory for ETM event");
gptimer_group_t *group = timer->group; gptimer_group_t *group = timer->group;
int group_id = group->group_id; int group_id = group->group_id;
int timer_id = timer->timer_id; int timer_id = timer->timer_id;
uint32_t event_id = TIMER_LL_ETM_EVENT_TABLE(group_id, timer_id, event_type); uint32_t event_id = TIMER_LL_ETM_EVENT_TABLE(group_id, timer_id, config->event_type);
ESP_GOTO_ON_FALSE(event_id != 0, ESP_ERR_NOT_SUPPORTED, err, TAG, "not supported event type"); ESP_GOTO_ON_FALSE(event_id != 0, ESP_ERR_NOT_SUPPORTED, err, TAG, "not supported event type");
// fill the ETM event object // fill the ETM event object
@@ -62,19 +62,19 @@ err:
return ret; return ret;
} }
esp_err_t gptimer_new_etm_task(gptimer_handle_t timer, gptimer_etm_task_type_t task_type, esp_etm_task_handle_t *out_task) esp_err_t gptimer_new_etm_task(gptimer_handle_t timer, const gptimer_etm_task_config_t *config, esp_etm_task_handle_t *out_task)
{ {
esp_etm_task_t *task = NULL; esp_etm_task_t *task = NULL;
esp_err_t ret = ESP_OK; esp_err_t ret = ESP_OK;
ESP_GOTO_ON_FALSE(timer && out_task, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument"); ESP_GOTO_ON_FALSE(timer && config && out_task, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
ESP_GOTO_ON_FALSE(task_type < GPTIMER_ETM_TASK_MAX, ESP_ERR_INVALID_ARG, err, TAG, "invalid task type"); ESP_GOTO_ON_FALSE(config->task_type < GPTIMER_ETM_TASK_MAX, ESP_ERR_INVALID_ARG, err, TAG, "invalid task type");
task = heap_caps_calloc(1, sizeof(esp_etm_task_t), ETM_MEM_ALLOC_CAPS); task = heap_caps_calloc(1, sizeof(esp_etm_task_t), ETM_MEM_ALLOC_CAPS);
ESP_GOTO_ON_FALSE(task, ESP_ERR_NO_MEM, err, TAG, "no memory for ETM task"); ESP_GOTO_ON_FALSE(task, ESP_ERR_NO_MEM, err, TAG, "no memory for ETM task");
gptimer_group_t *group = timer->group; gptimer_group_t *group = timer->group;
int group_id = group->group_id; int group_id = group->group_id;
int timer_id = timer->timer_id; int timer_id = timer->timer_id;
uint32_t task_id = TIMER_LL_ETM_TASK_TABLE(group_id, timer_id, task_type); uint32_t task_id = TIMER_LL_ETM_TASK_TABLE(group_id, timer_id, config->task_type);
ESP_GOTO_ON_FALSE(task_id != 0, ESP_ERR_NOT_SUPPORTED, err, TAG, "not supported task type"); ESP_GOTO_ON_FALSE(task_id != 0, ESP_ERR_NOT_SUPPORTED, err, TAG, "not supported task type");
// fill the ETM task object // fill the ETM task object

22
components/driver/include/driver/gptimer_etm.h
View File

@@ -14,20 +14,34 @@
extern "C" { extern "C" {
#endif #endif
/**
* @brief GPTimer ETM event configuration
*/
typedef struct {
gptimer_etm_event_type_t event_type; /*!< GPTimer ETM event type */
} gptimer_etm_event_config_t;
/** /**
* @brief Get the ETM event for GPTimer * @brief Get the ETM event for GPTimer
* *
* @note The created ETM event object can be deleted later by calling `esp_etm_del_event` * @note The created ETM event object can be deleted later by calling `esp_etm_del_event`
* *
* @param[in] timer Timer handle created by `gptimer_new_timer` * @param[in] timer Timer handle created by `gptimer_new_timer`
* @param[in] event_type GPTimer ETM event type * @param[in] config GPTimer ETM event configuration
* @param[out] out_event Returned ETM event handle * @param[out] out_event Returned ETM event handle
* @return * @return
* - ESP_OK: Get ETM event successfully * - ESP_OK: Get ETM event successfully
* - ESP_ERR_INVALID_ARG: Get ETM event failed because of invalid argument * - ESP_ERR_INVALID_ARG: Get ETM event failed because of invalid argument
* - ESP_FAIL: Get ETM event failed because of other error * - ESP_FAIL: Get ETM event failed because of other error
*/ */
esp_err_t gptimer_new_etm_event(gptimer_handle_t timer, gptimer_etm_event_type_t event_type, esp_etm_event_handle_t *out_event); esp_err_t gptimer_new_etm_event(gptimer_handle_t timer, const gptimer_etm_event_config_t *config, esp_etm_event_handle_t *out_event);
/**
* @brief GPTimer ETM task configuration
*/
typedef struct {
gptimer_etm_task_type_t task_type; /*!< GPTimer ETM task type */
} gptimer_etm_task_config_t;
/** /**
* @brief Get the ETM task for GPTimer * @brief Get the ETM task for GPTimer
@@ -35,14 +49,14 @@ esp_err_t gptimer_new_etm_event(gptimer_handle_t timer, gptimer_etm_event_type_t
* @note The created ETM task object can be deleted later by calling `esp_etm_del_task` * @note The created ETM task object can be deleted later by calling `esp_etm_del_task`
* *
* @param[in] timer Timer handle created by `gptimer_new_timer` * @param[in] timer Timer handle created by `gptimer_new_timer`
* @param[in] task_type GPTimer ETM task type * @param[in] config GPTimer ETM task configuration
* @param[out] out_task Returned ETM task handle * @param[out] out_task Returned ETM task handle
* @return * @return
* - ESP_OK: Get ETM task successfully * - ESP_OK: Get ETM task successfully
* - ESP_ERR_INVALID_ARG: Get ETM task failed because of invalid argument * - ESP_ERR_INVALID_ARG: Get ETM task failed because of invalid argument
* - ESP_FAIL: Get ETM task failed because of other error * - ESP_FAIL: Get ETM task failed because of other error
*/ */
esp_err_t gptimer_new_etm_task(gptimer_handle_t timer, gptimer_etm_task_type_t task_type, esp_etm_task_handle_t *out_task); esp_err_t gptimer_new_etm_task(gptimer_handle_t timer, const gptimer_etm_task_config_t *config, esp_etm_task_handle_t *out_task);
#ifdef __cplusplus #ifdef __cplusplus
} }

5
components/esp_hw_support/dma/async_memcpy_impl_gdma.c
View File

@@ -114,7 +114,10 @@ esp_err_t async_memcpy_impl_new_etm_event(async_memcpy_impl_t *impl, async_memcp
{ {
if (event_type == ASYNC_MEMCPY_ETM_EVENT_COPY_DONE) { if (event_type == ASYNC_MEMCPY_ETM_EVENT_COPY_DONE) {
// use the RX EOF to indicate the async memcpy done event // use the RX EOF to indicate the async memcpy done event
return gdma_new_etm_event(impl->rx_channel, GDMA_ETM_EVENT_EOF, out_event); gdma_etm_event_config_t etm_event_conf = {
.event_type = GDMA_ETM_EVENT_EOF,
};
return gdma_new_etm_event(impl->rx_channel, &etm_event_conf, out_event);
} else { } else {
return ESP_ERR_NOT_SUPPORTED; return ESP_ERR_NOT_SUPPORTED;
} }

20
components/esp_hw_support/dma/gdma_etm.c
View File

@@ -49,12 +49,12 @@ static esp_err_t gdma_del_etm_task(esp_etm_task_t *task)
return ESP_OK; return ESP_OK;
} }
esp_err_t gdma_new_etm_event(gdma_channel_handle_t dma_chan, gdma_etm_event_type_t event_type, esp_etm_event_handle_t *out_event) esp_err_t gdma_new_etm_event(gdma_channel_handle_t dma_chan, const gdma_etm_event_config_t *config, esp_etm_event_handle_t *out_event)
{ {
esp_etm_event_t *event = NULL; esp_etm_event_t *event = NULL;
esp_err_t ret = ESP_OK; esp_err_t ret = ESP_OK;
ESP_GOTO_ON_FALSE(dma_chan && out_event, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument"); ESP_GOTO_ON_FALSE(dma_chan && config && out_event, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
ESP_GOTO_ON_FALSE(event_type < GDMA_ETM_EVENT_MAX, ESP_ERR_INVALID_ARG, err, TAG, "invalid event type"); ESP_GOTO_ON_FALSE(config->event_type < GDMA_ETM_EVENT_MAX, ESP_ERR_INVALID_ARG, err, TAG, "invalid event type");
event = heap_caps_calloc(1, sizeof(esp_etm_event_t), ETM_MEM_ALLOC_CAPS); event = heap_caps_calloc(1, sizeof(esp_etm_event_t), ETM_MEM_ALLOC_CAPS);
ESP_GOTO_ON_FALSE(event, ESP_ERR_NO_MEM, err, TAG, "no memory for ETM event"); ESP_GOTO_ON_FALSE(event, ESP_ERR_NO_MEM, err, TAG, "no memory for ETM event");
@@ -63,9 +63,9 @@ esp_err_t gdma_new_etm_event(gdma_channel_handle_t dma_chan, gdma_etm_event_type
uint32_t event_id = 0; uint32_t event_id = 0;
if (dma_chan->direction == GDMA_CHANNEL_DIRECTION_RX) { if (dma_chan->direction == GDMA_CHANNEL_DIRECTION_RX) {
event_id = GDMA_LL_RX_ETM_EVENT_TABLE(group->group_id, pair->pair_id, event_type); event_id = GDMA_LL_RX_ETM_EVENT_TABLE(group->group_id, pair->pair_id, config->event_type);
} else { } else {
event_id = GDMA_LL_TX_ETM_EVENT_TABLE(group->group_id, pair->pair_id, event_type); event_id = GDMA_LL_TX_ETM_EVENT_TABLE(group->group_id, pair->pair_id, config->event_type);
} }
ESP_GOTO_ON_FALSE(event_id != 0, ESP_ERR_NOT_SUPPORTED, err, TAG, "not supported event type"); ESP_GOTO_ON_FALSE(event_id != 0, ESP_ERR_NOT_SUPPORTED, err, TAG, "not supported event type");
@@ -83,12 +83,12 @@ err:
return ret; return ret;
} }
esp_err_t gdma_new_etm_task(gdma_channel_handle_t dma_chan, gdma_etm_task_type_t task_type, esp_etm_task_handle_t *out_task) esp_err_t gdma_new_etm_task(gdma_channel_handle_t dma_chan, const gdma_etm_task_config_t *config, esp_etm_task_handle_t *out_task)
{ {
gdma_etm_task_t *task = NULL; gdma_etm_task_t *task = NULL;
esp_err_t ret = ESP_OK; esp_err_t ret = ESP_OK;
ESP_GOTO_ON_FALSE(dma_chan && out_task, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument"); ESP_GOTO_ON_FALSE(dma_chan && config && out_task, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
ESP_GOTO_ON_FALSE(task_type < GDMA_ETM_TASK_MAX, ESP_ERR_INVALID_ARG, err, TAG, "invalid task type"); ESP_GOTO_ON_FALSE(config->task_type < GDMA_ETM_TASK_MAX, ESP_ERR_INVALID_ARG, err, TAG, "invalid task type");
task = heap_caps_calloc(1, sizeof(gdma_etm_task_t), ETM_MEM_ALLOC_CAPS); task = heap_caps_calloc(1, sizeof(gdma_etm_task_t), ETM_MEM_ALLOC_CAPS);
ESP_GOTO_ON_FALSE(task, ESP_ERR_NO_MEM, err, TAG, "no memory for ETM task"); ESP_GOTO_ON_FALSE(task, ESP_ERR_NO_MEM, err, TAG, "no memory for ETM task");
@@ -97,10 +97,10 @@ esp_err_t gdma_new_etm_task(gdma_channel_handle_t dma_chan, gdma_etm_task_type_t
uint32_t task_id = 0; uint32_t task_id = 0;
if (dma_chan->direction == GDMA_CHANNEL_DIRECTION_RX) { if (dma_chan->direction == GDMA_CHANNEL_DIRECTION_RX) {
task_id = GDMA_LL_RX_ETM_TASK_TABLE(group->group_id, pair->pair_id, task_type); task_id = GDMA_LL_RX_ETM_TASK_TABLE(group->group_id, pair->pair_id, config->task_type);
gdma_ll_rx_enable_etm_task(group->hal.dev, pair->pair_id, true); gdma_ll_rx_enable_etm_task(group->hal.dev, pair->pair_id, true);
} else { } else {
task_id = GDMA_LL_TX_ETM_TASK_TABLE(group->group_id, pair->pair_id, task_type); task_id = GDMA_LL_TX_ETM_TASK_TABLE(group->group_id, pair->pair_id, config->task_type);
gdma_ll_tx_enable_etm_task(group->hal.dev, pair->pair_id, true); gdma_ll_tx_enable_etm_task(group->hal.dev, pair->pair_id, true);
} }
ESP_GOTO_ON_FALSE(task_id != 0, ESP_ERR_NOT_SUPPORTED, err, TAG, "not supported task type"); ESP_GOTO_ON_FALSE(task_id != 0, ESP_ERR_NOT_SUPPORTED, err, TAG, "not supported task type");

22
components/esp_hw_support/include/esp_private/gdma.h
View File

@@ -327,13 +327,20 @@ esp_err_t gdma_append(gdma_channel_handle_t dma_chan);
*/ */
esp_err_t gdma_reset(gdma_channel_handle_t dma_chan); esp_err_t gdma_reset(gdma_channel_handle_t dma_chan);
/**
* @brief GDMA ETM event configuration
*/
typedef struct {
gdma_etm_event_type_t event_type; /*!< GDMA ETM event type */
} gdma_etm_event_config_t;
/** /**
* @brief Get the ETM event for GDMA channel * @brief Get the ETM event for GDMA channel
* *
* @note The created ETM event object can be deleted later by calling `esp_etm_del_event` * @note The created ETM event object can be deleted later by calling `esp_etm_del_event`
* *
* @param[in] dma_chan GDMA channel handle, allocated by `gdma_new_channel` * @param[in] dma_chan GDMA channel handle, allocated by `gdma_new_channel`
* @param[in] event_type GDMA ETM event type * @param[in] config GDMA ETM event configuration
* @param[out] out_event Returned ETM event handle * @param[out] out_event Returned ETM event handle
* @return * @return
* - ESP_OK: Get ETM event successfully * - ESP_OK: Get ETM event successfully
@@ -341,7 +348,14 @@ esp_err_t gdma_reset(gdma_channel_handle_t dma_chan);
* - ESP_ERR_NOT_SUPPORTED: Get ETM event failed because the GDMA hardware doesn't support ETM event * - ESP_ERR_NOT_SUPPORTED: Get ETM event failed because the GDMA hardware doesn't support ETM event
* - ESP_FAIL: Get ETM event failed because of other error * - ESP_FAIL: Get ETM event failed because of other error
*/ */
esp_err_t gdma_new_etm_event(gdma_channel_handle_t dma_chan, gdma_etm_event_type_t event_type, esp_etm_event_handle_t *out_event); esp_err_t gdma_new_etm_event(gdma_channel_handle_t dma_chan, const gdma_etm_event_config_t *config, esp_etm_event_handle_t *out_event);
/**
* @brief GDMA ETM task configuration
*/
typedef struct {
gdma_etm_task_type_t task_type; /*!< GDMA ETM task type */
} gdma_etm_task_config_t;
/** /**
* @brief Get the ETM task for GDMA channel * @brief Get the ETM task for GDMA channel
@@ -349,7 +363,7 @@ esp_err_t gdma_new_etm_event(gdma_channel_handle_t dma_chan, gdma_etm_event_type
* @note The created ETM task object can be deleted later by calling `esp_etm_del_task` * @note The created ETM task object can be deleted later by calling `esp_etm_del_task`
* *
* @param[in] dma_chan GDMA channel handle, allocated by `gdma_new_channel` * @param[in] dma_chan GDMA channel handle, allocated by `gdma_new_channel`
* @param[in] task_type GDMA ETM task type * @param[in] config GDMA ETM task configuration
* @param[out] out_task Returned ETM task handle * @param[out] out_task Returned ETM task handle
* @return * @return
* - ESP_OK: Get ETM task successfully * - ESP_OK: Get ETM task successfully
@@ -357,7 +371,7 @@ esp_err_t gdma_new_etm_event(gdma_channel_handle_t dma_chan, gdma_etm_event_type
* - ESP_ERR_NOT_SUPPORTED: Get ETM task failed because the gdma hardware doesn't support ETM task * - ESP_ERR_NOT_SUPPORTED: Get ETM task failed because the gdma hardware doesn't support ETM task
* - ESP_FAIL: Get ETM task failed because of other error * - ESP_FAIL: Get ETM task failed because of other error
*/ */
esp_err_t gdma_new_etm_task(gdma_channel_handle_t dma_chan, gdma_etm_task_type_t task_type, esp_etm_task_handle_t *out_task); esp_err_t gdma_new_etm_task(gdma_channel_handle_t dma_chan, const gdma_etm_task_config_t *config, esp_etm_task_handle_t *out_task);
#ifdef __cplusplus #ifdef __cplusplus
} }

1
components/esp_hw_support/test_apps/etm/main/test_gdma_etm.c
View File

@@ -69,6 +69,7 @@ TEST_CASE("async_memcpy_eof_event", "[etm]")
printf("start memcpy\r\n"); printf("start memcpy\r\n");
for (int j = 0; j < 19; j++) { for (int j = 0; j < 19; j++) {
TEST_ESP_OK(esp_async_memcpy(mcp_ctx, dst_buf, src_buf, buffer_size, NULL, NULL)); TEST_ESP_OK(esp_async_memcpy(mcp_ctx, dst_buf, src_buf, buffer_size, NULL, NULL));
vTaskDelay(pdMS_TO_TICKS(10));
} }
// simply wait for the last memcpy to finish // simply wait for the last memcpy to finish
vTaskDelay(pdMS_TO_TICKS(1000)); vTaskDelay(pdMS_TO_TICKS(1000));

41
components/esp_hw_support/test_apps/etm/main/test_gptimer_etm.c
View File

@@ -55,7 +55,10 @@ TEST_CASE("gptimer_etm_alarm_event_with_interrupt_enabled", "[etm]")
printf("get gptimer etm event handle\r\n"); printf("get gptimer etm event handle\r\n");
esp_etm_event_handle_t gptimer_event = NULL; esp_etm_event_handle_t gptimer_event = NULL;
TEST_ESP_OK(gptimer_new_etm_event(gptimer, GPTIMER_ETM_EVENT_ALARM_MATCH, &gptimer_event)); gptimer_etm_event_config_t gptimer_etm_event_conf = {
.event_type = GPTIMER_ETM_EVENT_ALARM_MATCH,
};
TEST_ESP_OK(gptimer_new_etm_event(gptimer, &gptimer_etm_event_conf, &gptimer_event));
printf("connect event and task to the channel\r\n"); printf("connect event and task to the channel\r\n");
TEST_ESP_OK(esp_etm_channel_connect(etm_channel_a, gptimer_event, gpio_task)); TEST_ESP_OK(esp_etm_channel_connect(etm_channel_a, gptimer_event, gpio_task));
@@ -136,9 +139,15 @@ TEST_CASE("gptimer_etm_alarm_event_without_interrupt", "[etm]")
printf("get gptimer etm event and task handle\r\n"); printf("get gptimer etm event and task handle\r\n");
esp_etm_event_handle_t gptimer_event = NULL; esp_etm_event_handle_t gptimer_event = NULL;
TEST_ESP_OK(gptimer_new_etm_event(gptimer, GPTIMER_ETM_EVENT_ALARM_MATCH, &gptimer_event)); gptimer_etm_event_config_t gptimer_etm_event_conf = {
.event_type = GPTIMER_ETM_EVENT_ALARM_MATCH,
};
TEST_ESP_OK(gptimer_new_etm_event(gptimer, &gptimer_etm_event_conf, &gptimer_event));
esp_etm_task_handle_t gptimer_task = NULL; esp_etm_task_handle_t gptimer_task = NULL;
TEST_ESP_OK(gptimer_new_etm_task(gptimer, GPTIMER_ETM_TASK_EN_ALARM, &gptimer_task)); gptimer_etm_task_config_t gptimer_etm_task_conf = {
.task_type = GPTIMER_ETM_TASK_EN_ALARM,
};
TEST_ESP_OK(gptimer_new_etm_task(gptimer, &gptimer_etm_task_conf, & gptimer_task));
printf("connect event and task to the channel\r\n"); printf("connect event and task to the channel\r\n");
TEST_ESP_OK(esp_etm_channel_connect(etm_channel_a, gptimer_event, gpio_task)); TEST_ESP_OK(esp_etm_channel_connect(etm_channel_a, gptimer_event, gpio_task));
@@ -220,11 +229,18 @@ TEST_CASE("gptimer_auto_reload_by_etm", "[etm]")
printf("get gptimer etm event and task handle\r\n"); printf("get gptimer etm event and task handle\r\n");
esp_etm_event_handle_t gptimer_event_alarm = NULL; esp_etm_event_handle_t gptimer_event_alarm = NULL;
TEST_ESP_OK(gptimer_new_etm_event(gptimer, GPTIMER_ETM_EVENT_ALARM_MATCH, &gptimer_event_alarm)); gptimer_etm_event_config_t gptimer_etm_event_conf = {
.event_type = GPTIMER_ETM_EVENT_ALARM_MATCH,
};
TEST_ESP_OK(gptimer_new_etm_event(gptimer, &gptimer_etm_event_conf, &gptimer_event_alarm));
esp_etm_task_handle_t gptimer_task_en_alarm = NULL; esp_etm_task_handle_t gptimer_task_en_alarm = NULL;
TEST_ESP_OK(gptimer_new_etm_task(gptimer, GPTIMER_ETM_TASK_EN_ALARM, &gptimer_task_en_alarm)); gptimer_etm_task_config_t gptimer_etm_task_conf = {
.task_type = GPTIMER_ETM_TASK_EN_ALARM,
};
TEST_ESP_OK(gptimer_new_etm_task(gptimer, &gptimer_etm_task_conf, &gptimer_task_en_alarm));
esp_etm_task_handle_t gptimer_task_reload = NULL; esp_etm_task_handle_t gptimer_task_reload = NULL;
TEST_ESP_OK(gptimer_new_etm_task(gptimer, GPTIMER_ETM_TASK_RELOAD, &gptimer_task_reload)); gptimer_etm_task_conf.task_type = GPTIMER_ETM_TASK_RELOAD;
TEST_ESP_OK(gptimer_new_etm_task(gptimer, &gptimer_etm_task_conf, &gptimer_task_reload));
printf("connect event and task to the channel\r\n"); printf("connect event and task to the channel\r\n");
TEST_ESP_OK(esp_etm_channel_connect(etm_channel_a, gptimer_event_alarm, gpio_task)); TEST_ESP_OK(esp_etm_channel_connect(etm_channel_a, gptimer_event_alarm, gpio_task));
@@ -311,7 +327,10 @@ TEST_CASE("gptimer_etm_task_capture", "[etm]")
printf("get gptimer etm task handle\r\n"); printf("get gptimer etm task handle\r\n");
esp_etm_task_handle_t gptimer_task = NULL; esp_etm_task_handle_t gptimer_task = NULL;
TEST_ESP_OK(gptimer_new_etm_task(gptimer, GPTIMER_ETM_TASK_CAPTURE, &gptimer_task)); gptimer_etm_task_config_t gptimer_etm_task_conf = {
.task_type = GPTIMER_ETM_TASK_CAPTURE,
};
TEST_ESP_OK(gptimer_new_etm_task(gptimer, &gptimer_etm_task_conf, &gptimer_task));
printf("connect event and task to the channel\r\n"); printf("connect event and task to the channel\r\n");
TEST_ESP_OK(esp_etm_channel_connect(etm_channel_a, gpio_event, gptimer_task)); TEST_ESP_OK(esp_etm_channel_connect(etm_channel_a, gpio_event, gptimer_task));
@@ -393,8 +412,12 @@ TEST_CASE("gptimer_start_stop_by_etm_task", "[etm]")
printf("get gptimer etm task handle\r\n"); printf("get gptimer etm task handle\r\n");
esp_etm_task_handle_t gptimer_task_start, gptimer_task_stop; esp_etm_task_handle_t gptimer_task_start, gptimer_task_stop;
TEST_ESP_OK(gptimer_new_etm_task(gptimer, GPTIMER_ETM_TASK_START_COUNT, &gptimer_task_start)); gptimer_etm_task_config_t gptimer_etm_task_conf = {
TEST_ESP_OK(gptimer_new_etm_task(gptimer, GPTIMER_ETM_TASK_STOP_COUNT, &gptimer_task_stop)); .task_type = GPTIMER_ETM_TASK_START_COUNT,
};
TEST_ESP_OK(gptimer_new_etm_task(gptimer, &gptimer_etm_task_conf, &gptimer_task_start));
gptimer_etm_task_conf.task_type = GPTIMER_ETM_TASK_STOP_COUNT;
TEST_ESP_OK(gptimer_new_etm_task(gptimer, &gptimer_etm_task_conf, &gptimer_task_stop));
printf("connect event and task to the channel\r\n"); printf("connect event and task to the channel\r\n");
TEST_ESP_OK(esp_etm_channel_connect(etm_channel_a, gpio_event_pos, gptimer_task_start)); TEST_ESP_OK(esp_etm_channel_connect(etm_channel_a, gpio_event_pos, gptimer_task_start));

5
examples/peripherals/timer_group/gptimer_capture_hc_sr04/main/gptimer_capture_hc_sr04.c
View File

@@ -104,7 +104,10 @@ void app_main(void)
ESP_LOGI(TAG, "Get gptimer etm task handle (capture)"); ESP_LOGI(TAG, "Get gptimer etm task handle (capture)");
esp_etm_task_handle_t gptimer_capture_task = NULL; esp_etm_task_handle_t gptimer_capture_task = NULL;
ESP_ERROR_CHECK(gptimer_new_etm_task(gptimer, GPTIMER_ETM_TASK_CAPTURE, &gptimer_capture_task)); gptimer_etm_task_config_t gptimer_etm_task_conf = {
.task_type = GPTIMER_ETM_TASK_CAPTURE,
};
ESP_ERROR_CHECK(gptimer_new_etm_task(gptimer, &gptimer_etm_task_conf, &gptimer_capture_task));
ESP_LOGI(TAG, "Create ETM channel then connect gpio event and gptimer task"); ESP_LOGI(TAG, "Create ETM channel then connect gpio event and gptimer task");
esp_etm_channel_handle_t etm_chan = NULL; esp_etm_channel_handle_t etm_chan = NULL;