yc_client/main/ulp_riscv_adc_example_main.c

/*
 * SPDX-FileCopyrightText: 2022 Espressif Systems (Shanghai) CO LTD
 *
 * SPDX-License-Identifier: Unlicense OR CC0-1.0
 */
/* ULP riscv example

   This example code is in the Public Domain (or CC0 licensed, at your option.)

   Unless required by applicable law or agreed to in writing, this
   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
   CONDITIONS OF ANY KIND, either express or implied.
*/

#include <stdio.h>
#include <inttypes.h>
#include "esp_sleep.h"
#include "ulp_riscv.h"
#include "ulp_riscv_adc.h"
#include "ulp_main.h"
#include "ulp/example_config.h"
#include "esp_err.h"
#include "driver/adc.h"
#include "esp_adc/adc_oneshot.h"
#include "esp_adc/adc_cali.h"
#include "esp_adc/adc_cali_scheme.h"
#include "user_sleep.h"

#include "driver/uart.h"
#include "esp_sleep.h"
#include "esp_log.h"
#include "esp_timer.h"
#include "SPIFFS.h"

#include "LORA.h"
#include "FONT_LIB.h"
#include "driver/rtc_io.h"
#include "user_time.h"
#include "Decection.h"
#include "yc_protocol.h"

#include "esp_sleep.h"
#include "soc/sens_reg.h"
#include "driver/gpio.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/timers.h"
#include "iot_button.h"

static const char *LOG_TAG = "ulp_riscv_adc";
// extern  uint8_t _wakeup_reson;  //内存上次唤醒的原因
extern QueueHandle_t screen_queue;
bool is_first_run = false; // 当前时间片只执行一次标志

bool is_first_charge = false; // 当前充电发送只执行一次标志

uint8_t charging_flag;
extern const uint8_t ulp_main_bin_start[] asm("_binary_ulp_main_bin_start");
extern const uint8_t ulp_main_bin_end[] asm("_binary_ulp_main_bin_end");
extern bool is_paired_sleep;
static void init_ulp_program(void);

extern void app_init();

extern RTC_DATA_ATTR uint8_t wakeup_reson; // 内存上次唤醒的原因

extern int64_t sleep_before_us; // 开始进入睡眠时间
extern int64_t sleep_afterr_us; // 唤醒时间

volatile int charge_is_success;
volatile int charge_is_running;

bool read_charge_is_success()
{
    return true;
}

bool read_charge_is_running()
{
    return true;
}

static void light_sleep_task(void *args)
{
    // if(Machine_info.eflagID != 0xff)  //如果未分配ID
    // {
    //  esp_light_sleep_start();  //进入休眠
    // }
    extern bool is_adv;
    int bat_times = 0;
    extern bool is_epd_ok;
    extern bool is_epd_ok_cplt;
    int lev_2 = 0;
    while (true)
    {
        if (is_key_press() || !is_epd_ok || !is_epd_ok_cplt || !is_change_chanel_ok)
        {
            ESP_LOGI(LOG_TAG, "%d %d %d %dnot sleep 1s continue", is_key_press(), !is_epd_ok, !is_epd_ok_cplt, !is_change_chanel_ok);
            vTaskDelay(1000 / portTICK_PERIOD_MS);
            continue;
        }
        extern bool is_sleep;
        if (is_sleep == true)
        {
            // lora_set_power_level(0);
#if USER_LIGHT_SLEEP_ENABLE
            // ESP_LOGE(LOG_TAG, "start light_sleep ,is_first_run = %d\r\n", is_first_run);

            if (Machine_info.power_status == 0) // 关机状态
            {
                lora_set_power_level(0);

                font_into_sleep();
#include "EPD.h"
                epd_sleep(SCREEN_LEFT);
                epd_sleep(SCREEN_RIGHT);

                // gpio_hold_en(PIN_L_CS);
                // gpio_hold_en(PIN_R_CS);

                // gpio_set_level(PIN_L_CS,1);
                // gpio_set_level(PIN_R_CS,1);
                // gpio_reset_pin(46);

                // uart_wait_tx_idle_polling(CONFIG_ESP_CONSOLE_UART_NUM);
                // ESP_ERROR_CHECK(uart_wait_tx_done(UART_NUM_1,portMAX_DELAY));
                esp_sleep_disable_wakeup_source(ESP_SLEEP_WAKEUP_TIMER);

#if 1 // 电源按键

                gpio_reset_pin(4);
                int ext_wakeup_pin_0 = 4;
                // printf("Enabling EXT0 wakeup on pin GPIO%d\n", ext_wakeup_pin_0);
                ESP_ERROR_CHECK(esp_sleep_enable_ext0_wakeup(ext_wakeup_pin_0, 0));

                // Configure pullup/downs via RTCIO to tie wakeup pins to inactive level during deepsleep.
                // EXT0 resides in the same power domain (RTC_PERIPH) as the RTC IO pullup/downs.
                // No need to keep that power domain explicitly, unlike EXT1.
                ESP_ERROR_CHECK(rtc_gpio_pullup_en(ext_wakeup_pin_0));
                ESP_ERROR_CHECK(rtc_gpio_pulldown_dis(ext_wakeup_pin_0));

#endif

                // 充电按键

#if 0
                                // adc_oneshot_del_unit(adc1_handle);
                                gpio_reset_pin(2);
                                int ext_wakeup_pin_1 = 2;
                                //printf("Enabling EXT0 wakeup on pin GPIO%d\n", ext_wakeup_pin_0);
                                ESP_ERROR_CHECK(esp_sleep_enable_ext0_wakeup(ext_wakeup_pin_1, 0));

                                // Configure pullup/downs via RTCIO to tie wakeup pins to inactive level during deepsleep.
                                // EXT0 resides in the same power domain (RTC_PERIPH) as the RTC IO pullup/downs.
                                // No need to keep that power domain explicitly, unlike EXT1.
                                ESP_ERROR_CHECK(rtc_gpio_pullup_en(ext_wakeup_pin_1));
                                ESP_ERROR_CHECK(rtc_gpio_pulldown_dis(ext_wakeup_pin_1));
                                //gpio_hold_en(4);
#else
                gpio_reset_pin(2);
                const int ext_wakeup_pin_1 = 2;
                const uint64_t ext_wakeup_pin_1_mask = 1ULL << ext_wakeup_pin_1;
                // printf("Enabling EXT1 wakeup on pins GPIO %d\r\n", ext_wakeup_pin_1);
                ESP_ERROR_CHECK(esp_sleep_enable_ext1_wakeup(ext_wakeup_pin_1_mask, ESP_EXT1_WAKEUP_ALL_LOW));

#endif

                esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON);
                ESP_ERROR_CHECK(esp_sleep_enable_ulp_wakeup());

                // if (!is_key_press())
                // {
                printf("=>deep sleep\r\n");
                uart_wait_tx_idle_polling(1); // 抛出剩余串口1消息
                uart_wait_tx_idle_polling(CONFIG_ESP_CONSOLE_UART_NUM);
                iot_button_stop();
                adc_oneshot_del_unit(adc1_handle);
                // vTaskDelay(100 / portTICK_PERIOD_MS);
                is_first_run = false;
                esp_deep_sleep_start();
                // }

                // esp_light_sleep_start();
            }
            else if ((Machine_info.power_status == 1) && Machine_info.paired == 1 && is_paired_sleep) // 开机状态且配对
            {
                lora_set_power_level(0);
                is_paired_sleep = false; // 只有发送完lora消息后才会进入休眠
                font_into_sleep();
#include "EPD.h"
                epd_sleep(SCREEN_LEFT);
                epd_sleep(SCREEN_RIGHT);

                // uart_driver_delete(UART_NUM_1);
                // gpio_reset_pin(LORA_TXD_PIN);
                // gpio_reset_pin(LORA_RXD_PIN);

                // gpio_config_t io_conf = {};
                // io_conf.pin_bit_mask = (1<<LORA_TXD_PIN);
                // io_conf.mode = GPIO_MODE_OUTPUT;
                // io_conf.pull_up_en = false;
                // gpio_config(&io_conf);

                // io_conf.pin_bit_mask = (1<<LORA_RXD_PIN);
                // io_conf.mode = GPIO_MODE_OUTPUT;
                // io_conf.pull_up_en = false;
                // gpio_config(&io_conf);

                // gpio_set_level(LORA_TXD_PIN, 0);
                // gpio_set_level(LORA_RXD_PIN, 0);
                // gpio_hold_en(LORA_TXD_PIN);
                // gpio_hold_en(LORA_RXD_PIN);

#if 0
                            adc_oneshot_del_unit(adc1_handle);
                            gpio_reset_pin(8);
                            int ext_wakeup_pin_0 = 8;
                            printf("Enabling EXT0 wakeup on pin GPIO%d\n", ext_wakeup_pin_0);
                            ESP_ERROR_CHECK(esp_sleep_enable_ext0_wakeup(ext_wakeup_pin_0, 0));

                            // Configure pullup/downs via RTCIO to tie wakeup pins to inactive level during deepsleep.
                            // EXT0 resides in the same power domain (RTC_PERIPH) as the RTC IO pullup/downs.
                            // No need to keep that power domain explicitly, unlike EXT1.
                            ESP_ERROR_CHECK(rtc_gpio_pullup_en(ext_wakeup_pin_0));
                            ESP_ERROR_CHECK(rtc_gpio_pulldown_dis(ext_wakeup_pin_0));
#else

                iot_button_stop();
#if 1 // 电源按键
      // adc_oneshot_del_unit(adc1_handle);
                gpio_reset_pin(4);
                int ext_wakeup_pin_0 = 4;
                printf("Enabling EXT0 wakeup on pin GPIO%d\n", ext_wakeup_pin_0);
                ESP_ERROR_CHECK(esp_sleep_enable_ext0_wakeup(ext_wakeup_pin_0, 0));

                // Configure pullup/downs via RTCIO to tie wakeup pins to inactive level during deepsleep.
                // EXT0 resides in the same power domain (RTC_PERIPH) as the RTC IO pullup/downs.
                // No need to keep that power domain explicitly, unlike EXT1.
                ESP_ERROR_CHECK(rtc_gpio_pullup_en(ext_wakeup_pin_0));
                ESP_ERROR_CHECK(rtc_gpio_pulldown_dis(ext_wakeup_pin_0));

                esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON);
                ESP_ERROR_CHECK(esp_sleep_enable_ulp_wakeup());

#endif

#endif
                // 重新配置休眠唤醒时间
                esp_sleep_enable_timer_wakeup(TIMER_WAKEUP_TIME_US); // 配置当前休眠的唤醒时间
                // OTA 不休眠
                if (!is_adv)
                {
                    getRtcTime(&Machine_info);
                    printRtcTime("-> sleep");
                    ESP_LOGW(LOG_TAG, "-> sleep\r\n");
                    uart_wait_tx_idle_polling(1);                           // 抛出剩余串口1消息
                    uart_wait_tx_idle_polling(CONFIG_ESP_CONSOLE_UART_NUM); // 抛出剩余串口0消息
                    // vTaskDelay(100 / portTICK_PERIOD_MS);
                    is_first_run = false;
                    esp_light_sleep_start();
                }
                else
                {
                    iot_button_stop();
                    ESP_LOGW(LOG_TAG, "OTA not sleep");
                }
            }
            else
            {
                goto not_sleep;
            }

            is_sleep = false;
#endif
        not_sleep:
            ESP_LOGE(LOG_TAG, "is_sleep = %d Machine_info.power_status = %d Machine_info.paired =%d is_paired_sleep = %d not_sleep", is_sleep, Machine_info.power_status, Machine_info.paired, is_paired_sleep);
        }

        // char *wakeup_reason = malloc(20*sizeof(uint8_t));
        int reson = esp_sleep_get_wakeup_cause();
        if (is_btn_timeout())
        {
            terminal_send_data(); // 添加数据队列
        }
        ESP_LOGW(LOG_TAG, "wakeup reson = %d\r\n", reson);
        printRtcTime("wakeup ");
        switch (reson)
        {
        case ESP_SLEEP_WAKEUP_TIMER:
            iot_button_resume();
            if (is_first_run == false)
            {
                lora_set_power_level(1); // 打开lora电源
                font_exit_sleep();       // 退出睡眠
                gpio_hold_dis(LORA_TXD_PIN);
                gpio_hold_dis(LORA_RXD_PIN);

                // 恢复串口i功能
                uart_sleep_out_config();

                getRtcTime(&Machine_info);
                Machine_info.batt_precent = read_battery_voltage();
                Machine_info.wait_send_rssi_bat++;
                printf("weakup: bat %d wait_send_rssi_bat = %d,\r\n", Machine_info.batt_precent, Machine_info.wait_send_rssi_bat);

                if (Machine_info.paired == 1)
                {

                    printList(Send_list); // 打印待发数据

                    // if(Machine_info.wait_send_rssi_bat>(30*60/TIMER_WAKEUP_TIME_S))//30分钟发一次lora
                    if (Machine_info.wait_send_rssi_bat > 60) // 30分钟唤醒一次->(30*60/TIMER_WAKEUP_TIME_S) = 60
                    // if (Machine_info.wait_send_rssi_bat>10)
                    {
                        ESP_LOGE(LOG_TAG, "-> 30minite send lora info");
                        Machine_info.wait_send_rssi_bat = 0;
                        // f_send_test();
                        f_send_get_time();
                        f_send_get_chart_data();
                        f_send_battary_vaule(Machine_info.batt_precent);
                    }

                    if ((Machine_info.last_button.Minute != Machine_info.min) /*||(Machine_info.last_button.Hour != Machine_info.Hour)*/) //
                    {
                        if (is_sync_time(&Machine_info)) // 同步到时间
                        {
                            ESP_LOGW(LOG_TAG, "update left value min %d,last min %d\r\n", Machine_info.min, Machine_info.last_button.Minute);
                            Machine_info.last_button.time_min += (Machine_info.min - Machine_info.last_button.Minute);
                        }
                        else
                        {
                            printf("time not sync\r\n");
                        }
                    }

                    printf("start timer id = %d,%d\r\n", Machine_info.eflagID, Machine_info.eflagID * TIMER_CAN_SEND_TIME);

                    // Already_send_timer_stop();
                    Already_send_timer_start(LORA_POWER_TIME + (Machine_info.eflagID * TIMER_CAN_SEND_TIME));
                }
                is_first_run = true;
            }

            break;
        case ESP_SLEEP_WAKEUP_GPIO:

            lev_2 = gpio_get_level(2);

            {
                if (Machine_info.power_status == 0) // 关机的情况
                {

                    if (!lev_2) // 充电
                    {

                        if (is_first_charge == false)
                        {

                            Machine_info.is_charge = true; // 充电中标志
                            is_first_charge = true;

                            gpio_hold_dis(PIN_R_CS);
                            set_screen_dis_info_and_send_queue(true, false, false, false, 100);
                            printf("charge in\r\n");
                        }
                    }
                    else // 未充电
                    {
                        if (is_first_charge == true)
                        {
                            Machine_info.is_charge = false; // 拔掉充电
                            is_first_charge = false;
                            gpio_hold_dis(PIN_R_CS);
                            set_screen_dis_info_and_send_queue(true, false, false, false, 100);
                            // sleep_timer_start(1000);

                            // user_compare(last_batt_precent,Machine_info.batt_precent);//刷完左屏，比较一次电量。电量图标不同则刷一次右屏

                            printf("not charge in or charge out\r\n");
                        }
                    }
                }
                else if (Machine_info.power_status == 1) // 开机的情况
                {

                    if (!lev_2) // 充电
                    {
                        if (is_first_charge == false)
                        {

                            Machine_info.is_charge = true; // 充电中标志
                            is_first_charge = true;
                            right_screen_send();
                            printf("charge in\r\n");
                        }
                    }
                    else
                    {
                        if (is_first_charge == true)
                        {
                            Machine_info.is_charge = false; // 拔掉充电
                            is_first_charge = false;

                            right_screen_send();

                            // user_compare(last_batt_precent,Machine_info.batt_precent);//刷完左屏，比较一次电量。电量图标不同则刷一次右屏

                            printf("not charge in or charge out\r\n");
                        }
                    }
                }
            }

            break;
        case ESP_SLEEP_WAKEUP_UART:

            // wakeup_reason = "uart";
            /* Hang-up for a while to switch and execuse the uart task
             * Otherwise the chip may fall sleep again before running uart task */
            vTaskDelay(1);
            break;
        case ESP_SLEEP_WAKEUP_ULP:
            iot_button_resume();
            if ((Machine_info.power_status == 1) && Machine_info.paired == 1)
            {
                is_paired_sleep = true;
                ESP_LOGW(LOG_TAG, "is_paired_sleep = true");
            }
            break;
        case ESP_SLEEP_WAKEUP_EXT0:

            if (!is_adv)
            {
                iot_button_resume();
            }
            if (Machine_info.paired && Machine_info.power_status && !is_key_press())
            {
                vTaskDelay(2000 / portTICK_PERIOD_MS);
                is_paired_sleep = true;
                is_sleep = true; // 配对且关机，进入休眠
            }

            break;
        default:

            break;
        }
        // 先屏蔽电量刷屏部分代码2024.1.11
        /* extern bool is_adv;
         if(is_adv)//OTA 模式不检测电量
         {
             printf("is_adv\r\n");
         }
         else */
        if (Machine_info.power_status == 0) // 关机的情况
        {
            user_compare_power_off(Machine_info.last_batt_precent, Machine_info.batt_precent);
        }
        else if (Machine_info.power_status == 1) // 开机的情况
        {
            if (read_battery_voltage() == 0)
            {
                ESP_LOGE(LOG_TAG, "-->low batt!!!! , power off\r\n");
#if 1
                if (Machine_info.paired == 1)
                {
                    is_paired_sleep = true;
                }
                set_screen_dis_info_and_send_queue(false, true, true, false, 500);
                set_screen_dis_info_and_send_queue(true, false, false, false, 500);
#endif
            }

            lev_2 = gpio_get_level(2);

            {

                if (Machine_info.power_status == 1) // 开机的情况
                {

                    if (!lev_2) // 充电
                    {
                        if (is_first_charge == false)
                        {

                            Machine_info.is_charge = true; // 充电中标志
                            is_first_charge = true;
                            right_screen_send();
                            printf("charge in\r\n");
                        }
                    }
                    else
                    {
                        if (is_first_charge == true)
                        {
                            Machine_info.is_charge = false; // 拔掉充电
                            is_first_charge = false;

                            right_screen_send();

                            // user_compare(last_batt_precent,Machine_info.batt_precent);//刷完左屏，比较一次电量。电量图标不同则刷一次右屏

                            printf("not charge in or charge out\r\n");
                        }
                    }
                }
            }

            bat_times++;

            if (bat_times > 30)
            {
                bat_times = 0;
                Machine_info.batt_precent = read_battery_voltage();
                // printf("compare current bat and last bat refresh display,current = %d,last =%d\r\n", Machine_info.batt_precent, Machine_info.last_batt_precent);
                // user_compare(Machine_info.last_batt_precent, Machine_info.batt_precent); // 刷完左屏，比较一次电量。电量值不同则刷一次右屏
                Machine_info.last_batt_precent = Machine_info.batt_precent;
            }
        }

        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
    vTaskDelete(NULL);
}

/*********************************************************************************
 * function   :   app_main
 * Description :  初始化任务相关
 * Input       :
 * Output      :
 * Author      :                      Data : 2023 11.08
 **********************************************************************************/
void app_main(void)
{
    printRtcTime("app_main before");
    app_init();   // 用户任务相关
    sleep_init(); // 使能协处理器相关
                  // 创建休眠任务
    xTaskCreate(light_sleep_task, "light_sleep_task", 4096 * 5, NULL, 1, NULL);

    printRtcTime("app_main after");
    printf("Machine_info.power_status = %d\r\n", Machine_info.power_status);

    if (Machine_info.power_status == 0) // 关机状态
    {
        sleep_timer_start(5000);
    }
}

/*********************************************************************************
 * function   :   init_ulp_program
 * Description :  初始化ulp处理器相关
 * Input       :
 * Output      :
 * Author      :                      Data : 2023 11.08
 **********************************************************************************/
static void init_ulp_program(void)
{
    ulp_riscv_adc_cfg_t cfg = {
        .adc_n = EXAMPLE_ADC_UNIT,
        .channel = EXAMPLE_ADC_CHANNEL,
        .width = EXAMPLE_ADC_WIDTH,
        .atten = EXAMPLE_ADC_ATTEN,
    };

    extern adc_oneshot_unit_handle_t adc1_handle;
    ESP_ERROR_CHECK(adc_oneshot_del_unit(adc1_handle));

#if 0
// #include "user_button.h"
// power_button_deinit();
// power_button_init(adc1_handle);
#endif

    ESP_ERROR_CHECK(ulp_riscv_adc_init(&cfg));

    esp_err_t err = ulp_riscv_load_binary(ulp_main_bin_start, (ulp_main_bin_end - ulp_main_bin_start));

    ESP_ERROR_CHECK(err);

/* The first argument is the period index, which is not used by the ULP-RISC-V timer
 * The second argument is the period in microseconds, which gives a wakeup time period of: 20ms
 */
#if 0
ulp_set_wakeup_period(0, 20000);
#else
    ulp_set_wakeup_period(0, 50000);
#endif
    /* Start the program */

    /* Start the program */
    // ulp_riscv_cfg_t cfg1 = {
    //     .wakeup_source = ULP_RISCV_WAKEUP_SOURCE_GPIO,
    // };

    // err = ulp_riscv_config_and_run(&cfg1);
    err = ulp_riscv_run();

    ESP_ERROR_CHECK(err);
}

void sleep_init()
{

#if 1
    // 设置协处理器配置相关adc唤醒相关
    esp_sleep_wakeup_cause_t cause = esp_sleep_get_wakeup_cause();
    /* not a wakeup from ULP, load the firmware */
    if (((cause != ESP_SLEEP_WAKEUP_ULP) && (cause != ESP_SLEEP_WAKEUP_TIMER)) && (cause != ESP_SLEEP_WAKEUP_EXT0))
    {
        printf("Not a ULP-RISC-V wakeup (cause = %d), initializing it! \n", cause);
        init_ulp_program();
    }

    /* ULP Risc-V read and detected a temperature above the limit */
    if (cause == ESP_SLEEP_WAKEUP_ULP)
    {
        printf("ULP-RISC-V woke up the main CPU\n");
        printf("Threshold: high = %" PRIu32 "\n", ulp_adc_threshold);
        printf("Value = %" PRIu32 " was above threshold\n", ulp_wakeup_result);
    }

    /* Go back to sleep, only the ULP Risc-V will run */
    // printf("Entering in sleep\n\n");
    /* RTC peripheral power domain needs to be kept on to keep SAR ADC related configs during sleep */
    esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON);

    ESP_ERROR_CHECK(esp_sleep_enable_ulp_wakeup());

#endif

#if 0
   /* Initialize GPIO */
    gpio_config_t config = 
    {
        .pin_bit_mask = (1ULL << 4),
        .mode = GPIO_MODE_INPUT,
        .pull_down_en = false,
        .pull_up_en = true,
        .intr_type = GPIO_INTR_NEGEDGE
    };


      gpio_config_t charge_config = 
    {
        .pin_bit_mask = (1ULL<<2),
        .mode = GPIO_MODE_INPUT,
        .pull_down_en = false,
        .pull_up_en = true,
        .intr_type = GPIO_INTR_LOW_LEVEL
    };


    if(gpio_config(&config)!=ESP_OK)
    {
           printf("gpio_config fail\r\n");
    }
   if(gpio_config(&charge_config)!=ESP_OK)
    {
           printf("gpio_config fail\r\n");
    }



//    gpio_hold_en(2);
//    gpio_hold_en(38);

    //配置下降沿触发
    if(gpio_wakeup_enable(4,GPIO_INTR_LOW_LEVEL)!=ESP_OK)
    {
        printf("gpio_wakeup_enable fail\r\n");
    }



    if(gpio_wakeup_enable(2,GPIO_INTR_LOW_LEVEL)!=ESP_OK)
    {
        printf("gpio_wakeup_enable fail\r\n");
    }
    //     if(gpio_wakeup_enable(38,GPIO_INTR_LOW_LEVEL)!=ESP_OK)
    // {
    //     printf("gpio_wakeup_enable fail\r\n");
    // }

    if(esp_sleep_enable_gpio_wakeup()!=ESP_OK)  //使能GPIO唤醒
    {
        printf("esp_sleep_enable_gpio_wakeup fail\r\n");
    }
#else

    //   rtc_gpio_init(4);
    //   rtc_gpio_set_direction(4, RTC_GPIO_MODE_INPUT_ONLY);
    //   rtc_gpio_pullup_en(4);
    //   rtc_gpio_pulldown_dis(4);

    //     //配置下降沿触发
    //     if(gpio_wakeup_enable(4,GPIO_INTR_LOW_LEVEL)!=ESP_OK)
    //     {
    //         printf("gpio_wakeup_enable fail\r\n");
    //     }

    //     if(esp_sleep_enable_gpio_wakeup()!=ESP_OK)  //使能GPIO唤醒
    //     {
    //         printf("esp_sleep_enable_gpio_wakeup fail\r\n");
    //     }

#endif
}