d63f6431c5
Allows disabling backwards compatibility, which is not enabled by default since IDF 5. Since these symbols have been stable for many years now, it's time to let them go. - portTICK_RATE_MS renamed to portTICK_PERIOD_MS - xSemaphoreHandle renamed to SemaphoreHandle_t - xTaskHandle renamed to TaskHandle_t
675 lines
23 KiB
C
675 lines
23 KiB
C
/*
|
|
* ESPRESSIF MIT License
|
|
*
|
|
* Copyright (c) 2018 <ESPRESSIF SYSTEMS (SHANGHAI) PTE LTD>
|
|
*
|
|
* Permission is hereby granted for use on all ESPRESSIF SYSTEMS products, in
|
|
* which case, it is free of charge, to any person obtaining a copy of this
|
|
* software and associated documentation files (the "Software"), to deal in the
|
|
* Software without restriction, including without limitation the rights to use,
|
|
* copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
|
* the Software, and to permit persons to whom the Software is furnished to do
|
|
* so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*
|
|
*/
|
|
#include "esp_peripherals.h"
|
|
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#include "audio_event_iface.h"
|
|
#include "audio_mem.h"
|
|
#include "board.h"
|
|
#include "esp_err.h"
|
|
#include "esp_log.h"
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#include "nvs_flash.h"
|
|
#include "periph_adc_button.h"
|
|
#include "periph_button.h"
|
|
#include "periph_console.h"
|
|
#include "periph_gpio_isr.h"
|
|
#include "periph_is31fl3216.h"
|
|
#include "periph_led.h"
|
|
#include "periph_sdcard.h"
|
|
#include "periph_spiffs.h"
|
|
#include "periph_touch.h"
|
|
#include "periph_wifi.h"
|
|
#include "periph_ws2812.h"
|
|
#include "tcpip_adapter.h"
|
|
#include "unity.h"
|
|
|
|
static const char *TAG = "ESP_PERIPH_TEST";
|
|
|
|
#define TEST_PERIPHERALS_MEMORY_LEAK_TIMES 1000
|
|
|
|
static void periph_adc_button_test(void) {
|
|
ESP_LOGI(TAG, "Set up peripherals handle");
|
|
esp_periph_config_t periph_cfg = DEFAULT_ESP_PERIPH_SET_CONFIG();
|
|
esp_periph_set_handle_t set = esp_periph_set_init(&periph_cfg);
|
|
TEST_ASSERT_NOT_NULL(set);
|
|
|
|
ESP_LOGI(TAG, "Register ADC button to peripherals");
|
|
periph_adc_button_cfg_t adc_btn_cfg = PERIPH_ADC_BUTTON_DEFAULT_CONFIG();
|
|
adc_arr_t adc_btn_tag = ADC_DEFAULT_ARR();
|
|
adc_btn_tag.total_steps = 6;
|
|
int btn_array[7] = {190, 600, 1000, 1375, 1775, 2195, 3100};
|
|
adc_btn_tag.adc_level_step = btn_array;
|
|
adc_btn_cfg.arr = &adc_btn_tag;
|
|
adc_btn_cfg.arr_size = 1;
|
|
esp_periph_handle_t adc_btn_handle = periph_adc_button_init(&adc_btn_cfg);
|
|
TEST_ASSERT_NOT_NULL(adc_btn_handle);
|
|
TEST_ASSERT_FALSE(esp_periph_start(set, adc_btn_handle));
|
|
|
|
ESP_LOGI(TAG, "Set up event listener");
|
|
audio_event_iface_cfg_t evt_cfg = AUDIO_EVENT_IFACE_DEFAULT_CFG();
|
|
audio_event_iface_handle_t evt = audio_event_iface_init(&evt_cfg);
|
|
TEST_ASSERT_NOT_NULL(evt);
|
|
|
|
ESP_LOGI(TAG, "Listening event from peripherals");
|
|
TEST_ASSERT_FALSE(
|
|
audio_event_iface_set_listener(esp_periph_set_get_event_iface(set), evt));
|
|
|
|
ESP_LOGI(TAG, "Test start, please press buttons on the board ... ");
|
|
while (1) {
|
|
audio_event_iface_msg_t msg;
|
|
TEST_ASSERT_FALSE(audio_event_iface_listen(evt, &msg, portMAX_DELAY));
|
|
ESP_LOGI(TAG, "action: %d, act id: %d", msg.cmd, (int)msg.data);
|
|
if ((int)msg.data == 0) {
|
|
ESP_LOGW(TAG, "press id 0, quit test");
|
|
break;
|
|
}
|
|
}
|
|
|
|
ESP_LOGI(TAG, "Quit test, release all resources");
|
|
TEST_ASSERT_FALSE(esp_periph_set_stop_all(set));
|
|
TEST_ASSERT_FALSE(audio_event_iface_remove_listener(
|
|
esp_periph_set_get_event_iface(set), evt));
|
|
TEST_ASSERT_FALSE(audio_event_iface_destroy(evt));
|
|
TEST_ASSERT_FALSE(esp_periph_set_destroy(set));
|
|
}
|
|
|
|
TEST_CASE("adc button test", "[peripherals]") { periph_adc_button_test(); }
|
|
|
|
static void periph_gpio_button_test(void) {
|
|
ESP_LOGI(TAG, "Set up peripherals handle");
|
|
esp_periph_config_t periph_cfg = DEFAULT_ESP_PERIPH_SET_CONFIG();
|
|
esp_periph_set_handle_t set = esp_periph_set_init(&periph_cfg);
|
|
TEST_ASSERT_NOT_NULL(set);
|
|
|
|
ESP_LOGI(TAG, "Register gpio button to peripherals");
|
|
periph_button_cfg_t btn_cfg = {
|
|
.gpio_mask = (1ULL << get_input_rec_id()) |
|
|
(1ULL << get_input_mode_id()), // REC BTN & MODE BTN
|
|
};
|
|
esp_periph_handle_t button_handle = periph_button_init(&btn_cfg);
|
|
TEST_ASSERT_NOT_NULL(button_handle);
|
|
TEST_ASSERT_FALSE(esp_periph_start(set, button_handle));
|
|
|
|
ESP_LOGI(TAG, "Set up event listener");
|
|
audio_event_iface_cfg_t evt_cfg = AUDIO_EVENT_IFACE_DEFAULT_CFG();
|
|
audio_event_iface_handle_t evt = audio_event_iface_init(&evt_cfg);
|
|
TEST_ASSERT_NOT_NULL(evt);
|
|
|
|
ESP_LOGI(TAG, "Listening event from peripherals");
|
|
TEST_ASSERT_FALSE(
|
|
audio_event_iface_set_listener(esp_periph_set_get_event_iface(set), evt));
|
|
|
|
ESP_LOGI(TAG, "Test start, please press buttons on the board ... ");
|
|
while (1) {
|
|
audio_event_iface_msg_t msg;
|
|
TEST_ASSERT_FALSE(audio_event_iface_listen(evt, &msg, portMAX_DELAY));
|
|
ESP_LOGI(TAG, "action: %d, act id: %d", msg.cmd, (int)msg.data);
|
|
if ((int)msg.data == get_input_mode_id()) {
|
|
ESP_LOGW(TAG, "press [mode] button, quit test");
|
|
break;
|
|
}
|
|
}
|
|
|
|
ESP_LOGI(TAG, "Quit test, release all resources");
|
|
TEST_ASSERT_FALSE(esp_periph_set_stop_all(set));
|
|
TEST_ASSERT_FALSE(audio_event_iface_remove_listener(
|
|
esp_periph_set_get_event_iface(set), evt));
|
|
TEST_ASSERT_FALSE(audio_event_iface_destroy(evt));
|
|
TEST_ASSERT_FALSE(esp_periph_set_destroy(set));
|
|
}
|
|
|
|
TEST_CASE("gpio button test", "[peripherals]") { periph_gpio_button_test(); }
|
|
|
|
static esp_err_t play_func(esp_periph_handle_t periph, int argc, char *argv[]) {
|
|
if (argc == 1) {
|
|
ESP_LOGI(TAG, "play music, url:%s", argv[0]);
|
|
} else if (argc == 0) {
|
|
ESP_LOGI(TAG, "play");
|
|
} else {
|
|
ESP_LOGE(TAG, "error input");
|
|
}
|
|
return ESP_OK;
|
|
}
|
|
|
|
static esp_err_t pause_func(esp_periph_handle_t periph, int argc,
|
|
char *argv[]) {
|
|
if (argc == 0) {
|
|
ESP_LOGI(TAG, "pause");
|
|
} else {
|
|
ESP_LOGE(TAG, "error input");
|
|
}
|
|
return ESP_OK;
|
|
}
|
|
|
|
static bool task_flag;
|
|
|
|
static esp_err_t quit_func(esp_periph_handle_t periph, int argc, char *argv[]) {
|
|
if (argc == 0) {
|
|
ESP_LOGI(TAG, "quit console");
|
|
task_flag = false;
|
|
} else {
|
|
ESP_LOGE(TAG, "error input");
|
|
}
|
|
return ESP_OK;
|
|
}
|
|
|
|
const periph_console_cmd_t cli_cmd[] = {
|
|
{
|
|
.cmd = "play",
|
|
.id = 0,
|
|
.help = "play music",
|
|
.func = play_func,
|
|
},
|
|
{
|
|
.cmd = "pause",
|
|
.id = 1,
|
|
.help = "pause music",
|
|
.func = pause_func,
|
|
},
|
|
{.cmd = "quit", .id = 2, .help = "quit command line", .func = quit_func}};
|
|
|
|
static void periph_console_test(void) {
|
|
ESP_LOGI(TAG, "Set up peripherals handle");
|
|
esp_periph_config_t periph_cfg = DEFAULT_ESP_PERIPH_SET_CONFIG();
|
|
esp_periph_set_handle_t set = esp_periph_set_init(&periph_cfg);
|
|
TEST_ASSERT_NOT_NULL(set);
|
|
|
|
ESP_LOGI(TAG, "Register console to peripherals");
|
|
periph_console_cfg_t console_cfg = {
|
|
.command_num = sizeof(cli_cmd) / sizeof(periph_console_cmd_t),
|
|
.commands = cli_cmd,
|
|
};
|
|
esp_periph_handle_t console_handle = periph_console_init(&console_cfg);
|
|
TEST_ASSERT_NOT_NULL(console_handle);
|
|
|
|
task_flag = true;
|
|
ESP_LOGI(TAG, "Start console, please input ...");
|
|
TEST_ASSERT_FALSE(esp_periph_start(set, console_handle));
|
|
|
|
while (task_flag) {
|
|
vTaskDelay(10 / portTICK_PERIOD_MS);
|
|
}
|
|
|
|
ESP_LOGI(TAG, "Quit test, release all resources");
|
|
TEST_ASSERT_FALSE(esp_periph_set_stop_all(set));
|
|
TEST_ASSERT_FALSE(esp_periph_set_destroy(set));
|
|
}
|
|
|
|
TEST_CASE("console test", "[peripherals]") { periph_console_test(); }
|
|
|
|
static void periph_gpio_isr_test(void) {
|
|
ESP_LOGI(TAG, "Set up peripherals handle");
|
|
esp_periph_config_t periph_cfg = DEFAULT_ESP_PERIPH_SET_CONFIG();
|
|
esp_periph_set_handle_t set = esp_periph_set_init(&periph_cfg);
|
|
TEST_ASSERT_NOT_NULL(set);
|
|
|
|
ESP_LOGI(TAG, "Register gpio isr to peripherals");
|
|
gpio_isr_info_t gpio_isr_info = {.gpio_num = SDCARD_INTR_GPIO,
|
|
.type = GPIO_INTR_ANYEDGE};
|
|
periph_gpio_isr_cfg_t gpio_isr_cfg = {.info_size = 1,
|
|
.gpio_isr_info = &gpio_isr_info};
|
|
esp_periph_handle_t gpio_isr_handle = periph_gpio_isr_init(&gpio_isr_cfg);
|
|
TEST_ASSERT_NOT_NULL(gpio_isr_handle);
|
|
TEST_ASSERT_FALSE(esp_periph_start(set, gpio_isr_handle));
|
|
|
|
ESP_LOGI(TAG, "Set up event listener");
|
|
audio_event_iface_cfg_t evt_cfg = AUDIO_EVENT_IFACE_DEFAULT_CFG();
|
|
audio_event_iface_handle_t evt = audio_event_iface_init(&evt_cfg);
|
|
TEST_ASSERT_NOT_NULL(evt);
|
|
|
|
ESP_LOGI(TAG,
|
|
"Listening event from peripherals, please insert a sdcard to the "
|
|
"board ...");
|
|
TEST_ASSERT_FALSE(
|
|
audio_event_iface_set_listener(esp_periph_set_get_event_iface(set), evt));
|
|
|
|
while (1) {
|
|
audio_event_iface_msg_t msg;
|
|
TEST_ASSERT_FALSE(audio_event_iface_listen(evt, &msg, portMAX_DELAY));
|
|
|
|
if ((int)msg.data == SDCARD_INTR_GPIO) {
|
|
ESP_LOGW(TAG, "Detect sdcard insertion, quit test");
|
|
break;
|
|
}
|
|
}
|
|
|
|
ESP_LOGI(TAG, "Quit test, release all resources");
|
|
TEST_ASSERT_FALSE(esp_periph_set_stop_all(set));
|
|
TEST_ASSERT_FALSE(audio_event_iface_remove_listener(
|
|
esp_periph_set_get_event_iface(set), evt));
|
|
TEST_ASSERT_FALSE(audio_event_iface_destroy(evt));
|
|
TEST_ASSERT_FALSE(esp_periph_set_destroy(set));
|
|
}
|
|
|
|
TEST_CASE("gpio isr test", "[peripherals]") { periph_gpio_isr_test(); }
|
|
|
|
static void periph_is31fl3216_test(void) {
|
|
ESP_LOGI(TAG, "Set up peripherals handle");
|
|
esp_periph_config_t periph_cfg = DEFAULT_ESP_PERIPH_SET_CONFIG();
|
|
esp_periph_set_handle_t set = esp_periph_set_init(&periph_cfg);
|
|
TEST_ASSERT_NOT_NULL(set);
|
|
periph_is31fl3216_cfg_t is31fl3216_cfg = {.state = IS31FL3216_STATE_ON};
|
|
|
|
ESP_LOGI(TAG, "Register gpio isr to peripherals");
|
|
esp_periph_handle_t is31fl3216_handle =
|
|
periph_is31fl3216_init(&is31fl3216_cfg);
|
|
TEST_ASSERT_FALSE(esp_periph_start(set, is31fl3216_handle));
|
|
|
|
for (int i = 0; i < BLUE_LED_MAX_NUM; i++) {
|
|
TEST_ASSERT_FALSE(periph_is31fl3216_set_duty(is31fl3216_handle, i, 255));
|
|
}
|
|
|
|
TEST_ASSERT_FALSE(periph_is31fl3216_set_light_on_num(is31fl3216_handle, 1,
|
|
BLUE_LED_MAX_NUM));
|
|
TEST_ASSERT_FALSE(periph_is31fl3216_set_interval(is31fl3216_handle, 100));
|
|
TEST_ASSERT_FALSE(periph_is31fl3216_set_shift_mode(
|
|
is31fl3216_handle, PERIPH_IS31_SHIFT_MODE_ACC));
|
|
TEST_ASSERT_FALSE(
|
|
periph_is31fl3216_set_state(is31fl3216_handle, IS31FL3216_STATE_SHIFT));
|
|
ESP_LOGI(TAG, "Start testing for 5 seconds...");
|
|
|
|
vTaskDelay(5000 / portTICK_PERIOD_MS);
|
|
|
|
ESP_LOGI(TAG, "Quit test, release all resources");
|
|
TEST_ASSERT_FALSE(esp_periph_set_stop_all(set));
|
|
TEST_ASSERT_FALSE(esp_periph_set_destroy(set));
|
|
}
|
|
|
|
TEST_CASE("is31fl3216 test", "[peripherals]") { periph_is31fl3216_test(); }
|
|
|
|
static void periph_led_test(void) {
|
|
ESP_LOGI(TAG, "Set up peripherals handle");
|
|
esp_periph_config_t periph_cfg = DEFAULT_ESP_PERIPH_SET_CONFIG();
|
|
esp_periph_set_handle_t set = esp_periph_set_init(&periph_cfg);
|
|
TEST_ASSERT_NOT_NULL(set);
|
|
|
|
periph_led_cfg_t led_cfg = {
|
|
.led_speed_mode = LEDC_LOW_SPEED_MODE,
|
|
.led_duty_resolution = LEDC_TIMER_10_BIT,
|
|
.led_timer_num = LEDC_TIMER_0,
|
|
.led_freq_hz = 5000,
|
|
};
|
|
|
|
esp_periph_handle_t led_handle = periph_led_init(&led_cfg);
|
|
TEST_ASSERT_FALSE(esp_periph_start(set, led_handle));
|
|
|
|
TEST_ASSERT_FALSE(periph_led_blink(led_handle, get_blue_led_gpio(), 1000,
|
|
1000, true, -1, 0));
|
|
TEST_ASSERT_FALSE(periph_led_blink(led_handle, get_green_led_gpio(), 500, 500,
|
|
false, 4, 0));
|
|
|
|
ESP_LOGI(TAG, "running...");
|
|
vTaskDelay(1000 / portTICK_PERIOD_MS);
|
|
ESP_LOGI(TAG, "STOP BLUE LED");
|
|
TEST_ASSERT_FALSE(periph_led_stop(led_handle, get_blue_led_gpio()));
|
|
|
|
vTaskDelay(1000 / portTICK_PERIOD_MS);
|
|
ESP_LOGI(TAG, "Changing blink preset...");
|
|
TEST_ASSERT_FALSE(periph_led_blink(led_handle, get_blue_led_gpio(), 500, 200,
|
|
false, -1, 0));
|
|
TEST_ASSERT_FALSE(periph_led_blink(led_handle, get_green_led_gpio(), 500,
|
|
1000, true, -1, 0));
|
|
|
|
ESP_LOGI(TAG, "Quit test, release all resources");
|
|
TEST_ASSERT_FALSE(esp_periph_set_stop_all(set));
|
|
TEST_ASSERT_FALSE(esp_periph_set_destroy(set));
|
|
}
|
|
|
|
TEST_CASE("led test", "[peripherals]") { periph_led_test(); }
|
|
|
|
static void periph_sdcard_test(void) {
|
|
ESP_LOGI(TAG, "Set up peripherals handle");
|
|
esp_periph_config_t periph_cfg = DEFAULT_ESP_PERIPH_SET_CONFIG();
|
|
esp_periph_set_handle_t set = esp_periph_set_init(&periph_cfg);
|
|
TEST_ASSERT_NOT_NULL(set);
|
|
|
|
#ifdef CONFIG_ESP_LYRAT_MINI_V1_1_BOARD
|
|
gpio_config_t sdcard_pwr_pin_cfg = {
|
|
.pin_bit_mask = 1UL << SDCARD_PWR_CTRL,
|
|
.mode = GPIO_MODE_OUTPUT,
|
|
.pull_up_en = GPIO_PULLUP_DISABLE,
|
|
.pull_down_en = GPIO_PULLDOWN_DISABLE,
|
|
.intr_type = GPIO_INTR_DISABLE,
|
|
};
|
|
|
|
gpio_config(&sdcard_pwr_pin_cfg);
|
|
gpio_set_level(SDCARD_PWR_CTRL, 0);
|
|
#endif
|
|
|
|
periph_sdcard_cfg_t sdcard_cfg = {.card_detect_pin = get_sdcard_intr_gpio(),
|
|
.root = "/sdcard"};
|
|
|
|
esp_periph_handle_t sdcard_handle = periph_sdcard_init(&sdcard_cfg);
|
|
TEST_ASSERT_NOT_NULL(sdcard_handle);
|
|
TEST_ASSERT_FALSE(esp_periph_start(set, sdcard_handle));
|
|
|
|
while (!periph_sdcard_is_mounted(sdcard_handle)) {
|
|
vTaskDelay(500 / portTICK_PERIOD_MS);
|
|
}
|
|
|
|
ESP_LOGI(TAG, "Wirte a string to sdcard");
|
|
FILE *fp = fopen("/sdcard/test", "w+");
|
|
TEST_ASSERT_NOT_NULL(fp);
|
|
char test_str[] = "hello, this is sdcard test";
|
|
TEST_ASSERT_EQUAL_INT(strlen(test_str),
|
|
fwrite(test_str, 1, strlen(test_str), fp));
|
|
TEST_ASSERT_FALSE(fsync(fileno(fp)));
|
|
TEST_ASSERT_FALSE(fclose(fp));
|
|
|
|
ESP_LOGI(TAG, "Read a string from sdcard");
|
|
fp = fopen("/sdcard/test", "r");
|
|
TEST_ASSERT_NOT_NULL(fp);
|
|
char *read_str = audio_calloc(1, strlen(test_str) + 1);
|
|
TEST_ASSERT_NOT_NULL(read_str);
|
|
TEST_ASSERT_EQUAL_INT(strlen(test_str),
|
|
fread(read_str, 1, strlen(test_str), fp));
|
|
ESP_LOGW(TAG, "read string from sdcard file: %s", read_str);
|
|
TEST_ASSERT_EQUAL_INT(0, strncmp(read_str, test_str, strlen(test_str)));
|
|
|
|
ESP_LOGI(TAG, "Quit test, release all resources");
|
|
TEST_ASSERT_FALSE(esp_periph_set_stop_all(set));
|
|
TEST_ASSERT_FALSE(esp_periph_set_destroy(set));
|
|
free(read_str);
|
|
fclose(fp);
|
|
}
|
|
|
|
TEST_CASE("sdcard test", "[peripherals]") { periph_sdcard_test(); }
|
|
|
|
static void periph_spiffs_test(void) {
|
|
ESP_LOGI(TAG, "Set up peripherals handle");
|
|
esp_periph_config_t periph_cfg = DEFAULT_ESP_PERIPH_SET_CONFIG();
|
|
esp_periph_set_handle_t set = esp_periph_set_init(&periph_cfg);
|
|
TEST_ASSERT_NOT_NULL(set);
|
|
|
|
periph_spiffs_cfg_t spiffs_cfg = {.root = "/spiffs",
|
|
.max_files = 5,
|
|
.format_if_mount_failed = true,
|
|
.partition_label = NULL};
|
|
esp_periph_handle_t spiffs_handle = periph_spiffs_init(&spiffs_cfg);
|
|
TEST_ASSERT_NOT_NULL(spiffs_handle);
|
|
TEST_ASSERT_FALSE(esp_periph_start(set, spiffs_handle));
|
|
|
|
while (!periph_spiffs_is_mounted(spiffs_handle)) {
|
|
vTaskDelay(500 / portTICK_PERIOD_MS);
|
|
}
|
|
|
|
FILE *fp = fopen("/spiffs/test", "w+");
|
|
TEST_ASSERT_NOT_NULL(fp);
|
|
char test_str[] = "hello, this is spiffs test";
|
|
TEST_ASSERT_EQUAL_INT(strlen(test_str),
|
|
fwrite(test_str, 1, strlen(test_str), fp));
|
|
TEST_ASSERT_FALSE(fclose(fp));
|
|
|
|
ESP_LOGI(TAG, "Read a string from spiffs");
|
|
fp = fopen("/spiffs/test", "r");
|
|
TEST_ASSERT_NOT_NULL(fp);
|
|
char *read_str = audio_calloc(1, strlen(test_str) + 1);
|
|
TEST_ASSERT_NOT_NULL(read_str);
|
|
TEST_ASSERT_EQUAL_INT(strlen(test_str),
|
|
fread(read_str, 1, strlen(test_str), fp));
|
|
ESP_LOGW(TAG, "read string from spiffs file: %s", read_str);
|
|
TEST_ASSERT_EQUAL_INT(0, strncmp(read_str, test_str, strlen(test_str)));
|
|
fclose(fp);
|
|
|
|
ESP_LOGI(TAG, "Quit test, release all resources");
|
|
TEST_ASSERT_FALSE(esp_periph_set_stop_all(set));
|
|
TEST_ASSERT_FALSE(esp_periph_set_destroy(set));
|
|
free(read_str);
|
|
}
|
|
|
|
TEST_CASE("spiffs test", "[peripherals]") { periph_spiffs_test(); }
|
|
|
|
static void periph_touch_pad_test(void) {
|
|
ESP_LOGI(TAG, "Set up peripherals handle");
|
|
esp_periph_config_t periph_cfg = DEFAULT_ESP_PERIPH_SET_CONFIG();
|
|
esp_periph_set_handle_t set = esp_periph_set_init(&periph_cfg);
|
|
TEST_ASSERT_NOT_NULL(set);
|
|
|
|
ESP_LOGI(TAG, "Register touch pad to peripherals");
|
|
periph_touch_cfg_t touch_cfg = {
|
|
.touch_mask =
|
|
TOUCH_PAD_SEL4 | TOUCH_PAD_SEL7 | TOUCH_PAD_SEL8 | TOUCH_PAD_SEL9,
|
|
.tap_threshold_percent = 70,
|
|
};
|
|
esp_periph_handle_t touch_handle = periph_touch_init(&touch_cfg);
|
|
TEST_ASSERT_NOT_NULL(touch_handle);
|
|
TEST_ASSERT_FALSE(esp_periph_start(set, touch_handle));
|
|
|
|
ESP_LOGI(TAG, "Set up event listener");
|
|
audio_event_iface_cfg_t evt_cfg = AUDIO_EVENT_IFACE_DEFAULT_CFG();
|
|
audio_event_iface_handle_t evt = audio_event_iface_init(&evt_cfg);
|
|
TEST_ASSERT_NOT_NULL(evt);
|
|
|
|
ESP_LOGI(TAG, "Listening event from peripherals, please press the touch pad");
|
|
TEST_ASSERT_FALSE(
|
|
audio_event_iface_set_listener(esp_periph_set_get_event_iface(set), evt));
|
|
|
|
while (1) {
|
|
audio_event_iface_msg_t msg;
|
|
TEST_ASSERT_FALSE(audio_event_iface_listen(evt, &msg, portMAX_DELAY));
|
|
if ((int)msg.data == get_input_set_id()) {
|
|
ESP_LOGI(TAG, "[set] touched, quit test");
|
|
break;
|
|
}
|
|
|
|
if (msg.cmd == PERIPH_TOUCH_TAP) {
|
|
if ((int)msg.data == get_input_play_id()) {
|
|
ESP_LOGI(TAG, "[play] touched");
|
|
}
|
|
if ((int)msg.data == get_input_volup_id()) {
|
|
ESP_LOGI(TAG, "[vol+] touched");
|
|
}
|
|
if ((int)msg.data == get_input_voldown_id()) {
|
|
ESP_LOGI(TAG, "[vol-] touched");
|
|
}
|
|
}
|
|
|
|
if (msg.cmd == PERIPH_TOUCH_RELEASE) {
|
|
if ((int)msg.data == get_input_play_id()) {
|
|
ESP_LOGI(TAG, "[play] released");
|
|
}
|
|
if ((int)msg.data == get_input_volup_id()) {
|
|
ESP_LOGI(TAG, "[vol+] released");
|
|
}
|
|
if ((int)msg.data == get_input_voldown_id()) {
|
|
ESP_LOGI(TAG, "[vol-] released");
|
|
}
|
|
}
|
|
}
|
|
|
|
ESP_LOGI(TAG, "Quit test, release all resources");
|
|
TEST_ASSERT_FALSE(esp_periph_set_stop_all(set));
|
|
TEST_ASSERT_FALSE(audio_event_iface_remove_listener(
|
|
esp_periph_set_get_event_iface(set), evt));
|
|
TEST_ASSERT_FALSE(audio_event_iface_destroy(evt));
|
|
TEST_ASSERT_FALSE(esp_periph_set_destroy(set));
|
|
}
|
|
|
|
static void periph_ws2812_test(void) {
|
|
ESP_LOGI(TAG, "Set up peripherals handle");
|
|
esp_periph_config_t periph_cfg = DEFAULT_ESP_PERIPH_SET_CONFIG();
|
|
esp_periph_set_handle_t set = esp_periph_set_init(&periph_cfg);
|
|
TEST_ASSERT_NOT_NULL(set);
|
|
|
|
periph_ws2812_cfg_t cfg = {
|
|
.gpio_num = GPIO_NUM_3,
|
|
.led_num = 2,
|
|
};
|
|
esp_periph_handle_t handle = periph_ws2812_init(&cfg);
|
|
TEST_ASSERT_FALSE(esp_periph_start(set, handle));
|
|
|
|
periph_ws2812_ctrl_cfg_t *control_cfg =
|
|
malloc(sizeof(periph_ws2812_ctrl_cfg_t) * cfg.led_num);
|
|
|
|
control_cfg[0].color = LED2812_COLOR_RED;
|
|
control_cfg[0].mode = PERIPH_WS2812_BLINK;
|
|
control_cfg[0].loop = 50;
|
|
control_cfg[0].time_off_ms = 100;
|
|
control_cfg[0].time_on_ms = 1000;
|
|
|
|
control_cfg[1].color = LED2812_COLOR_BLUE;
|
|
control_cfg[1].mode = PERIPH_WS2812_ONE;
|
|
control_cfg[1].loop = 50;
|
|
control_cfg[1].time_off_ms = 2000;
|
|
control_cfg[1].time_on_ms = 2000;
|
|
|
|
TEST_ASSERT_FALSE(periph_ws2812_control(handle, control_cfg, NULL));
|
|
vTaskDelay(5000 / portTICK_PERIOD_MS);
|
|
|
|
ESP_LOGI(TAG, "Quit test, release all resources");
|
|
TEST_ASSERT_FALSE(esp_periph_set_stop_all(set));
|
|
TEST_ASSERT_FALSE(esp_periph_set_destroy(set));
|
|
free(control_cfg);
|
|
}
|
|
|
|
TEST_CASE("touch pad test", "[peripherals]") { periph_touch_pad_test(); }
|
|
|
|
static void periph_wifi_test(void) {
|
|
ESP_LOGI(TAG, "Set up peripherals handle");
|
|
esp_periph_config_t periph_cfg = DEFAULT_ESP_PERIPH_SET_CONFIG();
|
|
esp_periph_set_handle_t set = esp_periph_set_init(&periph_cfg);
|
|
TEST_ASSERT_NOT_NULL(set);
|
|
|
|
ESP_LOGI(TAG, "Initialize wifi environment");
|
|
esp_err_t ret = nvs_flash_init();
|
|
if (ret == ESP_ERR_NVS_NO_FREE_PAGES ||
|
|
ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
|
|
ESP_ERROR_CHECK(nvs_flash_erase());
|
|
ret = nvs_flash_init();
|
|
}
|
|
ESP_ERROR_CHECK(ret);
|
|
tcpip_adapter_init();
|
|
|
|
periph_wifi_cfg_t wifi_cfg = {0};
|
|
wifi_cfg.ssid = "ESP-Audio";
|
|
wifi_cfg.password = "esp123456";
|
|
|
|
esp_periph_handle_t wifi_handle = periph_wifi_init(&wifi_cfg);
|
|
esp_periph_start(set, wifi_handle);
|
|
periph_wifi_wait_for_connected(wifi_handle, portMAX_DELAY);
|
|
|
|
vTaskDelay(100 / portTICK_PERIOD_MS);
|
|
|
|
ESP_LOGI(TAG, "Quit test, release all resources");
|
|
TEST_ASSERT_FALSE(esp_periph_set_stop_all(set));
|
|
TEST_ASSERT_FALSE(esp_periph_set_destroy(set));
|
|
TEST_ASSERT_FALSE(nvs_flash_deinit());
|
|
}
|
|
|
|
TEST_CASE("wifi test", "[peripherals]") { periph_wifi_test(); }
|
|
|
|
TEST_CASE("[memory leak test] [gpio isr]", "[peripherals]") {
|
|
int test_count = TEST_PERIPHERALS_MEMORY_LEAK_TIMES;
|
|
while (test_count--) {
|
|
printf("-------Residual times: %d -------\n", test_count);
|
|
periph_gpio_isr_test();
|
|
}
|
|
}
|
|
|
|
TEST_CASE("[memory leak test] [adc button]", "[peripherals]") {
|
|
int test_count = TEST_PERIPHERALS_MEMORY_LEAK_TIMES;
|
|
while (test_count--) {
|
|
printf("-------Residual times: %d -------\n", test_count);
|
|
periph_adc_button_test();
|
|
}
|
|
}
|
|
|
|
TEST_CASE("[memory leak test] [console]", "[peripherals]") {
|
|
int test_count = TEST_PERIPHERALS_MEMORY_LEAK_TIMES;
|
|
while (test_count--) {
|
|
printf("-------Residual times: %d -------\n", test_count);
|
|
periph_console_test();
|
|
}
|
|
}
|
|
|
|
TEST_CASE("[memory leak test] [led]", "[peripherals]") {
|
|
int test_count = TEST_PERIPHERALS_MEMORY_LEAK_TIMES;
|
|
while (test_count--) {
|
|
printf("-------Residual times: %d -------\n", test_count);
|
|
periph_led_test();
|
|
}
|
|
}
|
|
|
|
TEST_CASE("[memory leak test] [spiffs]", "[peripherals]") {
|
|
int test_count = TEST_PERIPHERALS_MEMORY_LEAK_TIMES;
|
|
while (test_count--) {
|
|
printf("-------Residual times: %d -------\n", test_count);
|
|
periph_spiffs_test();
|
|
}
|
|
}
|
|
|
|
TEST_CASE("[memory leak test] [wifi]", "[peripherals]") {
|
|
int test_count = TEST_PERIPHERALS_MEMORY_LEAK_TIMES;
|
|
while (test_count--) {
|
|
printf("-------Residual times: %d -------\n", test_count);
|
|
periph_wifi_test();
|
|
}
|
|
}
|
|
|
|
TEST_CASE("[memory leak test] [gpio button]", "[peripherals]") {
|
|
int test_count = TEST_PERIPHERALS_MEMORY_LEAK_TIMES;
|
|
while (test_count--) {
|
|
printf("-------Residual times: %d -------\n", test_count);
|
|
periph_gpio_button_test();
|
|
}
|
|
}
|
|
|
|
TEST_CASE("[memory leak test] [is31fl3216]", "[peripherals]") {
|
|
int test_count = TEST_PERIPHERALS_MEMORY_LEAK_TIMES;
|
|
while (test_count--) {
|
|
printf("-------Residual times: %d -------\n", test_count);
|
|
periph_is31fl3216_test();
|
|
}
|
|
}
|
|
|
|
TEST_CASE("[memory leak test] [sdcard]", "[peripherals]") {
|
|
int test_count = TEST_PERIPHERALS_MEMORY_LEAK_TIMES;
|
|
while (test_count--) {
|
|
printf("-------Residual times: %d -------\n", test_count);
|
|
periph_sdcard_test();
|
|
}
|
|
}
|
|
|
|
TEST_CASE("[memory leak test] [touch]", "[peripherals]") {
|
|
int test_count = TEST_PERIPHERALS_MEMORY_LEAK_TIMES;
|
|
while (test_count--) {
|
|
printf("-------Residual times: %d -------\n", test_count);
|
|
periph_touch_pad_test();
|
|
}
|
|
}
|
|
|
|
TEST_CASE("[memory leak test] [ws2812]", "[peripherals]") {
|
|
int test_count = TEST_PERIPHERALS_MEMORY_LEAK_TIMES;
|
|
while (test_count--) {
|
|
printf("-------Residual times: %d -------\n", test_count);
|
|
periph_ws2812_test();
|
|
}
|
|
}
|