自学教程：C++ ESP_ERROR_CHECK函数代码示例

void wifi_init_softap(){    ap_event_group = xEventGroupCreate();    //tcpip_adapter_init();    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();    ESP_ERROR_CHECK(esp_wifi_init(&cfg));    wifi_config_t wifi_config = {        .ap = {            .ssid = EXAMPLE_DEFAULT_SSID,            .ssid_len = 0,            .max_connection=EXAMPLE_MAX_STA_CONN,            .password = EXAMPLE_DEFAULT_PWD,            .authmode = WIFI_AUTH_WPA_WPA2_PSK        },    };    if (strlen(EXAMPLE_DEFAULT_PWD) ==0) {	wifi_config.ap.authmode = WIFI_AUTH_OPEN;    }    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_AP));    ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_AP, &wifi_config));    ESP_ERROR_CHECK(esp_wifi_start());    ESP_LOGI(TAG, "wifi_init_softap finished.SSID:%s password:%s /n",    	    EXAMPLE_DEFAULT_SSID, EXAMPLE_DEFAULT_PWD);}

static void sc_callback(smartconfig_status_t status, void *pdata){    switch (status) {        case SC_STATUS_WAIT:            ESP_LOGI(TAG, "SC_STATUS_WAIT");            break;        case SC_STATUS_FIND_CHANNEL:            ESP_LOGI(TAG, "SC_STATUS_FINDING_CHANNEL");            break;        case SC_STATUS_GETTING_SSID_PSWD:            ESP_LOGI(TAG, "SC_STATUS_GETTING_SSID_PSWD");            break;        case SC_STATUS_LINK:            ESP_LOGI(TAG, "SC_STATUS_LINK");            wifi_config_t *wifi_config = pdata;            ESP_LOGI(TAG, "SSID:%s", wifi_config->sta.ssid);            ESP_LOGI(TAG, "PASSWORD:%s", wifi_config->sta.password);            ESP_ERROR_CHECK( esp_wifi_disconnect() );            ESP_ERROR_CHECK( esp_wifi_set_config(ESP_IF_WIFI_STA, wifi_config) );            ESP_ERROR_CHECK( esp_wifi_connect() );            break;        case SC_STATUS_LINK_OVER:            ESP_LOGI(TAG, "SC_STATUS_LINK_OVER");            if (pdata != NULL) {                uint8_t phone_ip[4] = { 0 };                memcpy(phone_ip, (uint8_t* )pdata, 4);                ESP_LOGI(TAG, "Phone ip: %d.%d.%d.%d/n", phone_ip[0], phone_ip[1], phone_ip[2], phone_ip[3]);            }            xEventGroupSetBits(wifi_event_group, ESPTOUCH_DONE_BIT);            break;        default:            break;    }}

void app_main(){  vTaskDelay(1000 / portTICK_PERIOD_MS);  ESP_ERROR_CHECK(nvs_flash_init_partition("Mynvs"));  nvs_handle handle;  ESP_ERROR_CHECK(nvs_open_from_partition("Mynvs","store", NVS_READWRITE, &handle));  int32_t val = 0;  esp_err_t result = nvs_get_i32(handle, "val", &val);  switch (result)  {  case ESP_ERR_NOT_FOUND:    ESP_LOGE(TAG, "Value not set yet");    break;  case ESP_OK:    ESP_LOGI(TAG, "Value is %d", val);    break;  default:    ESP_LOGE(TAG, "Error (%s) opening NVS handle!/n", esp_err_to_name(result));    break;  }  val++;  ESP_ERROR_CHECK(nvs_set_i32(handle, "val", val));  ESP_ERROR_CHECK(nvs_commit(handle));  nvs_close(handle);}

static esp_err_t event_handler(void *ctx, system_event_t *event){    httpd_handle_t *server = (httpd_handle_t *) ctx;    switch(event->event_id) {    case SYSTEM_EVENT_STA_START:        ESP_LOGI(TAG, "SYSTEM_EVENT_STA_START");        ESP_ERROR_CHECK(esp_wifi_connect());        break;    case SYSTEM_EVENT_STA_GOT_IP:        ESP_LOGI(TAG, "SYSTEM_EVENT_STA_GOT_IP");        ESP_LOGI(TAG, "Got IP: '%s'",                ip4addr_ntoa(&event->event_info.got_ip.ip_info.ip));        /* Start the web server */        if (*server == NULL) {            *server = start_webserver();        }        break;    case SYSTEM_EVENT_STA_DISCONNECTED:        ESP_LOGI(TAG, "SYSTEM_EVENT_STA_DISCONNECTED");        ESP_ERROR_CHECK(esp_wifi_connect());        /* Stop the web server */        if (*server) {            stop_webserver(*server);            *server = NULL;        }        break;    default:        break;    }    return ESP_OK;}

void app_main(void){    // Initialize NVS    esp_err_t ret = nvs_flash_init();    if (ret == ESP_ERR_NVS_NO_FREE_PAGES) {        ESP_ERROR_CHECK(nvs_flash_erase());        ret = nvs_flash_init();    }    ESP_ERROR_CHECK(ret);    initialise_wifi();    ret = xTaskCreate(&mqtt_client_thread,                      MQTT_CLIENT_THREAD_NAME,                      MQTT_CLIENT_THREAD_STACK_WORDS,                      NULL,                      MQTT_CLIENT_THREAD_PRIO,                      NULL);    if (ret != pdPASS)  {        ESP_LOGE(TAG, "mqtt create client thread %s failed", MQTT_CLIENT_THREAD_NAME);    }}

static bool wifi_cmd_sta_join(const char* ssid, const char* pass){    int bits = xEventGroupWaitBits(wifi_event_group, CONNECTED_BIT, 0, 1, 0);    wifi_config_t wifi_config = { 0 };    strlcpy((char*) wifi_config.sta.ssid, ssid, sizeof(wifi_config.sta.ssid));    if (pass) {        strncpy((char*) wifi_config.sta.password, pass, sizeof(wifi_config.sta.password));    }    if (bits & CONNECTED_BIT) {        reconnect = false;        xEventGroupClearBits(wifi_event_group, CONNECTED_BIT);        ESP_ERROR_CHECK( esp_wifi_disconnect() );        xEventGroupWaitBits(wifi_event_group, DISCONNECTED_BIT, 0, 1, portTICK_RATE_MS);    }    reconnect = true;    ESP_ERROR_CHECK( esp_wifi_set_mode(WIFI_MODE_STA) );    ESP_ERROR_CHECK( esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config) );    ESP_ERROR_CHECK( esp_wifi_connect() );    xEventGroupWaitBits(wifi_event_group, CONNECTED_BIT, 0, 1, 5000/portTICK_RATE_MS);        return true;}

static void setup_gpios(){    // Input:    //     4: Joy #2 Pot x    //    // Output:    //     5: Joy #1 Pot X    //    21: Joy #1 Pot X    // Output: 5 (LED) and 21    gpio_config_t io_conf;    io_conf.intr_type = GPIO_INTR_DISABLE;    io_conf.mode = GPIO_MODE_OUTPUT;    io_conf.pin_bit_mask = ((1ULL << GPIO_NUM_21) | (1ULL << GPIO_NUM_5));    io_conf.pull_down_en = false;    io_conf.pull_up_en = false;    ESP_ERROR_CHECK( gpio_config(&io_conf) );    // Input: read POT X    io_conf.intr_type = GPIO_INTR_POSEDGE;    io_conf.mode = GPIO_MODE_INPUT;    io_conf.pin_bit_mask = 1ULL << GPIO_NUM_18;    io_conf.pull_down_en = false;    io_conf.pull_up_en = true;    ESP_ERROR_CHECK( gpio_config(&io_conf) );    // install gpio isr service    ESP_ERROR_CHECK( gpio_install_isr_service(0) );    //hook isr handler for specific gpio pin    ESP_ERROR_CHECK( gpio_isr_handler_add(GPIO_NUM_18, gpio_isr_handler_up, (void*) GPIO_NUM_18) ); //   ESP_ERROR_CHECK( gpio_isr_register(gpio_isr_handler_up, (void*) GPIO_NUM_4, 0, NULL) );}

void test_spi_task(void *ignore) {	ESP_LOGD(tag, ">> test_spi_task");	spi_bus_config_t bus_config;	bus_config.sclk_io_num = 21; // CLK	bus_config.mosi_io_num = 22; // MOSI	bus_config.miso_io_num = -1; // MISO	bus_config.quadwp_io_num = -1; // Not used	bus_config.quadhd_io_num = -1; // Not used	ESP_LOGI(tag, "... Initializing bus.");	ESP_ERROR_CHECK(spi_bus_initialize(HSPI_HOST, &bus_config, 1));	spi_device_handle_t handle;	spi_device_interface_config_t dev_config;	dev_config.address_bits = 0;	dev_config.command_bits = 0;	dev_config.dummy_bits = 0;	dev_config.mode = 0;	dev_config.duty_cycle_pos = 0;	dev_config.cs_ena_posttrans = 0;	dev_config.cs_ena_pretrans = 0;	dev_config.clock_speed_hz = 10000;	dev_config.spics_io_num = 23;	dev_config.flags = 0;	dev_config.queue_size = 1;	dev_config.pre_cb = NULL;	dev_config.post_cb = NULL;	ESP_LOGI(tag, "... Adding device bus.");	ESP_ERROR_CHECK(spi_bus_add_device(HSPI_HOST, &dev_config, &handle));	char data[3];	spi_transaction_t trans_desc;	trans_desc.address = 0;	trans_desc.command = 0;	trans_desc.flags = 0;	trans_desc.length = 3 * 8;	trans_desc.rxlength = 0;	trans_desc.tx_buffer = data;	trans_desc.rx_buffer = data;	data[0] = 0x12;	data[1] = 0x34;	data[2] = 0x56;	ESP_LOGI(tag, "... Transmitting.");	ESP_ERROR_CHECK(spi_device_transmit(handle, &trans_desc));	ESP_LOGI(tag, "... Removing device.");	ESP_ERROR_CHECK(spi_bus_remove_device(handle));	ESP_LOGI(tag, "... Freeing bus.");	ESP_ERROR_CHECK(spi_bus_free(HSPI_HOST));	ESP_LOGD(tag, "<< test_spi_task");	vTaskDelete(NULL);}

/** * Save our connection info for retrieval on a subsequent restart. */static void saveConnectionInfo(connection_info_t *pConnectionInfo) {	nvs_handle handle;	ESP_ERROR_CHECK(nvs_open(BOOTWIFI_NAMESPACE, NVS_READWRITE, &handle));	ESP_ERROR_CHECK(nvs_set_blob(handle, KEY_CONNECTION_INFO, pConnectionInfo,			sizeof(connection_info_t)));	ESP_ERROR_CHECK(nvs_set_u32(handle, KEY_VERSION, g_version));	ESP_ERROR_CHECK(nvs_commit(handle));	nvs_close(handle);} // setConnectionInfo

static void initialise_wifi(void){	wifi_event_group = xEventGroupCreate();	ESP_ERROR_CHECK(esp_event_loop_init(event_handler, NULL));	wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();	ESP_ERROR_CHECK(esp_wifi_init(&cfg));	ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM));	ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));	ESP_ERROR_CHECK(esp_wifi_start());}

static void scan_task(void *pvParameters){	while(1) {		xEventGroupWaitBits(wifi_event_group, SCAN_DONE_BIT, false, true, portMAX_DELAY);        ESP_LOGI(TAG, "WIFI scan doen");		xEventGroupClearBits(wifi_event_group, SCAN_DONE_BIT);		uint16_t apCount = 0;		esp_wifi_scan_get_ap_num(&apCount);		printf("Number of access points found: %d/n", apCount);		if (apCount == 0) {			ESP_LOGI(TAG, "Nothing AP found");			return;		}		wifi_ap_record_t *list = (wifi_ap_record_t *)malloc(sizeof(wifi_ap_record_t) * apCount);		ESP_ERROR_CHECK(esp_wifi_scan_get_ap_records(&apCount, list));		int i;		printf("======================================================================/n");		printf("             SSID             |    RSSI    |           AUTH           /n");		printf("======================================================================/n");		for (i=0; i<apCount; i++) {			char *authmode;			switch(list[i].authmode) {			case WIFI_AUTH_OPEN:               authmode = "WIFI_AUTH_OPEN";               break;            case WIFI_AUTH_WEP:               authmode = "WIFI_AUTH_WEP";               break;                       case WIFI_AUTH_WPA_PSK:               authmode = "WIFI_AUTH_WPA_PSK";               break;                       case WIFI_AUTH_WPA2_PSK:               authmode = "WIFI_AUTH_WPA2_PSK";               break;                       case WIFI_AUTH_WPA_WPA2_PSK:               authmode = "WIFI_AUTH_WPA_WPA2_PSK";               break;            default:               authmode = "Unknown";               break;			}			printf("%26.26s    |    % 4d    |    %22.22s/n",list[i].ssid, list[i].rssi, authmode);		}		free(list);		printf("/n/n");		// scan again		vTaskDelay(2000 / portTICK_PERIOD_MS);		//The true parameter cause the function to block until the scan is done.		ESP_ERROR_CHECK(esp_wifi_scan_start(&scanConf, true));	}}

void Service::register_characteristic(Characteristic *nC) {	assert(handle != 0);	if(nC->is_descriptor) {		auto ret = esp_ble_gatts_add_char_descr(handle, &(nC->id), nC->perm, &(nC->value), &(nC->autoResp));		ESP_ERROR_CHECK(ret);	}	else {		auto ret = esp_ble_gatts_add_char(handle, &(nC->id), nC->perm, nC->prop, &(nC->value), &(nC->autoResp));		ESP_ERROR_CHECK(ret);	}}

void initI2C() {	i2c_config_t conf;	conf.mode = I2C_MODE_MASTER;	conf.sda_io_num = SDA_PIN;	conf.scl_io_num = SCL_PIN;	conf.sda_pullup_en = GPIO_PULLUP_ENABLE;	conf.scl_pullup_en = GPIO_PULLUP_ENABLE;	conf.master.clk_speed = 100000;	ESP_ERROR_CHECK(i2c_param_config(I2C_NUM_0, &conf));	ESP_ERROR_CHECK(i2c_driver_install(I2C_NUM_0, I2C_MODE_MASTER, 0, 0, 0));}

void app_main(){    // Initialize NVS    esp_err_t ret = nvs_flash_init();    if (ret == ESP_ERR_NVS_NO_FREE_PAGES) {        ESP_ERROR_CHECK(nvs_flash_erase());        ret = nvs_flash_init();    }    ESP_ERROR_CHECK( ret );    wifi_scan();}

void app_main(){    /* Initialize NVS 
C++ ESP_LOGD函数代码示例
C++ ESL_EXCEPTION函数代码示例