/* * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Unlicense OR CC0-1.0 */ /* ---------------------------------------------------------- README ------------------------------------------------ * This doc is aimed at explain some important code block and do some records for the test result, if developer or * test-owner has some question in reading this code implementation, please read it first. * * CODE Block: * `code-block-1`: Touch Element lib need some time to finish the initialization so as to configure the right threshold. * Since some hardware issue(Must to pass 2 times "meas_done" interrupt), Touch Element lib will spend * some time(Maybe <30ms) to finish the initialization, every operations (interrupts) happen to touch * sensor will be ignored before initialization. That's why "vTaskDelay()" could be saw in after call * "touch_element_start()". However, this just for the unit test, in the real application, users don't * need to delay something. * * NOTES: * `Simulator`: Currently the event simulator depend on the touch sensor driver and play some "hack" in some register so * as to raise a FAKE interrupt. It means that Touch Element lib test case must be burned on dev-kit and keep * the touch channel as clean as possible, ESP32-S2-Saola is good test board. //TODO: Remove the dependent of touch sensor driver. ------------------------------------------------------------------------------------------------------------------ */ #include #include #include #include #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include "freertos/queue.h" #include "freertos/semphr.h" #include "unity.h" #include "touch_element/touch_button.h" #include "touch_element/touch_slider.h" #include "touch_element/touch_matrix.h" typedef struct { QueueHandle_t valid_msg_handle; SemaphoreHandle_t response_sig_handle; } test_monitor_t; /* ------------------------------------------------------------------------------------------------------------------ */ extern void test_button_event_simulator(touch_button_handle_t button_handle, touch_button_event_t button_event); extern void test_button_handler(touch_button_handle_t handle, touch_button_message_t *message, void *arg); extern void test_button_event_check(touch_elem_message_t *valid_message, touch_elem_message_t *current_message); extern void test_button_event_trigger_and_check(touch_button_handle_t handle, touch_button_event_t button_event); extern void test_button_callback_trigger_and_check(touch_button_handle_t handle, touch_button_event_t button_event, bool should_trigger, test_monitor_t *monitor); extern void test_slider_event_simulator(touch_slider_handle_t slider_handle, touch_slider_event_t slider_event, uint32_t random); extern void test_slider_event_check(touch_elem_message_t *valid_message, touch_elem_message_t *current_message); extern void test_matrix_event_simulator(touch_matrix_handle_t matrix_handle, touch_matrix_event_t matrix_event, uint32_t pos_index); extern void test_matrix_event_check(touch_elem_message_t *valid_message, touch_elem_message_t *current_message); /* ------------------------------------------------------------------------------------------------------------------ */ static void test_waterproof_event_simulator(touch_pad_t guard_channel, touch_button_event_t guard_state); static void test_system_waterproof_guard(void); static void test_integrat_btn_sld_mat(void); static void test_integration_monitor_task(void *arg); /* ------------------------------------------------------------------------------------------------------------------ */ TEST_CASE("Touch element integration test", "[touch_element]") { touch_elem_global_config_t global_config = TOUCH_ELEM_GLOBAL_DEFAULT_CONFIG(); TEST_ESP_OK(touch_element_install(&global_config)); test_integrat_btn_sld_mat(); touch_element_uninstall(); } TEST_CASE("Touch element waterproof test", "[touch_element]") { touch_elem_global_config_t global_config = TOUCH_ELEM_GLOBAL_DEFAULT_CONFIG(); TEST_ESP_OK(touch_element_install(&global_config)); test_system_waterproof_guard(); //TODO: add waterproof work with slider and matrix touch_element_uninstall(); } static void test_system_waterproof_guard(void) { static const touch_pad_t button_channel_array[12] = { TOUCH_PAD_NUM1, TOUCH_PAD_NUM2, TOUCH_PAD_NUM3, TOUCH_PAD_NUM4, TOUCH_PAD_NUM5, TOUCH_PAD_NUM6, TOUCH_PAD_NUM7, TOUCH_PAD_NUM8, TOUCH_PAD_NUM9, TOUCH_PAD_NUM10, TOUCH_PAD_NUM11, TOUCH_PAD_NUM12 }; const uint8_t BUTTON_CHANNEL_NUM = sizeof(button_channel_array) / sizeof(touch_pad_t); test_monitor_t monitor; touch_button_handle_t button_handle[BUTTON_CHANNEL_NUM]; monitor.valid_msg_handle = xQueueCreate(10, sizeof(touch_elem_message_t)); monitor.response_sig_handle = xSemaphoreCreateBinary(); TEST_ASSERT(monitor.valid_msg_handle != NULL || monitor.response_sig_handle != NULL); touch_button_global_config_t global_config = TOUCH_BUTTON_GLOBAL_DEFAULT_CONFIG(); TEST_ESP_OK(touch_button_install(&global_config)); for (int i = 0; i < BUTTON_CHANNEL_NUM; i++) { touch_button_config_t button_config = { .channel_num = button_channel_array[i], .channel_sens = 0.1F }; TEST_ESP_OK(touch_button_create(&button_config, &button_handle[i])); TEST_ESP_OK(touch_button_subscribe_event(button_handle[i], TOUCH_ELEM_EVENT_ON_PRESS | TOUCH_ELEM_EVENT_ON_RELEASE, (void *)&monitor)); TEST_ESP_OK(touch_button_set_dispatch_method(button_handle[i], TOUCH_ELEM_DISP_CALLBACK)); TEST_ESP_OK(touch_button_set_callback(button_handle[i], test_button_handler)); } printf("Touch Element waterproof guard sensor test start\n"); srandom((unsigned int)time(NULL)); {//No use waterproof guard sensor touch_elem_waterproof_config_t waterproof_config = { .guard_channel = TOUCH_WATERPROOF_GUARD_NOUSE, .guard_sensitivity = 0.0F }; TEST_ESP_OK(touch_element_waterproof_install(&waterproof_config)); TEST_ESP_OK(touch_element_start()); vTaskDelay(pdMS_TO_TICKS(500)); //Mention in README, code-block-1 for (int i = 0; i < 10; i++) { //Start state test printf("Touch Element waterproof no-use guard sensor test... (%d/10)\n", i + 1); touch_button_handle_t current_handle = button_handle[random() % 12]; test_button_callback_trigger_and_check(current_handle, TOUCH_BUTTON_EVT_ON_PRESS, true, &monitor); test_button_callback_trigger_and_check(current_handle, TOUCH_BUTTON_EVT_ON_RELEASE, true, &monitor); } TEST_ESP_OK(touch_element_stop()); touch_element_waterproof_uninstall(); } {//Use waterproof guard sensor(Add all handles) touch_elem_waterproof_config_t waterproof_config = { .guard_channel = TOUCH_PAD_NUM13, .guard_sensitivity = 0.1F }; TEST_ESP_OK(touch_element_waterproof_install(&waterproof_config)); for (int i = 0; i < BUTTON_CHANNEL_NUM; i++) { TEST_ESP_OK(touch_element_waterproof_add(button_handle[i])); } TEST_ESP_OK(touch_element_start()); vTaskDelay(pdMS_TO_TICKS(500)); //Mention in README, code-block-1 for (int i = 0; i < 10; i++) { printf("Touch Element waterproof use guard sensor random trigger test... (%d/10)\n", i + 1); bool should_trigger = random() % 2; if (should_trigger) { touch_button_handle_t current_handle = button_handle[random() % 12]; test_button_callback_trigger_and_check(current_handle, TOUCH_BUTTON_EVT_ON_PRESS, should_trigger, &monitor); test_button_callback_trigger_and_check(current_handle, TOUCH_BUTTON_EVT_ON_RELEASE, should_trigger, &monitor); } else { test_waterproof_event_simulator(waterproof_config.guard_channel, TOUCH_BUTTON_EVT_ON_PRESS); //Waterproof guard sensor trigger touch_button_handle_t current_handle = button_handle[random() % 12]; test_button_callback_trigger_and_check(current_handle, TOUCH_BUTTON_EVT_ON_PRESS, should_trigger, &monitor); test_button_callback_trigger_and_check(current_handle, TOUCH_BUTTON_EVT_ON_RELEASE, should_trigger, &monitor); test_waterproof_event_simulator(waterproof_config.guard_channel, TOUCH_BUTTON_EVT_ON_RELEASE); //Waterproof guard sensor release } } TEST_ESP_OK(touch_element_stop()); touch_element_waterproof_uninstall(); } {//Put half button handles into guard ring const uint8_t protect_handle_threshold = BUTTON_CHANNEL_NUM / 2; touch_elem_waterproof_config_t waterproof_config = { .guard_channel = TOUCH_PAD_NUM13, .guard_sensitivity = 0.1F }; TEST_ESP_OK(touch_element_waterproof_install(&waterproof_config)); for (int i = 0; i < protect_handle_threshold; i++) { TEST_ESP_OK(touch_element_waterproof_add(button_handle[i])); } TEST_ESP_OK(touch_element_start()); vTaskDelay(pdMS_TO_TICKS(500)); //Mention in README, code-block-1 for (int i = 0; i < 10; i++) { printf("Touch Element waterproof use guard sensor test(guard sensor is triggered will half button handles)... (%d/10)\n", i + 1); test_waterproof_event_simulator(waterproof_config.guard_channel, TOUCH_BUTTON_EVT_ON_PRESS); //Waterproof guard sensor trigger uint32_t handle_index = random() % 12; touch_button_handle_t current_handle = button_handle[handle_index]; bool should_trigger = (handle_index < protect_handle_threshold) ? false : true; test_button_callback_trigger_and_check(current_handle, TOUCH_BUTTON_EVT_ON_PRESS, should_trigger, &monitor); test_button_callback_trigger_and_check(current_handle, TOUCH_BUTTON_EVT_ON_RELEASE, should_trigger, &monitor); test_waterproof_event_simulator(waterproof_config.guard_channel, TOUCH_BUTTON_EVT_ON_RELEASE); //Waterproof guard sensor release } TEST_ESP_OK(touch_element_stop()); touch_element_waterproof_uninstall(); } for (int i = 0; i < BUTTON_CHANNEL_NUM; i++) { TEST_ESP_OK(touch_button_delete(button_handle[i])); } touch_button_uninstall(); vQueueDelete(monitor.valid_msg_handle); vSemaphoreDelete(monitor.response_sig_handle); printf("Touch Element waterproof guard sensor test finish\n"); } static void test_waterproof_event_simulator(touch_pad_t guard_channel, touch_button_event_t guard_state) { if (guard_state == TOUCH_BUTTON_EVT_ON_PRESS) { touch_pad_set_cnt_mode(guard_channel, TOUCH_PAD_SLOPE_3, TOUCH_PAD_TIE_OPT_DEFAULT); } else if (guard_state == TOUCH_BUTTON_EVT_ON_RELEASE) { touch_pad_set_cnt_mode(guard_channel, TOUCH_PAD_SLOPE_7, TOUCH_PAD_TIE_OPT_DEFAULT); } else { printf("guard sensor simulator doesn't support this operation\n"); } /* Fixme: If the normal instance and guard sensor trigger at the same time, guard sensor will lock the state failed */ vTaskDelay(pdMS_TO_TICKS(100)); } static void test_integrat_btn_sld_mat(void) { static const touch_pad_t button_channel_array[3] = { TOUCH_PAD_NUM1, TOUCH_PAD_NUM2, TOUCH_PAD_NUM3 }; static const float button_sens_array[3] = { 0.1F, 0.1F, 0.1F }; static const touch_pad_t slider_channel_array[5] = { TOUCH_PAD_NUM4, TOUCH_PAD_NUM5, TOUCH_PAD_NUM6, TOUCH_PAD_NUM7, TOUCH_PAD_NUM8 }; static const float slider_sens_array[5] = { 0.1F, 0.1F, 0.1F, 0.1F, 0.1F }; static const touch_pad_t x_axis_channel[3] = { TOUCH_PAD_NUM9, TOUCH_PAD_NUM10, TOUCH_PAD_NUM11, }; static const touch_pad_t y_axis_channel[3] = { TOUCH_PAD_NUM12, TOUCH_PAD_NUM13, TOUCH_PAD_NUM14, }; static const float x_axis_channel_sens[3] = { 0.1F, 0.1F, 0.1F, }; static const float y_axis_channel_sens[3] = { 0.1F, 0.1F, 0.1F, }; const uint8_t BUTTON_CHANNEL_NUM = sizeof(button_channel_array) / sizeof(touch_pad_t); const uint8_t SLIDER_CHANNEL_NUM = sizeof(slider_channel_array) / sizeof(touch_pad_t); const uint8_t MATRIX_CHANNEL_NUM_X = sizeof(x_axis_channel) / sizeof(touch_pad_t); const uint8_t MATRIX_CHANNEL_NUM_Y = sizeof(y_axis_channel) / sizeof(touch_pad_t); printf("Integration test(button + slider + matrix) start\n"); BaseType_t os_ret; touch_button_handle_t button_handle[BUTTON_CHANNEL_NUM]; touch_slider_handle_t slider_handle; touch_matrix_handle_t matrix_handle; test_monitor_t monitor; TaskHandle_t task_handle = NULL; monitor.valid_msg_handle = xQueueCreate(10, sizeof(touch_elem_message_t)); monitor.response_sig_handle = xSemaphoreCreateBinary(); os_ret = xTaskCreate(&test_integration_monitor_task, "test_integration_monitor_task", 4096, (void *)&monitor, 5, &task_handle); TEST_ASSERT(monitor.valid_msg_handle != NULL && monitor.response_sig_handle != NULL && os_ret == pdPASS); touch_button_global_config_t button_global_config = TOUCH_BUTTON_GLOBAL_DEFAULT_CONFIG(); touch_slider_global_config_t slider_global_config = TOUCH_SLIDER_GLOBAL_DEFAULT_CONFIG(); touch_matrix_global_config_t matrix_global_config = TOUCH_MATRIX_GLOBAL_DEFAULT_CONFIG(); TEST_ESP_OK(touch_button_install(&button_global_config)); TEST_ESP_OK(touch_slider_install(&slider_global_config)); TEST_ESP_OK(touch_matrix_install(&matrix_global_config)); for (int i = 0; i < BUTTON_CHANNEL_NUM; i++) { touch_button_config_t button_config = { .channel_num = button_channel_array[i], .channel_sens = button_sens_array[i] }; TEST_ESP_OK(touch_button_create(&button_config, &button_handle[i])); TEST_ESP_OK(touch_button_subscribe_event(button_handle[i], TOUCH_ELEM_EVENT_ON_PRESS | TOUCH_ELEM_EVENT_ON_RELEASE, NULL)); TEST_ESP_OK(touch_button_set_dispatch_method(button_handle[i], TOUCH_ELEM_DISP_EVENT)); } touch_slider_config_t slider_config = { .channel_array = slider_channel_array, .sensitivity_array = slider_sens_array, .channel_num = SLIDER_CHANNEL_NUM, .position_range = 101 }; TEST_ESP_OK(touch_slider_create(&slider_config, &slider_handle)); TEST_ESP_OK(touch_slider_subscribe_event(slider_handle, TOUCH_ELEM_EVENT_ON_PRESS | TOUCH_ELEM_EVENT_ON_RELEASE, NULL)); TEST_ESP_OK(touch_slider_set_dispatch_method(slider_handle, TOUCH_ELEM_DISP_EVENT)); touch_matrix_config_t matrix_config = { .x_channel_array = x_axis_channel, .y_channel_array = y_axis_channel, .x_sensitivity_array = x_axis_channel_sens, .y_sensitivity_array = y_axis_channel_sens, .x_channel_num = MATRIX_CHANNEL_NUM_X, .y_channel_num = MATRIX_CHANNEL_NUM_Y }; TEST_ESP_OK(touch_matrix_create(&matrix_config, &matrix_handle)); TEST_ESP_OK(touch_matrix_subscribe_event(matrix_handle, TOUCH_ELEM_EVENT_ON_PRESS | TOUCH_ELEM_EVENT_ON_RELEASE, NULL)); TEST_ESP_OK(touch_matrix_set_dispatch_method(matrix_handle, TOUCH_ELEM_DISP_EVENT)); TEST_ESP_OK(touch_element_start()); vTaskDelay(pdMS_TO_TICKS(500)); //Mention in README, code-block-1 srandom((unsigned int)time(NULL)); for (int i = 0; i < 30; i++) { printf("Integration test... (%d/30)\n", i + 1); touch_elem_message_t valid_message; touch_button_message_t button_message; touch_slider_message_t slider_message; touch_matrix_message_t matrix_message; valid_message.element_type = (random() % (TOUCH_ELEM_TYPE_MATRIX + 1)); if (valid_message.element_type == TOUCH_ELEM_TYPE_BUTTON) { uint32_t button_index = random() % BUTTON_CHANNEL_NUM; valid_message.handle = button_handle[button_index]; button_message.event = TOUCH_BUTTON_EVT_ON_PRESS; memcpy(valid_message.child_msg, &button_message, sizeof(button_message)); //Construct child message xQueueSend(monitor.valid_msg_handle, &valid_message, portMAX_DELAY); test_button_event_simulator(valid_message.handle, button_message.event); } else if (valid_message.element_type == TOUCH_ELEM_TYPE_SLIDER) { valid_message.handle = slider_handle; slider_message.event = TOUCH_SLIDER_EVT_ON_PRESS; slider_message.position = 0; //No check memcpy(valid_message.child_msg, &slider_message, sizeof(slider_message)); //Construct child message xQueueSend(monitor.valid_msg_handle, &valid_message, portMAX_DELAY); test_slider_event_simulator(valid_message.handle, slider_message.event, 1); } else if (valid_message.element_type == TOUCH_ELEM_TYPE_MATRIX) { uint32_t matrix_x_axis_index = random() % MATRIX_CHANNEL_NUM_X; uint32_t matrix_y_axis_index = random() % MATRIX_CHANNEL_NUM_Y; valid_message.handle = matrix_handle; matrix_message.event = TOUCH_MATRIX_EVT_ON_PRESS; matrix_message.position.x_axis = matrix_x_axis_index; matrix_message.position.y_axis = matrix_y_axis_index; matrix_message.position.index = matrix_x_axis_index * MATRIX_CHANNEL_NUM_Y + matrix_y_axis_index; memcpy(valid_message.child_msg, &matrix_message, sizeof(matrix_message)); //Construct child message xQueueSend(monitor.valid_msg_handle, &valid_message, portMAX_DELAY); test_matrix_event_simulator(valid_message.handle, matrix_message.event, matrix_message.position.index); } else { TEST_ABORT(); } os_ret = xSemaphoreTake(monitor.response_sig_handle, pdMS_TO_TICKS(500)); TEST_ASSERT_MESSAGE(os_ret == pdPASS, "response queue timeout (500ms)"); if (valid_message.element_type == TOUCH_ELEM_TYPE_BUTTON) { button_message.event = TOUCH_BUTTON_EVT_ON_RELEASE; memcpy(valid_message.child_msg, &button_message, sizeof(button_message)); xQueueSend(monitor.valid_msg_handle, &valid_message, portMAX_DELAY); test_button_event_simulator(valid_message.handle, button_message.event); } else if (valid_message.element_type == TOUCH_ELEM_TYPE_SLIDER) { slider_message.event = TOUCH_SLIDER_EVT_ON_RELEASE; memcpy(valid_message.child_msg, &slider_message, sizeof(slider_message)); xQueueSend(monitor.valid_msg_handle, &valid_message, portMAX_DELAY); test_slider_event_simulator(valid_message.handle, slider_message.event, 1); } else if (valid_message.element_type == TOUCH_ELEM_TYPE_MATRIX) { matrix_message.event = TOUCH_MATRIX_EVT_ON_RELEASE; memcpy(valid_message.child_msg, &matrix_message, sizeof(matrix_message)); xQueueSend(monitor.valid_msg_handle, &valid_message, portMAX_DELAY); const touch_matrix_message_t *matrix_message_ptr = touch_matrix_get_message(&valid_message); test_matrix_event_simulator(valid_message.handle, matrix_message.event, matrix_message_ptr->position.index); } os_ret = xSemaphoreTake(monitor.response_sig_handle, pdMS_TO_TICKS(500)); TEST_ASSERT_MESSAGE(os_ret == pdPASS, "response queue timeout (500ms)"); } TEST_ESP_OK(touch_element_stop()); for (int i = 0; i < BUTTON_CHANNEL_NUM; i++) { TEST_ESP_OK(touch_button_delete(button_handle[i])); } TEST_ESP_OK(touch_slider_delete(slider_handle)); TEST_ESP_OK(touch_matrix_delete(matrix_handle)); touch_button_uninstall(); touch_slider_uninstall(); touch_matrix_uninstall(); while (eTaskGetState(task_handle) == eRunning) { vTaskDelay(pdTICKS_TO_MS(1)); } vTaskDelete(task_handle); vQueueDelete(monitor.valid_msg_handle); vSemaphoreDelete(monitor.response_sig_handle); printf("Integration test(button + slider + matrix) finish\n"); } static void test_integration_monitor_task(void *arg) { test_monitor_t *monitor = (test_monitor_t *)arg; BaseType_t os_ret; touch_elem_message_t current_message, valid_message; while (1) { touch_element_message_receive(¤t_message, portMAX_DELAY); os_ret = xQueueReceive(monitor->valid_msg_handle, &valid_message, pdMS_TO_TICKS(500)); //Get the valid message for the verification, 500ms timeout TEST_ASSERT_MESSAGE(os_ret == pdPASS, "trigger queue timeout (500ms)"); if (current_message.element_type == TOUCH_ELEM_TYPE_BUTTON) { test_button_event_check(&valid_message, ¤t_message); } else if (current_message.element_type == TOUCH_ELEM_TYPE_SLIDER) { test_slider_event_check(&valid_message, ¤t_message); } else if (current_message.element_type == TOUCH_ELEM_TYPE_MATRIX) { test_matrix_event_check(&valid_message, ¤t_message); } xSemaphoreGive(monitor->response_sig_handle); } }