ESPHome 2025.5.0
Loading...
Searching...
No Matches
wifi_component_esp8266.cpp
Go to the documentation of this file.
1#include "wifi_component.h"
3
4#ifdef USE_WIFI
5#ifdef USE_ESP8266
6
7#include <user_interface.h>
8
9#include <utility>
10#include <algorithm>
11#ifdef USE_WIFI_WPA2_EAP
12#include <wpa2_enterprise.h>
13#endif
14
15extern "C" {
16#include "lwip/err.h"
17#include "lwip/dns.h"
18#include "lwip/dhcp.h"
19#include "lwip/init.h" // LWIP_VERSION_
20#include "lwip/apps/sntp.h"
21#include "lwip/netif.h" // struct netif
22#include <AddrList.h>
23#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(3, 0, 0)
24#include "LwipDhcpServer.h"
25#if USE_ARDUINO_VERSION_CODE < VERSION_CODE(3, 1, 0)
26#include <ESP8266WiFi.h>
27#include "ESP8266WiFiAP.h"
28#define wifi_softap_set_dhcps_lease(lease) dhcpSoftAP.set_dhcps_lease(lease)
29#define wifi_softap_set_dhcps_lease_time(time) dhcpSoftAP.set_dhcps_lease_time(time)
30#define wifi_softap_set_dhcps_offer_option(offer, mode) dhcpSoftAP.set_dhcps_offer_option(offer, mode)
31#endif
32#endif
33}
34
36#include "esphome/core/log.h"
37#include "esphome/core/hal.h"
38#include "esphome/core/util.h"
40
41namespace esphome {
42namespace wifi {
43
44static const char *const TAG = "wifi_esp8266";
45
46static bool s_sta_connected = false; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
47static bool s_sta_got_ip = false; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
48static bool s_sta_connect_not_found = false; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
49static bool s_sta_connect_error = false; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
50static bool s_sta_connecting = false; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
51
52bool WiFiComponent::wifi_mode_(optional<bool> sta, optional<bool> ap) {
53 uint8_t current_mode = wifi_get_opmode();
54 bool current_sta = current_mode & 0b01;
55 bool current_ap = current_mode & 0b10;
56 bool target_sta = sta.value_or(current_sta);
57 bool target_ap = ap.value_or(current_ap);
58 if (current_sta == target_sta && current_ap == target_ap)
59 return true;
60
61 if (target_sta && !current_sta) {
62 ESP_LOGV(TAG, "Enabling STA.");
63 } else if (!target_sta && current_sta) {
64 ESP_LOGV(TAG, "Disabling STA.");
65 // Stop DHCP client when disabling STA
66 // See https://github.com/esp8266/Arduino/pull/5703
67 wifi_station_dhcpc_stop();
68 }
69 if (target_ap && !current_ap) {
70 ESP_LOGV(TAG, "Enabling AP.");
71 } else if (!target_ap && current_ap) {
72 ESP_LOGV(TAG, "Disabling AP.");
73 }
74
75 ETS_UART_INTR_DISABLE();
76 uint8_t mode = 0;
77 if (target_sta)
78 mode |= 0b01;
79 if (target_ap)
80 mode |= 0b10;
81 bool ret = wifi_set_opmode_current(mode);
82 ETS_UART_INTR_ENABLE();
83
84 if (!ret) {
85 ESP_LOGW(TAG, "Setting WiFi mode failed!");
86 }
87
88 return ret;
89}
91 sleep_type_t power_save;
92 switch (this->power_save_) {
94 power_save = LIGHT_SLEEP_T;
95 break;
97 power_save = MODEM_SLEEP_T;
98 break;
100 default:
101 power_save = NONE_SLEEP_T;
102 break;
103 }
104 wifi_fpm_auto_sleep_set_in_null_mode(1);
105 return wifi_set_sleep_type(power_save);
106}
107
108#if LWIP_VERSION_MAJOR != 1
109/*
110 lwip v2 needs to be notified of IP changes, see also
111 https://github.com/d-a-v/Arduino/blob/0e7d21e17144cfc5f53c016191daca8723e89ee8/libraries/ESP8266WiFi/src/ESP8266WiFiSTA.cpp#L251
112 */
113#undef netif_set_addr // need to call lwIP-v1.4 netif_set_addr()
114extern "C" {
115struct netif *eagle_lwip_getif(int netif_index);
116void netif_set_addr(struct netif *netif, const ip4_addr_t *ip, const ip4_addr_t *netmask, const ip4_addr_t *gw);
117};
118#endif
119
121 // enable STA
122 if (!this->wifi_mode_(true, {}))
123 return false;
124
125 enum dhcp_status dhcp_status = wifi_station_dhcpc_status();
126 if (!manual_ip.has_value()) {
127 // lwIP starts the SNTP client if it gets an SNTP server from DHCP. We don't need the time, and more importantly,
128 // the built-in SNTP client has a memory leak in certain situations. Disable this feature.
129 // https://github.com/esphome/issues/issues/2299
130 sntp_servermode_dhcp(false);
131
132 // Use DHCP client
133 if (dhcp_status != DHCP_STARTED) {
134 bool ret = wifi_station_dhcpc_start();
135 if (!ret) {
136 ESP_LOGV(TAG, "Starting DHCP client failed!");
137 }
138 return ret;
139 }
140 return true;
141 }
142
143 bool ret = true;
144
145#if LWIP_VERSION_MAJOR != 1
146 // get current->previous IP address
147 // (check below)
148 ip_info previp{};
149 wifi_get_ip_info(STATION_IF, &previp);
150#endif
151
152 struct ip_info info {};
153 info.ip = manual_ip->static_ip;
154 info.gw = manual_ip->gateway;
155 info.netmask = manual_ip->subnet;
156
157 if (dhcp_status == DHCP_STARTED) {
158 bool dhcp_stop_ret = wifi_station_dhcpc_stop();
159 if (!dhcp_stop_ret) {
160 ESP_LOGV(TAG, "Stopping DHCP client failed!");
161 ret = false;
162 }
163 }
164 bool wifi_set_info_ret = wifi_set_ip_info(STATION_IF, &info);
165 if (!wifi_set_info_ret) {
166 ESP_LOGV(TAG, "Setting manual IP info failed!");
167 ret = false;
168 }
169
170 ip_addr_t dns;
171 if (manual_ip->dns1.is_set()) {
172 dns = manual_ip->dns1;
173 dns_setserver(0, &dns);
174 }
175 if (manual_ip->dns2.is_set()) {
176 dns = manual_ip->dns2;
177 dns_setserver(1, &dns);
178 }
179
180#if LWIP_VERSION_MAJOR != 1
181 // trigger address change by calling lwIP-v1.4 api
182 // only when ip is already set by other mean (generally dhcp)
183 if (previp.ip.addr != 0 && previp.ip.addr != info.ip.addr) {
184 netif_set_addr(eagle_lwip_getif(STATION_IF), reinterpret_cast<const ip4_addr_t *>(&info.ip),
185 reinterpret_cast<const ip4_addr_t *>(&info.netmask), reinterpret_cast<const ip4_addr_t *>(&info.gw));
186 }
187#endif
188 return ret;
189}
190
192 if (!this->has_sta())
193 return {};
194 network::IPAddresses addresses;
195 uint8_t index = 0;
196 for (auto &addr : addrList) {
197 addresses[index++] = addr.ipFromNetifNum();
198 }
199 return addresses;
200}
202 const std::string &hostname = App.get_name();
203 bool ret = wifi_station_set_hostname(const_cast<char *>(hostname.c_str()));
204 if (!ret) {
205 ESP_LOGV(TAG, "Setting WiFi Hostname failed!");
206 }
207
208 // inform dhcp server of hostname change using dhcp_renew()
209 for (netif *intf = netif_list; intf; intf = intf->next) {
210 // unconditionally update all known interfaces
211#if LWIP_VERSION_MAJOR == 1
212 intf->hostname = (char *) wifi_station_get_hostname();
213#else
214 intf->hostname = wifi_station_get_hostname();
215#endif
216 if (netif_dhcp_data(intf) != nullptr) {
217 // renew already started DHCP leases
218 err_t lwipret = dhcp_renew(intf);
219 if (lwipret != ERR_OK) {
220 ESP_LOGW(TAG, "wifi_apply_hostname_(%s): lwIP error %d on interface %c%c (index %d)", intf->hostname,
221 (int) lwipret, intf->name[0], intf->name[1], intf->num);
222 ret = false;
223 }
224 }
225 }
226
227 return ret;
228}
229
230bool WiFiComponent::wifi_sta_connect_(const WiFiAP &ap) {
231 // enable STA
232 if (!this->wifi_mode_(true, {}))
233 return false;
234
235 this->wifi_disconnect_();
236
237 struct station_config conf {};
238 memset(&conf, 0, sizeof(conf));
239 if (ap.get_ssid().size() > sizeof(conf.ssid)) {
240 ESP_LOGE(TAG, "SSID is too long");
241 return false;
242 }
243 if (ap.get_password().size() > sizeof(conf.password)) {
244 ESP_LOGE(TAG, "password is too long");
245 return false;
246 }
247 memcpy(reinterpret_cast<char *>(conf.ssid), ap.get_ssid().c_str(), ap.get_ssid().size());
248 memcpy(reinterpret_cast<char *>(conf.password), ap.get_password().c_str(), ap.get_password().size());
249
250 if (ap.get_bssid().has_value()) {
251 conf.bssid_set = 1;
252 memcpy(conf.bssid, ap.get_bssid()->data(), 6);
253 } else {
254 conf.bssid_set = 0;
255 }
256
257#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 4, 0)
258 if (ap.get_password().empty()) {
259 conf.threshold.authmode = AUTH_OPEN;
260 } else {
261 // Only allow auth modes with at least WPA
262 conf.threshold.authmode = AUTH_WPA_PSK;
263 }
264 conf.threshold.rssi = -127;
265#endif
266
267 ETS_UART_INTR_DISABLE();
268 bool ret = wifi_station_set_config_current(&conf);
269 ETS_UART_INTR_ENABLE();
270
271 if (!ret) {
272 ESP_LOGV(TAG, "Setting WiFi Station config failed!");
273 return false;
274 }
275
276 if (!this->wifi_sta_ip_config_(ap.get_manual_ip())) {
277 return false;
278 }
279
280 // setup enterprise authentication if required
281#ifdef USE_WIFI_WPA2_EAP
282 if (ap.get_eap().has_value()) {
283 // note: all certificates and keys have to be null terminated. Lengths are appended by +1 to include \0.
284 EAPAuth eap = ap.get_eap().value();
285 ret = wifi_station_set_enterprise_identity((uint8_t *) eap.identity.c_str(), eap.identity.length());
286 if (ret) {
287 ESP_LOGV(TAG, "esp_wifi_sta_wpa2_ent_set_identity failed! %d", ret);
288 }
289 int ca_cert_len = strlen(eap.ca_cert);
290 int client_cert_len = strlen(eap.client_cert);
291 int client_key_len = strlen(eap.client_key);
292 if (ca_cert_len) {
293 ret = wifi_station_set_enterprise_ca_cert((uint8_t *) eap.ca_cert, ca_cert_len + 1);
294 if (ret) {
295 ESP_LOGV(TAG, "esp_wifi_sta_wpa2_ent_set_ca_cert failed! %d", ret);
296 }
297 }
298 // workout what type of EAP this is
299 // validation is not required as the config tool has already validated it
300 if (client_cert_len && client_key_len) {
301 // if we have certs, this must be EAP-TLS
302 ret = wifi_station_set_enterprise_cert_key((uint8_t *) eap.client_cert, client_cert_len + 1,
303 (uint8_t *) eap.client_key, client_key_len + 1,
304 (uint8_t *) eap.password.c_str(), strlen(eap.password.c_str()));
305 if (ret) {
306 ESP_LOGV(TAG, "esp_wifi_sta_wpa2_ent_set_cert_key failed! %d", ret);
307 }
308 } else {
309 // in the absence of certs, assume this is username/password based
310 ret = wifi_station_set_enterprise_username((uint8_t *) eap.username.c_str(), eap.username.length());
311 if (ret) {
312 ESP_LOGV(TAG, "esp_wifi_sta_wpa2_ent_set_username failed! %d", ret);
313 }
314 ret = wifi_station_set_enterprise_password((uint8_t *) eap.password.c_str(), eap.password.length());
315 if (ret) {
316 ESP_LOGV(TAG, "esp_wifi_sta_wpa2_ent_set_password failed! %d", ret);
317 }
318 }
319 ret = wifi_station_set_wpa2_enterprise_auth(true);
320 if (ret) {
321 ESP_LOGV(TAG, "esp_wifi_sta_wpa2_ent_enable failed! %d", ret);
322 }
323 }
324#endif // USE_WIFI_WPA2_EAP
325
326 this->wifi_apply_hostname_();
327
328 // Reset flags, do this _before_ wifi_station_connect as the callback method
329 // may be called from wifi_station_connect
330 s_sta_connecting = true;
331 s_sta_connected = false;
332 s_sta_got_ip = false;
333 s_sta_connect_error = false;
334 s_sta_connect_not_found = false;
335
336 ETS_UART_INTR_DISABLE();
337 ret = wifi_station_connect();
338 ETS_UART_INTR_ENABLE();
339 if (!ret) {
340 ESP_LOGV(TAG, "wifi_station_connect failed!");
341 return false;
342 }
343
344#if USE_NETWORK_IPV6
345 bool connected = false;
346 while (!connected) {
347 uint8_t ipv6_addr_count = 0;
348 for (auto addr : addrList) {
349 ESP_LOGV(TAG, "Address %s", addr.toString().c_str());
350 if (addr.isV6()) {
351 ipv6_addr_count++;
352 }
353 }
354 delay(500); // NOLINT
355 connected = (ipv6_addr_count >= USE_NETWORK_MIN_IPV6_ADDR_COUNT);
356 }
357#endif /* USE_NETWORK_IPV6 */
358
359 if (ap.get_channel().has_value()) {
360 ret = wifi_set_channel(*ap.get_channel());
361 if (!ret) {
362 ESP_LOGV(TAG, "wifi_set_channel failed!");
363 return false;
364 }
365 }
366
367 return true;
368}
369
370class WiFiMockClass : public ESP8266WiFiGenericClass {
371 public:
372 static void _event_callback(void *event) { ESP8266WiFiGenericClass::_eventCallback(event); } // NOLINT
373};
374
375const LogString *get_auth_mode_str(uint8_t mode) {
376 switch (mode) {
377 case AUTH_OPEN:
378 return LOG_STR("OPEN");
379 case AUTH_WEP:
380 return LOG_STR("WEP");
381 case AUTH_WPA_PSK:
382 return LOG_STR("WPA PSK");
383 case AUTH_WPA2_PSK:
384 return LOG_STR("WPA2 PSK");
385 case AUTH_WPA_WPA2_PSK:
386 return LOG_STR("WPA/WPA2 PSK");
387 default:
388 return LOG_STR("UNKNOWN");
389 }
390}
391#ifdef ipv4_addr
392std::string format_ip_addr(struct ipv4_addr ip) {
393 char buf[20];
394 sprintf(buf, "%u.%u.%u.%u", uint8_t(ip.addr >> 0), uint8_t(ip.addr >> 8), uint8_t(ip.addr >> 16),
395 uint8_t(ip.addr >> 24));
396 return buf;
397}
398#else
399std::string format_ip_addr(struct ip_addr ip) {
400 char buf[20];
401 sprintf(buf, "%u.%u.%u.%u", uint8_t(ip.addr >> 0), uint8_t(ip.addr >> 8), uint8_t(ip.addr >> 16),
402 uint8_t(ip.addr >> 24));
403 return buf;
404}
405#endif
406const LogString *get_op_mode_str(uint8_t mode) {
407 switch (mode) {
408 case WIFI_OFF:
409 return LOG_STR("OFF");
410 case WIFI_STA:
411 return LOG_STR("STA");
412 case WIFI_AP:
413 return LOG_STR("AP");
414 case WIFI_AP_STA:
415 return LOG_STR("AP+STA");
416 default:
417 return LOG_STR("UNKNOWN");
418 }
419}
420
421const LogString *get_disconnect_reason_str(uint8_t reason) {
422 /* If this were one big switch statement, GCC would generate a lookup table for it. However, the values of the
423 * REASON_* constants aren't continuous, and GCC will fill in the gap with the default value -- wasting 4 bytes of RAM
424 * per entry. As there's ~175 default entries, this wastes 700 bytes of RAM.
425 */
426 if (reason <= REASON_CIPHER_SUITE_REJECTED) { // This must be the last constant with a value <200
427 switch (reason) {
428 case REASON_AUTH_EXPIRE:
429 return LOG_STR("Auth Expired");
430 case REASON_AUTH_LEAVE:
431 return LOG_STR("Auth Leave");
432 case REASON_ASSOC_EXPIRE:
433 return LOG_STR("Association Expired");
434 case REASON_ASSOC_TOOMANY:
435 return LOG_STR("Too Many Associations");
436 case REASON_NOT_AUTHED:
437 return LOG_STR("Not Authenticated");
438 case REASON_NOT_ASSOCED:
439 return LOG_STR("Not Associated");
440 case REASON_ASSOC_LEAVE:
441 return LOG_STR("Association Leave");
442 case REASON_ASSOC_NOT_AUTHED:
443 return LOG_STR("Association not Authenticated");
444 case REASON_DISASSOC_PWRCAP_BAD:
445 return LOG_STR("Disassociate Power Cap Bad");
446 case REASON_DISASSOC_SUPCHAN_BAD:
447 return LOG_STR("Disassociate Supported Channel Bad");
448 case REASON_IE_INVALID:
449 return LOG_STR("IE Invalid");
450 case REASON_MIC_FAILURE:
451 return LOG_STR("Mic Failure");
452 case REASON_4WAY_HANDSHAKE_TIMEOUT:
453 return LOG_STR("4-Way Handshake Timeout");
454 case REASON_GROUP_KEY_UPDATE_TIMEOUT:
455 return LOG_STR("Group Key Update Timeout");
456 case REASON_IE_IN_4WAY_DIFFERS:
457 return LOG_STR("IE In 4-Way Handshake Differs");
458 case REASON_GROUP_CIPHER_INVALID:
459 return LOG_STR("Group Cipher Invalid");
460 case REASON_PAIRWISE_CIPHER_INVALID:
461 return LOG_STR("Pairwise Cipher Invalid");
462 case REASON_AKMP_INVALID:
463 return LOG_STR("AKMP Invalid");
464 case REASON_UNSUPP_RSN_IE_VERSION:
465 return LOG_STR("Unsupported RSN IE version");
466 case REASON_INVALID_RSN_IE_CAP:
467 return LOG_STR("Invalid RSN IE Cap");
468 case REASON_802_1X_AUTH_FAILED:
469 return LOG_STR("802.1x Authentication Failed");
470 case REASON_CIPHER_SUITE_REJECTED:
471 return LOG_STR("Cipher Suite Rejected");
472 }
473 }
474
475 switch (reason) {
476 case REASON_BEACON_TIMEOUT:
477 return LOG_STR("Beacon Timeout");
478 case REASON_NO_AP_FOUND:
479 return LOG_STR("AP Not Found");
480 case REASON_AUTH_FAIL:
481 return LOG_STR("Authentication Failed");
482 case REASON_ASSOC_FAIL:
483 return LOG_STR("Association Failed");
484 case REASON_HANDSHAKE_TIMEOUT:
485 return LOG_STR("Handshake Failed");
486 case REASON_UNSPECIFIED:
487 default:
488 return LOG_STR("Unspecified");
489 }
490}
491
492void WiFiComponent::wifi_event_callback(System_Event_t *event) {
493 switch (event->event) {
494 case EVENT_STAMODE_CONNECTED: {
495 auto it = event->event_info.connected;
496 char buf[33];
497 memcpy(buf, it.ssid, it.ssid_len);
498 buf[it.ssid_len] = '\0';
499 ESP_LOGV(TAG, "Event: Connected ssid='%s' bssid=%s channel=%u", buf, format_mac_addr(it.bssid).c_str(),
500 it.channel);
501 s_sta_connected = true;
502 break;
503 }
504 case EVENT_STAMODE_DISCONNECTED: {
505 auto it = event->event_info.disconnected;
506 char buf[33];
507 memcpy(buf, it.ssid, it.ssid_len);
508 buf[it.ssid_len] = '\0';
509 if (it.reason == REASON_NO_AP_FOUND) {
510 ESP_LOGW(TAG, "Event: Disconnected ssid='%s' reason='Probe Request Unsuccessful'", buf);
511 s_sta_connect_not_found = true;
512 } else {
513 ESP_LOGW(TAG, "Event: Disconnected ssid='%s' bssid=" LOG_SECRET("%s") " reason='%s'", buf,
514 format_mac_addr(it.bssid).c_str(), LOG_STR_ARG(get_disconnect_reason_str(it.reason)));
515 s_sta_connect_error = true;
516 }
517 s_sta_connected = false;
518 s_sta_connecting = false;
519 break;
520 }
521 case EVENT_STAMODE_AUTHMODE_CHANGE: {
522 auto it = event->event_info.auth_change;
523 ESP_LOGV(TAG, "Event: Changed AuthMode old=%s new=%s", LOG_STR_ARG(get_auth_mode_str(it.old_mode)),
524 LOG_STR_ARG(get_auth_mode_str(it.new_mode)));
525 // Mitigate CVE-2020-12638
526 // https://lbsfilm.at/blog/wpa2-authenticationmode-downgrade-in-espressif-microprocessors
527 if (it.old_mode != AUTH_OPEN && it.new_mode == AUTH_OPEN) {
528 ESP_LOGW(TAG, "Potential Authmode downgrade detected, disconnecting...");
529 // we can't call retry_connect() from this context, so disconnect immediately
530 // and notify main thread with error_from_callback_
531 wifi_station_disconnect();
533 }
534 break;
535 }
536 case EVENT_STAMODE_GOT_IP: {
537 auto it = event->event_info.got_ip;
538 ESP_LOGV(TAG, "Event: Got IP static_ip=%s gateway=%s netmask=%s", format_ip_addr(it.ip).c_str(),
539 format_ip_addr(it.gw).c_str(), format_ip_addr(it.mask).c_str());
540 s_sta_got_ip = true;
541 break;
542 }
543 case EVENT_STAMODE_DHCP_TIMEOUT: {
544 ESP_LOGW(TAG, "Event: Getting IP address timeout");
545 break;
546 }
547 case EVENT_SOFTAPMODE_STACONNECTED: {
548 auto it = event->event_info.sta_connected;
549 ESP_LOGV(TAG, "Event: AP client connected MAC=%s aid=%u", format_mac_addr(it.mac).c_str(), it.aid);
550 break;
551 }
552 case EVENT_SOFTAPMODE_STADISCONNECTED: {
553 auto it = event->event_info.sta_disconnected;
554 ESP_LOGV(TAG, "Event: AP client disconnected MAC=%s aid=%u", format_mac_addr(it.mac).c_str(), it.aid);
555 break;
556 }
557 case EVENT_SOFTAPMODE_PROBEREQRECVED: {
558 auto it = event->event_info.ap_probereqrecved;
559 ESP_LOGVV(TAG, "Event: AP receive Probe Request MAC=%s RSSI=%d", format_mac_addr(it.mac).c_str(), it.rssi);
560 break;
561 }
562#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 4, 0)
563 case EVENT_OPMODE_CHANGED: {
564 auto it = event->event_info.opmode_changed;
565 ESP_LOGV(TAG, "Event: Changed Mode old=%s new=%s", LOG_STR_ARG(get_op_mode_str(it.old_opmode)),
566 LOG_STR_ARG(get_op_mode_str(it.new_opmode)));
567 break;
568 }
569 case EVENT_SOFTAPMODE_DISTRIBUTE_STA_IP: {
570 auto it = event->event_info.distribute_sta_ip;
571 ESP_LOGV(TAG, "Event: AP Distribute Station IP MAC=%s IP=%s aid=%u", format_mac_addr(it.mac).c_str(),
572 format_ip_addr(it.ip).c_str(), it.aid);
573 break;
574 }
575#endif
576 default:
577 break;
578 }
579
580 if (event->event == EVENT_STAMODE_DISCONNECTED) {
582 }
583
584 WiFiMockClass::_event_callback(event);
585}
586
587bool WiFiComponent::wifi_apply_output_power_(float output_power) {
588 uint8_t val = static_cast<uint8_t>(output_power * 4);
589 system_phy_set_max_tpw(val);
590 return true;
591}
593 if (!this->wifi_mode_(true, {}))
594 return false;
595
596 bool ret1, ret2;
597 ETS_UART_INTR_DISABLE();
598 ret1 = wifi_station_set_auto_connect(0);
599 ret2 = wifi_station_set_reconnect_policy(false);
600 ETS_UART_INTR_ENABLE();
601
602 if (!ret1 || !ret2) {
603 ESP_LOGV(TAG, "Disabling Auto-Connect failed!");
604 }
605
606 delay(10);
607 return true;
608}
609
611 wifi_set_event_handler_cb(&WiFiComponent::wifi_event_callback);
612
613 // Make sure WiFi is in clean state before anything starts
614 this->wifi_mode_(false, false);
615}
616
618 station_status_t status = wifi_station_get_connect_status();
619 switch (status) {
620 case STATION_GOT_IP:
622 case STATION_NO_AP_FOUND:
624 ;
625 case STATION_CONNECT_FAIL:
626 case STATION_WRONG_PASSWORD:
628 case STATION_CONNECTING:
630 case STATION_IDLE:
631 default:
633 }
634}
635bool WiFiComponent::wifi_scan_start_(bool passive) {
636 static bool first_scan = false;
637
638 // enable STA
639 if (!this->wifi_mode_(true, {}))
640 return false;
641
642 struct scan_config config {};
643 memset(&config, 0, sizeof(config));
644 config.ssid = nullptr;
645 config.bssid = nullptr;
646 config.channel = 0;
647 config.show_hidden = 1;
648#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 4, 0)
649 config.scan_type = passive ? WIFI_SCAN_TYPE_PASSIVE : WIFI_SCAN_TYPE_ACTIVE;
650 if (first_scan) {
651 if (passive) {
652 config.scan_time.passive = 200;
653 } else {
654 config.scan_time.active.min = 100;
655 config.scan_time.active.max = 200;
656 }
657 } else {
658 if (passive) {
659 config.scan_time.passive = 500;
660 } else {
661 config.scan_time.active.min = 400;
662 config.scan_time.active.max = 500;
663 }
664 }
665#endif
666 first_scan = false;
667 bool ret = wifi_station_scan(&config, &WiFiComponent::s_wifi_scan_done_callback);
668 if (!ret) {
669 ESP_LOGV(TAG, "wifi_station_scan failed!");
670 return false;
671 }
672
673 return ret;
674}
676 bool ret = true;
677 // Only call disconnect if interface is up
678 if (wifi_get_opmode() & WIFI_STA)
679 ret = wifi_station_disconnect();
680 station_config conf{};
681 memset(&conf, 0, sizeof(conf));
682 ETS_UART_INTR_DISABLE();
683 wifi_station_set_config_current(&conf);
684 ETS_UART_INTR_ENABLE();
685 return ret;
686}
690
691void WiFiComponent::wifi_scan_done_callback_(void *arg, STATUS status) {
692 this->scan_result_.clear();
693
694 if (status != OK) {
695 ESP_LOGV(TAG, "Scan failed! %d", status);
696 this->retry_connect();
697 return;
698 }
699 auto *head = reinterpret_cast<bss_info *>(arg);
700 for (bss_info *it = head; it != nullptr; it = STAILQ_NEXT(it, next)) {
701 WiFiScanResult res({it->bssid[0], it->bssid[1], it->bssid[2], it->bssid[3], it->bssid[4], it->bssid[5]},
702 std::string(reinterpret_cast<char *>(it->ssid), it->ssid_len), it->channel, it->rssi,
703 it->authmode != AUTH_OPEN, it->is_hidden != 0);
704 this->scan_result_.push_back(res);
705 }
706 this->scan_done_ = true;
707}
708
709#ifdef USE_WIFI_AP
711 // enable AP
712 if (!this->wifi_mode_({}, true))
713 return false;
714
715 struct ip_info info {};
716 if (manual_ip.has_value()) {
717 info.ip = manual_ip->static_ip;
718 info.gw = manual_ip->gateway;
719 info.netmask = manual_ip->subnet;
720 } else {
721 info.ip = network::IPAddress(192, 168, 4, 1);
722 info.gw = network::IPAddress(192, 168, 4, 1);
723 info.netmask = network::IPAddress(255, 255, 255, 0);
724 }
725
726 if (wifi_softap_dhcps_status() == DHCP_STARTED) {
727 if (!wifi_softap_dhcps_stop()) {
728 ESP_LOGW(TAG, "Stopping DHCP server failed!");
729 }
730 }
731
732 if (!wifi_set_ip_info(SOFTAP_IF, &info)) {
733 ESP_LOGE(TAG, "Setting SoftAP info failed!");
734 return false;
735 }
736
737#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(3, 0, 0) && USE_ARDUINO_VERSION_CODE < VERSION_CODE(3, 1, 0)
738 dhcpSoftAP.begin(&info);
739#endif
740
741 struct dhcps_lease lease {};
742 lease.enable = true;
743 network::IPAddress start_address = network::IPAddress(&info.ip);
744 start_address += 99;
745 lease.start_ip = start_address;
746 ESP_LOGV(TAG, "DHCP server IP lease start: %s", start_address.str().c_str());
747 start_address += 10;
748 lease.end_ip = start_address;
749 ESP_LOGV(TAG, "DHCP server IP lease end: %s", start_address.str().c_str());
750 if (!wifi_softap_set_dhcps_lease(&lease)) {
751 ESP_LOGE(TAG, "Setting SoftAP DHCP lease failed!");
752 return false;
753 }
754
755 // lease time 1440 minutes (=24 hours)
756 if (!wifi_softap_set_dhcps_lease_time(1440)) {
757 ESP_LOGE(TAG, "Setting SoftAP DHCP lease time failed!");
758 return false;
759 }
760
761#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(3, 1, 0)
762 ESP8266WiFiClass::softAPDhcpServer().setRouter(true); // send ROUTER option with netif's gateway IP
763#else
764 uint8_t mode = 1;
765 // bit0, 1 enables router information from ESP8266 SoftAP DHCP server.
766 if (!wifi_softap_set_dhcps_offer_option(OFFER_ROUTER, &mode)) {
767 ESP_LOGE(TAG, "wifi_softap_set_dhcps_offer_option failed!");
768 return false;
769 }
770#endif
771
772 if (!wifi_softap_dhcps_start()) {
773 ESP_LOGE(TAG, "Starting SoftAP DHCPS failed!");
774 return false;
775 }
776
777 return true;
778}
779
780bool WiFiComponent::wifi_start_ap_(const WiFiAP &ap) {
781 // enable AP
782 if (!this->wifi_mode_({}, true))
783 return false;
784
785 struct softap_config conf {};
786 if (ap.get_ssid().size() > sizeof(conf.ssid)) {
787 ESP_LOGE(TAG, "AP SSID is too long");
788 return false;
789 }
790 memcpy(reinterpret_cast<char *>(conf.ssid), ap.get_ssid().c_str(), ap.get_ssid().size());
791 conf.ssid_len = static_cast<uint8>(ap.get_ssid().size());
792 conf.channel = ap.get_channel().value_or(1);
793 conf.ssid_hidden = ap.get_hidden();
794 conf.max_connection = 5;
795 conf.beacon_interval = 100;
796
797 if (ap.get_password().empty()) {
798 conf.authmode = AUTH_OPEN;
799 *conf.password = 0;
800 } else {
801 conf.authmode = AUTH_WPA2_PSK;
802 if (ap.get_password().size() > sizeof(conf.password)) {
803 ESP_LOGE(TAG, "AP password is too long");
804 return false;
805 }
806 memcpy(reinterpret_cast<char *>(conf.password), ap.get_password().c_str(), ap.get_password().size());
807 }
808
809 ETS_UART_INTR_DISABLE();
810 bool ret = wifi_softap_set_config_current(&conf);
811 ETS_UART_INTR_ENABLE();
812
813 if (!ret) {
814 ESP_LOGV(TAG, "wifi_softap_set_config_current failed!");
815 return false;
816 }
817
818 if (!this->wifi_ap_ip_config_(ap.get_manual_ip())) {
819 ESP_LOGV(TAG, "wifi_ap_ip_config_ failed!");
820 return false;
821 }
822
823 return true;
824}
825
826network::IPAddress WiFiComponent::wifi_soft_ap_ip() {
827 struct ip_info ip {};
828 wifi_get_ip_info(SOFTAP_IF, &ip);
829 return network::IPAddress(&ip.ip);
830}
831#endif // USE_WIFI_AP
832
834 bssid_t bssid{};
835 uint8_t *raw_bssid = WiFi.BSSID();
836 if (raw_bssid != nullptr) {
837 for (size_t i = 0; i < bssid.size(); i++)
838 bssid[i] = raw_bssid[i];
839 }
840 return bssid;
841}
842std::string WiFiComponent::wifi_ssid() { return WiFi.SSID().c_str(); }
843int8_t WiFiComponent::wifi_rssi() { return WiFi.RSSI(); }
844int32_t WiFiComponent::get_wifi_channel() { return WiFi.channel(); }
845network::IPAddress WiFiComponent::wifi_subnet_mask_() { return {(const ip_addr_t *) WiFi.subnetMask()}; }
846network::IPAddress WiFiComponent::wifi_gateway_ip_() { return {(const ip_addr_t *) WiFi.gatewayIP()}; }
847network::IPAddress WiFiComponent::wifi_dns_ip_(int num) { return {(const ip_addr_t *) WiFi.dnsIP(num)}; }
849
850} // namespace wifi
851} // namespace esphome
852
853#endif
854#endif
BedjetMode mode
BedJet operating mode.
uint8_t status
Definition bl0942.h:8
const std::string & get_name() const
Get the name of this Application set by pre_setup().
bool has_value() const
Definition optional.h:87
void wifi_scan_done_callback_(void *arg, STATUS status)
bool wifi_sta_ip_config_(optional< ManualIP > manual_ip)
static void wifi_event_callback(System_Event_t *event)
std::vector< WiFiScanResult > scan_result_
bool wifi_ap_ip_config_(optional< ManualIP > manual_ip)
static void s_wifi_scan_done_callback(void *arg, STATUS status)
static std::string format_mac_addr(const uint8_t mac[6])
bool wifi_apply_output_power_(float output_power)
bool wifi_mode_(optional< bool > sta, optional< bool > ap)
in_addr ip_addr_t
Definition ip_address.h:22
in_addr ip4_addr_t
Definition ip_address.h:23
mopeka_std_values val[4]
std::array< IPAddress, 5 > IPAddresses
Definition ip_address.h:143
const char *const TAG
Definition spi.cpp:8
std::array< uint8_t, 6 > bssid_t
const char * get_auth_mode_str(uint8_t mode)
const char * get_disconnect_reason_str(uint8_t reason)
struct netif * eagle_lwip_getif(int netif_index)
std::string format_ip_addr(struct ipv4_addr ip)
void netif_set_addr(struct netif *netif, const ip4_addr_t *ip, const ip4_addr_t *netmask, const ip4_addr_t *gw)
WiFiComponent * global_wifi_component
const char * get_op_mode_str(uint8_t mode)
Providing packet encoding functions for exchanging data with a remote host.
Definition a01nyub.cpp:7
void IRAM_ATTR HOT delay(uint32_t ms)
Definition core.cpp:28
Application App
Global storage of Application pointer - only one Application can exist.