5 #include <freertos/FreeRTOS.h> 6 #include <freertos/task.h> 7 #include <freertos/event_groups.h> 8 #include <esp_system.h> 10 #include <esp_wifi_types.h> 11 #include <esp_event.h> 12 #include <esp_netif.h> 16 #ifdef USE_WIFI_WPA2_EAP 31 static const char *
const TAG =
"wifi_esp32";
33 static EventGroupHandle_t s_wifi_event_group;
34 static xQueueHandle s_event_queue;
35 static esp_netif_t *s_sta_netif =
nullptr;
36 static esp_netif_t *s_ap_netif =
nullptr;
37 static bool s_sta_started =
false;
38 static bool s_sta_connected =
false;
39 static bool s_sta_got_ip =
false;
40 static bool s_ap_started =
false;
41 static bool s_sta_connect_not_found =
false;
42 static bool s_sta_connect_error =
false;
43 static bool s_sta_connecting =
false;
44 static bool s_wifi_started =
false;
47 esp_event_base_t event_base;
50 wifi_event_sta_scan_done_t sta_scan_done;
51 wifi_event_sta_connected_t sta_connected;
52 wifi_event_sta_disconnected_t sta_disconnected;
53 wifi_event_sta_authmode_change_t sta_authmode_change;
54 wifi_event_ap_staconnected_t ap_staconnected;
55 wifi_event_ap_stadisconnected_t ap_stadisconnected;
56 wifi_event_ap_probe_req_rx_t ap_probe_req_rx;
57 wifi_event_bss_rssi_low_t bss_rssi_low;
58 ip_event_got_ip_t ip_got_ip;
59 ip_event_got_ip6_t ip_got_ip6;
60 ip_event_ap_staipassigned_t ip_ap_staipassigned;
66 void event_handler(
void *arg, esp_event_base_t event_base, int32_t event_id,
void *event_data) {
68 memset(&event, 0,
sizeof(IDFWiFiEvent));
69 event.event_base = event_base;
70 event.event_id = event_id;
71 if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {
73 }
else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_STOP) {
75 }
else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_AUTHMODE_CHANGE) {
76 memcpy(&event.data.sta_authmode_change, event_data,
sizeof(wifi_event_sta_authmode_change_t));
77 }
else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_CONNECTED) {
78 memcpy(&event.data.sta_connected, event_data,
sizeof(wifi_event_sta_connected_t));
79 }
else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
80 memcpy(&event.data.sta_disconnected, event_data,
sizeof(wifi_event_sta_disconnected_t));
81 }
else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
82 memcpy(&event.data.ip_got_ip, event_data,
sizeof(ip_event_got_ip_t));
83 }
else if (event_base == IP_EVENT && event_id == IP_EVENT_GOT_IP6) {
84 memcpy(&event.data.ip_got_ip6, event_data,
sizeof(ip_event_got_ip6_t));
85 }
else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_LOST_IP) {
87 }
else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_SCAN_DONE) {
88 memcpy(&event.data.sta_scan_done, event_data,
sizeof(wifi_event_sta_scan_done_t));
89 }
else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_AP_START) {
91 }
else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_AP_STOP) {
93 }
else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_AP_PROBEREQRECVED) {
94 memcpy(&event.data.ap_probe_req_rx, event_data,
sizeof(wifi_event_ap_probe_req_rx_t));
95 }
else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_AP_STACONNECTED) {
96 memcpy(&event.data.ap_staconnected, event_data,
sizeof(wifi_event_ap_staconnected_t));
97 }
else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_AP_STADISCONNECTED) {
98 memcpy(&event.data.ap_stadisconnected, event_data,
sizeof(wifi_event_ap_stadisconnected_t));
99 }
else if (event_base == IP_EVENT && event_id == IP_EVENT_AP_STAIPASSIGNED) {
100 memcpy(&event.data.ip_ap_staipassigned, event_data,
sizeof(ip_event_ap_staipassigned_t));
107 auto *to_send =
new IDFWiFiEvent;
108 memcpy(to_send, &event,
sizeof(IDFWiFiEvent));
110 if (xQueueSend(s_event_queue, &to_send, 0L) != pdPASS) {
116 #ifdef USE_ESP32_IGNORE_EFUSE_MAC_CRC 122 esp_err_t err = esp_netif_init();
124 ESP_LOGE(TAG,
"esp_netif_init failed: %s", esp_err_to_name(err));
127 s_wifi_event_group = xEventGroupCreate();
128 if (s_wifi_event_group ==
nullptr) {
129 ESP_LOGE(TAG,
"xEventGroupCreate failed");
133 s_event_queue = xQueueCreate(64,
sizeof(IDFWiFiEvent *));
134 if (s_event_queue ==
nullptr) {
135 ESP_LOGE(TAG,
"xQueueCreate failed");
138 err = esp_event_loop_create_default();
140 ESP_LOGE(TAG,
"esp_event_loop_create_default failed: %s", esp_err_to_name(err));
143 esp_event_handler_instance_t instance_wifi_id, instance_ip_id;
144 err = esp_event_handler_instance_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &
event_handler,
nullptr, &instance_wifi_id);
146 ESP_LOGE(TAG,
"esp_event_handler_instance_register failed: %s", esp_err_to_name(err));
149 err = esp_event_handler_instance_register(IP_EVENT, ESP_EVENT_ANY_ID, &
event_handler,
nullptr, &instance_ip_id);
151 ESP_LOGE(TAG,
"esp_event_handler_instance_register failed: %s", esp_err_to_name(err));
155 s_sta_netif = esp_netif_create_default_wifi_sta();
156 s_ap_netif = esp_netif_create_default_wifi_ap();
157 wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
159 err = esp_wifi_init(&cfg);
161 ESP_LOGE(TAG,
"esp_wifi_init failed: %s", esp_err_to_name(err));
164 err = esp_wifi_set_storage(WIFI_STORAGE_RAM);
166 ESP_LOGE(TAG,
"esp_wifi_set_storage failed: %s", esp_err_to_name(err));
173 wifi_mode_t current_mode = WIFI_MODE_NULL;
174 if (s_wifi_started) {
175 err = esp_wifi_get_mode(¤t_mode);
177 ESP_LOGW(TAG,
"esp_wifi_get_mode failed: %s", esp_err_to_name(err));
181 bool current_sta = current_mode == WIFI_MODE_STA || current_mode == WIFI_MODE_APSTA;
182 bool current_ap = current_mode == WIFI_MODE_AP || current_mode == WIFI_MODE_APSTA;
184 bool set_sta = sta.
has_value() ? *sta : current_sta;
185 bool set_ap = ap.
has_value() ? *ap : current_ap;
187 wifi_mode_t set_mode;
188 if (set_sta && set_ap) {
189 set_mode = WIFI_MODE_APSTA;
190 }
else if (set_sta && !set_ap) {
191 set_mode = WIFI_MODE_STA;
192 }
else if (!set_sta && set_ap) {
193 set_mode = WIFI_MODE_AP;
195 set_mode = WIFI_MODE_NULL;
198 if (current_mode == set_mode)
201 if (set_sta && !current_sta) {
202 ESP_LOGV(TAG,
"Enabling STA.");
203 }
else if (!set_sta && current_sta) {
204 ESP_LOGV(TAG,
"Disabling STA.");
206 if (set_ap && !current_ap) {
207 ESP_LOGV(TAG,
"Enabling AP.");
208 }
else if (!set_ap && current_ap) {
209 ESP_LOGV(TAG,
"Disabling AP.");
212 if (set_mode == WIFI_MODE_NULL && s_wifi_started) {
213 err = esp_wifi_stop();
215 ESP_LOGV(TAG,
"esp_wifi_stop failed: %s", esp_err_to_name(err));
218 s_wifi_started =
false;
222 err = esp_wifi_set_mode(set_mode);
224 ESP_LOGW(TAG,
"esp_wifi_set_mode failed: %s", esp_err_to_name(err));
228 if (set_mode != WIFI_MODE_NULL && !s_wifi_started) {
229 err = esp_wifi_start();
231 ESP_LOGV(TAG,
"esp_wifi_start failed: %s", esp_err_to_name(err));
234 s_wifi_started =
true;
243 int8_t
val =
static_cast<int8_t
>(output_power * 4);
244 return esp_wifi_set_max_tx_power(val) == ESP_OK;
248 wifi_ps_type_t power_save;
249 switch (this->power_save_) {
251 power_save = WIFI_PS_MIN_MODEM;
254 power_save = WIFI_PS_MAX_MODEM;
258 power_save = WIFI_PS_NONE;
261 return esp_wifi_set_ps(power_save) == ESP_OK;
266 if (!this->wifi_mode_(
true, {}))
271 memset(&conf, 0,
sizeof(conf));
272 strncpy(reinterpret_cast<char *>(conf.sta.ssid), ap.
get_ssid().c_str(),
sizeof(conf.sta.ssid));
273 strncpy(reinterpret_cast<char *>(conf.sta.password), ap.
get_password().c_str(),
sizeof(conf.sta.password));
277 conf.sta.threshold.authmode = WIFI_AUTH_OPEN;
279 conf.sta.threshold.authmode = WIFI_AUTH_WPA_WPA2_PSK;
282 #ifdef USE_WIFI_WPA2_EAP 283 if (ap.
get_eap().has_value()) {
284 conf.sta.threshold.authmode = WIFI_AUTH_WPA2_ENTERPRISE;
288 #ifdef USE_WIFI_11KV_SUPPORT 289 conf.sta.btm_enabled = this->btm_;
290 conf.sta.rm_enabled = this->rrm_;
294 conf.sta.bssid_set =
true;
295 memcpy(conf.sta.bssid, ap.
get_bssid()->data(), 6);
297 conf.sta.bssid_set =
false;
301 conf.sta.scan_method = WIFI_FAST_SCAN;
303 conf.sta.scan_method = WIFI_ALL_CHANNEL_SCAN;
307 conf.sta.listen_interval = 0;
309 #if ESP_IDF_VERSION_MAJOR >= 4 312 conf.sta.pmf_cfg.capable =
true;
313 conf.sta.pmf_cfg.required =
false;
318 conf.sta.threshold.rssi = -127;
320 conf.sta.threshold.authmode = WIFI_AUTH_OPEN;
322 wifi_config_t current_conf;
324 err = esp_wifi_get_config(WIFI_IF_STA, ¤t_conf);
326 ESP_LOGW(TAG,
"esp_wifi_get_config failed: %s", esp_err_to_name(err));
330 if (memcmp(¤t_conf, &conf,
sizeof(wifi_config_t)) != 0) {
331 err = esp_wifi_disconnect();
333 ESP_LOGV(TAG,
"esp_wifi_disconnect failed: %s", esp_err_to_name(err));
338 err = esp_wifi_set_config(WIFI_IF_STA, &conf);
340 ESP_LOGV(TAG,
"esp_wifi_set_config failed: %s", esp_err_to_name(err));
349 #ifdef USE_WIFI_WPA2_EAP 350 if (ap.
get_eap().has_value()) {
353 err = esp_wifi_sta_wpa2_ent_set_identity((uint8_t *) eap.
identity.c_str(), eap.
identity.length());
355 ESP_LOGV(TAG,
"esp_wifi_sta_wpa2_ent_set_identity failed! %d", err);
357 int ca_cert_len = strlen(eap.
ca_cert);
361 err = esp_wifi_sta_wpa2_ent_set_ca_cert((uint8_t *) eap.
ca_cert, ca_cert_len + 1);
363 ESP_LOGV(TAG,
"esp_wifi_sta_wpa2_ent_set_ca_cert failed! %d", err);
368 if (client_cert_len && client_key_len) {
370 err = esp_wifi_sta_wpa2_ent_set_cert_key((uint8_t *) eap.
client_cert, client_cert_len + 1,
371 (uint8_t *) eap.
client_key, client_key_len + 1,
374 ESP_LOGV(TAG,
"esp_wifi_sta_wpa2_ent_set_cert_key failed! %d", err);
378 err = esp_wifi_sta_wpa2_ent_set_username((uint8_t *) eap.
username.c_str(), eap.
username.length());
380 ESP_LOGV(TAG,
"esp_wifi_sta_wpa2_ent_set_username failed! %d", err);
382 err = esp_wifi_sta_wpa2_ent_set_password((uint8_t *) eap.
password.c_str(), eap.
password.length());
384 ESP_LOGV(TAG,
"esp_wifi_sta_wpa2_ent_set_password failed! %d", err);
387 err = esp_wifi_sta_wpa2_ent_enable();
389 ESP_LOGV(TAG,
"esp_wifi_sta_wpa2_ent_enable failed! %d", err);
392 #endif // USE_WIFI_WPA2_EAP 396 s_sta_connecting =
true;
397 s_sta_connected =
false;
398 s_sta_got_ip =
false;
399 s_sta_connect_error =
false;
400 s_sta_connect_not_found =
false;
402 err = esp_wifi_connect();
404 ESP_LOGW(TAG,
"esp_wifi_connect failed: %s", esp_err_to_name(err));
413 if (!this->wifi_mode_(
true, {}))
416 tcpip_adapter_dhcp_status_t dhcp_status;
417 esp_err_t err = tcpip_adapter_dhcpc_get_status(TCPIP_ADAPTER_IF_STA, &dhcp_status);
419 ESP_LOGV(TAG,
"tcpip_adapter_dhcpc_get_status failed: %s", esp_err_to_name(err));
425 if (dhcp_status != TCPIP_ADAPTER_DHCP_STARTED) {
426 err = tcpip_adapter_dhcpc_start(TCPIP_ADAPTER_IF_STA);
428 ESP_LOGV(TAG,
"Starting DHCP client failed! %d", err);
430 return err == ESP_OK;
435 tcpip_adapter_ip_info_t info;
436 memset(&info, 0,
sizeof(info));
437 info.ip.addr =
static_cast<uint32_t
>(manual_ip->static_ip);
438 info.gw.addr =
static_cast<uint32_t
>(manual_ip->gateway);
439 info.netmask.addr =
static_cast<uint32_t
>(manual_ip->subnet);
441 err = tcpip_adapter_dhcpc_stop(TCPIP_ADAPTER_IF_STA);
442 if (err != ESP_OK && err != ESP_ERR_ESP_NETIF_DHCP_ALREADY_STOPPED) {
443 ESP_LOGV(TAG,
"tcpip_adapter_dhcpc_stop failed: %s", esp_err_to_name(err));
447 err = tcpip_adapter_set_ip_info(TCPIP_ADAPTER_IF_STA, &info);
449 ESP_LOGV(TAG,
"tcpip_adapter_set_ip_info failed: %s", esp_err_to_name(err));
454 dns.type = IPADDR_TYPE_V4;
455 if (uint32_t(manual_ip->dns1) != 0) {
456 dns.u_addr.ip4.addr =
static_cast<uint32_t
>(manual_ip->dns1);
457 dns_setserver(0, &dns);
459 if (uint32_t(manual_ip->dns2) != 0) {
460 dns.u_addr.ip4.addr =
static_cast<uint32_t
>(manual_ip->dns2);
461 dns_setserver(1, &dns);
468 if (!this->has_sta())
470 tcpip_adapter_ip_info_t ip;
471 esp_err_t err = tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_STA, &ip);
473 ESP_LOGV(TAG,
"tcpip_adapter_get_ip_info failed: %s", esp_err_to_name(err));
489 case WIFI_AUTH_WPA_PSK:
491 case WIFI_AUTH_WPA2_PSK:
493 case WIFI_AUTH_WPA_WPA2_PSK:
494 return "WPA/WPA2 PSK";
495 case WIFI_AUTH_WPA2_ENTERPRISE:
496 return "WPA2 Enterprise";
497 case WIFI_AUTH_WPA3_PSK:
499 case WIFI_AUTH_WPA2_WPA3_PSK:
500 return "WPA2/WPA3 PSK";
501 case WIFI_AUTH_WAPI_PSK:
512 case WIFI_REASON_AUTH_EXPIRE:
513 return "Auth Expired";
514 case WIFI_REASON_AUTH_LEAVE:
516 case WIFI_REASON_ASSOC_EXPIRE:
517 return "Association Expired";
518 case WIFI_REASON_ASSOC_TOOMANY:
519 return "Too Many Associations";
520 case WIFI_REASON_NOT_AUTHED:
521 return "Not Authenticated";
522 case WIFI_REASON_NOT_ASSOCED:
523 return "Not Associated";
524 case WIFI_REASON_ASSOC_LEAVE:
525 return "Association Leave";
526 case WIFI_REASON_ASSOC_NOT_AUTHED:
527 return "Association not Authenticated";
528 case WIFI_REASON_DISASSOC_PWRCAP_BAD:
529 return "Disassociate Power Cap Bad";
530 case WIFI_REASON_DISASSOC_SUPCHAN_BAD:
531 return "Disassociate Supported Channel Bad";
532 case WIFI_REASON_IE_INVALID:
534 case WIFI_REASON_MIC_FAILURE:
535 return "Mic Failure";
536 case WIFI_REASON_4WAY_HANDSHAKE_TIMEOUT:
537 return "4-Way Handshake Timeout";
538 case WIFI_REASON_GROUP_KEY_UPDATE_TIMEOUT:
539 return "Group Key Update Timeout";
540 case WIFI_REASON_IE_IN_4WAY_DIFFERS:
541 return "IE In 4-Way Handshake Differs";
542 case WIFI_REASON_GROUP_CIPHER_INVALID:
543 return "Group Cipher Invalid";
544 case WIFI_REASON_PAIRWISE_CIPHER_INVALID:
545 return "Pairwise Cipher Invalid";
546 case WIFI_REASON_AKMP_INVALID:
547 return "AKMP Invalid";
548 case WIFI_REASON_UNSUPP_RSN_IE_VERSION:
549 return "Unsupported RSN IE version";
550 case WIFI_REASON_INVALID_RSN_IE_CAP:
551 return "Invalid RSN IE Cap";
552 case WIFI_REASON_802_1X_AUTH_FAILED:
553 return "802.1x Authentication Failed";
554 case WIFI_REASON_CIPHER_SUITE_REJECTED:
555 return "Cipher Suite Rejected";
556 case WIFI_REASON_BEACON_TIMEOUT:
557 return "Beacon Timeout";
558 case WIFI_REASON_NO_AP_FOUND:
559 return "AP Not Found";
560 case WIFI_REASON_AUTH_FAIL:
561 return "Authentication Failed";
562 case WIFI_REASON_ASSOC_FAIL:
563 return "Association Failed";
564 case WIFI_REASON_HANDSHAKE_TIMEOUT:
565 return "Handshake Failed";
566 case WIFI_REASON_CONNECTION_FAIL:
567 return "Connection Failed";
568 case WIFI_REASON_UNSPECIFIED:
570 return "Unspecified";
577 if (xQueueReceive(s_event_queue, &data, 0L) != pdTRUE) {
583 wifi_process_event_(data);
590 if (data->event_base == WIFI_EVENT && data->event_id == WIFI_EVENT_STA_START) {
591 ESP_LOGV(TAG,
"Event: WiFi STA start");
593 err = tcpip_adapter_set_hostname(TCPIP_ADAPTER_IF_STA,
App.
get_name().c_str());
595 ESP_LOGW(TAG,
"tcpip_adapter_set_hostname failed: %s", esp_err_to_name(err));
598 s_sta_started =
true;
600 wifi_apply_power_save_();
602 }
else if (data->event_base == WIFI_EVENT && data->event_id == WIFI_EVENT_STA_STOP) {
603 ESP_LOGV(TAG,
"Event: WiFi STA stop");
604 s_sta_started =
false;
606 }
else if (data->event_base == WIFI_EVENT && data->event_id == WIFI_EVENT_STA_AUTHMODE_CHANGE) {
607 const auto &it = data->data.sta_authmode_change;
608 ESP_LOGV(TAG,
"Event: Authmode Change old=%s new=%s",
get_auth_mode_str(it.old_mode),
611 }
else if (data->event_base == WIFI_EVENT && data->event_id == WIFI_EVENT_STA_CONNECTED) {
612 const auto &it = data->data.sta_connected;
614 assert(it.ssid_len <= 32);
615 memcpy(buf, it.ssid, it.ssid_len);
616 buf[it.ssid_len] =
'\0';
617 ESP_LOGV(TAG,
"Event: Connected ssid='%s' bssid=" LOG_SECRET(
"%s")
" channel=%u, authmode=%s", buf,
619 s_sta_connected =
true;
621 }
else if (data->event_base == WIFI_EVENT && data->event_id == WIFI_EVENT_STA_DISCONNECTED) {
622 const auto &it = data->data.sta_disconnected;
624 assert(it.ssid_len <= 32);
625 memcpy(buf, it.ssid, it.ssid_len);
626 buf[it.ssid_len] =
'\0';
627 if (it.reason == WIFI_REASON_NO_AP_FOUND) {
628 ESP_LOGW(TAG,
"Event: Disconnected ssid='%s' reason='Probe Request Unsuccessful'", buf);
629 s_sta_connect_not_found =
true;
632 ESP_LOGW(TAG,
"Event: Disconnected ssid='%s' bssid=" LOG_SECRET(
"%s")
" reason='%s'", buf,
634 s_sta_connect_error =
true;
636 s_sta_connected =
false;
637 s_sta_connecting =
false;
638 error_from_callback_ =
true;
640 }
else if (data->event_base == IP_EVENT && data->event_id == IP_EVENT_STA_GOT_IP) {
641 const auto &it = data->data.ip_got_ip;
642 #ifdef LWIP_IPV6_AUTOCONFIG 643 tcpip_adapter_create_ip6_linklocal(TCPIP_ADAPTER_IF_STA);
645 ESP_LOGV(TAG,
"Event: Got IP static_ip=%s gateway=%s",
format_ip4_addr(it.ip_info.ip).c_str(),
649 }
else if (data->event_base == IP_EVENT && data->event_id == IP_EVENT_GOT_IP6) {
650 const auto &it = data->data.ip_got_ip6;
651 ESP_LOGV(TAG,
"Event: Got IPv6 address=%s",
format_ip6_addr(it.ip6_info.ip).c_str());
653 }
else if (data->event_base == IP_EVENT && data->event_id == IP_EVENT_STA_LOST_IP) {
654 ESP_LOGV(TAG,
"Event: Lost IP");
655 s_sta_got_ip =
false;
657 }
else if (data->event_base == WIFI_EVENT && data->event_id == WIFI_EVENT_SCAN_DONE) {
658 const auto &it = data->data.sta_scan_done;
659 ESP_LOGV(TAG,
"Event: WiFi Scan Done status=%u number=%u scan_id=%u", it.status, it.number, it.scan_id);
661 scan_result_.clear();
662 this->scan_done_ =
true;
663 if (it.status != 0) {
668 uint16_t number = it.number;
669 std::vector<wifi_ap_record_t> records(number);
670 err = esp_wifi_scan_get_ap_records(&number, records.data());
672 ESP_LOGW(TAG,
"esp_wifi_scan_get_ap_records failed: %s", esp_err_to_name(err));
675 records.resize(number);
677 scan_result_.reserve(number);
678 for (
int i = 0; i < number; i++) {
679 auto &record = records[i];
681 std::copy(record.bssid, record.bssid + 6, bssid.begin());
682 std::string ssid(reinterpret_cast<const char *>(record.ssid));
683 WiFiScanResult result(bssid, ssid, record.primary, record.rssi, record.authmode != WIFI_AUTH_OPEN, ssid.empty());
684 scan_result_.push_back(result);
687 }
else if (data->event_base == WIFI_EVENT && data->event_id == WIFI_EVENT_AP_START) {
688 ESP_LOGV(TAG,
"Event: WiFi AP start");
691 }
else if (data->event_base == WIFI_EVENT && data->event_id == WIFI_EVENT_AP_STOP) {
692 ESP_LOGV(TAG,
"Event: WiFi AP stop");
693 s_ap_started =
false;
695 }
else if (data->event_base == WIFI_EVENT && data->event_id == WIFI_EVENT_AP_PROBEREQRECVED) {
696 const auto &it = data->data.ap_probe_req_rx;
697 ESP_LOGVV(TAG,
"Event: AP receive Probe Request MAC=%s RSSI=%d", format_mac_addr(it.mac).c_str(), it.rssi);
699 }
else if (data->event_base == WIFI_EVENT && data->event_id == WIFI_EVENT_AP_STACONNECTED) {
700 const auto &it = data->data.ap_staconnected;
701 ESP_LOGV(TAG,
"Event: AP client connected MAC=%s", format_mac_addr(it.mac).c_str());
703 }
else if (data->event_base == WIFI_EVENT && data->event_id == WIFI_EVENT_AP_STADISCONNECTED) {
704 const auto &it = data->data.ap_stadisconnected;
705 ESP_LOGV(TAG,
"Event: AP client disconnected MAC=%s", format_mac_addr(it.mac).c_str());
707 }
else if (data->event_base == IP_EVENT && data->event_id == IP_EVENT_AP_STAIPASSIGNED) {
708 const auto &it = data->data.ip_ap_staipassigned;
709 ESP_LOGV(TAG,
"Event: AP client assigned IP %s",
format_ip4_addr(it.ip).c_str());
714 if (s_sta_connected && s_sta_got_ip) {
717 if (s_sta_connect_error) {
720 if (s_sta_connect_not_found) {
723 if (s_sta_connecting) {
730 if (!this->wifi_mode_(
true, {}))
733 wifi_scan_config_t config{};
734 config.ssid =
nullptr;
735 config.bssid =
nullptr;
737 config.show_hidden =
true;
738 config.scan_type = WIFI_SCAN_TYPE_ACTIVE;
739 config.scan_time.active.min = 100;
740 config.scan_time.active.max = 300;
742 esp_err_t err = esp_wifi_scan_start(&config,
false);
744 ESP_LOGV(TAG,
"esp_wifi_scan_start failed: %s", esp_err_to_name(err));
755 if (!this->wifi_mode_({},
true))
758 tcpip_adapter_ip_info_t info;
759 memset(&info, 0,
sizeof(info));
761 info.ip.addr =
static_cast<uint32_t
>(manual_ip->static_ip);
762 info.gw.addr =
static_cast<uint32_t
>(manual_ip->gateway);
763 info.netmask.addr =
static_cast<uint32_t
>(manual_ip->subnet);
769 tcpip_adapter_dhcp_status_t dhcp_status;
770 tcpip_adapter_dhcps_get_status(TCPIP_ADAPTER_IF_AP, &dhcp_status);
771 err = tcpip_adapter_dhcps_stop(TCPIP_ADAPTER_IF_AP);
773 ESP_LOGV(TAG,
"tcpip_adapter_dhcps_stop failed! %d", err);
777 err = tcpip_adapter_set_ip_info(TCPIP_ADAPTER_IF_AP, &info);
779 ESP_LOGV(TAG,
"tcpip_adapter_set_ip_info failed! %d", err);
786 start_address[3] += 99;
787 lease.start_ip.addr =
static_cast<uint32_t
>(start_address);
788 ESP_LOGV(TAG,
"DHCP server IP lease start: %s", start_address.
str().c_str());
789 start_address[3] += 100;
790 lease.end_ip.addr =
static_cast<uint32_t
>(start_address);
791 ESP_LOGV(TAG,
"DHCP server IP lease end: %s", start_address.str().c_str());
792 err = tcpip_adapter_dhcps_option(TCPIP_ADAPTER_OP_SET, TCPIP_ADAPTER_REQUESTED_IP_ADDRESS, &lease,
sizeof(lease));
795 ESP_LOGV(TAG,
"tcpip_adapter_dhcps_option failed! %d", err);
799 err = tcpip_adapter_dhcps_start(TCPIP_ADAPTER_IF_AP);
802 ESP_LOGV(TAG,
"tcpip_adapter_dhcps_start failed! %d", err);
810 if (!this->wifi_mode_({},
true))
814 memset(&conf, 0,
sizeof(conf));
815 strncpy(reinterpret_cast<char *>(conf.ap.ssid), ap.
get_ssid().c_str(),
sizeof(conf.ap.ssid));
817 conf.ap.ssid_hidden = ap.
get_ssid().size();
818 conf.ap.max_connection = 5;
819 conf.ap.beacon_interval = 100;
822 conf.ap.authmode = WIFI_AUTH_OPEN;
823 *conf.ap.password = 0;
825 conf.ap.authmode = WIFI_AUTH_WPA2_PSK;
826 strncpy(reinterpret_cast<char *>(conf.ap.password), ap.
get_password().c_str(),
sizeof(conf.ap.password));
829 #if ESP_IDF_VERSION_MAJOR >= 4 831 conf.ap.pairwise_cipher = WIFI_CIPHER_TYPE_CCMP;
834 esp_err_t err = esp_wifi_set_config(WIFI_IF_AP, &conf);
836 ESP_LOGV(TAG,
"esp_wifi_set_config failed! %d", err);
841 ESP_LOGV(TAG,
"wifi_ap_ip_config_ failed!");
848 tcpip_adapter_ip_info_t ip;
849 tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_AP, &ip);
855 wifi_ap_record_t info;
856 esp_err_t err = esp_wifi_sta_get_ap_info(&info);
859 ESP_LOGW(TAG,
"esp_wifi_sta_get_ap_info failed: %s", esp_err_to_name(err));
862 std::copy(info.bssid, info.bssid + 6, res.begin());
866 wifi_ap_record_t info{};
867 esp_err_t err = esp_wifi_sta_get_ap_info(&info);
869 ESP_LOGW(TAG,
"esp_wifi_sta_get_ap_info failed: %s", esp_err_to_name(err));
872 auto *ssid_s =
reinterpret_cast<const char *
>(info.ssid);
873 size_t len = strnlen(ssid_s,
sizeof(info.ssid));
874 return {ssid_s, len};
877 wifi_ap_record_t info;
878 esp_err_t err = esp_wifi_sta_get_ap_info(&info);
880 ESP_LOGW(TAG,
"esp_wifi_sta_get_ap_info failed: %s", esp_err_to_name(err));
887 wifi_second_chan_t second;
888 esp_err_t err = esp_wifi_get_channel(&primary, &second);
890 ESP_LOGW(TAG,
"esp_wifi_get_channel failed: %s", esp_err_to_name(err));
896 esp_netif_ip_info_t ip;
897 esp_err_t err = esp_netif_get_ip_info(s_sta_netif, &ip);
899 ESP_LOGW(TAG,
"esp_netif_get_ip_info failed: %s", esp_err_to_name(err));
902 return {ip.netmask.addr};
905 esp_netif_ip_info_t ip;
906 esp_err_t err = esp_netif_get_ip_info(s_sta_netif, &ip);
908 ESP_LOGW(TAG,
"esp_netif_get_ip_info failed: %s", esp_err_to_name(err));
914 const ip_addr_t *dns_ip = dns_getserver(num);
915 return {dns_ip->u_addr.ip4.addr};
WiFiSTAConnectStatus wifi_sta_connect_status_()
std::array< uint8_t, 6 > bssid_t
const optional< EAPAuth > & get_eap() const
const std::string & get_password() const
network::IPAddress wifi_dns_ip_(int num)
bool wifi_mode_(optional< bool > sta, optional< bool > ap)
const optional< bssid_t > & get_bssid() const
bool wifi_apply_output_power_(float output_power)
bool wifi_sta_ip_config_(optional< ManualIP > manual_ip)
void event_handler(void *arg, esp_event_base_t event_base, int32_t event_id, void *event_data)
network::IPAddress wifi_subnet_mask_()
bool wifi_apply_hostname_()
std::string format_ip6_addr(const esp_ip6_addr_t &ip)
bool wifi_start_ap_(const WiFiAP &ap)
void wifi_process_event_(IDFWiFiEvent *data)
const optional< ManualIP > & get_manual_ip() const
const optional< uint8_t > & get_channel() const
BedjetMode mode
BedJet operating mode.
bool wifi_apply_power_save_()
Application App
Global storage of Application pointer - only one Application can exist.
bool wifi_ap_ip_config_(optional< ManualIP > manual_ip)
void set_mac_address(uint8_t *mac)
Set the MAC address to use from the provided byte array (6 bytes).
const std::string & get_name() const
Get the name of this Application set by set_name().
network::IPAddress wifi_soft_ap_ip()
bool wifi_sta_pre_setup_()
const char * get_auth_mode_str(uint8_t mode)
network::IPAddress wifi_gateway_ip_()
std::string format_ip4_addr(const esphome_ip4_addr_t &ip)
const std::string & get_ssid() const
const char * get_disconnect_reason_str(uint8_t reason)
std::string get_mac_address_pretty()
Get the device MAC address as a string, in colon-separated uppercase hex notation.
std::string str_snprintf(const char *fmt, size_t len,...)
network::IPAddress wifi_sta_ip()
value_type value_or(U const &v) const
bool wifi_sta_connect_(const WiFiAP &ap)
void get_mac_address_raw(uint8_t *mac)
Get the device MAC address as raw bytes, written into the provided byte array (6 bytes).