Merge branch 'master-cmake' of https://github.com/sle118/squeezelite-esp32 into master-cmake

components/driver_bt/bt_app_sink.c

@@ -92,7 +92,7 @@ static void bt_volume_up(bool pressed) {
 	// volume UP/DOWN buttons are not supported by iPhone/Android
 	volume_set_by_local_host(s_volume < 127-3 ? s_volume + 3 : 127);
 	(*bt_app_a2d_cmd_cb)(BT_SINK_VOLUME, s_volume);
-	ESP_LOGI(BT_AV_TAG, "BT volume up %u", s_volume);
+	ESP_LOGD(BT_AV_TAG, "BT volume up %u", s_volume);
 }
 
 static void bt_volume_down(bool pressed) {
@@ -148,7 +148,7 @@ void bt_disconnect(void) {
 	displayer_control(DISPLAYER_SHUTDOWN);
 	if (s_audio == AUDIO_PLAYING) esp_avrc_ct_send_passthrough_cmd(tl++ & 0x0f, ESP_AVRC_PT_CMD_STOP, ESP_AVRC_PT_CMD_STATE_PRESSED);
 	actrls_unset();
-	ESP_LOGI(BT_AV_TAG, "forced disconnection %d", s_audio);
+	ESP_LOGD(BT_AV_TAG, "forced disconnection %d", s_audio);
 }
 
 /* update metadata if any */
@@ -277,7 +277,7 @@ static void bt_av_hdl_a2d_evt(uint16_t event, void *p_param)
     case ESP_A2D_CONNECTION_STATE_EVT: {
         a2d = (esp_a2d_cb_param_t *)(p_param);
         uint8_t *bda = a2d->conn_stat.remote_bda;
-        ESP_LOGI(BT_AV_TAG, "A2DP connection state: %s, [%02x:%02x:%02x:%02x:%02x:%02x]",
+        ESP_LOGD(BT_AV_TAG, "A2DP connection state: %s, [%02x:%02x:%02x:%02x:%02x:%02x]",
              s_a2d_conn_state_str[a2d->conn_stat.state], bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
         if (a2d->conn_stat.state == ESP_A2D_CONNECTION_STATE_DISCONNECTED) {
             esp_bt_gap_set_scan_mode(ESP_BT_CONNECTABLE, ESP_BT_GENERAL_DISCOVERABLE);
@@ -290,7 +290,7 @@ static void bt_av_hdl_a2d_evt(uint16_t event, void *p_param)
     }
     case ESP_A2D_AUDIO_STATE_EVT: {
         a2d = (esp_a2d_cb_param_t *)(p_param);
-        ESP_LOGI(BT_AV_TAG, "A2DP audio state: %s", s_a2d_audio_state_str[a2d->audio_stat.state]);
+        ESP_LOGD(BT_AV_TAG, "A2DP audio state: %s", s_a2d_audio_state_str[a2d->audio_stat.state]);
 
         if (ESP_A2D_AUDIO_STATE_STARTED == a2d->audio_stat.state) {
 			s_audio = AUDIO_CONNECTED;
@@ -320,7 +320,7 @@ static void bt_av_hdl_a2d_evt(uint16_t event, void *p_param)
     }
     case ESP_A2D_AUDIO_CFG_EVT: {
         a2d = (esp_a2d_cb_param_t *)(p_param);
-        ESP_LOGI(BT_AV_TAG, "A2DP audio stream configuration, codec type %d", a2d->audio_cfg.mcc.type);
+        ESP_LOGD(BT_AV_TAG, "A2DP audio stream configuration, codec type %d", a2d->audio_cfg.mcc.type);
         // for now only SBC stream is supported
         if (a2d->audio_cfg.mcc.type == ESP_A2D_MCT_SBC) {
             s_sample_rate = 16000;
@@ -382,12 +382,12 @@ void bt_av_notify_evt_handler(uint8_t event_id, esp_avrc_rn_param_t *event_param
 {
     switch (event_id) {
     case ESP_AVRC_RN_TRACK_CHANGE:
-		ESP_LOGI(BT_AV_TAG, "Track changed");
+		ESP_LOGD(BT_AV_TAG, "Track changed");
         bt_av_new_track();
 		(*bt_app_a2d_cmd_cb)(BT_SINK_PROGRESS, 0, 0);
         break;
     case ESP_AVRC_RN_PLAY_STATUS_CHANGE:
-        ESP_LOGI(BT_AV_TAG, "Playback status changed: 0x%x", event_parameter->playback);
+        ESP_LOGD(BT_AV_TAG, "Playback status changed: 0x%x", event_parameter->playback);
 		if (s_audio != AUDIO_IDLE) {
 			switch (event_parameter->playback) {
 			case ESP_AVRC_PLAYBACK_PLAYING:
@@ -410,7 +410,7 @@ void bt_av_notify_evt_handler(uint8_t event_id, esp_avrc_rn_param_t *event_param
 				(*bt_app_a2d_cmd_cb)(BT_SINK_STOP);
 				break;
 			default:
-				ESP_LOGI(BT_AV_TAG, "Un-handled event");
+				ESP_LOGW(BT_AV_TAG, "Un-handled event");
 				break;
 			}	
 		} else {
@@ -433,7 +433,7 @@ static void bt_av_hdl_avrc_ct_evt(uint16_t event, void *p_param)
     switch (event) {
     case ESP_AVRC_CT_CONNECTION_STATE_EVT: {
         uint8_t *bda = rc->conn_stat.remote_bda;
-        ESP_LOGI(BT_RC_CT_TAG, "AVRC conn_state evt: state %d, [%02x:%02x:%02x:%02x:%02x:%02x]",
+        ESP_LOGD(BT_RC_CT_TAG, "AVRC conn_state evt: state %d, [%02x:%02x:%02x:%02x:%02x:%02x]",
                  rc->conn_stat.connected, bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
 
         if (rc->conn_stat.connected) {
@@ -446,11 +446,11 @@ static void bt_av_hdl_avrc_ct_evt(uint16_t event, void *p_param)
         break;
     }
     case ESP_AVRC_CT_PASSTHROUGH_RSP_EVT: {
-        ESP_LOGI(BT_RC_CT_TAG, "AVRC passthrough rsp: key_code 0x%x, key_state %d", rc->psth_rsp.key_code, rc->psth_rsp.key_state);
+        ESP_LOGD(BT_RC_CT_TAG, "AVRC passthrough rsp: key_code 0x%x, key_state %d", rc->psth_rsp.key_code, rc->psth_rsp.key_state);
         break;
     }
     case ESP_AVRC_CT_METADATA_RSP_EVT: {
-        ESP_LOGI(BT_RC_CT_TAG, "AVRC metadata rsp: attribute id 0x%x, %s", rc->meta_rsp.attr_id, rc->meta_rsp.attr_text);
+        ESP_LOGD(BT_RC_CT_TAG, "AVRC metadata rsp: attribute id 0x%x, %s", rc->meta_rsp.attr_id, rc->meta_rsp.attr_text);
 		
 		if (rc->meta_rsp.attr_id == ESP_AVRC_MD_ATTR_PLAYING_TIME) s_metadata.duration = atoi((char*) rc->meta_rsp.attr_text);
 		else if (rc->meta_rsp.attr_id == ESP_AVRC_MD_ATTR_TITLE) strncpy(s_metadata.title, (char*) rc->meta_rsp.attr_text, METADATA_LEN);
@@ -467,11 +467,11 @@ static void bt_av_hdl_avrc_ct_evt(uint16_t event, void *p_param)
         break;
     }
     case ESP_AVRC_CT_REMOTE_FEATURES_EVT: {
-        ESP_LOGI(BT_RC_CT_TAG, "AVRC remote features %x, TG features %x", rc->rmt_feats.feat_mask, rc->rmt_feats.tg_feat_flag);
+        ESP_LOGD(BT_RC_CT_TAG, "AVRC remote features %x, TG features %x", rc->rmt_feats.feat_mask, rc->rmt_feats.tg_feat_flag);
         break;
     }
     case ESP_AVRC_CT_GET_RN_CAPABILITIES_RSP_EVT: {
-        ESP_LOGI(BT_RC_CT_TAG, "remote rn_cap: count %d, bitmask 0x%x", rc->get_rn_caps_rsp.cap_count,
+        ESP_LOGD(BT_RC_CT_TAG, "remote rn_cap: count %d, bitmask 0x%x", rc->get_rn_caps_rsp.cap_count,
                  rc->get_rn_caps_rsp.evt_set.bits);
         s_avrc_peer_rn_cap.bits = rc->get_rn_caps_rsp.evt_set.bits;
         bt_av_new_track();
@@ -487,7 +487,7 @@ static void bt_av_hdl_avrc_ct_evt(uint16_t event, void *p_param)
 
 static void volume_set_by_controller(uint8_t volume)
 {
-    ESP_LOGI(BT_RC_TG_TAG, "Volume is set by remote controller %d%%\n", (uint32_t)volume * 100 / 0x7f);
+    ESP_LOGD(BT_RC_TG_TAG, "Volume is set by remote controller %d%%\n", (uint32_t)volume * 100 / 0x7f);
     _lock_acquire(&s_volume_lock);
     s_volume = volume;
     _lock_release(&s_volume_lock);
@@ -496,7 +496,7 @@ static void volume_set_by_controller(uint8_t volume)
 
 static void volume_set_by_local_host(uint8_t volume)
 {
-    ESP_LOGI(BT_RC_TG_TAG, "Volume is set locally to: %d%%", (uint32_t)volume * 100 / 0x7f);
+    ESP_LOGD(BT_RC_TG_TAG, "Volume is set locally to: %d%%", (uint32_t)volume * 100 / 0x7f);
     _lock_acquire(&s_volume_lock);
     s_volume = volume;
     _lock_release(&s_volume_lock);
@@ -516,21 +516,21 @@ static void bt_av_hdl_avrc_tg_evt(uint16_t event, void *p_param)
     switch (event) {
     case ESP_AVRC_TG_CONNECTION_STATE_EVT: {
         uint8_t *bda = rc->conn_stat.remote_bda;
-        ESP_LOGI(BT_RC_TG_TAG, "AVRC conn_state evt: state %d, [%02x:%02x:%02x:%02x:%02x:%02x]",
+        ESP_LOGD(BT_RC_TG_TAG, "AVRC conn_state evt: state %d, [%02x:%02x:%02x:%02x:%02x:%02x]",
                  rc->conn_stat.connected, bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
         break;
     }
     case ESP_AVRC_TG_PASSTHROUGH_CMD_EVT: {
-        ESP_LOGI(BT_RC_TG_TAG, "AVRC passthrough cmd: key_code 0x%x, key_state %d", rc->psth_cmd.key_code, rc->psth_cmd.key_state);
+        ESP_LOGD(BT_RC_TG_TAG, "AVRC passthrough cmd: key_code 0x%x, key_state %d", rc->psth_cmd.key_code, rc->psth_cmd.key_state);
         break;
     }
     case ESP_AVRC_TG_SET_ABSOLUTE_VOLUME_CMD_EVT: {
-        ESP_LOGI(BT_RC_TG_TAG, "AVRC set absolute volume: %d%%", (int)rc->set_abs_vol.volume * 100/ 0x7f);
+        ESP_LOGD(BT_RC_TG_TAG, "AVRC set absolute volume: %d%%", (int)rc->set_abs_vol.volume * 100/ 0x7f);
         volume_set_by_controller(rc->set_abs_vol.volume);
         break;
     }
     case ESP_AVRC_TG_REGISTER_NOTIFICATION_EVT: {
-        ESP_LOGI(BT_RC_TG_TAG, "AVRC register event notification: %d, param: 0x%x", rc->reg_ntf.event_id, rc->reg_ntf.event_parameter);
+        ESP_LOGD(BT_RC_TG_TAG, "AVRC register event notification: %d, param: 0x%x", rc->reg_ntf.event_id, rc->reg_ntf.event_parameter);
         if (rc->reg_ntf.event_id == ESP_AVRC_RN_VOLUME_CHANGE) {
             s_volume_notify = true;
             esp_avrc_rn_param_t rn_param;
@@ -540,7 +540,7 @@ static void bt_av_hdl_avrc_tg_evt(uint16_t event, void *p_param)
         break;
     }
     case ESP_AVRC_TG_REMOTE_FEATURES_EVT: {
-        ESP_LOGI(BT_RC_TG_TAG, "AVRC remote features %x, CT features %x", rc->rmt_feats.feat_mask, rc->rmt_feats.ct_feat_flag);
+        ESP_LOGD(BT_RC_TG_TAG, "AVRC remote features %x, CT features %x", rc->rmt_feats.feat_mask, rc->rmt_feats.ct_feat_flag);
         break;
     }
     default:
@@ -632,15 +632,15 @@ void bt_sink_deinit(void)
 {
 	/* this still does not work, can't figure out how to stop properly this BT stack */
 	bt_app_task_shut_down();
-	ESP_LOGI(BT_AV_TAG, "bt_app_task shutdown successfully");	
+	ESP_LOGD(BT_AV_TAG, "bt_app_task shutdown successfully");
 	if (esp_bluedroid_disable() != ESP_OK) return;
-    ESP_LOGI(BT_AV_TAG, "esp_bluedroid_disable called successfully");
+    ESP_LOGD(BT_AV_TAG, "esp_bluedroid_disable called successfully");
     if (esp_bluedroid_deinit() != ESP_OK) return;
-    ESP_LOGI(BT_AV_TAG, "esp_bluedroid_deinit called successfully");
+    ESP_LOGD(BT_AV_TAG, "esp_bluedroid_deinit called successfully");
     if (esp_bt_controller_disable() != ESP_OK) return;
-    ESP_LOGI(BT_AV_TAG, "esp_bt_controller_disable called successfully");
+    ESP_LOGD(BT_AV_TAG, "esp_bt_controller_disable called successfully");
     if (esp_bt_controller_deinit() != ESP_OK) return;
-	ESP_LOGI(BT_AV_TAG, "bt stopped successfully");
+	ESP_LOGD(BT_AV_TAG, "bt stopped successfully");
 }
 
 static void bt_app_gap_cb(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *param)
@@ -648,7 +648,7 @@ static void bt_app_gap_cb(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *pa
     switch (event) {
     case ESP_BT_GAP_AUTH_CMPL_EVT: {
         if (param->auth_cmpl.stat == ESP_BT_STATUS_SUCCESS) {
-            ESP_LOGI(BT_AV_TAG, "authentication success: %s", param->auth_cmpl.device_name);
+            ESP_LOGD(BT_AV_TAG, "authentication success: %s", param->auth_cmpl.device_name);
             esp_log_buffer_hex(BT_AV_TAG, param->auth_cmpl.bda, ESP_BD_ADDR_LEN);
         } else {
             ESP_LOGE(BT_AV_TAG, "authentication failed, status:%d", param->auth_cmpl.stat);
@@ -658,19 +658,19 @@ static void bt_app_gap_cb(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *pa
 
 #if (CONFIG_BT_SSP_ENABLED == true)
     case ESP_BT_GAP_CFM_REQ_EVT:
-        ESP_LOGI(BT_AV_TAG, "ESP_BT_GAP_CFM_REQ_EVT Please compare the numeric value: %d", param->cfm_req.num_val);
+        ESP_LOGD(BT_AV_TAG, "ESP_BT_GAP_CFM_REQ_EVT Please compare the numeric value: %d", param->cfm_req.num_val);
         esp_bt_gap_ssp_confirm_reply(param->cfm_req.bda, true);
         break;
     case ESP_BT_GAP_KEY_NOTIF_EVT:
-        ESP_LOGI(BT_AV_TAG, "ESP_BT_GAP_KEY_NOTIF_EVT passkey:%d", param->key_notif.passkey);
+        ESP_LOGD(BT_AV_TAG, "ESP_BT_GAP_KEY_NOTIF_EVT passkey:%d", param->key_notif.passkey);
         break;
     case ESP_BT_GAP_KEY_REQ_EVT:
-        ESP_LOGI(BT_AV_TAG, "ESP_BT_GAP_KEY_REQ_EVT Please enter passkey!");
+        ESP_LOGD(BT_AV_TAG, "ESP_BT_GAP_KEY_REQ_EVT Please enter passkey!");
         break;
 #endif
 
     default: {
-        ESP_LOGI(BT_AV_TAG, "event: %d", event);
+        ESP_LOGD(BT_AV_TAG, "event: %d", event);
         break;
     }
     }

components/squeezelite-ota/squeezelite-ota.c

@@ -369,7 +369,7 @@ esp_err_t init_config(ota_thread_parms_t * p_ota_thread_parms){
 }
 esp_partition_t * _get_ota_partition(esp_partition_subtype_t subtype){
 	esp_partition_t *ota_partition=NULL;
-	ESP_LOGI(TAG, "Looking for OTA partition.");
+	ESP_LOGD(TAG, "Looking for OTA partition.");
 
 	esp_partition_iterator_t it = esp_partition_find(ESP_PARTITION_TYPE_APP, subtype , NULL);
 	if(it == NULL){
@@ -378,7 +378,7 @@ esp_partition_t * _get_ota_partition(esp_partition_subtype_t subtype){
 	else {
 		ota_partition = (esp_partition_t *) esp_partition_get(it);
 		if(ota_partition != NULL){
-			ESP_LOGI(TAG, "Found OTA partition: %s.",ota_partition->label);
+			ESP_LOGD(TAG, "Found OTA partition: %s.",ota_partition->label);
 		}
 		else {
 			ESP_LOGE(TAG,"OTA partition not found!  Unable update application.");
@@ -414,7 +414,7 @@ esp_err_t _erase_last_boot_app_partition(const esp_partition_t *ota_partition)
 		ESP_LOGW(TAG,"Invalid erase block size of %u. Value should be a multiple of %d and will be adjusted to %u.", single_pass_size, SPI_FLASH_SEC_SIZE,temp_single_pass_size);
 		single_pass_size=temp_single_pass_size;
 	}
-	ESP_LOGI(TAG,"Erasing flash partition of size %u in blocks of %d bytes", ota_partition->size, single_pass_size);
+	ESP_LOGD(TAG,"Erasing flash partition of size %u in blocks of %d bytes", ota_partition->size, single_pass_size);
 	num_passes=ota_partition->size/single_pass_size;
 	remain_size=ota_partition->size-(num_passes*single_pass_size);
 	ESP_LOGI(TAG,"Erasing in %d passes with blocks of %d bytes ", num_passes,single_pass_size);
@@ -509,7 +509,7 @@ esp_err_t ota_header_check(){
     ota_status->last_invalid_app= esp_ota_get_last_invalid_partition();
     ota_status->ota_partition = _get_ota_partition(ESP_PARTITION_SUBTYPE_APP_OTA_0);
 
-    ESP_LOGI(TAG, "Running partition [%s] type %d subtype %d (offset 0x%08x)", ota_status->running->label, ota_status->running->type, ota_status->running->subtype, ota_status->running->address);
+    ESP_LOGD(TAG, "Running partition [%s] type %d subtype %d (offset 0x%08x)", ota_status->running->label, ota_status->running->type, ota_status->running->subtype, ota_status->running->address);
     if (ota_status->total_image_len > ota_status->ota_partition->size){
     	ota_task_cleanup("Error: Image size (%d) too large to fit in partition (%d).",ota_status->ota_partition->size,ota_status->total_image_len );
         return ESP_FAIL;
@@ -523,7 +523,7 @@ esp_err_t ota_header_check(){
         ESP_LOGW(TAG, "Configured OTA boot partition at offset 0x%08x, but running from offset 0x%08x", ota_status->configured->address, ota_status->running->address);
         ESP_LOGW(TAG, "(This can happen if either the OTA boot data or preferred boot image become corrupted somehow.)");
     }
-    ESP_LOGI(TAG, "Next ota update partition is: [%s] subtype %d at offset 0x%x",
+    ESP_LOGD(TAG, "Next ota update partition is: [%s] subtype %d at offset 0x%x",
     		ota_status->update_partition->label, ota_status->update_partition->subtype, ota_status->update_partition->address);
 
     if (ota_status->total_image_len >= IMAGE_HEADER_SIZE) {
@@ -531,12 +531,12 @@ esp_err_t ota_header_check(){
 		memcpy(&new_app_info, &ota_status->bin_data[sizeof(esp_image_header_t) + sizeof(esp_image_segment_header_t)], sizeof(esp_app_desc_t));
 		ESP_LOGI(TAG, "New firmware version: %s", new_app_info.version);
 		if (esp_ota_get_partition_description(ota_status->running, &running_app_info) == ESP_OK) {
-			ESP_LOGI(TAG, "Running recovery version: %s", running_app_info.version);
+			ESP_LOGD(TAG, "Running recovery version: %s", running_app_info.version);
 		}
 		sendMessaging(MESSAGING_INFO,"New version is : %s",new_app_info.version);
 		esp_app_desc_t invalid_app_info;
 		if (esp_ota_get_partition_description(ota_status->last_invalid_app, &invalid_app_info) == ESP_OK) {
-			ESP_LOGI(TAG, "Last invalid firmware version: %s", invalid_app_info.version);
+			ESP_LOGD(TAG, "Last invalid firmware version: %s", invalid_app_info.version);
 		}
 
 		if (memcmp(new_app_info.version, running_app_info.version, sizeof(new_app_info.version)) == 0) {
@@ -564,7 +564,7 @@ void ota_task(void *pvParameter)
 
     ota_status->update_partition = esp_ota_get_next_update_partition(NULL);
 
-	ESP_LOGI(TAG,"Initializing OTA configuration");
+	ESP_LOGD(TAG,"Initializing OTA configuration");
 	err = init_config(pvParameter);
 	if(err!=ESP_OK){
 		ota_task_cleanup("Error: Failed to initialize OTA.");
@@ -636,7 +636,7 @@ void ota_task(void *pvParameter)
 			taskYIELD();
 
         } else if (data_read == 0) {
-            ESP_LOGI(TAG, "End of OTA data stream");
+            ESP_LOGD(TAG, "End of OTA data stream");
             break;
         }
     }
@@ -684,12 +684,12 @@ esp_err_t process_recovery_ota(const char * bin_url, char * bin_buffer, uint32_t
 
 	if(bin_url){
 		ota_thread_parms.url =strdup(bin_url);
-		ESP_LOGI(TAG, "Starting ota on core %u for : %s", OTA_CORE,ota_thread_parms.url);
+		ESP_LOGD(TAG, "Starting ota on core %u for : %s", OTA_CORE,ota_thread_parms.url);
 	}
 	else {
 		ota_thread_parms.bin = bin_buffer;
 		ota_thread_parms.length = length;
-		ESP_LOGI(TAG, "Starting ota on core %u for file upload", OTA_CORE);
+		ESP_LOGD(TAG, "Starting ota on core %u for file upload", OTA_CORE);
 	}
 
     char * num_buffer=config_alloc_get(NVS_TYPE_STR, "ota_stack");
@@ -715,7 +715,7 @@ esp_err_t process_recovery_ota(const char * bin_url, char * bin_buffer, uint32_t
 //    ret=xTaskCreatePinnedToCore(&ota_task, "ota_task", stack_size , (void *)&ota_thread_parms, task_priority, NULL, OTA_CORE);
     ret=xTaskCreate(&ota_task, "ota_task", stack_size , (void *)&ota_thread_parms, task_priority, NULL);
     if (ret != pdPASS)  {
-            ESP_LOGI(TAG, "create thread %s failed", "ota_task");
+            ESP_LOGE(TAG, "create thread %s failed", "ota_task");
             return ESP_FAIL;
     }
     return ESP_OK;

components/wifi-manager/wifi_manager.c

@@ -335,7 +335,7 @@ void wifi_manager_start(){
 esp_err_t wifi_manager_save_sta_config(){
 	nvs_handle handle;
 	esp_err_t esp_err;
-	ESP_LOGI(TAG,   "About to save config to flash");
+	ESP_LOGD(TAG,   "About to save config to flash");
 
 	if(wifi_manager_config_sta){
 		esp_err = nvs_open(wifi_manager_nvs_namespace, NVS_READWRITE, &handle);
@@ -396,14 +396,14 @@ bool wifi_manager_fetch_wifi_sta_config(){
 		memset(buff,0x00,sizeof(uint8_t) * sz);
 		esp_err = nvs_get_blob(handle, "ssid", buff, &sz);
 		if(esp_err != ESP_OK){
-			ESP_LOGI(TAG,  "No ssid found in nvs.");
+			ESP_LOGD(TAG,  "No ssid found in nvs.");
 			FREE_AND_NULL(buff);
 			nvs_close(handle);
 			return false;
 		}
 		memcpy(wifi_manager_config_sta->sta.ssid, buff, sizeof(wifi_manager_config_sta->sta.ssid));
 		FREE_AND_NULL(buff);
-		ESP_LOGI(TAG,   "wifi_manager_fetch_wifi_sta_config: ssid:%s ",wifi_manager_config_sta->sta.ssid);
+		ESP_LOGD(TAG,   "wifi_manager_fetch_wifi_sta_config: ssid:%s ",wifi_manager_config_sta->sta.ssid);
 
 				/* password */
 		sz = sizeof(wifi_manager_config_sta->sta.password);
@@ -416,7 +416,7 @@ bool wifi_manager_fetch_wifi_sta_config(){
 		}
 		else {
 			memcpy(wifi_manager_config_sta->sta.password, buff, sizeof(wifi_manager_config_sta->sta.password));
-			ESP_LOGI(TAG,   "wifi_manager_fetch_wifi_sta_config: password:%s",wifi_manager_config_sta->sta.password);
+			ESP_LOGD(TAG,   "wifi_manager_fetch_wifi_sta_config: password:%s",wifi_manager_config_sta->sta.password);
 		}
 		FREE_AND_NULL(buff);
 		nvs_close(handle);
@@ -577,7 +577,7 @@ void wifi_manager_unlock_sta_ip_string(){
 void wifi_manager_safe_update_sta_ip_string(struct ip4_addr * ip4){
 	if(wifi_manager_lock_sta_ip_string(portMAX_DELAY)){
 		strcpy(wifi_manager_sta_ip, ip4!=NULL?ip4addr_ntoa(ip4):"0.0.0.0");
-		ESP_LOGI(TAG,   "Set STA IP String to: %s", wifi_manager_sta_ip);
+		ESP_LOGD(TAG,   "Set STA IP String to: %s", wifi_manager_sta_ip);
 		wifi_manager_unlock_sta_ip_string();
 	}
 }
@@ -620,7 +620,7 @@ static void event_handler(void* arg, esp_event_base_t event_base, int32_t event_
     if(event_base== WIFI_EVENT){
 		switch(event_id) {
 			case WIFI_EVENT_WIFI_READY:
-				ESP_LOGI(TAG,   "WIFI_EVENT_WIFI_READY");
+				ESP_LOGD(TAG,   "WIFI_EVENT_WIFI_READY");
 				break;
 
 			case WIFI_EVENT_SCAN_DONE:
@@ -630,7 +630,7 @@ static void event_handler(void* arg, esp_event_base_t event_base, int32_t event_
 				break;
 
 			case WIFI_EVENT_STA_AUTHMODE_CHANGE:
-				ESP_LOGI(TAG,   "WIFI_EVENT_STA_AUTHMODE_CHANGE");
+				ESP_LOGD(TAG,   "WIFI_EVENT_STA_AUTHMODE_CHANGE");
 //		        	structwifi_event_sta_authmode_change_t
 //		        	Argument structure for WIFI_EVENT_STA_AUTHMODE_CHANGE event
 //
@@ -645,7 +645,7 @@ static void event_handler(void* arg, esp_event_base_t event_base, int32_t event_
 
 
 			case WIFI_EVENT_AP_START:
-				ESP_LOGI(TAG,   "WIFI_EVENT_AP_START");
+				ESP_LOGD(TAG,   "WIFI_EVENT_AP_START");
 				xEventGroupSetBits(wifi_manager_event_group, WIFI_MANAGER_AP_STARTED_BIT);
 				break;
 
@@ -686,22 +686,22 @@ static void event_handler(void* arg, esp_event_base_t event_base, int32_t event_
 			case WIFI_EVENT_AP_STACONNECTED:{ /* a user disconnected from the SoftAP */
 				wifi_event_ap_staconnected_t * stac = (wifi_event_ap_staconnected_t *)event_data;
 				char * mac = get_mac_string(stac->mac);
-				ESP_LOGI(TAG,   "WIFI_EVENT_AP_STACONNECTED. aid: %d, mac: %s",stac->aid,STR_OR_BLANK(mac));
+				ESP_LOGD(TAG,   "WIFI_EVENT_AP_STACONNECTED. aid: %d, mac: %s",stac->aid,STR_OR_BLANK(mac));
 				FREE_AND_NULL(mac);
 				xEventGroupSetBits(wifi_manager_event_group, WIFI_MANAGER_AP_STA_CONNECTED_BIT);
 			}
 				break;
 			case WIFI_EVENT_AP_STADISCONNECTED:
-				ESP_LOGI(TAG,   "WIFI_EVENT_AP_STADISCONNECTED");
+				ESP_LOGD(TAG,   "WIFI_EVENT_AP_STADISCONNECTED");
 				xEventGroupClearBits(wifi_manager_event_group, WIFI_MANAGER_AP_STA_CONNECTED_BIT);
 				break;
 
 			case WIFI_EVENT_STA_START:
-				ESP_LOGI(TAG,   "WIFI_EVENT_STA_START");
+				ESP_LOGD(TAG,   "WIFI_EVENT_STA_START");
 				break;
 
 			case WIFI_EVENT_STA_STOP:
-				ESP_LOGI(TAG,   "WIFI_EVENT_STA_STOP");
+				ESP_LOGD(TAG,   "WIFI_EVENT_STA_STOP");
 				break;
 
 			case WIFI_EVENT_STA_CONNECTED:{
@@ -730,7 +730,7 @@ static void event_handler(void* arg, esp_event_base_t event_base, int32_t event_
 				wifi_event_sta_connected_t * s =(wifi_event_sta_connected_t*)event_data;
 				char * bssid = get_mac_string(s->bssid);
 				char * ssid = strdup((char*)s->ssid);
-				ESP_LOGI(TAG,   "WIFI_EVENT_STA_CONNECTED. Channel: %d, Access point: %s, BSSID: %s ", s->channel, STR_OR_BLANK(ssid), (bssid));
+				ESP_LOGD(TAG,   "WIFI_EVENT_STA_CONNECTED. Channel: %d, Access point: %s, BSSID: %s ", s->channel, STR_OR_BLANK(ssid), (bssid));
 				FREE_AND_NULL(bssid);
 				FREE_AND_NULL(ssid);
 
@@ -756,7 +756,7 @@ static void event_handler(void* arg, esp_event_base_t event_base, int32_t event_
 //		    		reason of disconnection
 				wifi_event_sta_disconnected_t * s =(wifi_event_sta_disconnected_t*)event_data;
 				char * bssid = get_mac_string(s->bssid);
-				ESP_LOGI(TAG,   "WIFI_EVENT_STA_DISCONNECTED. From BSSID: %s, reason code: %d (%s)", STR_OR_BLANK(bssid),s->reason, get_disconnect_code_desc(s->reason));
+				ESP_LOGD(TAG,   "WIFI_EVENT_STA_DISCONNECTED. From BSSID: %s, reason code: %d (%s)", STR_OR_BLANK(bssid),s->reason, get_disconnect_code_desc(s->reason));
 				FREE_AND_NULL(bssid);
 				if(last_connected>0) total_connected_time+=((esp_timer_get_time()-last_connected)/(1000*1000));
 				last_connected = 0;
@@ -819,16 +819,16 @@ static void event_handler(void* arg, esp_event_base_t event_base, int32_t event_
 			}
 				break;
 			case IP_EVENT_STA_LOST_IP:
-				ESP_LOGI(TAG,   "IP_EVENT_STA_LOST_IP");
+				ESP_LOGD(TAG,   "IP_EVENT_STA_LOST_IP");
 				break;
 			case IP_EVENT_AP_STAIPASSIGNED:
-				ESP_LOGI(TAG,   "IP_EVENT_AP_STAIPASSIGNED");
+				ESP_LOGD(TAG,   "IP_EVENT_AP_STAIPASSIGNED");
 				break;
 			case IP_EVENT_GOT_IP6:
-				ESP_LOGI(TAG,   "IP_EVENT_GOT_IP6");
+				ESP_LOGD(TAG,   "IP_EVENT_GOT_IP6");
 				break;
 			case IP_EVENT_ETH_GOT_IP:
-				ESP_LOGI(TAG,   "IP_EVENT_ETH_GOT_IP");
+				ESP_LOGD(TAG,   "IP_EVENT_ETH_GOT_IP");
 				break;
 			default:
 				break;
@@ -996,7 +996,7 @@ void wifi_manager_config_ap(){
 		};
 		ESP_LOGI(TAG,  "Configuring Access Point.");
 
-		ESP_LOGI(TAG,"Stopping DHCP on interface ");
+		ESP_LOGD(TAG,"Stopping DHCP on interface ");
 		if((err= tcpip_adapter_dhcps_stop(TCPIP_ADAPTER_IF_AP))!=ESP_OK) 	/* stop AP DHCP server */
 		{
 			ESP_LOGW(TAG,  "Stopping DHCP failed. Error %s",esp_err_to_name(err));
@@ -1006,19 +1006,19 @@ void wifi_manager_config_ap(){
 		 */
 		value = config_alloc_get_default(NVS_TYPE_STR, "ap_ip_address", DEFAULT_AP_IP, 0);
 		if(value!=NULL){
-			ESP_LOGI(TAG,  "IP Address: %s", value);
+			ESP_LOGD(TAG,  "IP Address: %s", value);
 			inet_pton(AF_INET,value, &info.ip); /* access point is on a static IP */
 		}
 		FREE_AND_NULL(value);
 		value = config_alloc_get_default(NVS_TYPE_STR, "ap_ip_gateway", CONFIG_DEFAULT_AP_GATEWAY, 0);
 		if(value!=NULL){
-			ESP_LOGI(TAG,  "Gateway: %s", value);
+			ESP_LOGD(TAG,  "Gateway: %s", value);
 			inet_pton(AF_INET,value, &info.gw); /* access point is on a static IP */
 		}
 		FREE_AND_NULL(value);
 		value = config_alloc_get_default(NVS_TYPE_STR, "ap_ip_netmask", CONFIG_DEFAULT_AP_NETMASK, 0);
 		if(value!=NULL){
-			ESP_LOGI(TAG,  "Netmask: %s", value);
+			ESP_LOGD(TAG,  "Netmask: %s", value);
 			inet_pton(AF_INET,value, &info.netmask); /* access point is on a static IP */
 		}
 		FREE_AND_NULL(value);
@@ -1047,7 +1047,7 @@ void wifi_manager_config_ap(){
 
 		value = config_alloc_get_default(NVS_TYPE_STR, "ap_channel", STR(CONFIG_DEFAULT_AP_CHANNEL), 0);
 		if(value!=NULL){
-			ESP_LOGI(TAG,  "Channel: %s", value);
+			ESP_LOGD(TAG,  "Channel: %s", value);
 			ap_config.ap.channel=atoi(value);
 		}
 		FREE_AND_NULL(value);
@@ -1057,10 +1057,10 @@ void wifi_manager_config_ap(){
 		ap_config.ap.max_connection = DEFAULT_AP_MAX_CONNECTIONS;
 		ap_config.ap.beacon_interval = DEFAULT_AP_BEACON_INTERVAL;
 
-		ESP_LOGI(TAG,  "Auth Mode: %d", ap_config.ap.authmode);
-		ESP_LOGI(TAG,  "SSID Hidden: %d", ap_config.ap.ssid_hidden);
-		ESP_LOGI(TAG,  "Max Connections: %d", ap_config.ap.max_connection);
-		ESP_LOGI(TAG,  "Beacon interval: %d", ap_config.ap.beacon_interval);
+		ESP_LOGD(TAG,  "Auth Mode: %d", ap_config.ap.authmode);
+		ESP_LOGD(TAG,  "SSID Hidden: %d", ap_config.ap.ssid_hidden);
+		ESP_LOGD(TAG,  "Max Connections: %d", ap_config.ap.max_connection);
+		ESP_LOGD(TAG,  "Beacon interval: %d", ap_config.ap.beacon_interval);
 
 		ESP_LOGD(TAG,  "");
 		if((err= esp_wifi_set_mode(WIFI_MODE_APSTA))!=ESP_OK) 	/* stop AP DHCP server */
@@ -1196,14 +1196,14 @@ void wifi_manager( void * pvParameters ){
 				break;
 
 			case ORDER_LOAD_AND_RESTORE_STA:
-				ESP_LOGI(TAG,   "MESSAGE: ORDER_LOAD_AND_RESTORE_STA. About to fetch wifi STA configuration");
+				ESP_LOGD(TAG,   "MESSAGE: ORDER_LOAD_AND_RESTORE_STA. About to fetch wifi STA configuration");
 				if(wifi_manager_fetch_wifi_sta_config()){
 					ESP_LOGI(TAG,   "Saved wifi found on startup. Will attempt to connect.");
 					wifi_manager_send_message(ORDER_CONNECT_STA, (void*)CONNECTION_REQUEST_RESTORE_CONNECTION);
 				}
 				else{
 					/* no wifi saved: start soft AP! This is what should happen during a first run */
-					ESP_LOGI(TAG,   "No saved wifi found on startup. Starting access point.");
+					ESP_LOGD(TAG,   "No saved wifi found on startup. Starting access point.");
 					wifi_manager_send_message(ORDER_START_AP, NULL);
 				}
 
@@ -1213,7 +1213,7 @@ void wifi_manager( void * pvParameters ){
 				break;
 
 			case ORDER_CONNECT_STA:
-				ESP_LOGI(TAG,   "MESSAGE: ORDER_CONNECT_STA - Begin");
+				ESP_LOGD(TAG,   "MESSAGE: ORDER_CONNECT_STA - Begin");
 
 				/* very important: precise that this connection attempt is specifically requested.
 				 * Param in that case is a boolean indicating if the request was made automatically
@@ -1231,7 +1231,7 @@ void wifi_manager( void * pvParameters ){
 					//todo:  support static ip address
 //					if(wifi_settings.sta_static_ip) {
 //						// There's a static ip address configured, so
-//						ESP_LOGI(TAG,   "Assigning static ip to STA interface. IP: %s , GW: %s , Mask: %s",
+//						ESP_LOGD(TAG,   "Assigning static ip to STA interface. IP: %s , GW: %s , Mask: %s",
 //										ip4addr_ntoa(&wifi_settings.sta_static_ip_config.ip),
 //										ip4addr_ntoa(&wifi_settings.sta_static_ip_config.gw),
 //										ip4addr_ntoa(&wifi_settings.sta_static_ip_config.netmask));
@@ -1247,7 +1247,7 @@ void wifi_manager( void * pvParameters ){
 						ESP_LOGD(TAG,   "wifi_manager: Checking if DHCP client for STA interface is running");
 						ESP_ERROR_CHECK(tcpip_adapter_dhcpc_get_status(TCPIP_ADAPTER_IF_STA, &status));
 						if (status!=TCPIP_ADAPTER_DHCP_STARTED) {
-							ESP_LOGI(TAG,   "wifi_manager: Start DHCP client for STA interface");
+							ESP_LOGD(TAG,   "wifi_manager: Start DHCP client for STA interface");
 							ESP_ERROR_CHECK(tcpip_adapter_dhcpc_start(TCPIP_ADAPTER_IF_STA));
 //						}
 					}
@@ -1293,14 +1293,14 @@ void wifi_manager( void * pvParameters ){
 			case EVENT_STA_DISCONNECTED:{
 				wifi_event_sta_disconnected_t disc_event;
 
-				ESP_LOGI(TAG,   "MESSAGE: EVENT_STA_DISCONNECTED");
+				ESP_LOGD(TAG,   "MESSAGE: EVENT_STA_DISCONNECTED");
 				if(msg.param == NULL){
 					ESP_LOGE(TAG,  "MESSAGE: EVENT_STA_DISCONNECTED - expected parameter not found!");
 				}
 				else{
 					memcpy(&disc_event,(wifi_event_sta_disconnected_t*)msg.param,sizeof(disc_event));
 					free(msg.param);
-					ESP_LOGI(TAG,   "MESSAGE: EVENT_STA_DISCONNECTED with Reason code: %d (%s)", disc_event.reason, get_disconnect_code_desc(disc_event.reason));
+					ESP_LOGD(TAG,   "MESSAGE: EVENT_STA_DISCONNECTED with Reason code: %d (%s)", disc_event.reason, get_disconnect_code_desc(disc_event.reason));
 				}
 
 				/* this even can be posted in numerous different conditions
@@ -1371,7 +1371,7 @@ void wifi_manager( void * pvParameters ){
 
 				}
 				else if (uxBits & WIFI_MANAGER_REQUEST_DISCONNECT_BIT){
-					ESP_LOGI(TAG,   "WiFi disconnected by user");
+					ESP_LOGD(TAG,   "WiFi disconnected by user");
 					/* user manually requested a disconnect so the lost connection is a normal event. Clear the flag and restart the AP */
 					xEventGroupClearBits(wifi_manager_event_group, WIFI_MANAGER_REQUEST_DISCONNECT_BIT);
 
@@ -1426,7 +1426,7 @@ void wifi_manager( void * pvParameters ){
 				break;
 
 			case ORDER_START_AP:
-				ESP_LOGI(TAG,   "MESSAGE: ORDER_START_AP");
+				ESP_LOGD(TAG,   "MESSAGE: ORDER_START_AP");
 				wifi_manager_config_ap();
 				ESP_LOGD(TAG,  "AP Starting, requesting wifi scan.");
 				wifi_manager_scan_async();
@@ -1435,7 +1435,7 @@ void wifi_manager( void * pvParameters ){
 				break;
 
 			case EVENT_STA_GOT_IP:
-				ESP_LOGI(TAG,   "MESSAGE: EVENT_STA_GOT_IP");
+				ESP_LOGD(TAG,   "MESSAGE: EVENT_STA_GOT_IP");
 
 				uxBits = xEventGroupGetBits(wifi_manager_event_group);
 
@@ -1485,7 +1485,7 @@ void wifi_manager( void * pvParameters ){
 				}
 				break;
 			case ORDER_DISCONNECT_STA:
-				ESP_LOGI(TAG,   "MESSAGE: ORDER_DISCONNECT_STA. Calling esp_wifi_disconnect()");
+				ESP_LOGD(TAG,   "MESSAGE: ORDER_DISCONNECT_STA. Calling esp_wifi_disconnect()");
 
 				/* precise this is coming from a user request */
 				xEventGroupSetBits(wifi_manager_event_group, WIFI_MANAGER_REQUEST_DISCONNECT_BIT);

components/wifi-manager/wifi_manager_http_server.c

@@ -135,7 +135,7 @@ esp_err_t http_server_start()
     //todo:  use the endpoint below to configure session token?
     // config.open_fn
 
-    ESP_LOGI(TAG, "Starting HTTP Server");
+    ESP_LOGD(TAG, "Starting HTTP Server");
     esp_err_t err= __httpd_start(&_server, &config);
     if(err != ESP_OK){
     	ESP_LOGE_LOC(TAG,"Start server failed");
@@ -153,7 +153,7 @@ esp_err_t http_server_start()
 /* Function to free context */
 void adder_free_func(void *ctx)
 {
-    ESP_LOGI(TAG, "/adder Free Context function called");
+    ESP_LOGD(TAG, "/adder Free Context function called");
     free(ctx);
 }