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

refactor(system): reformated esp_timer, linux and log comp with astyle

Browse Source
This commit is contained in:
Marius Vikhammer
2024-02-04 14:50:54 +08:00
parent d749575648
commit 77dcb6d46e
19 changed files with 159 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files

174
components/esp_timer/test_apps/main/test_esp_timer.c
View File

@@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@@ -23,12 +23,10 @@
#define SEC (1000000)
#ifdef CONFIG_ESP_TIMER_PROFILING
#define WITH_PROFILING 1
#endif
static void dummy_cb(void* arg)
{
}
@@ -37,14 +35,14 @@ TEST_CASE("esp_timer orders timers correctly", "[esp_timer]")
{
uint64_t timeouts[] = { 10000, 1000, 10000, 5000, 20000, 1000 };
size_t indices[] = { 3, 0, 4, 2, 5, 1 };
const size_t num_timers = sizeof(timeouts)/sizeof(timeouts[0]);
const size_t num_timers = sizeof(timeouts) / sizeof(timeouts[0]);
esp_timer_handle_t handles[num_timers];
char* names[num_timers];
for (size_t i = 0; i < num_timers; ++i) {
asprintf(&names[i], "timer%d", i);
esp_timer_create_args_t args = {
.callback = &dummy_cb,
.name = names[i]
.callback = &dummy_cb,
.name = names[i]
};
TEST_ESP_OK(esp_timer_create(&args, &handles[i]));
TEST_ESP_OK(esp_timer_start_once(handles[i], timeouts[i] * 100));
@@ -96,7 +94,7 @@ static void set_alarm_task(void* arg)
int64_t now = start;
int count = 0;
const int delays[] = {50, 5000, 10000000};
const int delays_count = sizeof(delays)/sizeof(delays[0]);
const int delays_count = sizeof(delays) / sizeof(delays[0]);
while (now - start < test_time_sec * 1000000) {
now = esp_timer_impl_get_time();
esp_timer_impl_set_alarm(now + delays[count % delays_count]);
@@ -132,14 +130,14 @@ TEST_CASE("esp_timer produces correct delay", "[esp_timer]")
int64_t t_end;
esp_timer_handle_t timer1;
esp_timer_create_args_t args = {
.callback = &test_correct_delay_timer_func,
.arg = &t_end,
.name = "timer1"
.callback = &test_correct_delay_timer_func,
.arg = &t_end,
.name = "timer1"
};
TEST_ESP_OK(esp_timer_create(&args, &timer1));
const int delays_ms[] = {20, 100, 200, 250};
const size_t delays_count = sizeof(delays_ms)/sizeof(delays_ms[0]);
const size_t delays_count = sizeof(delays_ms) / sizeof(delays_ms[0]);
ref_clock_init();
for (size_t i = 0; i < delays_count; ++i) {
@@ -157,7 +155,7 @@ TEST_CASE("esp_timer produces correct delay", "[esp_timer]")
}
ref_clock_deinit();
TEST_ESP_OK( esp_timer_dump(stdout) );
TEST_ESP_OK(esp_timer_dump(stdout));
esp_timer_delete(timer1);
}
@@ -182,7 +180,7 @@ static void test_periodic_correct_delays_timer_func(void* arg)
p_args->intervals[p_args->cur_interval++] = ms_diff;
// Deliberately make timer handler run longer.
// We check that this doesn't affect the result.
esp_rom_delay_us(10*1000);
esp_rom_delay_us(10 * 1000);
if (p_args->cur_interval == NUM_INTERVALS) {
printf("done\n");
TEST_ESP_OK(esp_timer_stop(p_args->timer));
@@ -196,9 +194,9 @@ TEST_CASE("periodic esp_timer produces correct delays", "[esp_timer]")
test_periodic_correct_delays_args_t args = {0};
esp_timer_handle_t timer1;
esp_timer_create_args_t create_args = {
.callback = &test_periodic_correct_delays_timer_func,
.arg = &args,
.name = "timer1",
.callback = &test_periodic_correct_delays_timer_func,
.arg = &args,
.name = "timer1",
};
TEST_ESP_OK(esp_timer_create(&create_args, &timer1));
ref_clock_init();
@@ -214,14 +212,13 @@ TEST_CASE("periodic esp_timer produces correct delays", "[esp_timer]")
TEST_ASSERT_INT32_WITHIN(portTICK_PERIOD_MS, (i + 1) * delay_ms, args.intervals[i]);
}
ref_clock_deinit();
TEST_ESP_OK( esp_timer_dump(stdout) );
TEST_ESP_OK(esp_timer_dump(stdout));
TEST_ESP_OK( esp_timer_delete(timer1) );
TEST_ESP_OK(esp_timer_delete(timer1));
vSemaphoreDelete(args.done);
}
#undef NUM_INTERVALS
#define N 5
typedef struct {
@@ -248,7 +245,7 @@ static void test_timers_ordered_correctly_timer_func(void* arg)
int expected_index = p_args->common->order[count];
int ms_since_start = (ref_clock_get() - p_args->t_start) / 1000;
printf("Time %dms, at count %d, expected timer %d, got timer %d\n",
ms_since_start, count, expected_index, p_args->timer_index);
ms_since_start, count, expected_index, p_args->timer_index);
if (expected_index != p_args->timer_index) {
p_args->pass = false;
esp_timer_stop(p_args->timer);
@@ -263,7 +260,7 @@ static void test_timers_ordered_correctly_timer_func(void* arg)
}
int next_interval = p_args->intervals[p_args->intervals_count];
printf("starting timer %d interval #%d, %d ms\n",
p_args->timer_index, p_args->intervals_count, next_interval);
p_args->timer_index, p_args->intervals_count, next_interval);
esp_timer_start_once(p_args->timer, next_interval * 1000);
}
@@ -280,37 +277,36 @@ TEST_CASE("multiple timers are ordered correctly", "[esp_timer]")
int64_t now = ref_clock_get();
test_timers_ordered_correctly_args_t args1 = {
.timer_index = 1,
.intervals = {10, 40, 20, 40, 30},
.common = &common,
.pass = true,
.done = done,
.t_start = now
.timer_index = 1,
.intervals = {10, 40, 20, 40, 30},
.common = &common,
.pass = true,
.done = done,
.t_start = now
};
test_timers_ordered_correctly_args_t args2 = {
.timer_index = 2,
.intervals = {20, 20, 60, 30, 40},
.common = &common,
.pass = true,
.done = done,
.t_start = now
.timer_index = 2,
.intervals = {20, 20, 60, 30, 40},
.common = &common,
.pass = true,
.done = done,
.t_start = now
};
test_timers_ordered_correctly_args_t args3 = {
.timer_index = 3,
.intervals = {30, 30, 60, 30, 10},
.common = &common,
.pass = true,
.done = done,
.t_start = now
.timer_index = 3,
.intervals = {30, 30, 60, 30, 10},
.common = &common,
.pass = true,
.done = done,
.t_start = now
};
esp_timer_create_args_t create_args = {
.callback = &test_timers_ordered_correctly_timer_func,
.arg = &args1,
.name = "1"
.callback = &test_timers_ordered_correctly_timer_func,
.arg = &args1,
.name = "1"
};
TEST_ESP_OK(esp_timer_create(&create_args, &args1.timer));
@@ -337,16 +333,16 @@ TEST_CASE("multiple timers are ordered correctly", "[esp_timer]")
ref_clock_deinit();
TEST_ESP_OK( esp_timer_dump(stdout) );
TEST_ESP_OK(esp_timer_dump(stdout));
TEST_ESP_OK( esp_timer_delete(args1.timer) );
TEST_ESP_OK( esp_timer_delete(args2.timer) );
TEST_ESP_OK( esp_timer_delete(args3.timer) );
TEST_ESP_OK(esp_timer_delete(args1.timer));
TEST_ESP_OK(esp_timer_delete(args2.timer));
TEST_ESP_OK(esp_timer_delete(args3.timer));
}
#undef N
static void test_short_intervals_timer_func(void* arg) {
static void test_short_intervals_timer_func(void* arg)
{
SemaphoreHandle_t done = (SemaphoreHandle_t) arg;
xSemaphoreGive(done);
printf(".");
@@ -361,19 +357,19 @@ TEST_CASE("esp_timer for very short intervals", "[esp_timer]")
SemaphoreHandle_t semaphore = xSemaphoreCreateCounting(2, 0);
esp_timer_create_args_t timer_args = {
.callback = &test_short_intervals_timer_func,
.arg = (void*) semaphore,
.name = "foo"
.callback = &test_short_intervals_timer_func,
.arg = (void*) semaphore,
.name = "foo"
};
esp_timer_handle_t timer1, timer2;
ESP_ERROR_CHECK( esp_timer_create(&timer_args, &timer1) );
ESP_ERROR_CHECK( esp_timer_create(&timer_args, &timer2) );
ESP_ERROR_CHECK(esp_timer_create(&timer_args, &timer1));
ESP_ERROR_CHECK(esp_timer_create(&timer_args, &timer2));
const int timeout_ms = 10;
for (int timeout_delta_us = -150; timeout_delta_us < 150; timeout_delta_us++) {
printf("delta=%d", timeout_delta_us);
ESP_ERROR_CHECK( esp_timer_start_once(timer1, timeout_ms * 1000) );
ESP_ERROR_CHECK( esp_timer_start_once(timer2, timeout_ms * 1000 + timeout_delta_us) );
ESP_ERROR_CHECK(esp_timer_start_once(timer1, timeout_ms * 1000));
ESP_ERROR_CHECK(esp_timer_start_once(timer2, timeout_ms * 1000 + timeout_delta_us));
TEST_ASSERT_EQUAL(pdPASS, xSemaphoreTake(semaphore, timeout_ms * 2));
TEST_ASSERT_EQUAL(pdPASS, xSemaphoreTake(semaphore, timeout_ms * 2));
printf("\n");
@@ -394,7 +390,7 @@ TEST_CASE("esp_timer_get_time call takes less than 1us", "[esp_timer]")
for (int i = 0; i < iter_count; ++i) {
end = esp_timer_get_time();
}
int ns_per_call = (int) ((end - begin) * 1000 / iter_count);
int ns_per_call = (int)((end - begin) * 1000 / iter_count);
TEST_PERFORMANCE_LESS_THAN(ESP_TIMER_GET_TIME_PER_CALL, "%dns", ns_per_call);
}
@@ -415,7 +411,8 @@ typedef struct {
int64_t dummy;
} test_monotonic_values_state_t;
static void timer_test_monotonic_values_task(void* arg) {
static void timer_test_monotonic_values_task(void* arg)
{
test_monotonic_values_state_t* state = (test_monotonic_values_state_t*) arg;
state->pass = true;
@@ -455,7 +452,7 @@ static void timer_test_monotonic_values_task(void* arg) {
state->avg_diff /= state->test_cnt;
xSemaphoreGive(state->done);
vTaskDelete(NULL);
}
}
TEST_CASE("esp_timer_get_time returns monotonic values", "[esp_timer]")
{
@@ -469,11 +466,11 @@ TEST_CASE("esp_timer_get_time returns monotonic values", "[esp_timer]")
}
for (int i = 0; i < portNUM_PROCESSORS; ++i) {
TEST_ASSERT_TRUE( xSemaphoreTake(done, portMAX_DELAY) );
TEST_ASSERT_TRUE(xSemaphoreTake(done, portMAX_DELAY));
printf("CPU%d: %s test_cnt=%d error_cnt=%d avg_diff=%d |max_error|=%d\n",
i, states[i].pass ? "PASS" : "FAIL",
states[i].test_cnt, states[i].error_cnt,
(int) states[i].avg_diff, (int) states[i].max_error);
i, states[i].pass ? "PASS" : "FAIL",
states[i].test_cnt, states[i].error_cnt,
(int) states[i].avg_diff, (int) states[i].max_error);
}
vSemaphoreDelete(done);
@@ -505,13 +502,13 @@ static void test_delete_from_callback_timer_func(void* varg)
TEST_CASE("Can delete timer from callback", "[esp_timer]")
{
test_delete_from_callback_arg_t args = {
.notify_from_timer_cb = xSemaphoreCreateBinary(),
.notify_from_timer_cb = xSemaphoreCreateBinary(),
};
esp_timer_create_args_t timer_args = {
.callback = &test_delete_from_callback_timer_func,
.arg = &args,
.name = "self_deleter"
.callback = &test_delete_from_callback_timer_func,
.arg = &args,
.name = "self_deleter"
};
esp_timer_create(&timer_args, &args.timer);
esp_timer_start_once(args.timer, 10000);
@@ -523,7 +520,6 @@ TEST_CASE("Can delete timer from callback", "[esp_timer]")
vSemaphoreDelete(args.notify_from_timer_cb);
}
typedef struct {
SemaphoreHandle_t delete_start;
SemaphoreHandle_t delete_done;
@@ -561,8 +557,8 @@ TEST_CASE("Can delete timer from a separate task, triggered from callback", "[es
};
esp_timer_create_args_t timer_args = {
.callback = &timer_delete_test_callback,
.arg = &args
.callback = &timer_delete_test_callback,
.arg = &args
};
esp_timer_handle_t timer;
TEST_ESP_OK(esp_timer_create(&timer_args, &timer));
@@ -593,7 +589,8 @@ typedef struct {
int64_t cb_time;
} test_run_when_expected_state_t;
static void test_run_when_expected_timer_func(void* varg) {
static void test_run_when_expected_timer_func(void* varg)
{
test_run_when_expected_state_t* arg = (test_run_when_expected_state_t*) varg;
arg->cb_time = ref_clock_get();
}
@@ -605,8 +602,8 @@ TEST_CASE("after esp_timer_impl_advance, timers run when expected", "[esp_timer]
test_run_when_expected_state_t state = { 0 };
esp_timer_create_args_t timer_args = {
.callback = &test_run_when_expected_timer_func,
.arg = &state
.callback = &test_run_when_expected_timer_func,
.arg = &state
};
esp_timer_handle_t timer;
TEST_ESP_OK(esp_timer_create(&timer_args, &timer));
@@ -668,7 +665,7 @@ TEST_CASE("Can start/stop timer from ISR context", "[esp_timer]")
esp_register_freertos_tick_hook(test_tick_hook);
TEST_ASSERT(xSemaphoreTake(sem, portMAX_DELAY));
esp_deregister_freertos_tick_hook(test_tick_hook);
TEST_ESP_OK( esp_timer_delete(timer1) );
TEST_ESP_OK(esp_timer_delete(timer1));
vSemaphoreDelete(sem);
}
@@ -750,7 +747,6 @@ TEST_CASE("esp_timer_impl_set_alarm does not set an alarm below the current time
TEST_ASSERT(time_jumped == false);
}
static esp_timer_handle_t oneshot_timer;
static void oneshot_timer_callback(void* arg)
@@ -820,7 +816,6 @@ TEST_CASE("Test case when esp_timer_impl_set_alarm needs set timer < now_time",
TEST_ASSERT(alarm_reg <= (count_reg + offset));
}
static void timer_callback5(void* arg)
{
*(int64_t *)arg = esp_timer_get_time();
@@ -875,9 +870,9 @@ TEST_CASE("periodic esp_timer can be restarted", "[esp_timer]")
int timer_trig = 0;
esp_timer_handle_t timer1;
esp_timer_create_args_t create_args = {
.callback = &test_timer_triggered,
.arg = &timer_trig,
.name = "timer1",
.callback = &test_timer_triggered,
.arg = &timer_trig,
.name = "timer1",
};
TEST_ESP_OK(esp_timer_create(&create_args, &timer1));
TEST_ESP_OK(esp_timer_start_periodic(timer1, delay_ms * 1000));
@@ -907,8 +902,8 @@ TEST_CASE("periodic esp_timer can be restarted", "[esp_timer]")
/* Check that the alarm was triggered twice */
TEST_ASSERT_EQUAL(2, timer_trig);
TEST_ESP_OK( esp_timer_stop(timer1) );
TEST_ESP_OK( esp_timer_delete(timer1) );
TEST_ESP_OK(esp_timer_stop(timer1));
TEST_ESP_OK(esp_timer_delete(timer1));
}
TEST_CASE("one-shot esp_timer can be restarted", "[esp_timer]")
@@ -917,9 +912,9 @@ TEST_CASE("one-shot esp_timer can be restarted", "[esp_timer]")
int timer_trig = 0;
esp_timer_handle_t timer1;
esp_timer_create_args_t create_args = {
.callback = &test_timer_triggered,
.arg = &timer_trig,
.name = "timer1",
.callback = &test_timer_triggered,
.arg = &timer_trig,
.name = "timer1",
};
TEST_ESP_OK(esp_timer_create(&create_args, &timer1));
TEST_ESP_OK(esp_timer_start_once(timer1, delay_ms * 1000));
@@ -942,10 +937,9 @@ TEST_CASE("one-shot esp_timer can be restarted", "[esp_timer]")
/* Make sure the timer was triggered */
TEST_ASSERT_EQUAL(0, timer_trig);
TEST_ESP_OK( esp_timer_delete(timer1) );
TEST_ESP_OK(esp_timer_delete(timer1));
}
#ifdef CONFIG_ESP_TIMER_SUPPORTS_ISR_DISPATCH_METHOD
static int64_t old_time[2];
@@ -967,7 +961,7 @@ static void timer_isr_callback(void* arg)
TEST_CASE("Test ESP_TIMER_ISR dispatch method", "[esp_timer]")
{
TEST_ESP_OK(esp_timer_dump(stdout));
int timer[2]= {0, 1};
int timer[2] = {0, 1};
const esp_timer_create_args_t periodic_timer1_args = {
.callback = &timer_isr_callback,
.dispatch_method = ESP_TIMER_ISR,
@@ -1222,7 +1216,8 @@ volatile uint64_t isr_t1;
const uint64_t period_task_ms = 200;
const uint64_t period_isr_ms = 20;
void task_timer_cb(void *arg) {
void task_timer_cb(void *arg)
{
uint64_t t2 = esp_timer_get_time();
uint64_t dt_task_ms = (t2 - task_t1) / 1000;
task_t1 = t2;
@@ -1236,7 +1231,8 @@ void task_timer_cb(void *arg) {
}
}
void IRAM_ATTR isr_timer_cb(void *arg) {
void IRAM_ATTR isr_timer_cb(void *arg)
{
uint64_t t2 = esp_timer_get_time();
uint64_t dt_isr_ms = (t2 - isr_t1) / 1000;
isr_t1 = t2;