esp_err_t touch_ret = esp_board_manager_init_device_by_name("lcd_touch");
if (touch_ret == ESP_OK) {
    touch_ret = esp_board_manager_deinit_device_by_name("lcd_touch");
    if (touch_ret != ESP_OK) {
        ESP_LOGE(TAG, "touch release failed: %s", esp_err_to_name(touch_ret));
        ret = touch_ret;
        goto cleanup;
    }
} else {
    ESP_LOGW(TAG, "touch wake-up failed: %s", esp_err_to_name(touch_ret));
}
vTaskDelay(pdMS_TO_TICKS(10));

// ...

for (uint8_t address = 0x03; address <= 0x77; address++) {
    esp_err_t probe_ret = i2c_master_probe(bus, address, SCAN_TIMEOUT_MS);
    if (probe_ret == ESP_OK) {
        ESP_LOGI(TAG, "found 0x%02x %s",
                 (unsigned)address, known_device_name(address));
        found++;
    } else if (probe_ret == ESP_ERR_TIMEOUT) {
        timeout++;
    } else if (probe_ret != ESP_ERR_NOT_FOUND) {
        other_error++;
        ESP_LOGW(TAG, "probe 0x%02x failed: %s",
                 (unsigned)address, esp_err_to_name(probe_ret));
    }
}

void app_main(void)
{
    s31_rtc_handle_t *rtc = NULL;
    ESP_ERROR_CHECK(s31_rtc_acquire(&rtc));
    ESP_ERROR_CHECK(s31_rtc_start_1hz_interrupt(rtc));

    s31_rtc_time_t now = {0};
    ESP_ERROR_CHECK(s31_rtc_get_time(rtc, &now));
    if (now.voltage_low || now.year < 2024 || now.month == 0 || now.day == 0) {
        const s31_rtc_time_t initial = {
            .year = 2026, .month = 1, .day = 1, .weekday = 4,
            .hour = 12, .minute = 0, .second = 0,
        };
        ESP_LOGW(TAG, "invalid RTC time; setting 2026-01-01 12:00:00");
        ESP_ERROR_CHECK(s31_rtc_set_time(rtc, &initial));
    }

    uint32_t last_interrupt = 0;
    while (true) {
        ESP_ERROR_CHECK(s31_rtc_get_time(rtc, &now));
        ESP_LOGI(TAG, "%04u-%02u-%02u %02u:%02u:%02u weekday=%u VL=%d",
                 now.year, now.month, now.day, now.hour, now.minute, now.second,
                 now.weekday, now.voltage_low);
        s31_rtc_interrupt_status_t status = {0};
        ESP_ERROR_CHECK(s31_rtc_get_interrupt_status(rtc, &status));
        if (status.count != last_interrupt) {
            ESP_LOGI(TAG, "INT count=%lu level=%d control2=0x%02x",
                     (unsigned long)status.count, status.gpio_level, status.control2);
            ESP_ERROR_CHECK(s31_rtc_clear_interrupt(rtc));
            last_interrupt = status.count;
        }
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

void app_main(void)
{
    s31_imu_handle_t *imu = NULL;
    ESP_ERROR_CHECK(s31_imu_acquire(&imu));
    uint8_t who = 0;
    uint8_t revision = 0;
    ESP_ERROR_CHECK(s31_imu_get_identity(imu, &who, &revision));
    ESP_LOGI(TAG, "WHO_AM_I=0x%02x revision=0x%02x", who, revision);

    uint32_t sample = 0;
    while (true) {
        bool ready = false;
        uint8_t status_int = 0;
        uint8_t status0 = 0;
        esp_err_t ret = s31_imu_is_data_ready(imu, &ready, &status_int, &status0);
        if (ret == ESP_OK && ready) {
            s31_imu_data_t data = {0};
            ESP_ERROR_CHECK(s31_imu_read(imu, &data));
            ESP_LOGI(TAG,
                     "sample=%lu acc[g]=%+.3f,%+.3f,%+.3f gyro[dps]=%+.2f,%+.2f,%+.2f temp=%.2fC int=0x%02x status0=0x%02x gpio=%d",
                     (unsigned long)++sample, data.accel_x_g, data.accel_y_g,
                     data.accel_z_g, data.gyro_x_dps, data.gyro_y_dps,
                     data.gyro_z_dps, data.temperature_c, data.status_int,
                     data.status0, data.int_gpio_level);
        } else if (ret != ESP_OK) {
            ESP_LOGW(TAG, "status read failed: %s", esp_err_to_name(ret));
        } else {
            ESP_LOGD(TAG, "waiting: INT=0x%02x STATUS0=0x%02x", status_int, status0);
        }
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

void app_main(void)
{
    while (true) {
        s31_battery_handle_t *battery = NULL;
        esp_err_t ret = s31_battery_acquire(&battery);
        if (ret != ESP_OK) {
            ESP_LOGE(TAG,
                     "BQ27220 is not responding: %s. The gauge is powered from "
                     "the battery; connect a battery and verify the I2C bus with "
                     "01_i2c_scan. Retrying...",
                     esp_err_to_name(ret));
            vTaskDelay(pdMS_TO_TICKS(BATTERY_RETRY_DELAY_MS));
            continue;
        }

        ESP_LOGI(TAG, "BQ27220 detected");
        while (true) {
            s31_battery_info_t info = {0};
            ret = s31_battery_get_info(battery, &info);
            if (ret != ESP_OK) {
                ESP_LOGE(TAG, "BQ27220 read failed: %s", esp_err_to_name(ret));
                break;
            }
            ESP_LOGI(TAG,
                     "voltage=%umV current=%dmA avg=%dmA power=%dmW cap=%u/%umAh soc=%u%% soh=%u%% temp=%.1fC cycles=%u max_load=%dmA tte=%umin ttf=%umin status=0x%04x",
                     info.voltage_mv, info.current_ma, info.average_current_ma,
                     info.average_power_mw, info.remaining_capacity_mah,
                     info.full_charge_capacity_mah, info.state_of_charge_percent,
                     info.state_of_health_percent, info.temperature_c,
                     info.cycle_count, info.max_load_ma, info.time_to_empty_min,
                     info.time_to_full_min, info.status);
            vTaskDelay(pdMS_TO_TICKS(BATTERY_RETRY_DELAY_MS));
        }

        ret = s31_battery_release();
        if (ret != ESP_OK) {
            ESP_LOGW(TAG, "BQ27220 release failed: %s", esp_err_to_name(ret));
        }
        vTaskDelay(pdMS_TO_TICKS(BATTERY_RETRY_DELAY_MS));
    }
}

char path[512];
int len = snprintf(path, sizeof(path), "%s/s31_tf_card_demo.txt", sd->mount_point);
if (len <= 0 || (size_t)len >= sizeof(path)) {
    ESP_LOGE(TAG, "Test file path is too long");
    goto cleanup;
}

FILE *file = fopen(path, "w");
if (!file) {
    ESP_LOGE(TAG, "Failed to open %s for writing", path);
    goto cleanup;
}
int write_ret = fputs("ESP32-S31 TF card demo OK\n", file);
int close_ret = fclose(file);
if (write_ret == EOF || close_ret != 0) {
    ESP_LOGE(TAG, "Failed to write %s", path);
    goto cleanup;
}
ESP_LOGI(TAG, "wrote %s", path);

char line[64] = {0};
file = fopen(path, "r");
if (!file) {
    ESP_LOGE(TAG, "Failed to open %s for reading", path);
    goto cleanup;
}
if (!fgets(line, sizeof(line), file)) {
    ESP_LOGE(TAG, "Failed to read %s", path);
    fclose(file);
    goto cleanup;
}
fclose(file);
ESP_LOGI(TAG, "read back: %s", line);

ESP_ERROR_CHECK(esp_board_manager_init_device_by_name("audio_adc"));
dev_audio_codec_handles_t *adc = NULL;
ESP_ERROR_CHECK(esp_board_manager_get_device_handle("audio_adc", (void **)&adc));
ESP_ERROR_CHECK(adc && adc->codec_dev ? ESP_OK : ESP_ERR_INVALID_STATE);

esp_codec_dev_sample_info_t format = {
    .sample_rate = SAMPLE_RATE,
    .channel = CHANNELS,
    .bits_per_sample = 16,
    .mclk_multiple = 256,
};
ESP_ERROR_CHECK(esp_codec_dev_open(adc->codec_dev, &format) == ESP_CODEC_DEV_OK ? ESP_OK : ESP_FAIL);
ESP_ERROR_CHECK(esp_codec_dev_set_in_gain(adc->codec_dev, 30.0f) == ESP_CODEC_DEV_OK ? ESP_OK : ESP_FAIL);

// ...

while (true) {
    ESP_ERROR_CHECK(esp_codec_dev_read(adc->codec_dev, samples, BUFFER_BYTES) == ESP_CODEC_DEV_OK
                        ? ESP_OK : ESP_FAIL);
    int32_t left_peak = 0;
    int32_t right_peak = 0;
    for (int i = 0; i < FRAME_SAMPLES; i++) {
        int32_t left = abs(samples[i * 2]);
        int32_t right = abs(samples[i * 2 + 1]);
        left_peak = left > left_peak ? left : left_peak;
        right_peak = right > right_peak ? right : right_peak;
    }
    ESP_LOGI(TAG,
             "frame=%" PRIu32 " peak L=%ld R=%ld first samples: [%d,%d] [%d,%d] [%d,%d] [%d,%d]",
             frame++, (long)left_peak, (long)right_peak,
             samples[0], samples[1], samples[2], samples[3],
             samples[4], samples[5], samples[6], samples[7]);

periph_uart_handle_t *uart = NULL;
periph_uart_config_t *config = NULL;
ESP_ERROR_CHECK(esp_board_periph_ref_handle("uart_rs485", (void **)&uart));
ESP_ERROR_CHECK(esp_board_manager_get_periph_config("uart_rs485", (void **)&config));
ESP_ERROR_CHECK(uart ? ESP_OK : ESP_ERR_INVALID_STATE);
ESP_ERROR_CHECK(config ? ESP_OK : ESP_ERR_INVALID_STATE);
ESP_LOGI(TAG, "using uart_rs485: UART%d TX=GPIO%d RX=GPIO%d RTS/DE=GPIO%d baud=%d",
         uart->uart_num, config->tx_io_num, config->rx_io_num,
         config->rts_io_num, config->uart_config.baud_rate);

uint8_t rx[RX_BUFFER_SIZE];
uint32_t counter = 0;
while (true) {
    char tx[96];
    int length = snprintf(tx, sizeof(tx), "ESP32-S31 RS485 counter=%" PRIu32 "\r\n", counter++);
    uart_write_bytes(uart->uart_num, tx, length);
    uart_wait_tx_done(uart->uart_num, pdMS_TO_TICKS(100));
    int rx_len = uart_read_bytes(uart->uart_num, rx, sizeof(rx) - 1, pdMS_TO_TICKS(500));
    if (rx_len > 0) {
        rx[rx_len] = 0;
        ESP_LOGI(TAG, "RX %d byte(s): %s", rx_len, (char *)rx);
    }
    vTaskDelay(pdMS_TO_TICKS(1000));
}

uint8_t payload[16] = {0};
memcpy(payload, "S31 CAN FD", 10);
payload[12] = (uint8_t)(counter >> 24);
payload[13] = (uint8_t)(counter >> 16);
payload[14] = (uint8_t)(counter >> 8);
payload[15] = (uint8_t)counter;
twai_frame_t frame = {
    .header.id = 0x123,
    .header.dlc = twaifd_len2dlc(sizeof(payload)),
    .header.fdf = true,
    .header.brs = true,
    .buffer = payload,
    .buffer_len = sizeof(payload),
};
ret = twai_node_transmit(node, &frame, pdMS_TO_TICKS(100));

static void client_event(const usb_host_client_event_msg_t *event, void *arg)
{
    (void)arg;
    if (event->event == USB_HOST_CLIENT_EVENT_NEW_DEV) {
        usb_device_handle_t device = NULL;
        if (usb_host_device_open(s_client, event->new_dev.address, &device) == ESP_OK) {
            usb_device_info_t info = {0};
            if (usb_host_device_info(device, &info) == ESP_OK) {
                ESP_LOGI(TAG, "device %u speed=%s config=%u",
                         event->new_dev.address, usb_speed_text(info.speed),
                         info.bConfigurationValue);
            }
            const usb_device_desc_t *descriptor = NULL;
            if (usb_host_get_device_descriptor(device, &descriptor) == ESP_OK) {
                ESP_LOGI(TAG, "device %u VID=0x%04x PID=0x%04x class=0x%02x",
                         event->new_dev.address, descriptor->idVendor,
                         descriptor->idProduct, descriptor->bDeviceClass);
            }
            usb_host_device_close(s_client, device);
        }
    } else if (event->event == USB_HOST_CLIENT_EVENT_DEV_GONE) {
        ESP_LOGI(TAG, "device disconnected");
    }
}

while (true) {
    uint16_t *frame = frames[frame_index];
    draw_pattern(frame, config->lcd_width, config->lcd_height, pattern);
    sync_frame(frame, config->lcd_width, config->lcd_height);
    ESP_ERROR_CHECK(esp_lcd_panel_draw_bitmap(lcd->panel_handle,
                                              0, 0,
                                              config->lcd_width,
                                              config->lcd_height,
                                              frame));

    if (!backlight_enabled) {
        vTaskDelay(pdMS_TO_TICKS(LCD_FIRST_FRAME_SETTLE_MS));
        ESP_ERROR_CHECK(esp_board_manager_init_device_by_name("lcd_brightness"));
        backlight_enabled = true;
    }

    pattern = (pattern + 1) % 8;
    vTaskDelay(pdMS_TO_TICKS(1000));
    frame_index ^= 1U;
}

ESP_ERROR_CHECK(esp_lcd_touch_read_data(touch->touch_handle));
uint16_t x[MAX_POINTS] = {0};
uint16_t y[MAX_POINTS] = {0};
uint16_t strength[MAX_POINTS] = {0};
uint8_t points = 0;
if (esp_lcd_touch_get_coordinates(touch->touch_handle, x, y, strength,
                                  &points, MAX_POINTS)) {
    bool clear_requested = false;
    for (uint8_t i = 0; i < points; i++) {
        if (touch_in_clear_block(x[i], y[i], lcd_config->lcd_width)) {
            clear_requested = true;
            break;
        }
    }
    if (clear_requested) {
        ESP_ERROR_CHECK(draw_page(lcd->panel_handle, lcd_config->lcd_width,
                                  lcd_config->lcd_height, line));
        ESP_LOGI(TAG, "clear screen");
    } else {
        for (uint8_t i = 0; i < points; i++) {
            ESP_ERROR_CHECK(draw_mark(lcd->panel_handle, lcd_config->lcd_width,
                                      lcd_config->lcd_height, x[i], y[i],
                                      s_colors[i % MAX_POINTS], mark));
            ESP_LOGI(TAG, "touch=%" PRIu32 " point=%u x=%u y=%u strength=%u",
                     count++, i, x[i], y[i], strength[i]);
        }
    }

void app_main(void)
{
#if CONFIG_S31_TEST_USB_HOST_ONLY
    run_usb_host_only_test();
#else
    run_full_test();
#endif
}

esp_lv_adapter_config_t adapter = ESP_LV_ADAPTER_DEFAULT_CONFIG();
adapter.task_priority = 4;
adapter.task_stack_size = 8192;
adapter.tick_period_ms = 5;
ESP_ERROR_CHECK(esp_lv_adapter_init(&adapter));

esp_lv_adapter_display_config_t display_config =
    ESP_LV_ADAPTER_DISPLAY_RGB_DEFAULT_CONFIG(lcd->panel_handle, lcd->io_handle,
                                               lcd_config->lcd_width, lcd_config->lcd_height,
                                               ESP_LV_ADAPTER_ROTATE_0);
display_config.profile.buffer_height = 80;
display_config.profile.use_psram = true;
display_config.profile.require_double_buffer = true;
display_config.profile.enable_ppa_accel = CONFIG_S31_LVGL_DEMO_ENABLE_PPA;
display_config.tear_avoid_mode = ESP_LV_ADAPTER_TEAR_AVOID_MODE_DOUBLE_DIRECT;
lv_display_t *display = esp_lv_adapter_register_display(&display_config);
ESP_ERROR_CHECK(display ? ESP_OK : ESP_FAIL);

const esp_lv_adapter_touch_config_t touch_config =
    ESP_LV_ADAPTER_TOUCH_DEFAULT_CONFIG(display, touch->touch_handle);
ESP_ERROR_CHECK(esp_lv_adapter_register_touch(&touch_config) ? ESP_OK : ESP_FAIL);
ESP_ERROR_CHECK(esp_lv_adapter_start());

ESP_ERROR_CHECK(esp_lv_adapter_lock(-1));
app_ui_create();
app_ui_start();
esp_lv_adapter_unlock();

void app_main(void)
{
#if CONFIG_EXAMPLE_A2DP_SINK_USE_EXTERNAL_CODEC == FALSE
    ESP_ERROR_CHECK(esp_board_manager_init_device_by_name("audio_dac"));
#endif

    if (music_ui_start() != ESP_OK) {
        ESP_LOGW(BT_AV_TAG, "music UI disabled");
    }

    ESP_ERROR_CHECK(bredr_app_common_init());


    bt_app_task_start_up();
    /* bluetooth device name, connection mode and profile set up */
    bt_app_work_dispatch(bt_av_hdl_stack_evt, BT_APP_EVT_STACK_UP, NULL, 0, NULL, NULL);

}

static esp_err_t open_stream(uvc_host_stream_hdl_t *stream)
{
    uvc_host_stream_config_t config = s_stream_config;

    for (size_t i = 0; i < sizeof(s_preferred_formats) / sizeof(s_preferred_formats[0]); i++) {
        config.vs_format = s_preferred_formats[i];
        log_stream_format("Opening UVC stream", &config.vs_format);

        esp_err_t ret = uvc_host_stream_open(&config, pdMS_TO_TICKS(5000), stream);
        if (ret == ESP_OK) {
            return ESP_OK;
        }

        ESP_LOGW(TAG, "Open candidate %u failed: %s", (unsigned)i, esp_err_to_name(ret));
    }

    return ESP_ERR_NOT_FOUND;
}