好吧，碰到问题只能自己解决，把所有代码 文档走一遍

好讨厌啊，只想要个小小功能，要学着要学那

算了底层都一样就那几种 

异常与处理   不同版本间API不同（选择相应版本IDF5.4 文档5.4）；2CMAKELISTS.TXT 添加依赖，3SDKCONFIG 打开相应的功能

​​​​​​​

对着文档写即可，错误了对照示例 

新建 工程 

工程名（文件夹：exam1）

        CMakeLists.txt(版本信息，工具路径）

        main(文件夹）

                文件（exam1.c)

                CMakeLists.txt

最小模式 (idf.py create-object 项目名)

两个文件夹，两个CMAKELIST.TXT 一个主文件 

CMakeLists.txt
        cmake_minimum_required(VERSION 3.16)

        include($ENV{IDF_PATH}/tools/cmake/project.cmake)
        project(hello)

CMakeLists.txt

        idf_component_register(SRCS "hello.c")

编辑  - 运行 -监视 

idf.py build  flash monitor 

示例代码 - 文档 - 

串口打印输出 hello(支持标准库 fgets getopt (v)

#include <stdio.h>
#include "freertos/FreeRTOS.h"
void app_main(void)
{
    while(1){
        printf("hello");
        vTaskDelay(pdMS_TO_TICKS(200));  //延时函数 sleep
    }
    
    
}

 gpio(v)

#include <stdio.h>  
#include "driver/gpio.h"
#include "freertos/FreeRTOS.h"
void app_main(void)
{
    printf("gpio test");
    gpio_config_t io_cfg = {
        .intr_type = GPIO_INTR_DISABLE,
        .mode = GPIO_MODE_OUTPUT,
        .pin_bit_mask = 1ULL<<2,
        .pull_down_en = 0,
        .pull_up_en = 0,
    
    };
    gpio_config(&io_cfg);

    while(1){
         gpio_set_level(2,1);
         vTaskDelay(pdMS_TO_TICKS(200));
         gpio_set_level(2,0);
         vTaskDelay(pdMS_TO_TICKS(200));
         

    }
   

    
}
 
//CMakeLists.txt 添加  REQUIRES esp_driver_gpio

idf_component_register(SRCS "gpiotest.c"
	REQUIRES esp_driver_gpio)

// uart_repl_example_main
 esp_rom_gpio_connect_out_signal(DEFAULT_UART_RX_PIN, UART_PERIPH_SIGNAL(1, SOC_UART_TX_PIN_IDX), false, false);

    esp_rom_gpio_connect_in_signal(DEFAULT_UART_RX_PIN, UART_PERIPH_SIGNAL(0, SOC_UART_RX_PIN_IDX), false);

I2C(

#include <stdio.h>
#include <stdint.h>
#include "freertos/FREERTOS.h"
//#include "driver/i2c_master.h"
#include "driver/i2c_master.h"
//#include "clk_tree_defs.h"

void  app_main()
{
    i2c_master_bus_handle_t handle;
    i2c_master_bus_config_t m_config = {
        .clk_source = I2C_CLK_SRC_DEFAULT,
        .i2c_port = 0,
        .scl_io_num = 11,
        .sda_io_num = 12,
        .glitch_ignore_cnt = 7,
        .flags.enable_internal_pullup = true,
    };
    i2c_new_master_bus(&m_config,&handle);

    i2c_device_config_t dev_cfg = {
        .dev_addr_length = I2C_ADDR_BIT_LEN_7,
        .device_address = 0x58,
        .scl_speed_hz = 10000,

    };
    i2c_master_dev_handle_t dev_handle;
    i2c_master_bus_add_device(handle,&dev_cfg,&dev_handle);

    uint8_t data = 10;
    i2c_master_transmit(dev_handle,&data,1,-1);
    
    i2c_master_bus_rm_device(dev_handle);
    i2c_del_master_bus(handle);

}


//CMakeLists.txt
idf_component_register(SRCS "i2ctest.c"
                    INCLUDE_DIRS ".")

ADC(c)

//idf5.4
// examples\peripherals\dac\dac_oneshot\main\dac_oneshot_example_main.c 
//https://docs.espressif.com/projects/esp-idf/zh_CN/v5.4.2/esp32/api-reference/peripherals/dac.html

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "esp_adc/adc_oneshot.h"

//ADC_CHANNEL_8   // GPIO25, same as DAC channel 0
//ADC_CHANNEL_9   // GPIO26, same as DAC channel 1


void app_main()
{
  
    adc_oneshot_unit_handle_t hadc1;
    adc_oneshot_unit_init_cfg_t init_cfg = {
        .unit_id= ADC_UNIT_1,
    };
    ESP_ERROR_CHECK(adc_oneshot_new_unit(&init_cfg,&hadc1));

    adc_oneshot_chan_cfg_t cfg = {
        .atten = ADC_ATTEN_DB_12,
        .bitwidth = ADC_BITWIDTH_DEFAULT,
    };
    
    adc_oneshot_config_channel(hadc1,ADC_CHANNEL_8,&cfg);

    int data;
    while(1)
    {
        ESP_ERROR_CHECK(adc_oneshot_read(hadc1,ADC_CHANNEL_8,&data));
        printf("%d\n",data);

        vTaskDelay(pdMS_TO_TICKS(200));

    }


}

DAC

//

#include <stdio.h>
#include "driver/dac_oneshot.h"
#include "freertos/FreeRTOS.h"


// DAC_CHAN_0 = 0,     /*!< DAC channel 0 is GPIO25(ESP32) / GPIO17(ESP32S2) */
// DAC_CHAN_1 = 1,     /*!< DAC channel 1 is GPIO26(ESP32) / GPIO18(ESP32S2) */


void app_main(void)
{
    dac_oneshot_handle_t handle;
    dac_oneshot_config_t cfg={
        .chan_id = DAC_CHAN_0,
        //.ulp_mode = false;
    };

    
    dac_oneshot_new_channel(&cfg,&handle);

    for(;;)
    for(int val=0;val<250;val++)
    {
        dac_oneshot_output_voltage(handle,val);
        vTaskDelay(10/portTICK_PERIOD_MS);

    }

}

PWM 

//

TOUCH (touch_sens.h only idf5.5  ; touch sensor idf 5.4

#include <stdio.h>
#include <freertos/FreeRTOS.h>
#include "driver/touch_sensor.h"
//#include "driver/touch_sens.h"  //5.5 not for 5.4



#define TOUCH_THRESH_NO_USE  0
#define TOUCHPAD_FILTER_TOUCH_PEROID 10
#define TOUCH_NUM  2

void app_main(void )
{
    uint32_t data;
    uint16_t fvalue;
    
    touch_pad_init();
    touch_pad_set_voltage(TOUCH_HVOLT_2V7,TOUCH_LVOLT_0V5,TOUCH_HVOLT_ATTEN_1V);


    touch_pad_config(2);


    //touch_pad_filter_start(TOUCHPAD_FILTER_TOUCH_PEROID);

    while(1)
    {
        touch_pad_read_raw_data(2,&data);
        //touch_pad_read_filtered(2,&fvalue);
        //printf("raw %d filter: %d",data,fvalue);
        //touch_pad_read(TOUCH_NUM,&fvalue);


        vTaskDelay(pdMS_TO_TICKS(100));

    }




}

uart （连接IO 22 ->23 )

//
#include <stdio.h>
#include <string.h>
#include "esp_log.h"
#include "driver/uart.h"

// connect io  22 ->23 

void app_main(void)
{
    int uart_buff_size = 2048;
   // QueueHandle_t uart_queue;
    uart_driver_install(UART_NUM_2,uart_buff_size,0,0,NULL,0);

    uart_config_t uart_config = {
        .baud_rate = 115200,
        .data_bits = UART_DATA_8_BITS,
        .parity = UART_PARITY_DISABLE,
        .stop_bits = UART_STOP_BITS_1,
        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
        .source_clk = UART_SCLK_DEFAULT,
    };

    uart_param_config(UART_NUM_2,&uart_config);
    uart_set_pin(UART_NUM_2,22,23,-1,-1);

    char *str = "test string\n";
    char in_str[200];
    while(1)
    {
        uart_write_bytes(UART_NUM_2,str,strlen(str));
        
        int len = uart_read_bytes(UART_NUM_2,in_str,199,20/portTICK_PERIOD_MS);
        in_str[len] = '\0';
        ESP_LOGI("uart recv","%s",in_str);

        
    }

    //uart_driver_delete();

temperature(only support  esp p4  readme.txt 

nvs(V) blob   unsize binary data  :nvs document esp32

#include <stdio.h>
#include <freertos/FreeRTOS.h>
#include <driver/i2s_std.h>
#include "nvs_flash.h"

void app_main()
{
    nvs_handle_t hnvs; 
    nvs_flash_init();
    nvs_open("storage",NVS_READWRITE,&hnvs); 

    //int32_t restart_count = 0;
    int32_t data = 0;
    nvs_set_i32(hnvs,"data",32);
    
    nvs_get_i32(hnvs,"data",&data);
    printf(" %ld\n",data);
    

    nvs_close(hnvs);




}

I2S

#include <stdio.h>
#include <freertos/FreeRTOS.h>
#include <driver/i2s_std.h>

#define SPK_BCLK  4
#define SPK_WS 5
#define SPK_DOUT 18

#define MIC_BCLK 22
#define MIC_WS 23
#define MIC_DIN 26

i2s_chan_handle_t rx_chan,tx_chan;
uint32_t rbuf[1024];

void app_main()
{

    //----------------------------RX
    i2s_chan_config_t rx_chan_cfg = I2S_CHANNEL_DEFAULT_CONFIG(I2S_NUM_0,I2S_ROLE_MASTER);
    i2s_new_channel(&rx_chan_cfg,NULL,&rx_chan);

    i2s_std_config_t  rx_cfg = {
        .clk_cfg = I2S_STD_CLK_DEFAULT_CONFIG(44100),

        .slot_cfg = I2S_STD_MSB_SLOT_DEFAULT_CONFIG(I2S_DATA_BIT_WIDTH_16BIT,I2S_SLOT_MODE_MONO),
    
        .gpio_cfg = {
            .mclk = I2S_GPIO_UNUSED,
            .dout= I2S_GPIO_UNUSED,
            .bclk = MIC_BCLK,
            .ws = MIC_WS,
            .din = MIC_DIN,
            .invert_flags = {
                false,false,false,
            },
            

        },

        
        
    };
    rx_cfg.slot_cfg.slot_mask = I2S_STD_SLOT_LEFT;
    i2s_channel_init_std_mode(rx_chan,&rx_cfg);
    
    i2s_channel_enable(rx_chan);

    //----------------------------TX
    i2s_chan_config_t tx_chan_cfg = I2S_CHANNEL_DEFAULT_CONFIG(I2S_NUM_1,I2S_ROLE_MASTER);
    i2s_new_channel(&tx_chan_cfg,&tx_chan,NULL);

    i2s_std_config_t  tx_cfg = {
              .clk_cfg = I2S_STD_CLK_DEFAULT_CONFIG(44100),

        .slot_cfg = I2S_STD_MSB_SLOT_DEFAULT_CONFIG(I2S_DATA_BIT_WIDTH_16BIT,I2S_SLOT_MODE_MONO),
    
        .gpio_cfg = {
            .mclk = I2S_GPIO_UNUSED,
            .dout= I2S_GPIO_UNUSED,
            .bclk = SPK_BCLK,
            .ws = SPK_WS,
            .din = SPK_DOUT,
            .invert_flags = {
                false,false,false,
            },
        },
    };

    tx_cfg.slot_cfg.slot_mask = I2S_STD_SLOT_LEFT;
    i2s_channel_init_std_mode(tx_chan,&tx_cfg);

    i2s_channel_enable(tx_chan);

          size_t r_bytes =0;
          size_t w_bytes = 0;
    while(1)
    {

        i2s_channel_read(rx_chan,rbuf,1024,&r_bytes,1000);
        i2s_channel_write(tx_chan,rbuf,r_bytes,&w_bytes,1000);
        
    }
    

}

BLUETOOTH （依赖项与menuconfig 

#include <stdint.h>
#include <string.h>
#include <inttypes.h>
#include "esp_log.h"

#include "nvs.h"
#include "nvs_flash.h"

#include "esp_bt.h"
#include "esp_bt_main.h"
#include "esp_bt_device.h"
#include "esp_gap_bt_api.h"
#include "esp_log_buffer.h"

#include <freertos/FreeRTOS.h>

static bool get_name_from_eir(uint8_t *eir, char *bdname, uint8_t *bdname_len);

char *SPP_TAG = "gap";



esp_bd_addr_t peer_bd_addr = {0};
static uint8_t peer_bdname_len;
static char peer_bdname[ESP_BT_GAP_MAX_BDNAME_LEN + 1];

void bt_app_gap_cb(esp_bt_gap_cb_event_t event,esp_bt_gap_cb_param_t *param)
{ //HFP FP spp initor EXAMPLE 

    switch (event)
    {
    case ESP_BT_GAP_DISC_RES_EVT:  //DISCOVER RESULT EVENT 
    ESP_LOG_BUFFER_HEX("LOG_TAG", param->disc_res.bda, ESP_BD_ADDR_LEN);
    ESP_LOGI(SPP_TAG, "ESP_BT_GAP_DISC_RES_EVT");
    ESP_LOG_BUFFER_HEX(SPP_TAG, param->disc_res.bda, ESP_BD_ADDR_LEN);
        /* Find the target peer device name in the EIR data */
        for (int i = 0; i < param->disc_res.num_prop; i++){
            if (param->disc_res.prop[i].type == ESP_BT_GAP_DEV_PROP_EIR
                && get_name_from_eir(param->disc_res.prop[i].val, (char*)peer_bdname, &peer_bdname_len)){
                ESP_LOG_BUFFER_CHAR(SPP_TAG, peer_bdname, peer_bdname_len);
                // if (strlen(remote_device_name) == peer_bdname_len
                //     && strncmp(peer_bdname, remote_device_name, peer_bdname_len) == 0) {
                //     memcpy(peer_bd_addr, param->disc_res.bda, ESP_BD_ADDR_LEN);
                //     /* Have found the target peer device, cancel the previous GAP discover procedure. And go on
                //      * dsicovering the SPP service on the peer device */
                //     esp_bt_gap_cancel_discovery();
                    
                  //  esp_spp_start_discovery(peer_bd_addr);
                }
            }
        

    // for (int i = 0; i < param->disc_res.num_prop; i++){
    //             if (param->disc_res.prop[i].type == ESP_BT_GAP_DEV_PROP_EIR
                  
    //                 && get_name_from_eir(param->disc_res.prop[i].val, peer_bdname, &peer_bdname_len)){
    //                 if (strcmp(peer_bdname, remote_device_name) == 0) {
    //                     memcpy(peer_addr, param->disc_res.bda, ESP_BD_ADDR_LEN);
    //                     ESP_LOGI(BT_HF_TAG, "Found a target device address:");
    //                     ESP_LOG_BUFFER_HEX(BT_HF_TAG, peer_addr, ESP_BD_ADDR_LEN);
    //                     ESP_LOGI(BT_HF_TAG, "Found a target device name: %s", peer_bdname);
    //                     printf("Connect.\n");
    //                    // esp_hf_client_connect(peer_addr);
    //                     esp_bt_gap_cancel_discovery();
    //                 }
    //             }
    //     }
     //   break;
        
        /* code */

        break;
    case ESP_BT_GAP_DISC_STATE_CHANGED_EVT:  //DISCOVER STATE CHANGED
        ESP_LOGI("GAP","ESP_BT_GAP_DISC_STATE_CHANGED_EVT");
        break;
    
    case ESP_BT_GAP_RMT_SRVCS_EVT: //REMOTE SERVICE EVENT 
         ESP_LOGI("GAP","ESP_BT_GAP_RMT_SRVCS_EVT");
        break;
    
    case ESP_BT_GAP_RMT_SRVC_REC_EVT:  //REMOTE SERVICE RECORD EVENT
        ESP_LOGI("GAP","ESP_BT_GAP_RMT_SRVC_REC_EVT");
        break;
    default:
        printf("event: %d",event);
        break;
    }
     return ;

}


#define GAP_TAG "ble"
// ESP_LOG_BUFFER_HEX(BT_HF_TAG, param->conn_stat.remote_bda, ESP_BD_ADDR_LEN);
void app_main(void)
{
    char bda_str[18] = {0};
    nvs_flash_init();
    esp_err_t ret ; 
    esp_bt_controller_mem_release(ESP_BT_MODE_BLE);  //底功耗与传统蓝牙 无法同时使用 需舍掉一个
    
    //初始化控制器
    esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
    esp_bt_controller_init(&bt_cfg);
    esp_bt_controller_enable(ESP_BT_MODE_CLASSIC_BT);

    //初始化blueroid  api (connect dis connect )
    esp_bluedroid_config_t bdroid = BT_BLUEDROID_INIT_CONFIG_DEFAULT();
    esp_bluedroid_init_with_cfg(&bdroid);
    esp_bluedroid_enable();

    esp_bt_gap_register_callback(bt_app_gap_cb);



    esp_bt_gap_set_scan_mode(ESP_BT_CONNECTABLE,ESP_BT_GENERAL_DISCOVERABLE);
    esp_bt_gap_start_discovery(ESP_BT_INQ_MODE_GENERAL_INQUIRY,10,0);


}



static bool get_name_from_eir(uint8_t *eir, char *bdname, uint8_t *bdname_len)
{
    uint8_t *rmt_bdname = NULL;
    uint8_t rmt_bdname_len = 0;

    if (!eir) {
        return false;
    }

    rmt_bdname = esp_bt_gap_resolve_eir_data(eir, ESP_BT_EIR_TYPE_CMPL_LOCAL_NAME, &rmt_bdname_len);
    if (!rmt_bdname) {
        rmt_bdname = esp_bt_gap_resolve_eir_data(eir, ESP_BT_EIR_TYPE_SHORT_LOCAL_NAME, &rmt_bdname_len);
    }

    if (rmt_bdname) {
        if (rmt_bdname_len > ESP_BT_GAP_MAX_BDNAME_LEN) {
            rmt_bdname_len = ESP_BT_GAP_MAX_BDNAME_LEN;
        }

        if (bdname) {
            memcpy(bdname, rmt_bdname, rmt_bdname_len);
            bdname[rmt_bdname_len] = '\0';
        }
        if (bdname_len) {
            *bdname_len = rmt_bdname_len;
        }
        return true;
    }

    return false;
}

CMakelists.txt

idf_component_register(SRCS "bluetest.c"
                    INCLUDE_DIRS ".")

elf error ->

idf.py menuconfig

component-config> Bluetooth->Bluetooth  enable  
        Bluedroid Options -> Classic Bluetooth enable 

    char* dev_name = "ESP_DEVICE2.2";
    esp_bt_gap_set_device_name(dev_name);

WIFI 

#include <stdio.h>
#include <string.h>
#include "esp_log.h"
#include "esp_err.h"

#include "nvs_flash.h"
#include "esp_event.h"
#include "esp_wifi.h"

#include "freertos/FreeRTOS.h"

#define TAG "WIFI"

#define WIFI_CONNECTED_BIT BIT0
#define WIFI_FAIL_BIT BIT1

char* SSID = "CMCC-xxxx";
char* password  ="xxxxx";

esp_netif_t *netif_t = NULL;
esp_event_handler_instance_t ip_event_handler;
esp_event_handler_instance_t wifi_event_handler;

EventGroupHandle_t wifi_event_group = NULL;

uint8_t wifi_try = 0;
void wifi_event_cb(void *arg,esp_event_base_t event_base,int32_t event_id,void *event_data)
{// example wifi station example main
    switch(event_id)
    {
        case WIFI_EVENT_WIFI_READY:
            ESP_LOGI(TAG,"READY");
            break;
        case WIFI_EVENT_SCAN_DONE:
            ESP_LOGI(TAG,"SCAN DONE");
            break;
        case WIFI_EVENT_STA_START:
            ESP_LOGI(TAG,"STA START");
            esp_wifi_connect();
            break;
        case WIFI_EVENT_STA_STOP:
            ESP_LOGI(TAG,"STA STOP");
            break;
        case WIFI_EVENT_STA_CONNECTED:
            ESP_LOGI(TAG,"STA CONNECTED");
            break;
        case WIFI_EVENT_STA_DISCONNECTED:
            ESP_LOGI(TAG,"DISCONNECTED");
            if(wifi_try <3)
            {
                esp_wifi_connect();
                wifi_try++;
            }
            else
            xEventGroupSetBits(wifi_event_group,WIFI_FAIL_BIT);

            break;
        case WIFI_EVENT_STA_AUTHMODE_CHANGE:
            ESP_LOGI(TAG,"authmode change");
            break;
        default:
            ESP_LOGI(TAG,"NOT HANDLED EVENT");
            break;

    }
}


void app_main(void)
{
    nvs_flash_init();
    wifi_event_group = xEventGroupCreate();

    esp_netif_init();
    esp_event_loop_create_default();

    esp_wifi_set_default_wifi_sta_handlers();
    netif_t = esp_netif_create_default_wifi_sta();

    wifi_init_config_t wcfg  = WIFI_INIT_CONFIG_DEFAULT();
    esp_wifi_init(&wcfg);

    esp_event_handler_instance_register(WIFI_EVENT,ESP_EVENT_ANY_ID,&wifi_event_cb,NULL,&wifi_event_handler);
    esp_event_handler_instance_register(IP_EVENT,ESP_EVENT_ANY_ID,&wifi_event_cb,NULL,&ip_event_handler);

    //wifi config
    wifi_config_t cfg = {
        .sta.threshold.authmode = WIFI_AUTH_WPA2_PSK,
    };

    strncpy((char*)cfg.sta.ssid ,SSID,sizeof(cfg.sta.ssid));
    strncpy((char*)cfg.sta.password , password,sizeof(cfg.sta.password));

    ESP_ERROR_CHECK(esp_wifi_set_ps(WIFI_PS_NONE));
    ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM));

    esp_wifi_set_mode(WIFI_MODE_STA);
    esp_wifi_set_config(WIFI_IF_STA,&cfg);
    esp_wifi_start();

    EventBits_t bits = xEventGroupWaitBits(wifi_event_group,WIFI_CONNECTED_BIT|WIFI_FAIL_BIT,pdFALSE,pdFALSE,portMAX_DELAY);
    printf("wait bits");
    if(bits& WIFI_CONNECTED_BIT)
        ESP_LOGI(TAG,"CONNECTED WIFI");
    else
        ESP_LOGI(TAG,"FAILED");

    

    // DEINIT RELEASE
//     vEventGroupDelete(wifi_event_group);
//     esp_wifi_disconnect();
//     esp_wifi_stop();
//     esp_wifi_deinit();
//     esp_netif_destroy(netif_t);
//   //  esp_event_handler_instance_unregister(IP_EVENT,ESP_EVENT_ANY_ID,wifi_event_handler);
//     esp_event_handler_instance_unregister(WIFI_EVENT,ESP_EVENT_ANY_ID,wifi_event_handler) ;

    



}

最简单的方式（官方提供的）

通过 ESP-IDF 连接 Wi-Fi 入门指南 - 哔哩哔哩

添加依赖项文件   idf_component.yml (idf.py create-manifest)

dependencies:

  protocol_examples_common:

    path: ${IDF_PATH}/examples/common_components/protocol_examples_common

HTTP （protocol/http

#include <stdio.h>

#include "esp_log.h"
#include "nvs_flash.h"
#include "esp_wifi.h"
#include "esp_event.h"


#include "freertos/FreeRTOS.h"
#include "protocol_examples_common.h"
#include "esp_http_client.h"

#include "lwip/sockets.h"
#include "lwip/sys.h"
#include "lwip/netdb.h"
#include "lwip/dns.h"

#define WEB_SERVER "example.com"
#define WEB_PORT "80"
#define WEB_PATH "/"

char *TAG = "http";
char *REQUEST = "GET " WEB_PATH "HTTP/1.0\r\n"
"Host: " WEB_SERVER ":" WEB_PORT "\r\n"
"User_Agent:esp-idf/1.0 esp32\r\n"
"\r\n";

void app_main(void)
{
    nvs_flash_init();
    esp_netif_init();
    esp_event_loop_create_default();
    example_connect();

    const struct addrinfo hints = {
        .ai_family = AF_INET,
        .ai_socktype = SOCK_STREAM,
    };
 
    struct addrinfo *res;
    struct in_addr *addr;
    int s,r;
    char recv_buf[64];
    while(1)
    {
        int err = getaddrinfo(WEB_SERVER, WEB_PORT, &hints, &res);

        if(err != 0 || res == NULL) {
            ESP_LOGE(TAG, "DNS lookup failed err=%d res=%p", err, res);
            vTaskDelay(1000 / portTICK_PERIOD_MS);
            continue;
        }

        /* Code to print the resolved IP.

           Note: inet_ntoa is non-reentrant, look at ipaddr_ntoa_r for "real" code */
        addr = &((struct sockaddr_in *)res->ai_addr)->sin_addr;
        ESP_LOGI(TAG, "DNS lookup succeeded. IP=%s", inet_ntoa(*addr));

        s = socket(res->ai_family, res->ai_socktype, 0);
        if(s < 0) {
            ESP_LOGE(TAG, "... Failed to allocate socket.");
            freeaddrinfo(res);
            vTaskDelay(1000 / portTICK_PERIOD_MS);
            continue;
        }
        ESP_LOGI(TAG, "... allocated socket");

        if(connect(s, res->ai_addr, res->ai_addrlen) != 0) {
            ESP_LOGE(TAG, "... socket connect failed errno=%d", errno);
            close(s);
            freeaddrinfo(res);
            vTaskDelay(4000 / portTICK_PERIOD_MS);
            continue;
        }

        ESP_LOGI(TAG, "... connected");
        freeaddrinfo(res);

        if (write(s, REQUEST, strlen(REQUEST)) < 0) {
            ESP_LOGE(TAG, "... socket send failed");
            close(s);
            vTaskDelay(4000 / portTICK_PERIOD_MS);
            continue;
        }
        ESP_LOGI(TAG, "... socket send success");

        struct timeval receiving_timeout;
        receiving_timeout.tv_sec = 5;
        receiving_timeout.tv_usec = 0;
        if (setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &receiving_timeout,
                sizeof(receiving_timeout)) < 0) {
            ESP_LOGE(TAG, "... failed to set socket receiving timeout");
            close(s);
            vTaskDelay(4000 / portTICK_PERIOD_MS);
            continue;
        }
        ESP_LOGI(TAG, "... set socket receiving timeout success");

        /* Read HTTP response */
        do {
            bzero(recv_buf, sizeof(recv_buf));
            r = read(s, recv_buf, sizeof(recv_buf)-1);
            for(int i = 0; i < r; i++) {
                putchar(recv_buf[i]);
            }
        } while(r > 0);

        ESP_LOGI(TAG, "... done reading from socket. Last read return=%d errno=%d.", r, errno);
        close(s);
        for(int countdown = 10; countdown >= 0; countdown--) {
            ESP_LOGI(TAG, "%d... ", countdown);
            vTaskDelay(1000 / portTICK_PERIOD_MS);
        }
        ESP_LOGI(TAG, "Starting again!");
    }


}

异常与错误处理 

menuconfig 相应项未打开 

CMakeLists.txt PRIV_REQUIRES(nvs_flash )

idf_component_register(SRCS "xxx.c")未明确写明名称

依赖项 

错误输出 

ESP_LOGI("ERROR",FOMAT，。。）

bluetooth address 输出 ESP_LOG_BUFFER_HEX("ADDRSS",BDA_ADDRSS,6)