mirror of https://github.com/arendst/Tasmota.git
538 lines
17 KiB
C++
538 lines
17 KiB
C++
/*
|
|
xdrv_58_range_extender.ino - WiFi Range Extender for Tasmota
|
|
|
|
Copyright (C) 2021 sillyfrog and Theo Arends
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifdef USE_WIFI_RANGE_EXTENDER
|
|
/*********************************************************************************************
|
|
To use this, add the following to your user_config_override.h
|
|
#define USE_WIFI_RANGE_EXTENDER
|
|
|
|
Additionally, for the ESP8266, PIO_FRAMEWORK_ARDUINO_LWIP2_HIGHER_BANDWIDTH must be
|
|
set in your build options.
|
|
For example, in your platfromio_tasmota_cenv.ini, you will need an entry such as:
|
|
[env:tasmota-rangeextender]
|
|
build_flags = ${common.build_flags}
|
|
-D PIO_FRAMEWORK_ARDUINO_LWIP2_HIGHER_BANDWIDTH
|
|
|
|
For the ESP32, the arduino-esp32 library must be at least version 2, with
|
|
CONFIG_LWIP_IP_FORWARD option set, and optionally CONFIG_LWIP_IPV4_NAPT.
|
|
|
|
If you want to support NAPT (removing the need for routes on a core router):
|
|
#define USE_WIFI_RANGE_EXTENDER_NAPT
|
|
|
|
List AP clients (MAC, IP and RSSI) with command RgxClients on ESP32
|
|
|
|
|
|
An example full static configuration:
|
|
#define USE_WIFI_RANGE_EXTENDER
|
|
#define USE_WIFI_RANGE_EXTENDER_NAPT
|
|
#define WIFI_RGX_STATE 1
|
|
#define WIFI_RGX_NAPT 1
|
|
#define WIFI_RGX_SSID "rangeextender"
|
|
#define WIFI_RGX_PASSWORD "securepassword"
|
|
#define WIFI_RGX_IP_ADDRESS "10.99.1.1"
|
|
#define WIFI_RGX_SUBNETMASK "255.255.255.0"
|
|
|
|
|
|
A full command to enable the Range Extender, including with NAPT could be:
|
|
Backlog RgxSSID rangeextender ; RgxPassword securepassword ; RgxAddress 192.168.123.1 ; RgxSubnet 255.255.255.0; RgxState 1 ; RgxNAPT 1
|
|
|
|
\*********************************************************************************************/
|
|
|
|
#define XDRV_58 58
|
|
|
|
// Memory usage at 512: Heap from 30136 to 17632: 12504
|
|
// Memory usage at 128: Heap from 30136 to 26848: 3288
|
|
#define NAPT 128 // IP_NAPT_MAX: 512
|
|
#define NAPT_PORT 10 // IP_PORTMAP_MAX: 32
|
|
|
|
#warning **** USE_WIFI_RANGE_EXTENDER is enabled ****
|
|
|
|
#ifdef ESP8266
|
|
#if LWIP_FEATURES
|
|
// All good
|
|
#else
|
|
#error LWIP_FEATURES required, add "-D PIO_FRAMEWORK_ARDUINO_LWIP2_HIGHER_BANDWIDTH" to build_flags
|
|
#endif // LWIP_FEATURES
|
|
#endif // ESP8266
|
|
|
|
#ifdef ESP32
|
|
#ifdef CONFIG_LWIP_IP_FORWARD
|
|
// All good
|
|
#else
|
|
#error CONFIG_LWIP_IP_FORWARD not set, arduino-esp32 v2 or later required with CONFIG_LWIP_IP_FORWARD support
|
|
#endif // CONFIG_LWIP_IP_FORWARD
|
|
#ifdef USE_WIFI_RANGE_EXTENDER_NAPT
|
|
#ifdef CONFIG_LWIP_IPV4_NAPT
|
|
// All good
|
|
#else
|
|
#error CONFIG_LWIP_IPV4_NAPT not set, arduino-esp32 v2 or later required with CONFIG_LWIP_IPV4_NAPT support
|
|
#endif // CONFIG_LWIP_IPV4_NAPT
|
|
#endif // CONFIG_LWIP_IP_FORWARD
|
|
#endif // ESP32
|
|
|
|
const char kDrvRgxCommands[] PROGMEM = "Rgx|" // Prefix
|
|
"State"
|
|
"|" D_CMND_SSID
|
|
"|" D_CMND_PASSWORD
|
|
#ifdef USE_WIFI_RANGE_EXTENDER_NAPT
|
|
"|"
|
|
"NAPT"
|
|
"|"
|
|
"Port"
|
|
#endif // USE_WIFI_RANGE_EXTENDER_NAPT
|
|
"|"
|
|
"Clients"
|
|
"|"
|
|
"Address"
|
|
"|"
|
|
"Subnet";
|
|
|
|
void (*const DrvRgxCommand[])(void) PROGMEM = {
|
|
&CmndRgxState,
|
|
&CmndRgxSSID,
|
|
&CmndRgxPassword,
|
|
#ifdef USE_WIFI_RANGE_EXTENDER_NAPT
|
|
&CmndRgxNAPT,
|
|
&CmndRgxPort,
|
|
#endif // USE_WIFI_RANGE_EXTENDER_NAPT
|
|
&CmndRgxClients,
|
|
&CmndRgxAddresses,
|
|
&CmndRgxAddresses,
|
|
};
|
|
|
|
#ifdef USE_WIFI_RANGE_EXTENDER_NAPT
|
|
#ifdef ESP8266
|
|
#include <lwip/napt.h>
|
|
#endif // ESP8266
|
|
#endif // USE_WIFI_RANGE_EXTENDER_NAPT
|
|
|
|
#include <lwip/dns.h>
|
|
#ifdef ESP8266
|
|
#include <dhcpserver.h>
|
|
#endif // ESP8266
|
|
#ifdef ESP32
|
|
#include "lwip/lwip_napt.h"
|
|
#include <dhcpserver/dhcpserver.h>
|
|
#include "esp_wifi.h"
|
|
#include "esp_wifi_ap_get_sta_list.h"
|
|
#endif // ESP32
|
|
|
|
#define RGX_NOT_CONFIGURED 0
|
|
#define RGX_FORCE_CONFIGURE 1
|
|
#define RGX_CONFIGURED 2
|
|
#define RGX_CONFIG_INCOMPLETE 3
|
|
#define RGX_SETUP_NAPT 4
|
|
|
|
typedef struct
|
|
{
|
|
uint8_t status = RGX_NOT_CONFIGURED;
|
|
#ifdef USE_WIFI_RANGE_EXTENDER_NAPT
|
|
bool napt_enabled = false;
|
|
#endif // USE_WIFI_RANGE_EXTENDER_NAPT
|
|
} TRgxSettings;
|
|
|
|
TRgxSettings RgxSettings;
|
|
|
|
// externalize to be able to protect Rgx AP from teardown
|
|
bool RgxApUp()
|
|
{
|
|
return RgxSettings.status == RGX_CONFIGURED || RgxSettings.status == RGX_SETUP_NAPT;
|
|
}
|
|
|
|
// Check the current configuration is complete, updating RgxSettings.status
|
|
void RgxCheckConfig(void)
|
|
{
|
|
if (
|
|
strlen(SettingsText(SET_RGX_SSID)) > 0 &&
|
|
strlen(SettingsText(SET_RGX_PASSWORD)) >= 8 &&
|
|
Settings->ipv4_rgx_address &&
|
|
Settings->ipv4_rgx_subnetmask)
|
|
{
|
|
if (RgxSettings.status != RGX_FORCE_CONFIGURE)
|
|
{
|
|
RgxSettings.status = RGX_NOT_CONFIGURED;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
RgxSettings.status = RGX_CONFIG_INCOMPLETE;
|
|
}
|
|
}
|
|
|
|
void CmndRgxClients(void)
|
|
{
|
|
Response_P(PSTR("{\"RgxClients\":{"));
|
|
const char *sep = "";
|
|
|
|
#if defined(ESP32)
|
|
wifi_sta_list_t wifi_sta_list = {0};
|
|
wifi_sta_mac_ip_list_t wifi_sta_mac_ip_list = {0};
|
|
|
|
esp_wifi_ap_get_sta_list(&wifi_sta_list);
|
|
esp_wifi_ap_get_sta_list_with_ip(&wifi_sta_list, &wifi_sta_mac_ip_list);
|
|
|
|
for (int i=0; i<wifi_sta_mac_ip_list.num; i++)
|
|
{
|
|
const uint8_t *m = wifi_sta_mac_ip_list.sta[i].mac;
|
|
ResponseAppend_P(PSTR("%s\"%02X%02X%02X%02X%02X%02X\":{\"" D_CMND_IPADDRESS "\":\"%_I\",\"" D_JSON_RSSI "\":%d}"),
|
|
sep, m[0], m[1], m[2], m[3], m[4], m[5], wifi_sta_mac_ip_list.sta[i].ip, wifi_sta_list.sta[i].rssi);
|
|
sep = ",";
|
|
}
|
|
#elif defined(ESP8266)
|
|
struct station_info *station = wifi_softap_get_station_info();
|
|
while (station)
|
|
{
|
|
const uint8_t *m = station->bssid;
|
|
ResponseAppend_P(PSTR("%s\"%02X%02X%02X%02X%02X%02X\":{\"" D_CMND_IPADDRESS "\":\"%_I\"}"),
|
|
sep, m[0], m[1], m[2], m[3], m[4], m[5], station->ip.addr);
|
|
sep = ",";
|
|
station = STAILQ_NEXT(station, next);
|
|
}
|
|
wifi_softap_free_station_info();
|
|
#endif
|
|
|
|
ResponseAppend_P(PSTR("}}"));
|
|
}
|
|
|
|
void CmndRgxState(void)
|
|
{
|
|
if ((XdrvMailbox.payload >= 0) && (XdrvMailbox.payload <= 1))
|
|
{
|
|
if (Settings->sbflag1.range_extender != XdrvMailbox.payload)
|
|
{
|
|
Settings->sbflag1.range_extender = XdrvMailbox.payload;
|
|
if (0 == XdrvMailbox.payload)
|
|
{ // Turn off
|
|
TasmotaGlobal.restart_flag = 2;
|
|
}
|
|
}
|
|
}
|
|
ResponseCmndStateText(Settings->sbflag1.range_extender);
|
|
}
|
|
|
|
void CmndRgxAddresses(void)
|
|
{
|
|
char network_address[22];
|
|
ext_snprintf_P(network_address, sizeof(network_address), PSTR(" (%_I)"), (uint32_t)NetworkAddress());
|
|
uint32_t ipv4_address;
|
|
if (ParseIPv4(&ipv4_address, XdrvMailbox.data))
|
|
{
|
|
if (XdrvMailbox.command[3] == 'S') // Subnet
|
|
{
|
|
Settings->ipv4_rgx_subnetmask = ipv4_address;
|
|
}
|
|
else
|
|
{
|
|
Settings->ipv4_rgx_address = ipv4_address;
|
|
}
|
|
RgxSettings.status = RGX_FORCE_CONFIGURE;
|
|
}
|
|
ResponseRgxConfig();
|
|
}
|
|
|
|
void CmndRgxSSID(void)
|
|
{
|
|
if (XdrvMailbox.data_len > 0)
|
|
{
|
|
SettingsUpdateText(SET_RGX_SSID, (SC_CLEAR == Shortcut()) ? "" : XdrvMailbox.data);
|
|
RgxSettings.status = RGX_FORCE_CONFIGURE;
|
|
}
|
|
ResponseRgxConfig();
|
|
}
|
|
|
|
void CmndRgxPassword(void)
|
|
{
|
|
if (XdrvMailbox.data_len > 0)
|
|
{
|
|
SettingsUpdateText(SET_RGX_PASSWORD, (SC_CLEAR == Shortcut()) ? "" : XdrvMailbox.data);
|
|
RgxSettings.status = RGX_FORCE_CONFIGURE;
|
|
}
|
|
ResponseRgxConfig();
|
|
}
|
|
|
|
#ifdef USE_WIFI_RANGE_EXTENDER_NAPT
|
|
void CmndRgxNAPT(void)
|
|
{
|
|
if ((XdrvMailbox.payload >= 0) && (XdrvMailbox.payload <= 1))
|
|
{
|
|
if (Settings->sbflag1.range_extender_napt != XdrvMailbox.payload)
|
|
{
|
|
Settings->sbflag1.range_extender_napt = XdrvMailbox.payload;
|
|
if (0 == XdrvMailbox.payload)
|
|
{ // Turn off
|
|
// ESP32 does not disable reliably, reboot to ensure a complete disable of NAPT
|
|
// rebooting also completely frees up the used RAM
|
|
TasmotaGlobal.restart_flag = 2;
|
|
}
|
|
else
|
|
{
|
|
RgxSettings.status = RGX_FORCE_CONFIGURE;
|
|
}
|
|
}
|
|
}
|
|
ResponseCmndStateText(Settings->sbflag1.range_extender_napt);
|
|
}
|
|
|
|
// CmndRgxPort helper: Do port map and set response if successful
|
|
void CmndRgxPortMap(uint8_t proto, uint16_t gw_port, uint32_t dst_ip, uint16_t dst_port)
|
|
{
|
|
uint32_t gw_ip = (uint32_t)WiFi.localIP();
|
|
if (ip_portmap_add(proto, gw_ip, gw_port, dst_ip, dst_port))
|
|
{
|
|
Response_P(PSTR("OK %s %_I:%u -> %_I:%u"),
|
|
(proto == IP_PROTO_TCP) ? "TCP" : "UDP", gw_ip, gw_port, dst_ip, dst_port);
|
|
}
|
|
}
|
|
|
|
// CmndRgxPort helper: If mac from esp list and mac from command parameters are the same try port map and return true
|
|
bool CmndRgxPortMapCheck(const uint8_t *mac, const char *parm_mac, uint8_t proto, uint16_t gw_port, uint32_t dst_ip, uint16_t dst_port)
|
|
{
|
|
char list_mac[13];
|
|
snprintf(list_mac, sizeof(list_mac), PSTR("%02X%02X%02X%02X%02X%02X"), mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
|
|
if (strcasecmp(list_mac, parm_mac) == 0)
|
|
{
|
|
CmndRgxPortMap(proto, gw_port, dst_ip, dst_port);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void CmndRgxPort(void)
|
|
{
|
|
char *tok, *state, *parm_addr;
|
|
uint16_t gw, dst;
|
|
uint8_t proto = 0;
|
|
|
|
Response_P(PSTR("ERROR"));
|
|
|
|
// Parameter parsing
|
|
if (ArgC()!=4) return;
|
|
if ((tok = strtok_r(XdrvMailbox.data, ", ", &state)) == 0) return;
|
|
if (strcasecmp("TCP", tok) == 0) proto = IP_PROTO_TCP;
|
|
if (strcasecmp("UDP", tok) == 0) proto = IP_PROTO_UDP;
|
|
if (!proto) return;
|
|
if ((tok = strtok_r(0, ", ", &state)) == 0) return;
|
|
if ((gw = strtoul(tok, nullptr, 0)) == 0) return;
|
|
if ((parm_addr = strtok_r(0, ", ", &state)) == 0) return;
|
|
if ((tok = strtok_r(0, ", ", &state)) == 0) return;
|
|
if ((dst = strtoul(tok, nullptr, 0)) == 0) return;
|
|
|
|
// If forward address is an ip, then just do it...
|
|
// Useful for static IPs not used by the range extender dhcp server
|
|
// On ESP8266 the default dhcp ip range to avoid is .100-.200
|
|
// On ESP32 the default dhcp ip range to avoid is .2-.11
|
|
IPAddress ip;
|
|
if (ip.fromString(parm_addr))
|
|
{
|
|
CmndRgxPortMap(proto, gw, (uint32_t)ip, dst);
|
|
return;
|
|
}
|
|
|
|
// Forward address is a mac, find the associated ip...
|
|
#if defined(ESP32)
|
|
wifi_sta_list_t wifi_sta_list = {0};
|
|
wifi_sta_mac_ip_list_t wifi_sta_mac_ip_list = {0};
|
|
|
|
esp_wifi_ap_get_sta_list(&wifi_sta_list);
|
|
esp_wifi_ap_get_sta_list_with_ip(&wifi_sta_list, &wifi_sta_mac_ip_list);
|
|
|
|
for (int i=0; i<wifi_sta_mac_ip_list.num; i++)
|
|
{
|
|
if (CmndRgxPortMapCheck(wifi_sta_mac_ip_list.sta[i].mac, parm_addr, proto, gw, wifi_sta_mac_ip_list.sta[i].ip.addr, dst))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
#elif defined(ESP8266)
|
|
struct station_info *station = wifi_softap_get_station_info();
|
|
while (station)
|
|
{
|
|
if (CmndRgxPortMapCheck(station->bssid, parm_addr, proto, gw, station->ip.addr, dst))
|
|
{
|
|
break;
|
|
}
|
|
station = STAILQ_NEXT(station, next);
|
|
}
|
|
wifi_softap_free_station_info();
|
|
#endif // ESP8266
|
|
}
|
|
#endif // USE_WIFI_RANGE_EXTENDER_NAPT
|
|
|
|
void ResponseRgxConfig(void)
|
|
{
|
|
RgxCheckConfig();
|
|
Response_P(PSTR("{\"Rgx\":{\"Valid\":\"%s\",\"" D_CMND_SSID "\":\"%s\",\"" D_CMND_PASSWORD "\":\"%s\",\"" D_CMND_IPADDRESS "\":\"%_I\",\"" D_JSON_SUBNETMASK "\":\"%_I\"}}"),
|
|
(RgxSettings.status == RGX_CONFIG_INCOMPLETE) ? "false" : "true",
|
|
EscapeJSONString(SettingsText(SET_RGX_SSID)).c_str(),
|
|
EscapeJSONString(SettingsText(SET_RGX_PASSWORD)).c_str(),
|
|
Settings->ipv4_rgx_address,
|
|
Settings->ipv4_rgx_subnetmask);
|
|
}
|
|
|
|
void rngxSetup()
|
|
{
|
|
// Check we have a complete config first
|
|
RgxCheckConfig();
|
|
if (RgxSettings.status == RGX_CONFIG_INCOMPLETE)
|
|
{
|
|
AddLog(LOG_LEVEL_DEBUG, PSTR("RGX: Range Extender config incomplete"));
|
|
return;
|
|
}
|
|
#ifdef ESP8266
|
|
dhcps_set_dns(0, WiFi.dnsIP(0));
|
|
dhcps_set_dns(1, WiFi.dnsIP(1));
|
|
#endif // ESP8266
|
|
#ifdef ESP32
|
|
esp_err_t err;
|
|
esp_netif_t* esp_netif_STA = get_esp_interface_netif(ESP_IF_WIFI_STA);
|
|
esp_netif_t* esp_netif_AP = get_esp_interface_netif(ESP_IF_WIFI_AP);
|
|
esp_netif_dns_info_t ip_dns;
|
|
|
|
err = esp_netif_dhcps_stop(esp_netif_AP);
|
|
err = esp_netif_get_dns_info(esp_netif_STA, ESP_NETIF_DNS_MAIN, &ip_dns);
|
|
err = esp_netif_set_dns_info(esp_netif_AP, ESP_NETIF_DNS_MAIN, &ip_dns);
|
|
dhcps_offer_t opt_val = OFFER_DNS; // supply a dns server via dhcps
|
|
err = esp_netif_dhcps_option(esp_netif_AP, ESP_NETIF_OP_SET, ESP_NETIF_DOMAIN_NAME_SERVER, &opt_val, 1);
|
|
err = esp_netif_dhcps_start(esp_netif_AP);
|
|
#endif // ESP32
|
|
// WiFi.softAPConfig(EXTENDER_LOCAL_IP, EXTENDER_GATEWAY_IP, EXTENDER_SUBNET);
|
|
WiFi.softAPConfig(Settings->ipv4_rgx_address, Settings->ipv4_rgx_address, Settings->ipv4_rgx_subnetmask);
|
|
WiFi.softAP(SettingsText(SET_RGX_SSID), SettingsText(SET_RGX_PASSWORD));
|
|
AddLog(LOG_LEVEL_INFO, PSTR("RGX: WiFi Extender AP Enabled with SSID: %s"), WiFi.softAPSSID().c_str());
|
|
RgxSettings.status = RGX_SETUP_NAPT;
|
|
}
|
|
|
|
void rngxSetupNAPT(void)
|
|
{
|
|
// A short delay is required for enabling NAPT to work on the ESP32, hence a dedicated
|
|
// function called a second later
|
|
#ifdef USE_WIFI_RANGE_EXTENDER_NAPT
|
|
if (Settings->sbflag1.range_extender_napt && !RgxSettings.napt_enabled)
|
|
{
|
|
#ifdef ESP8266
|
|
// ip_napt_init can only be called once, however device will reboot when disabled
|
|
// so no need to limit calls to init separately.
|
|
err_t ret = ip_napt_init(NAPT, NAPT_PORT);
|
|
if (ret == ERR_OK)
|
|
{
|
|
AddLog(LOG_LEVEL_INFO, PSTR("RGX: NAPT initialization complete"));
|
|
err_t ret = ip_napt_enable_no(SOFTAP_IF, 1);
|
|
if (ret == ERR_OK)
|
|
{
|
|
AddLog(LOG_LEVEL_INFO, PSTR("RGX: NAPT Enabled"));
|
|
RgxSettings.napt_enabled = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AddLog(LOG_LEVEL_ERROR, PSTR("RGX: NAPT initialization failed! (%d)"), ret);
|
|
}
|
|
|
|
#endif // ESP8266
|
|
#ifdef ESP32
|
|
ip_napt_enable(WiFi.softAPIP(), 1);
|
|
AddLog(LOG_LEVEL_INFO, PSTR("RGX: NAPT Enabled"));
|
|
RgxSettings.napt_enabled = true;
|
|
#endif // ESP32
|
|
}
|
|
// This code path is no longer used as device will reboot to disable NAPT, maybe
|
|
// restored when working correctly on ESP32
|
|
/*
|
|
else if (!Settings->sbflag1.range_extender_napt && RgxSettings.napt_enabled)
|
|
{
|
|
#ifdef ESP8266
|
|
err_t ret = ip_napt_enable_no(SOFTAP_IF, 0);
|
|
if (ret == ERR_OK)
|
|
{
|
|
AddLog(LOG_LEVEL_INFO, "RGX: NAPT Disabled");
|
|
RgxSettings.napt_enabled = false;
|
|
}
|
|
#endif // ESP8266
|
|
#ifdef ESP32
|
|
ip_napt_enable(WiFi.softAPIP(), 0);
|
|
AddLog(LOG_LEVEL_INFO, "RGX: NAPT Disabled, reboot maybe required");
|
|
#endif // ESP32
|
|
}
|
|
*/
|
|
#endif // USE_WIFI_RANGE_EXTENDER_NAPT
|
|
RgxSettings.status = RGX_CONFIGURED;
|
|
}
|
|
|
|
/*********************************************************************************************\
|
|
* Interface
|
|
\*********************************************************************************************/
|
|
|
|
bool Xdrv58(uint32_t function)
|
|
{
|
|
bool result = false;
|
|
|
|
if (FUNC_COMMAND == function)
|
|
{
|
|
result = DecodeCommand(kDrvRgxCommands, DrvRgxCommand);
|
|
}
|
|
else if (Settings->sbflag1.range_extender && !TasmotaGlobal.restart_flag)
|
|
{
|
|
switch (function)
|
|
{
|
|
case FUNC_PRE_INIT:
|
|
break;
|
|
case FUNC_EVERY_SECOND:
|
|
// AddLog(LOG_LEVEL_INFO, PSTR("RGX: XXX DEBUG: Wifi.status: %d, WiFi.getMode(): %d, RgxSettings.status: %d, link_count: %d"), Wifi.status, WiFi.getMode(), RgxSettings.status, Wifi.link_count);
|
|
if (RgxSettings.status == RGX_NOT_CONFIGURED && Wifi.status == WL_CONNECTED)
|
|
{
|
|
// Setup only if WiFi in STA only mode
|
|
if (WiFi.getMode() == WIFI_STA)
|
|
{
|
|
// Connecting for the first time, setup WiFi
|
|
rngxSetup();
|
|
}
|
|
else
|
|
{
|
|
RgxSettings.status = RGX_CONFIGURED;
|
|
}
|
|
}
|
|
else if (RgxSettings.status == RGX_FORCE_CONFIGURE && Wifi.status == WL_CONNECTED)
|
|
{
|
|
rngxSetup();
|
|
}
|
|
else if (RgxSettings.status == RGX_SETUP_NAPT)
|
|
{
|
|
// Call NAPT a second later as ESP32 requires short delay
|
|
rngxSetupNAPT();
|
|
}
|
|
else if (RgxSettings.status == RGX_CONFIGURED)
|
|
{
|
|
if (Wifi.status == WL_CONNECTED && WiFi.getMode() != WIFI_AP_STA)
|
|
{
|
|
// Should not happen... our AP is gone and only a restart will get it back properly
|
|
AddLog(LOG_LEVEL_INFO, PSTR("RGX: WiFi mode is %d not %d. Restart..."), WiFi.getMode(), WIFI_AP_STA);
|
|
TasmotaGlobal.restart_flag = 2;
|
|
}
|
|
}
|
|
break;
|
|
case FUNC_ACTIVE:
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
#endif // USE_WIFI_RANGE_EXTENDER
|