mirror of
https://github.com/IoTManagerProject/IoTManager.git
synced 2026-03-26 14:12:16 +03:00
579 lines
16 KiB
C++
579 lines
16 KiB
C++
#include "utils/WiFiUtils.h"
|
||
#include <vector>
|
||
#if defined(ESP32)
|
||
#include <esp_task_wdt.h>
|
||
#endif
|
||
#define TRIESONE 20 // количество секунд ожидания подключения к одной сети из несколких
|
||
#define TRIES 30 // количество секунд ожидания подключения сети если она одна
|
||
|
||
#ifdef WIFI_ASYNC
|
||
std::vector<String> _ssidList;
|
||
std::vector<String> _passwordList;
|
||
// номер сети, для перебирания в момент подключения к сетям из массива
|
||
volatile uint8_t currentNetwork = 0;
|
||
volatile bool wifiConnecting = false;
|
||
volatile uint8_t connectionAttempts = 0;
|
||
//------------------------------------------
|
||
// Обработчики событий Wi-Fi
|
||
//------------------------------------------
|
||
void WiFiEvent(arduino_event_t *event)
|
||
{
|
||
switch (event->event_id)
|
||
{
|
||
#if defined(LIBRETINY) || defined(esp32c6_4mb) || defined(esp32c6_8mb)
|
||
case ARDUINO_EVENT_WIFI_STA_CONNECTED:
|
||
#else
|
||
case SYSTEM_EVENT_STA_CONNECTED:
|
||
#endif
|
||
// Подключились к STA
|
||
SerialPrint("i", "WIFI", "Connected to AP: " + WiFi.SSID());
|
||
// TODO если подключились, но не получили IP что будет?
|
||
break;
|
||
#if defined(LIBRETINY) || defined(esp32c6_4mb) || defined(esp32c6_8mb)
|
||
case ARDUINO_EVENT_WIFI_STA_GOT_IP:
|
||
#else
|
||
case SYSTEM_EVENT_STA_GOT_IP:
|
||
#endif
|
||
// Получили IP от роутера
|
||
// wifiReconnectTicker.detach();
|
||
ts.remove(WIFI_SCAN);
|
||
ts.remove(WIFI_CONN);
|
||
#ifdef LIBRETINY
|
||
SerialPrint("i", "WIFI", "http://" + ipToString(WiFi.localIP()));
|
||
jsonWriteStr(settingsFlashJson, "ip", ipToString(WiFi.localIP()));
|
||
#else
|
||
SerialPrint("i", "WIFI", "http://" + WiFi.localIP().toString());
|
||
jsonWriteStr(settingsFlashJson, "ip", WiFi.localIP().toString());
|
||
#endif
|
||
createItemFromNet("onWifi", "1", 1);
|
||
// запускаем MQTT
|
||
mqttInit();
|
||
SerialPrint("i", F("WIFI"), F("Network Init"));
|
||
|
||
// Отключаем AP при успешном подключении
|
||
WiFi.softAPdisconnect(true);
|
||
break;
|
||
#if defined(LIBRETINY) || defined(esp32c6_4mb) || defined(esp32c6_8mb)
|
||
case ARDUINO_EVENT_WIFI_STA_DISCONNECTED:
|
||
#else
|
||
case SYSTEM_EVENT_STA_DISCONNECTED:
|
||
#endif
|
||
// Отключились от STA
|
||
SerialPrint("i", "WIFI", "Disconnected from STA");
|
||
// Завершаем задачу проверки сети
|
||
ts.remove(WIFI_CONN);
|
||
if (wifiConnecting)
|
||
{ // если у нас ещё не закончились попытки подключения, то перезапускаем задачу
|
||
Serial.print(".");
|
||
checkConnection();
|
||
// wifiReconnectTicker.once_ms(WIFI_CHECK_INTERVAL, checkConnection);
|
||
}
|
||
else
|
||
{ // если попытки подключения исчерпаны, то переходим в AP
|
||
startAPMode();
|
||
}
|
||
break;
|
||
#if defined(LIBRETINY) || defined(esp32c6_4mb) || defined(esp32c6_8mb)
|
||
case ARDUINO_EVENT_WIFI_SCAN_DONE:
|
||
#else
|
||
case SYSTEM_EVENT_SCAN_DONE:
|
||
#endif
|
||
if (WiFi.scanComplete() >= 0) {
|
||
Serial.println("Valid Scan completed");
|
||
handleScanResults();
|
||
WiFi.scanDelete(); // Очищаем только при успешном сканировании
|
||
} else {
|
||
//Serial.println("Empty scan or error");
|
||
//WiFi.scanDelete(); // Принудительная очистка буфера
|
||
}
|
||
// Завершилось сканирование сетей
|
||
//Serial.println("Scan completed");
|
||
//handleScanResults();
|
||
break;
|
||
}
|
||
}
|
||
|
||
//------------------------------------------
|
||
// Обработка результатов сканирования
|
||
//------------------------------------------
|
||
void handleScanResults()
|
||
{
|
||
ssidListHeapJson = "{}";
|
||
_ssidList.clear();
|
||
_passwordList.clear();
|
||
jsonReadArray(settingsFlashJson, "routerssid", _ssidList);
|
||
jsonReadArray(settingsFlashJson, "routerpass", _passwordList);
|
||
int16_t numNetworks = WiFi.scanComplete();
|
||
if (numNetworks <= 0)
|
||
{
|
||
SerialPrint("i", "WIFI", "no networks found");
|
||
return;
|
||
}
|
||
|
||
// Ищем известные сети
|
||
int connectNumNet = -1;
|
||
// SerialPrint("i", "WIFI", "Count found: "+numNetworks);
|
||
for (int n = 0; n < numNetworks; ++n)
|
||
{
|
||
String ssid = WiFi.SSID(n);
|
||
jsonWriteStr_(ssidListHeapJson, String(n), ssid);
|
||
for (size_t i = 0; i < _ssidList.size(); i++)
|
||
{
|
||
if (ssid == _ssidList[i])
|
||
{
|
||
Serial.printf("Found known network: %s\n", _ssidList[i]);
|
||
if (connectNumNet < 0)
|
||
connectNumNet = i;
|
||
}
|
||
}
|
||
// if
|
||
}
|
||
sendStringToWs("ssidli", ssidListHeapJson, -1);
|
||
SerialPrint("i", "WIFI", "Scan Found: " + ssidListHeapJson);
|
||
if (connectNumNet >= 0 && !isNetworkActive())
|
||
{
|
||
// ts.remove(WIFI_SCAN);
|
||
connectToNextNetwork();
|
||
}
|
||
// checkConnection();
|
||
// connectToSTA(_ssidList[connectNumNet], _passwordList[connectNumNet]);
|
||
WiFi.scanDelete();
|
||
}
|
||
|
||
void WiFiUtilsItit()
|
||
{
|
||
#if !defined LIBRETINY
|
||
#if defined(esp32c6_4mb) || defined(esp32c6_8mb)
|
||
WiFi.setAutoReconnect(false);
|
||
#else
|
||
WiFi.setAutoConnect(false);
|
||
#endif
|
||
WiFi.persistent(true); // Сохраняет текущую сеть при сканировании
|
||
WiFi.setSleep(true);
|
||
#endif
|
||
WiFi.mode(WIFI_STA);
|
||
WiFi.onEvent(WiFiEvent);
|
||
_ssidList.clear();
|
||
_passwordList.clear();
|
||
jsonReadArray(settingsFlashJson, "routerssid", _ssidList);
|
||
jsonReadArray(settingsFlashJson, "routerpass", _passwordList);
|
||
|
||
if (_ssidList.empty() || _passwordList.empty())
|
||
{
|
||
SerialPrint("E", "WIFI", "No networks configured");
|
||
startAPMode();
|
||
return;
|
||
}
|
||
currentNetwork = 0;
|
||
connectionAttempts = 0;
|
||
connectToNextNetwork();
|
||
}
|
||
|
||
void connectToNextNetwork()
|
||
{
|
||
// все сети перебрали
|
||
if (currentNetwork >= _ssidList.size())
|
||
{
|
||
SerialPrint("i", "WIFI", "All networks tried");
|
||
ts.remove(WIFI_CONN);
|
||
startAPMode();
|
||
return;
|
||
}
|
||
|
||
wifiConnecting = true;
|
||
// connectionAttempts++;
|
||
|
||
const char *ssid = _ssidList[currentNetwork].c_str();
|
||
const char *pass = _passwordList[currentNetwork].c_str();
|
||
// Пробуем подключиться к сети
|
||
SerialPrint("i", "WIFI", "Connecting to: " + String(ssid));
|
||
WiFi.begin(ssid, pass);
|
||
|
||
#if defined(ESP32)
|
||
WiFi.setTxPower(WIFI_POWER_19_5dBm);
|
||
#elif defined(ESP8266)
|
||
WiFi.setOutputPower(20.5);
|
||
#endif
|
||
// проверяем статус подключения и перебираем сети если таймаут не вышел
|
||
checkConnection();
|
||
|
||
// wifiReconnectTicker.once_ms(WIFI_CHECK_INTERVAL, checkConnection);
|
||
}
|
||
|
||
void checkConnection()
|
||
{
|
||
ts.add(
|
||
WIFI_CONN, 1000,
|
||
[&](void *)
|
||
{
|
||
connectionAttempts++;
|
||
if (WiFi.status() == WL_CONNECTED)
|
||
{
|
||
connectionAttempts = 0;
|
||
wifiConnecting = false;
|
||
return;
|
||
}
|
||
|
||
if (connectionAttempts >= (_ssidList.size() > 1 ? TRIESONE : TRIES))
|
||
{
|
||
SerialPrint("i", "WIFI", "Max attempts reached");
|
||
currentNetwork++;
|
||
connectionAttempts = 0;
|
||
wifiConnecting = false;
|
||
}
|
||
|
||
if (wifiConnecting)
|
||
{
|
||
#ifdef ESP8266
|
||
if (WiFi.status() == WL_CONNECT_FAILED || WiFi.status() == WL_WRONG_PASSWORD)
|
||
#else
|
||
if (WiFi.status() == WL_CONNECT_FAILED)
|
||
#endif
|
||
{
|
||
SerialPrint("E", "WIFI", "Connection failed, wrong password?");
|
||
jsonWriteInt(errorsHeapJson, "passer", 1);
|
||
currentNetwork++;
|
||
connectionAttempts = 0;
|
||
}
|
||
|
||
// wifiReconnectTicker.once_ms(WIFI_CHECK_INTERVAL, checkConnection);
|
||
}
|
||
|
||
if (!wifiConnecting)
|
||
{
|
||
connectToNextNetwork();
|
||
}
|
||
},
|
||
nullptr, true);
|
||
}
|
||
|
||
//------------------------------------------
|
||
// Неблокирующее подключение к STA
|
||
//------------------------------------------
|
||
void connectToSTA(const char *ssid, const char *pass)
|
||
{
|
||
if (isNetworkActive())
|
||
return;
|
||
SerialPrint("i", "WIFI", "Connecting to ... " + String(ssid));
|
||
// SerialPrint("i", "WIFI", "pass connect: " + _passwordList[i]);
|
||
WiFi.begin(ssid, pass);
|
||
#if defined(ESP32)
|
||
WiFi.setTxPower(WIFI_POWER_19_5dBm);
|
||
#elif defined(ESP8266)
|
||
WiFi.setOutputPower(20.5);
|
||
#endif
|
||
}
|
||
|
||
void ScanAsync()
|
||
{
|
||
// bool res = false;
|
||
int n = WiFi.scanComplete();
|
||
SerialPrint("i", "WIFI", "scan result: " + String(n, DEC));
|
||
|
||
if (n == -1)
|
||
{ // Сканирование все еще выполняется
|
||
SerialPrint("i", "WIFI", "scanning in progress");
|
||
}
|
||
else
|
||
{
|
||
SerialPrint("i", "WIFI", "start scanning");
|
||
WiFi.scanNetworks(true, false);
|
||
}
|
||
}
|
||
#else
|
||
// ESP8266
|
||
void routerConnect()
|
||
{
|
||
#if !defined LIBRETINY
|
||
#if defined(esp32c6_4mb) || defined(esp32c6_8mb)
|
||
WiFi.setAutoReconnect(false);
|
||
#else
|
||
WiFi.setAutoConnect(false);
|
||
#endif
|
||
WiFi.persistent(false);
|
||
#endif
|
||
/* String s_staip = "192.168.2.62";
|
||
String s_gateway = "192.168.2.1";
|
||
String s_netmask = "255.255.255.0";
|
||
String s_dns = "192.168.2.1";
|
||
SerialPrint("i", "WIFI", "Use static IP");
|
||
WiFi.config(stringToIp(s_staip), stringToIp(s_gateway), stringToIp(s_netmask), stringToIp(s_dns));
|
||
// bool config(IPAddress local_ip, IPAddress gateway, IPAddress subnet, IPAddress dns1 = (uint32_t)0x00000000, IPAddress dns2 = (uint32_t)0x00000000);
|
||
SerialPrint("i", "WIFI", "Static IP: " + s_staip);
|
||
SerialPrint("i", "WIFI", "Gateway: " + s_gateway);
|
||
SerialPrint("i", "WIFI", "Netmask: " + s_netmask);
|
||
SerialPrint("i", "WIFI", "DNS: " + s_dns); */
|
||
WiFi.mode(WIFI_STA);
|
||
byte triesOne = TRIESONE;
|
||
|
||
std::vector<String> _ssidList;
|
||
std::vector<String> _passwordList;
|
||
jsonReadArray(settingsFlashJson, "routerssid", _ssidList);
|
||
jsonReadArray(settingsFlashJson, "routerpass", _passwordList);
|
||
if (_ssidList.size() > 1)
|
||
triesOne = TRIES;
|
||
|
||
if (_passwordList.size() == 0 && _ssidList[0] == "" && _passwordList[0] == "")
|
||
{
|
||
#ifndef LIBRETINY
|
||
WiFi.begin();
|
||
#endif
|
||
}
|
||
else
|
||
{
|
||
WiFi.begin(_ssidList[0].c_str(), _passwordList[0].c_str());
|
||
#if defined (ESP32)
|
||
WiFi.setTxPower(WIFI_POWER_19_5dBm);
|
||
#elif defined (ESP8266)
|
||
WiFi.setOutputPower(20.5);
|
||
#endif
|
||
String _ssid;
|
||
String _password;
|
||
for (int8_t i = 0; i < _ssidList.size(); i++)
|
||
{
|
||
_ssid = _ssid + _ssidList[i] + "; ";
|
||
}
|
||
for (int8_t i = 0; i < _passwordList.size(); i++)
|
||
{
|
||
_password = _password + _passwordList[i] + "; ";
|
||
}
|
||
SerialPrint("i", "WIFI", "ssid list: " + _ssid);
|
||
SerialPrint("i", "WIFI", "pass list: " + _password);
|
||
}
|
||
for (size_t i = 0; i < _ssidList.size(); i++)
|
||
{
|
||
triesOne = TRIESONE;
|
||
if (WiFi.status() == WL_CONNECTED)
|
||
break;
|
||
WiFi.begin(_ssidList[i].c_str(), _passwordList[i].c_str());
|
||
SerialPrint("i", "WIFI", "ssid connect: " + _ssidList[i]);
|
||
SerialPrint("i", "WIFI", "pass connect: " + _passwordList[i]);
|
||
while (--triesOne && WiFi.status() != WL_CONNECTED)
|
||
{
|
||
// SerialPrint("i", "WIFI", ": " + String((int)WiFi.status()));
|
||
#ifdef ESP8266
|
||
if (WiFi.status() == WL_CONNECT_FAILED || WiFi.status() == WL_WRONG_PASSWORD)
|
||
#else
|
||
if (WiFi.status() == WL_CONNECT_FAILED)
|
||
#endif
|
||
{
|
||
SerialPrint("E", "WIFI", "password is not correct");
|
||
triesOne = 1;
|
||
jsonWriteInt(errorsHeapJson, "passer", 1);
|
||
break;
|
||
}
|
||
#if defined(ESP32)
|
||
//SerialPrint("i", "Task", "Resetting WDT...");
|
||
#if !defined(esp32c6_4mb) && !defined(esp32c6_8mb) //TODO esp32-c6 переписать esp_task_wdt_init
|
||
esp_task_wdt_reset();
|
||
#endif
|
||
#endif
|
||
Serial.print(".");
|
||
delay(1000);
|
||
}
|
||
Serial.println("");
|
||
}
|
||
|
||
if (WiFi.status() != WL_CONNECTED)
|
||
{
|
||
Serial.println("");
|
||
startAPMode();
|
||
}
|
||
else
|
||
{
|
||
Serial.println("");
|
||
#ifdef LIBRETINY
|
||
SerialPrint("i", "WIFI", "http://" + ipToString(WiFi.localIP()));
|
||
jsonWriteStr(settingsFlashJson, "ip", ipToString(WiFi.localIP()));
|
||
#else
|
||
SerialPrint("i", "WIFI", "http://" + WiFi.localIP().toString());
|
||
jsonWriteStr(settingsFlashJson, "ip", WiFi.localIP().toString());
|
||
#endif
|
||
createItemFromNet("onWifi", "1", 1);
|
||
mqttInit();
|
||
}
|
||
SerialPrint("i", F("WIFI"), F("Network Init"));
|
||
}
|
||
#endif
|
||
bool startAPMode()
|
||
{
|
||
#ifdef WIFI_ASYNC
|
||
wifiConnecting = false;
|
||
currentNetwork = 0;
|
||
connectionAttempts = 0;
|
||
#endif
|
||
SerialPrint("i", "WIFI", "AP Mode");
|
||
|
||
WiFi.disconnect();
|
||
WiFi.mode(WIFI_AP);
|
||
|
||
String _ssidAP = jsonReadStr(settingsFlashJson, "apssid");
|
||
String _passwordAP = jsonReadStr(settingsFlashJson, "appass");
|
||
if (_passwordAP == "")
|
||
WiFi.softAP(_ssidAP.c_str(), NULL, 6);
|
||
else
|
||
WiFi.softAP(_ssidAP.c_str(), _passwordAP.c_str(), 6);
|
||
IPAddress myIP = WiFi.softAPIP();
|
||
#ifdef LIBRETINY
|
||
SerialPrint("i", "WIFI", "AP IP: " + ipToString(myIP));
|
||
jsonWriteStr(settingsFlashJson, "ip", ipToString(myIP));
|
||
#else
|
||
SerialPrint("i", "WIFI", "AP IP: " + myIP.toString());
|
||
jsonWriteStr(settingsFlashJson, "ip", myIP.toString());
|
||
#endif
|
||
if (jsonReadInt(errorsHeapJson, "passer") != 1)
|
||
{
|
||
ts.add(
|
||
WIFI_SCAN, 30 * 1000,
|
||
[&](void *)
|
||
{
|
||
#ifndef WIFI_ASYNC
|
||
std::vector<String> jArray;
|
||
jsonReadArray(settingsFlashJson, "routerssid", jArray);
|
||
for (int8_t i = 0; i < jArray.size(); i++)
|
||
{
|
||
SerialPrint("i", "WIFI", "scanning for " + jArray[i]);
|
||
}
|
||
if (RouterFind(jArray))
|
||
{
|
||
ts.remove(WIFI_SCAN);
|
||
WiFi.scanDelete();
|
||
routerConnect();
|
||
}
|
||
#else
|
||
ScanAsync();
|
||
#endif
|
||
},
|
||
nullptr, true);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
#ifndef WIFI_ASYNC
|
||
boolean RouterFind(std::vector<String> jArray)
|
||
{
|
||
bool res = false;
|
||
int n = WiFi.scanComplete();
|
||
SerialPrint("i", "WIFI", "scan result: " + String(n, DEC));
|
||
|
||
if (n == -2)
|
||
{ // Сканирование не было запущено, запускаем
|
||
SerialPrint("i", "WIFI", "start scanning");
|
||
WiFi.scanNetworks(true, false); // async, show_hidden
|
||
}
|
||
|
||
else if (n == -1)
|
||
{ // Сканирование все еще выполняется
|
||
SerialPrint("i", "WIFI", "scanning in progress");
|
||
}
|
||
|
||
else if (n == 0)
|
||
{ // ни одна сеть не найдена
|
||
SerialPrint("i", "WIFI", "no networks found");
|
||
WiFi.scanNetworks(true, false);
|
||
}
|
||
else if (n > 0)
|
||
{
|
||
for (int8_t i = 0; i < n; i++)
|
||
{
|
||
for (int8_t k = 0; k < jArray.size(); k++)
|
||
{
|
||
if (WiFi.SSID(i) == jArray[k])
|
||
{
|
||
res = true;
|
||
}
|
||
}
|
||
// SerialPrint("i", "WIFI", (res ? "*" : "") + String(i, DEC) + ") " + WiFi.SSID(i));
|
||
jsonWriteStr_(ssidListHeapJson, String(i), WiFi.SSID(i));
|
||
|
||
// String(WiFi.RSSI(i)
|
||
}
|
||
}
|
||
SerialPrint("i", "WIFI", ssidListHeapJson);
|
||
WiFi.scanDelete();
|
||
return res;
|
||
}
|
||
#endif
|
||
|
||
boolean isNetworkActive()
|
||
{
|
||
return WiFi.status() == WL_CONNECTED;
|
||
}
|
||
|
||
uint8_t getNumAPClients()
|
||
{
|
||
return WiFi.softAPgetStationNum();
|
||
}
|
||
|
||
uint8_t RSSIquality()
|
||
{
|
||
uint8_t res = 0;
|
||
if (isNetworkActive())
|
||
{
|
||
int rssi = WiFi.RSSI();
|
||
if (rssi >= -50)
|
||
{
|
||
res = 6; //"Excellent";
|
||
}
|
||
else if (rssi < -50 && rssi >= -60)
|
||
{
|
||
res = 5; //"Very good";
|
||
}
|
||
else if (rssi < -60 && rssi >= -70)
|
||
{
|
||
res = 4; //"Good";
|
||
}
|
||
else if (rssi < -70 && rssi >= -80)
|
||
{
|
||
res = 3; //"Low";
|
||
}
|
||
else if (rssi < -80 && rssi > -100)
|
||
{
|
||
res = 2; //"Very low";
|
||
}
|
||
else if (rssi <= -100)
|
||
{
|
||
res = 1; //"No signal";
|
||
}
|
||
}
|
||
return res;
|
||
}
|
||
|
||
#ifdef LIBRETINY
|
||
String httpGetString(HTTPClient &http)
|
||
{
|
||
String payload = "";
|
||
int len = http.getSize();
|
||
uint8_t buff[128] = {0};
|
||
WiFiClient *stream = http.getStreamPtr();
|
||
|
||
// read all data from server
|
||
while (http.connected() && (len > 0 || len == -1))
|
||
{
|
||
// get available data size
|
||
size_t size = stream->available();
|
||
|
||
if (size)
|
||
{
|
||
// read up to 128 byte
|
||
int c = stream->readBytes(buff, ((size > sizeof(buff)) ? sizeof(buff) : size));
|
||
|
||
// write it to Serial
|
||
// Serial.write(buff,c);
|
||
|
||
// payload += String((char*)buff);
|
||
char charBuff[c + 1]; // Create a character array with space for null terminator
|
||
memcpy(charBuff, buff, c); // Copy the data to the character array
|
||
charBuff[c] = '\0'; // Null-terminate the character array
|
||
payload += String(charBuff); // Append the character array to the payload
|
||
|
||
if (len > 0)
|
||
{
|
||
len -= c;
|
||
}
|
||
}
|
||
delay(1);
|
||
}
|
||
return payload;
|
||
}
|
||
#endif |