Mirror/squeezelite-esp32
1
0
Fork 0
mirror of https://github.com/sle118/squeezelite-esp32.git synced 2025-12-08 04:27:12 +03:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Philippe G
2020-07-10 23:37:14 -07:00
parent 596a277434 b5fcb6b235
commit dda27c9194
4 changed files with 82 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
components/driver_bt/bt_app_sink.c
View File

@@ -92,7 +92,7 @@ static void bt_volume_up(bool pressed) {
// volume UP/DOWN buttons are not supported by iPhone/Android // volume UP/DOWN buttons are not supported by iPhone/Android
volume_set_by_local_host(s_volume < 127-3 ? s_volume + 3 : 127); volume_set_by_local_host(s_volume < 127-3 ? s_volume + 3 : 127);
(*bt_app_a2d_cmd_cb)(BT_SINK_VOLUME, s_volume); (*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) { static void bt_volume_down(bool pressed) {
@@ -148,7 +148,7 @@ void bt_disconnect(void) {
displayer_control(DISPLAYER_SHUTDOWN); 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); 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(); 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 */ /* 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: { case ESP_A2D_CONNECTION_STATE_EVT: {
a2d = (esp_a2d_cb_param_t *)(p_param); a2d = (esp_a2d_cb_param_t *)(p_param);
uint8_t *bda = a2d->conn_stat.remote_bda; 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]); 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) { if (a2d->conn_stat.state == ESP_A2D_CONNECTION_STATE_DISCONNECTED) {
esp_bt_gap_set_scan_mode(ESP_BT_CONNECTABLE, ESP_BT_GENERAL_DISCOVERABLE); 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: { case ESP_A2D_AUDIO_STATE_EVT: {
a2d = (esp_a2d_cb_param_t *)(p_param); 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) { if (ESP_A2D_AUDIO_STATE_STARTED == a2d->audio_stat.state) {
s_audio = AUDIO_CONNECTED; 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: { case ESP_A2D_AUDIO_CFG_EVT: {
a2d = (esp_a2d_cb_param_t *)(p_param); 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 // for now only SBC stream is supported
if (a2d->audio_cfg.mcc.type == ESP_A2D_MCT_SBC) { if (a2d->audio_cfg.mcc.type == ESP_A2D_MCT_SBC) {
s_sample_rate = 16000; 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) { switch (event_id) {
case ESP_AVRC_RN_TRACK_CHANGE: 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_av_new_track();
(*bt_app_a2d_cmd_cb)(BT_SINK_PROGRESS, 0, 0); (*bt_app_a2d_cmd_cb)(BT_SINK_PROGRESS, 0, 0);
break; break;
case ESP_AVRC_RN_PLAY_STATUS_CHANGE: 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) { if (s_audio != AUDIO_IDLE) {
switch (event_parameter->playback) { switch (event_parameter->playback) {
case ESP_AVRC_PLAYBACK_PLAYING: 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); (*bt_app_a2d_cmd_cb)(BT_SINK_STOP);
break; break;
default: default:
ESP_LOGI(BT_AV_TAG, "Un-handled event"); ESP_LOGW(BT_AV_TAG, "Un-handled event");
break; break;
} }
} else { } else {
@@ -433,7 +433,7 @@ static void bt_av_hdl_avrc_ct_evt(uint16_t event, void *p_param)
switch (event) { switch (event) {
case ESP_AVRC_CT_CONNECTION_STATE_EVT: { case ESP_AVRC_CT_CONNECTION_STATE_EVT: {
uint8_t *bda = rc->conn_stat.remote_bda; 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]); rc->conn_stat.connected, bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
if (rc->conn_stat.connected) { if (rc->conn_stat.connected) {
@@ -446,11 +446,11 @@ static void bt_av_hdl_avrc_ct_evt(uint16_t event, void *p_param)
break; break;
} }
case ESP_AVRC_CT_PASSTHROUGH_RSP_EVT: { 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; break;
} }
case ESP_AVRC_CT_METADATA_RSP_EVT: { 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); 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); 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; break;
} }
case ESP_AVRC_CT_REMOTE_FEATURES_EVT: { 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; break;
} }
case ESP_AVRC_CT_GET_RN_CAPABILITIES_RSP_EVT: { 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); rc->get_rn_caps_rsp.evt_set.bits);
s_avrc_peer_rn_cap.bits = 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(); 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) 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); _lock_acquire(&s_volume_lock);
s_volume = volume; s_volume = volume;
_lock_release(&s_volume_lock); _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) 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); _lock_acquire(&s_volume_lock);
s_volume = volume; s_volume = volume;
_lock_release(&s_volume_lock); _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) { switch (event) {
case ESP_AVRC_TG_CONNECTION_STATE_EVT: { case ESP_AVRC_TG_CONNECTION_STATE_EVT: {
uint8_t *bda = rc->conn_stat.remote_bda; 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]); rc->conn_stat.connected, bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
break; break;
} }
case ESP_AVRC_TG_PASSTHROUGH_CMD_EVT: { 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; break;
} }
case ESP_AVRC_TG_SET_ABSOLUTE_VOLUME_CMD_EVT: { 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); volume_set_by_controller(rc->set_abs_vol.volume);
break; break;
} }
case ESP_AVRC_TG_REGISTER_NOTIFICATION_EVT: { 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) { if (rc->reg_ntf.event_id == ESP_AVRC_RN_VOLUME_CHANGE) {
s_volume_notify = true; s_volume_notify = true;
esp_avrc_rn_param_t rn_param; 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; break;
} }
case ESP_AVRC_TG_REMOTE_FEATURES_EVT: { 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; break;
} }
default: 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 */ /* this still does not work, can't figure out how to stop properly this BT stack */
bt_app_task_shut_down(); 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; 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; 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; 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; 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) 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) { switch (event) {
case ESP_BT_GAP_AUTH_CMPL_EVT: { case ESP_BT_GAP_AUTH_CMPL_EVT: {
if (param->auth_cmpl.stat == ESP_BT_STATUS_SUCCESS) { 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); esp_log_buffer_hex(BT_AV_TAG, param->auth_cmpl.bda, ESP_BD_ADDR_LEN);
} else { } else {
ESP_LOGE(BT_AV_TAG, "authentication failed, status:%d", param->auth_cmpl.stat); 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) #if (CONFIG_BT_SSP_ENABLED == true)
case ESP_BT_GAP_CFM_REQ_EVT: 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); esp_bt_gap_ssp_confirm_reply(param->cfm_req.bda, true);
break; break;
case ESP_BT_GAP_KEY_NOTIF_EVT: 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; break;
case ESP_BT_GAP_KEY_REQ_EVT: 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; break;
#endif #endif
default: { default: {
ESP_LOGI(BT_AV_TAG, "event: %d", event); ESP_LOGD(BT_AV_TAG, "event: %d", event);
break; break;
} }
} }

24
components/squeezelite-ota/squeezelite-ota.c
View File

@@ -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 * _get_ota_partition(esp_partition_subtype_t subtype){
esp_partition_t *ota_partition=NULL; 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); esp_partition_iterator_t it = esp_partition_find(ESP_PARTITION_TYPE_APP, subtype , NULL);
if(it == NULL){ if(it == NULL){
@@ -378,7 +378,7 @@ esp_partition_t * _get_ota_partition(esp_partition_subtype_t subtype){
else { else {
ota_partition = (esp_partition_t *) esp_partition_get(it); ota_partition = (esp_partition_t *) esp_partition_get(it);
if(ota_partition != NULL){ 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 { else {
ESP_LOGE(TAG,"OTA partition not found! Unable update application."); 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); 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; 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; num_passes=ota_partition->size/single_pass_size;
remain_size=ota_partition->size-(num_passes*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); 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->last_invalid_app= esp_ota_get_last_invalid_partition();
ota_status->ota_partition = _get_ota_partition(ESP_PARTITION_SUBTYPE_APP_OTA_0); 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){ 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 ); 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; 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, "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_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); ota_status->update_partition->label, ota_status->update_partition->subtype, ota_status->update_partition->address);
if (ota_status->total_image_len >= IMAGE_HEADER_SIZE) { 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)); 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); 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) { 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); sendMessaging(MESSAGING_INFO,"New version is : %s",new_app_info.version);
esp_app_desc_t invalid_app_info; esp_app_desc_t invalid_app_info;
if (esp_ota_get_partition_description(ota_status->last_invalid_app, &invalid_app_info) == ESP_OK) { 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) { 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); 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); err = init_config(pvParameter);
if(err!=ESP_OK){ if(err!=ESP_OK){
ota_task_cleanup("Error: Failed to initialize OTA."); ota_task_cleanup("Error: Failed to initialize OTA.");
@@ -636,7 +636,7 @@ void ota_task(void *pvParameter)
taskYIELD(); taskYIELD();
} else if (data_read == 0) { } else if (data_read == 0) {
ESP_LOGI(TAG, "End of OTA data stream"); ESP_LOGD(TAG, "End of OTA data stream");
break; break;
} }
} }
@@ -684,12 +684,12 @@ esp_err_t process_recovery_ota(const char * bin_url, char * bin_buffer, uint32_t
if(bin_url){ if(bin_url){
ota_thread_parms.url =strdup(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 { else {
ota_thread_parms.bin = bin_buffer; ota_thread_parms.bin = bin_buffer;
ota_thread_parms.length = length; 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"); 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=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); ret=xTaskCreate(&ota_task, "ota_task", stack_size , (void *)&ota_thread_parms, task_priority, NULL);
if (ret != pdPASS) { 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_FAIL;
} }
return ESP_OK; return ESP_OK;

76
components/wifi-manager/wifi_manager.c
View File

@@ -335,7 +335,7 @@ void wifi_manager_start(){
esp_err_t wifi_manager_save_sta_config(){ esp_err_t wifi_manager_save_sta_config(){
nvs_handle handle; nvs_handle handle;
esp_err_t esp_err; 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){ if(wifi_manager_config_sta){
esp_err = nvs_open(wifi_manager_nvs_namespace, NVS_READWRITE, &handle); 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); memset(buff,0x00,sizeof(uint8_t) * sz);
esp_err = nvs_get_blob(handle, "ssid", buff, &sz); esp_err = nvs_get_blob(handle, "ssid", buff, &sz);
if(esp_err != ESP_OK){ 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); FREE_AND_NULL(buff);
nvs_close(handle); nvs_close(handle);
return false; return false;
} }
memcpy(wifi_manager_config_sta->sta.ssid, buff, sizeof(wifi_manager_config_sta->sta.ssid)); memcpy(wifi_manager_config_sta->sta.ssid, buff, sizeof(wifi_manager_config_sta->sta.ssid));
FREE_AND_NULL(buff); 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 */ /* password */
sz = sizeof(wifi_manager_config_sta->sta.password); sz = sizeof(wifi_manager_config_sta->sta.password);
@@ -416,7 +416,7 @@ bool wifi_manager_fetch_wifi_sta_config(){
} }
else { else {
memcpy(wifi_manager_config_sta->sta.password, buff, sizeof(wifi_manager_config_sta->sta.password)); 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); FREE_AND_NULL(buff);
nvs_close(handle); 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){ void wifi_manager_safe_update_sta_ip_string(struct ip4_addr * ip4){
if(wifi_manager_lock_sta_ip_string(portMAX_DELAY)){ if(wifi_manager_lock_sta_ip_string(portMAX_DELAY)){
strcpy(wifi_manager_sta_ip, ip4!=NULL?ip4addr_ntoa(ip4):"0.0.0.0"); 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(); 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){ if(event_base== WIFI_EVENT){
switch(event_id) { switch(event_id) {
case WIFI_EVENT_WIFI_READY: case WIFI_EVENT_WIFI_READY:
ESP_LOGI(TAG, "WIFI_EVENT_WIFI_READY"); ESP_LOGD(TAG, "WIFI_EVENT_WIFI_READY");
break; break;
case WIFI_EVENT_SCAN_DONE: 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; break;
case WIFI_EVENT_STA_AUTHMODE_CHANGE: 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 // structwifi_event_sta_authmode_change_t
// Argument structure for WIFI_EVENT_STA_AUTHMODE_CHANGE event // 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: 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); xEventGroupSetBits(wifi_manager_event_group, WIFI_MANAGER_AP_STARTED_BIT);
break; 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 */ case WIFI_EVENT_AP_STACONNECTED:{ /* a user disconnected from the SoftAP */
wifi_event_ap_staconnected_t * stac = (wifi_event_ap_staconnected_t *)event_data; wifi_event_ap_staconnected_t * stac = (wifi_event_ap_staconnected_t *)event_data;
char * mac = get_mac_string(stac->mac); 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); FREE_AND_NULL(mac);
xEventGroupSetBits(wifi_manager_event_group, WIFI_MANAGER_AP_STA_CONNECTED_BIT); xEventGroupSetBits(wifi_manager_event_group, WIFI_MANAGER_AP_STA_CONNECTED_BIT);
} }
break; break;
case WIFI_EVENT_AP_STADISCONNECTED: 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); xEventGroupClearBits(wifi_manager_event_group, WIFI_MANAGER_AP_STA_CONNECTED_BIT);
break; break;
case WIFI_EVENT_STA_START: case WIFI_EVENT_STA_START:
ESP_LOGI(TAG, "WIFI_EVENT_STA_START"); ESP_LOGD(TAG, "WIFI_EVENT_STA_START");
break; break;
case WIFI_EVENT_STA_STOP: case WIFI_EVENT_STA_STOP:
ESP_LOGI(TAG, "WIFI_EVENT_STA_STOP"); ESP_LOGD(TAG, "WIFI_EVENT_STA_STOP");
break; break;
case WIFI_EVENT_STA_CONNECTED:{ 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; wifi_event_sta_connected_t * s =(wifi_event_sta_connected_t*)event_data;
char * bssid = get_mac_string(s->bssid); char * bssid = get_mac_string(s->bssid);
char * ssid = strdup((char*)s->ssid); 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(bssid);
FREE_AND_NULL(ssid); 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 // reason of disconnection
wifi_event_sta_disconnected_t * s =(wifi_event_sta_disconnected_t*)event_data; wifi_event_sta_disconnected_t * s =(wifi_event_sta_disconnected_t*)event_data;
char * bssid = get_mac_string(s->bssid); 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); FREE_AND_NULL(bssid);
if(last_connected>0) total_connected_time+=((esp_timer_get_time()-last_connected)/(1000*1000)); if(last_connected>0) total_connected_time+=((esp_timer_get_time()-last_connected)/(1000*1000));
last_connected = 0; last_connected = 0;
@@ -819,16 +819,16 @@ static void event_handler(void* arg, esp_event_base_t event_base, int32_t event_
} }
break; break;
case IP_EVENT_STA_LOST_IP: case IP_EVENT_STA_LOST_IP:
ESP_LOGI(TAG, "IP_EVENT_STA_LOST_IP"); ESP_LOGD(TAG, "IP_EVENT_STA_LOST_IP");
break; break;
case IP_EVENT_AP_STAIPASSIGNED: case IP_EVENT_AP_STAIPASSIGNED:
ESP_LOGI(TAG, "IP_EVENT_AP_STAIPASSIGNED"); ESP_LOGD(TAG, "IP_EVENT_AP_STAIPASSIGNED");
break; break;
case IP_EVENT_GOT_IP6: case IP_EVENT_GOT_IP6:
ESP_LOGI(TAG, "IP_EVENT_GOT_IP6"); ESP_LOGD(TAG, "IP_EVENT_GOT_IP6");
break; break;
case IP_EVENT_ETH_GOT_IP: case IP_EVENT_ETH_GOT_IP:
ESP_LOGI(TAG, "IP_EVENT_ETH_GOT_IP"); ESP_LOGD(TAG, "IP_EVENT_ETH_GOT_IP");
break; break;
default: default:
break; break;
@@ -996,7 +996,7 @@ void wifi_manager_config_ap(){
}; };
ESP_LOGI(TAG, "Configuring Access Point."); 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 */ 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)); 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); value = config_alloc_get_default(NVS_TYPE_STR, "ap_ip_address", DEFAULT_AP_IP, 0);
if(value!=NULL){ 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 */ inet_pton(AF_INET,value, &info.ip); /* access point is on a static IP */
} }
FREE_AND_NULL(value); FREE_AND_NULL(value);
value = config_alloc_get_default(NVS_TYPE_STR, "ap_ip_gateway", CONFIG_DEFAULT_AP_GATEWAY, 0); value = config_alloc_get_default(NVS_TYPE_STR, "ap_ip_gateway", CONFIG_DEFAULT_AP_GATEWAY, 0);
if(value!=NULL){ 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 */ inet_pton(AF_INET,value, &info.gw); /* access point is on a static IP */
} }
FREE_AND_NULL(value); FREE_AND_NULL(value);
value = config_alloc_get_default(NVS_TYPE_STR, "ap_ip_netmask", CONFIG_DEFAULT_AP_NETMASK, 0); value = config_alloc_get_default(NVS_TYPE_STR, "ap_ip_netmask", CONFIG_DEFAULT_AP_NETMASK, 0);
if(value!=NULL){ 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 */ inet_pton(AF_INET,value, &info.netmask); /* access point is on a static IP */
} }
FREE_AND_NULL(value); 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); value = config_alloc_get_default(NVS_TYPE_STR, "ap_channel", STR(CONFIG_DEFAULT_AP_CHANNEL), 0);
if(value!=NULL){ if(value!=NULL){
ESP_LOGI(TAG, "Channel: %s", value); ESP_LOGD(TAG, "Channel: %s", value);
ap_config.ap.channel=atoi(value); ap_config.ap.channel=atoi(value);
} }
FREE_AND_NULL(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.max_connection = DEFAULT_AP_MAX_CONNECTIONS;
ap_config.ap.beacon_interval = DEFAULT_AP_BEACON_INTERVAL; ap_config.ap.beacon_interval = DEFAULT_AP_BEACON_INTERVAL;
ESP_LOGI(TAG, "Auth Mode: %d", ap_config.ap.authmode); ESP_LOGD(TAG, "Auth Mode: %d", ap_config.ap.authmode);
ESP_LOGI(TAG, "SSID Hidden: %d", ap_config.ap.ssid_hidden); ESP_LOGD(TAG, "SSID Hidden: %d", ap_config.ap.ssid_hidden);
ESP_LOGI(TAG, "Max Connections: %d", ap_config.ap.max_connection); ESP_LOGD(TAG, "Max Connections: %d", ap_config.ap.max_connection);
ESP_LOGI(TAG, "Beacon interval: %d", ap_config.ap.beacon_interval); ESP_LOGD(TAG, "Beacon interval: %d", ap_config.ap.beacon_interval);
ESP_LOGD(TAG, ""); ESP_LOGD(TAG, "");
if((err= esp_wifi_set_mode(WIFI_MODE_APSTA))!=ESP_OK) /* stop AP DHCP server */ 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; break;
case ORDER_LOAD_AND_RESTORE_STA: 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()){ if(wifi_manager_fetch_wifi_sta_config()){
ESP_LOGI(TAG, "Saved wifi found on startup. Will attempt to connect."); ESP_LOGI(TAG, "Saved wifi found on startup. Will attempt to connect.");
wifi_manager_send_message(ORDER_CONNECT_STA, (void*)CONNECTION_REQUEST_RESTORE_CONNECTION); wifi_manager_send_message(ORDER_CONNECT_STA, (void*)CONNECTION_REQUEST_RESTORE_CONNECTION);
} }
else{ else{
/* no wifi saved: start soft AP! This is what should happen during a first run */ /* 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); wifi_manager_send_message(ORDER_START_AP, NULL);
} }
@@ -1213,7 +1213,7 @@ void wifi_manager( void * pvParameters ){
break; break;
case ORDER_CONNECT_STA: 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. /* very important: precise that this connection attempt is specifically requested.
* Param in that case is a boolean indicating if the request was made automatically * 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 //todo: support static ip address
// if(wifi_settings.sta_static_ip) { // if(wifi_settings.sta_static_ip) {
// // There's a static ip address configured, so // // 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.ip),
// ip4addr_ntoa(&wifi_settings.sta_static_ip_config.gw), // ip4addr_ntoa(&wifi_settings.sta_static_ip_config.gw),
// ip4addr_ntoa(&wifi_settings.sta_static_ip_config.netmask)); // 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_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)); ESP_ERROR_CHECK(tcpip_adapter_dhcpc_get_status(TCPIP_ADAPTER_IF_STA, &status));
if (status!=TCPIP_ADAPTER_DHCP_STARTED) { 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)); ESP_ERROR_CHECK(tcpip_adapter_dhcpc_start(TCPIP_ADAPTER_IF_STA));
// } // }
} }
@@ -1293,14 +1293,14 @@ void wifi_manager( void * pvParameters ){
case EVENT_STA_DISCONNECTED:{ case EVENT_STA_DISCONNECTED:{
wifi_event_sta_disconnected_t disc_event; 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){ if(msg.param == NULL){
ESP_LOGE(TAG, "MESSAGE: EVENT_STA_DISCONNECTED - expected parameter not found!"); ESP_LOGE(TAG, "MESSAGE: EVENT_STA_DISCONNECTED - expected parameter not found!");
} }
else{ else{
memcpy(&disc_event,(wifi_event_sta_disconnected_t*)msg.param,sizeof(disc_event)); memcpy(&disc_event,(wifi_event_sta_disconnected_t*)msg.param,sizeof(disc_event));
free(msg.param); 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 /* 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){ 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 */ /* 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); xEventGroupClearBits(wifi_manager_event_group, WIFI_MANAGER_REQUEST_DISCONNECT_BIT);
@@ -1426,7 +1426,7 @@ void wifi_manager( void * pvParameters ){
break; break;
case ORDER_START_AP: case ORDER_START_AP:
ESP_LOGI(TAG, "MESSAGE: ORDER_START_AP"); ESP_LOGD(TAG, "MESSAGE: ORDER_START_AP");
wifi_manager_config_ap(); wifi_manager_config_ap();
ESP_LOGD(TAG, "AP Starting, requesting wifi scan."); ESP_LOGD(TAG, "AP Starting, requesting wifi scan.");
wifi_manager_scan_async(); wifi_manager_scan_async();
@@ -1435,7 +1435,7 @@ void wifi_manager( void * pvParameters ){
break; break;
case EVENT_STA_GOT_IP: 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); uxBits = xEventGroupGetBits(wifi_manager_event_group);
@@ -1485,7 +1485,7 @@ void wifi_manager( void * pvParameters ){
} }
break; break;
case ORDER_DISCONNECT_STA: 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 */ /* precise this is coming from a user request */
xEventGroupSetBits(wifi_manager_event_group, WIFI_MANAGER_REQUEST_DISCONNECT_BIT); xEventGroupSetBits(wifi_manager_event_group, WIFI_MANAGER_REQUEST_DISCONNECT_BIT);

4
components/wifi-manager/wifi_manager_http_server.c
View File

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