WLED/wled00/wled.cpp

667 lines
17 KiB
C++
Raw Normal View History

2020-04-10 12:30:08 +02:00
#define WLED_DEFINE_GLOBAL_VARS //only in one source file, wled.cpp!
#include "wled.h"
#include "wled_ethernet.h"
2020-04-10 12:30:08 +02:00
#include <Arduino.h>
#if defined(ARDUINO_ARCH_ESP32) && defined(WLED_DISABLE_BROWNOUT_DET)
#include "soc/soc.h"
#include "soc/rtc_cntl_reg.h"
#endif
2020-04-10 12:30:08 +02:00
/*
* Main WLED class implementation. Mostly initialization and connection logic
*/
WLED::WLED()
{
}
// turns all LEDs off and restarts ESP
void WLED::reset()
{
briT = 0;
#ifdef WLED_ENABLE_WEBSOCKETS
ws.closeAll(1012);
#endif
2020-04-10 12:30:08 +02:00
long dly = millis();
while (millis() - dly < 450) {
2020-04-10 12:30:08 +02:00
yield(); // enough time to send response to client
}
setAllLeds();
2021-05-30 13:22:42 +02:00
DEBUG_PRINTLN(F("MODULE RESET"));
2020-04-10 12:30:08 +02:00
ESP.restart();
}
bool oappendi(int i)
{
char s[11];
sprintf(s, "%d", i);
2020-04-10 12:30:08 +02:00
return oappend(s);
}
bool oappend(const char* txt)
{
uint16_t len = strlen(txt);
if (olen + len >= OMAX)
return false; // buffer full
strcpy(obuf + olen, txt);
olen += len;
return true;
}
void prepareHostname(char* hostname)
{
const char *pC = serverDescription;
uint8_t pos = 5;
while (*pC && pos < 24) { // while !null and not over length
if (isalnum(*pC)) { // if the current char is alpha-numeric append it to the hostname
hostname[pos] = *pC;
pos++;
} else if (*pC == ' ' || *pC == '_' || *pC == '-' || *pC == '+' || *pC == '!' || *pC == '?' || *pC == '*') {
hostname[pos] = '-';
pos++;
}
// else do nothing - no leading hyphens and do not include hyphens for all other characters.
pC++;
}
// if the hostname is left blank, use the mac address/default mdns name
if (pos < 6) {
sprintf(hostname + 5, "%*s", 6, escapedMac.c_str() + 6);
} else { //last character must not be hyphen
while (pos > 0 && hostname[pos -1] == '-') {
hostname[pos -1] = 0;
pos--;
}
}
}
//handle Ethernet connection event
void WiFiEvent(WiFiEvent_t event)
{
2021-02-27 01:16:06 +01:00
#ifdef WLED_USE_ETHERNET
char hostname[25] = "wled-";
2021-02-27 01:16:06 +01:00
#endif
switch (event) {
#if defined(ARDUINO_ARCH_ESP32) && defined(WLED_USE_ETHERNET)
case SYSTEM_EVENT_ETH_START:
2021-05-30 13:22:42 +02:00
DEBUG_PRINT(F("ETH Started"));
break;
case SYSTEM_EVENT_ETH_CONNECTED:
2021-05-30 13:22:42 +02:00
DEBUG_PRINT(F("ETH Connected"));
if (!apActive) {
WiFi.disconnect(true);
}
if (staticIP != (uint32_t)0x00000000 && staticGateway != (uint32_t)0x00000000) {
ETH.config(staticIP, staticGateway, staticSubnet, IPAddress(8, 8, 8, 8));
} else {
ETH.config(INADDR_NONE, INADDR_NONE, INADDR_NONE);
}
// convert the "serverDescription" into a valid DNS hostname (alphanumeric)
prepareHostname(hostname);
ETH.setHostname(hostname);
showWelcomePage = false;
break;
case SYSTEM_EVENT_ETH_DISCONNECTED:
2021-05-30 13:22:42 +02:00
DEBUG_PRINT(F("ETH Disconnected"));
forceReconnect = true;
break;
#endif
default:
break;
}
}
2020-04-10 12:30:08 +02:00
void WLED::loop()
{
2021-05-27 00:09:52 +02:00
handleTime();
2020-04-10 12:30:08 +02:00
handleIR(); // 2nd call to function needed for ESP32 to return valid results -- should be good for ESP8266, too
handleConnection();
handleSerial();
handleNotifications();
handleTransitions();
#ifdef WLED_ENABLE_DMX
handleDMX();
#endif
userLoop();
2020-05-28 02:20:02 +02:00
usermods.loop();
2020-04-10 12:30:08 +02:00
yield();
handleIO();
handleIR();
handleAlexa();
yield();
if (doReboot)
reset();
2020-10-13 01:39:34 +02:00
if (doCloseFile) {
closeFile();
yield();
}
2020-04-10 12:30:08 +02:00
if (!realtimeMode || realtimeOverride) // block stuff if WARLS/Adalight is enabled
2020-04-10 12:30:08 +02:00
{
if (apActive)
dnsServer.processNextRequest();
#ifndef WLED_DISABLE_OTA
if (WLED_CONNECTED && aOtaEnabled)
ArduinoOTA.handle();
#endif
handleNightlight();
2020-11-11 23:48:14 +01:00
handlePlaylist();
2020-04-10 12:30:08 +02:00
yield();
handleHue();
handleBlynk();
yield();
if (!offMode || strip.isOffRefreshRequred)
2020-04-10 12:30:08 +02:00
strip.service();
#ifdef ESP8266
else if (!noWifiSleep)
delay(1); //required to make sure ESP enters modem sleep (see #1184)
#endif
2020-04-10 12:30:08 +02:00
}
yield();
#ifdef ESP8266
MDNS.update();
#endif
2021-05-30 13:22:42 +02:00
//millis() rolls over every 50 days
if (lastMqttReconnectAttempt > millis()) {
rolloverMillis++;
lastMqttReconnectAttempt = 0;
}
if (millis() - lastMqttReconnectAttempt > 30000) {
lastMqttReconnectAttempt = millis();
2020-04-10 12:30:08 +02:00
initMqtt();
2021-05-30 13:22:42 +02:00
yield();
// refresh WLED nodes list
2021-01-22 16:17:18 +01:00
refreshNodeList();
if (nodeBroadcastEnabled) sendSysInfoUDP();
2021-03-20 18:43:05 +01:00
yield();
}
2021-03-20 18:43:05 +01:00
//LED settings have been saved, re-init busses
2021-03-23 03:10:24 +01:00
//This code block causes severe FPS drop on ESP32 with the original "if (busConfigs[0] != nullptr)" conditional. Investigate!
if (doInitBusses) {
doInitBusses = false;
2021-05-30 13:22:42 +02:00
DEBUG_PRINTLN(F("Re-init busses."));
2021-03-20 18:43:05 +01:00
busses.removeAll();
uint32_t mem = 0;
2021-03-29 02:28:34 +02:00
strip.isRgbw = false;
2021-03-20 18:43:05 +01:00
for (uint8_t i = 0; i < WLED_MAX_BUSSES; i++) {
if (busConfigs[i] == nullptr) break;
mem += busses.memUsage(*busConfigs[i]);
if (mem <= MAX_LED_MEMORY) busses.add(*busConfigs[i]);
2021-03-29 02:28:34 +02:00
//if (BusManager::isRgbw(busConfigs[i]->type)) strip.isRgbw = true;
strip.isRgbw = (strip.isRgbw || BusManager::isRgbw(busConfigs[i]->type));
2021-03-20 18:43:05 +01:00
delete busConfigs[i]; busConfigs[i] = nullptr;
}
strip.finalizeInit(ledCount);
2021-03-20 18:43:05 +01:00
yield();
serializeConfig();
}
yield();
handleWs();
handleStatusLED();
2020-05-28 02:20:02 +02:00
2020-04-10 12:30:08 +02:00
// DEBUG serial logging
#ifdef WLED_DEBUG
if (millis() - debugTime > 9999) {
2021-05-30 13:22:42 +02:00
DEBUG_PRINTLN(F("---DEBUG INFO---"));
DEBUG_PRINT(F("Runtime: ")); DEBUG_PRINTLN(millis());
DEBUG_PRINT(F("Unix time: ")); toki.printTime(toki.getTime());
DEBUG_PRINT(F("Free heap: ")); DEBUG_PRINTLN(ESP.getFreeHeap());
#if defined(ARDUINO_ARCH_ESP32) && defined(WLED_USE_PSRAM)
if (psramFound()) {
DEBUG_PRINT(F("Total PSRAM: ")); DEBUG_PRINT(ESP.getPsramSize()/1024); DEBUG_PRINTLN("kB");
DEBUG_PRINT(F("Free PSRAM: ")); DEBUG_PRINT(ESP.getFreePsram()/1024); DEBUG_PRINTLN("kB");
} else
DEBUG_PRINTLN(F("No PSRAM"));
#endif
DEBUG_PRINT(F("Wifi state: ")); DEBUG_PRINTLN(WiFi.status());
2020-05-28 02:20:02 +02:00
2020-04-10 12:30:08 +02:00
if (WiFi.status() != lastWifiState) {
wifiStateChangedTime = millis();
}
lastWifiState = WiFi.status();
2021-05-30 13:22:42 +02:00
DEBUG_PRINT(F("State time: ")); DEBUG_PRINTLN(wifiStateChangedTime);
DEBUG_PRINT(F("NTP last sync: ")); DEBUG_PRINTLN(ntpLastSyncTime);
DEBUG_PRINT(F("Client IP: ")); DEBUG_PRINTLN(Network.localIP());
DEBUG_PRINT(F("Loops/sec: ")); DEBUG_PRINTLN(loops / 10);
2020-04-10 12:30:08 +02:00
loops = 0;
debugTime = millis();
}
loops++;
2020-05-28 02:20:02 +02:00
#endif // WLED_DEBUG
2021-05-24 14:34:03 +02:00
toki.resetTick();
2020-04-10 12:30:08 +02:00
}
void WLED::setup()
{
#if defined(ARDUINO_ARCH_ESP32) && defined(WLED_DISABLE_BROWNOUT_DET)
WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); //disable brownout detection
#endif
2020-04-10 12:30:08 +02:00
Serial.begin(115200);
Serial.setTimeout(50);
DEBUG_PRINTLN();
2021-05-30 13:22:42 +02:00
DEBUG_PRINT(F("---WLED "));
2020-04-10 12:30:08 +02:00
DEBUG_PRINT(versionString);
DEBUG_PRINT(" ");
DEBUG_PRINT(VERSION);
2021-05-30 13:22:42 +02:00
DEBUG_PRINTLN(F(" INIT---"));
2020-04-10 12:30:08 +02:00
#ifdef ARDUINO_ARCH_ESP32
2021-05-30 13:22:42 +02:00
DEBUG_PRINT(F("esp32 "));
2020-04-10 12:30:08 +02:00
DEBUG_PRINTLN(ESP.getSdkVersion());
#else
2021-05-30 13:22:42 +02:00
DEBUG_PRINT(F("esp8266 "));
2020-04-10 12:30:08 +02:00
DEBUG_PRINTLN(ESP.getCoreVersion());
#endif
2021-05-30 13:22:42 +02:00
DEBUG_PRINT(F("heap "));
2020-04-10 12:30:08 +02:00
DEBUG_PRINTLN(ESP.getFreeHeap());
2020-05-28 02:20:02 +02:00
registerUsermods();
2020-04-10 12:30:08 +02:00
2021-05-30 13:22:42 +02:00
#if defined(ARDUINO_ARCH_ESP32) && defined(WLED_USE_PSRAM)
if (psramFound()) {
pinManager.allocatePin(16); // GPIO16 reserved for SPI RAM
pinManager.allocatePin(17); // GPIO17 reserved for SPI RAM
}
#endif
2020-11-05 22:54:13 +01:00
//DEBUG_PRINT(F("LEDs inited. heap usage ~"));
//DEBUG_PRINTLN(heapPreAlloc - ESP.getFreeHeap());
2020-04-10 12:30:08 +02:00
2021-05-30 13:22:42 +02:00
#ifdef WLED_DEBUG
pinManager.allocatePin(1,true); // GPIO1 reserved for debug output
#endif
#ifdef WLED_USE_DMX //reserve GPIO2 as hardcoded DMX pin
pinManager.allocatePin(2);
#endif
2020-11-05 22:54:13 +01:00
bool fsinit = false;
DEBUGFS_PRINTLN(F("Mount FS"));
#ifdef ARDUINO_ARCH_ESP32
fsinit = WLED_FS.begin(true);
#else
fsinit = WLED_FS.begin();
2020-04-10 12:30:08 +02:00
#endif
2020-11-05 22:54:13 +01:00
if (!fsinit) {
DEBUGFS_PRINTLN(F("FS failed!"));
errorFlag = ERR_FS_BEGIN;
} else deEEP();
updateFSInfo();
2021-05-30 13:22:42 +02:00
DEBUG_PRINTLN(F("Reading config"));
deserializeConfigFromFS();
2020-04-10 12:30:08 +02:00
2021-01-17 00:20:31 +01:00
#if STATUSLED
2021-05-30 13:22:42 +02:00
if (!pinManager.isPinAllocated(STATUSLED)) pinMode(STATUSLED, OUTPUT);
#endif
2021-05-30 13:22:42 +02:00
DEBUG_PRINTLN(F("Initializing strip"));
2020-04-10 12:30:08 +02:00
beginStrip();
2021-05-30 13:22:42 +02:00
DEBUG_PRINTLN(F("Usermods setup"));
2020-04-10 12:30:08 +02:00
userSetup();
2020-05-28 02:20:02 +02:00
usermods.setup();
2020-04-10 12:30:08 +02:00
if (strcmp(clientSSID, DEFAULT_CLIENT_SSID) == 0)
showWelcomePage = true;
WiFi.persistent(false);
#ifdef WLED_USE_ETHERNET
WiFi.onEvent(WiFiEvent);
#endif
2020-04-10 12:30:08 +02:00
2021-05-30 13:22:42 +02:00
#ifdef WLED_ENABLE_ADALIGHT
if (!pinManager.isPinAllocated(3)) {
Serial.println(F("Ada"));
}
#endif
2020-04-10 12:30:08 +02:00
// generate module IDs
escapedMac = WiFi.macAddress();
escapedMac.replace(":", "");
escapedMac.toLowerCase();
if (strcmp(cmDNS, "x") == 0) // fill in unique mdns default
{
2020-09-20 01:18:31 +02:00
strcpy_P(cmDNS, PSTR("wled-"));
2020-04-10 12:30:08 +02:00
sprintf(cmDNS + 5, "%*s", 6, escapedMac.c_str() + 6);
}
if (mqttDeviceTopic[0] == 0) {
2020-09-20 01:18:31 +02:00
strcpy_P(mqttDeviceTopic, PSTR("wled/"));
2020-04-10 12:30:08 +02:00
sprintf(mqttDeviceTopic + 5, "%*s", 6, escapedMac.c_str() + 6);
}
if (mqttClientID[0] == 0) {
2020-09-20 01:18:31 +02:00
strcpy_P(mqttClientID, PSTR("WLED-"));
2020-04-10 12:30:08 +02:00
sprintf(mqttClientID + 5, "%*s", 6, escapedMac.c_str() + 6);
}
strip.service();
#ifndef WLED_DISABLE_OTA
if (aOtaEnabled) {
ArduinoOTA.onStart([]() {
#ifdef ESP8266
wifi_set_sleep_type(NONE_SLEEP_T);
#endif
2020-09-20 01:18:31 +02:00
DEBUG_PRINTLN(F("Start ArduinoOTA"));
2020-04-10 12:30:08 +02:00
});
if (strlen(cmDNS) > 0)
ArduinoOTA.setHostname(cmDNS);
}
#endif
#ifdef WLED_ENABLE_DMX
initDMX();
#endif
// HTTP server page init
initServer();
2021-05-30 13:22:42 +02:00
#if defined(ARDUINO_ARCH_ESP32) && defined(WLED_DISABLE_BROWNOUT_DET)
WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 1); //enable brownout detector
#endif
2020-04-10 12:30:08 +02:00
}
void WLED::beginStrip()
{
// Initialize NeoPixel Strip and button
2020-11-06 22:12:48 +01:00
if (ledCount > MAX_LEDS || ledCount == 0)
ledCount = 30;
strip.finalizeInit(ledCount);
2020-11-05 22:54:13 +01:00
strip.setBrightness(0);
2020-04-10 12:30:08 +02:00
strip.setShowCallback(handleOverlayDraw);
2021-05-30 13:22:42 +02:00
if (bootPreset > 0) {
applyPreset(bootPreset);
} else if (turnOnAtBoot) {
if (briS > 0) bri = briS;
else if (bri == 0) bri = 128;
} else {
briLast = briS; bri = 0;
}
2020-04-10 12:30:08 +02:00
colorUpdated(NOTIFIER_CALL_MODE_INIT);
2021-01-17 00:20:31 +01:00
// init relay pin
if (rlyPin>=0)
digitalWrite(rlyPin, (rlyMde ? bri : !bri));
2020-04-10 12:30:08 +02:00
// disable button if it is "pressed" unintentionally
2021-05-30 13:22:42 +02:00
//if (btnPin>=0 && buttonType == BTN_TYPE_PUSH && isButtonPressed())
// buttonType = BTN_TYPE_NONE;
2020-04-10 12:30:08 +02:00
}
void WLED::initAP(bool resetAP)
{
if (apBehavior == AP_BEHAVIOR_BUTTON_ONLY && !resetAP)
return;
if (!apSSID[0] || resetAP)
strcpy_P(apSSID, PSTR("WLED-AP"));
2020-04-10 12:30:08 +02:00
if (resetAP)
strcpy_P(apPass, PSTR(DEFAULT_AP_PASS));
2020-09-20 01:18:31 +02:00
DEBUG_PRINT(F("Opening access point "));
2020-04-10 12:30:08 +02:00
DEBUG_PRINTLN(apSSID);
WiFi.softAPConfig(IPAddress(4, 3, 2, 1), IPAddress(4, 3, 2, 1), IPAddress(255, 255, 255, 0));
WiFi.softAP(apSSID, apPass, apChannel, apHide);
if (!apActive) // start captive portal if AP active
2020-04-10 12:30:08 +02:00
{
2020-09-20 01:18:31 +02:00
DEBUG_PRINTLN(F("Init AP interfaces"));
2020-04-10 12:30:08 +02:00
server.begin();
if (udpPort > 0 && udpPort != ntpLocalPort) {
udpConnected = notifierUdp.begin(udpPort);
}
if (udpRgbPort > 0 && udpRgbPort != ntpLocalPort && udpRgbPort != udpPort) {
udpRgbConnected = rgbUdp.begin(udpRgbPort);
}
if (udpPort2 > 0 && udpPort2 != ntpLocalPort && udpPort2 != udpPort && udpPort2 != udpRgbPort) {
udp2Connected = notifier2Udp.begin(udpPort2);
}
e131.begin(false, e131Port, e131Universe, E131_MAX_UNIVERSE_COUNT);
2021-01-17 00:20:31 +01:00
2020-04-10 12:30:08 +02:00
dnsServer.setErrorReplyCode(DNSReplyCode::NoError);
dnsServer.start(53, "*", WiFi.softAPIP());
}
apActive = true;
}
void WLED::initConnection()
{
#ifdef WLED_ENABLE_WEBSOCKETS
ws.onEvent(wsEvent);
#endif
#if defined(ARDUINO_ARCH_ESP32) && defined(WLED_USE_ETHERNET)
// Only initialize ethernet board if not NONE
if (ethernetType != WLED_ETH_NONE && ethernetType < WLED_NUM_ETH_TYPES) {
ethernet_settings es = ethernetBoards[ethernetType];
ETH.begin(
(uint8_t) es.eth_address,
(int) es.eth_power,
(int) es.eth_mdc,
(int) es.eth_mdio,
(eth_phy_type_t) es.eth_type,
(eth_clock_mode_t) es.eth_clk_mode
);
}
#endif
WiFi.disconnect(true); // close old connections
2020-04-10 12:30:08 +02:00
#ifdef ESP8266
WiFi.setPhyMode(WIFI_PHY_MODE_11N);
#endif
if (staticIP[0] != 0 && staticGateway[0] != 0) {
WiFi.config(staticIP, staticGateway, staticSubnet, IPAddress(8, 8, 8, 8));
} else {
WiFi.config(0U, 0U, 0U);
}
lastReconnectAttempt = millis();
if (!WLED_WIFI_CONFIGURED) {
2020-09-20 01:18:31 +02:00
DEBUG_PRINT(F("No connection configured. "));
2020-04-10 12:30:08 +02:00
if (!apActive)
initAP(); // instantly go to ap mode
return;
} else if (!apActive) {
if (apBehavior == AP_BEHAVIOR_ALWAYS) {
initAP();
} else {
2020-09-20 01:18:31 +02:00
DEBUG_PRINTLN(F("Access point disabled."));
2020-04-10 12:30:08 +02:00
WiFi.softAPdisconnect(true);
WiFi.mode(WIFI_STA);
2020-04-10 12:30:08 +02:00
}
}
showWelcomePage = false;
2020-09-20 01:18:31 +02:00
DEBUG_PRINT(F("Connecting to "));
2020-04-10 12:30:08 +02:00
DEBUG_PRINT(clientSSID);
DEBUG_PRINTLN("...");
// convert the "serverDescription" into a valid DNS hostname (alphanumeric)
char hostname[25] = "wled-";
prepareHostname(hostname);
2021-01-17 00:20:31 +01:00
2020-04-10 12:30:08 +02:00
#ifdef ESP8266
WiFi.hostname(hostname);
2020-04-10 12:30:08 +02:00
#endif
WiFi.begin(clientSSID, clientPass);
#ifdef ARDUINO_ARCH_ESP32
WiFi.setSleep(!noWifiSleep);
WiFi.setHostname(hostname);
2020-04-10 12:30:08 +02:00
#else
wifi_set_sleep_type((noWifiSleep) ? NONE_SLEEP_T : MODEM_SLEEP_T);
#endif
}
void WLED::initInterfaces()
{
2020-09-20 01:18:31 +02:00
DEBUG_PRINTLN(F("Init STA interfaces"));
2020-04-10 12:30:08 +02:00
2021-05-30 13:22:42 +02:00
#ifndef WLED_DISABLE_HUESYNC
2020-04-10 12:30:08 +02:00
if (hueIP[0] == 0) {
hueIP[0] = Network.localIP()[0];
hueIP[1] = Network.localIP()[1];
hueIP[2] = Network.localIP()[2];
2020-04-10 12:30:08 +02:00
}
2021-05-30 13:22:42 +02:00
#endif
2020-04-10 12:30:08 +02:00
// init Alexa hue emulation
if (alexaEnabled)
alexaInit();
#ifndef WLED_DISABLE_OTA
if (aOtaEnabled)
ArduinoOTA.begin();
#endif
strip.service();
// Set up mDNS responder:
if (strlen(cmDNS) > 0) {
#ifndef WLED_DISABLE_OTA
if (!aOtaEnabled) //ArduinoOTA begins mDNS for us if enabled
2020-04-10 12:30:08 +02:00
MDNS.begin(cmDNS);
#else
MDNS.begin(cmDNS);
#endif
2020-04-10 12:30:08 +02:00
2020-09-20 01:18:31 +02:00
DEBUG_PRINTLN(F("mDNS started"));
2020-04-10 12:30:08 +02:00
MDNS.addService("http", "tcp", 80);
MDNS.addService("wled", "tcp", 80);
MDNS.addServiceTxt("wled", "tcp", "mac", escapedMac.c_str());
}
server.begin();
if (udpPort > 0 && udpPort != ntpLocalPort) {
udpConnected = notifierUdp.begin(udpPort);
if (udpConnected && udpRgbPort != udpPort)
udpRgbConnected = rgbUdp.begin(udpRgbPort);
if (udpConnected && udpPort2 != udpPort && udpPort2 != udpRgbPort)
udp2Connected = notifier2Udp.begin(udpPort2);
2020-04-10 12:30:08 +02:00
}
if (ntpEnabled)
ntpConnected = ntpUdp.begin(ntpLocalPort);
2021-05-30 13:22:42 +02:00
#ifndef WLED_DISABLE_BLYNK
initBlynk(blynkApiKey, blynkHost, blynkPort);
2021-05-30 13:22:42 +02:00
#endif
2020-04-13 00:42:27 +02:00
e131.begin(e131Multicast, e131Port, e131Universe, E131_MAX_UNIVERSE_COUNT);
2020-04-10 12:30:08 +02:00
reconnectHue();
initMqtt();
interfacesInited = true;
wasConnected = true;
}
byte stacO = 0;
uint32_t lastHeap;
unsigned long heapTime = 0;
void WLED::handleConnection()
{
if (millis() < 2000 && (!WLED_WIFI_CONFIGURED || apBehavior == AP_BEHAVIOR_ALWAYS))
return;
if (lastReconnectAttempt == 0)
initConnection();
// reconnect WiFi to clear stale allocations if heap gets too low
if (millis() - heapTime > 5000) {
uint32_t heap = ESP.getFreeHeap();
2021-05-30 13:22:42 +02:00
if (heap < JSON_BUFFER_SIZE+512 && lastHeap < JSON_BUFFER_SIZE+512) {
2020-09-20 01:18:31 +02:00
DEBUG_PRINT(F("Heap too low! "));
2020-04-10 12:30:08 +02:00
DEBUG_PRINTLN(heap);
forceReconnect = true;
}
lastHeap = heap;
heapTime = millis();
}
byte stac = 0;
if (apActive) {
#ifdef ESP8266
stac = wifi_softap_get_station_num();
#else
wifi_sta_list_t stationList;
esp_wifi_ap_get_sta_list(&stationList);
stac = stationList.num;
#endif
if (stac != stacO) {
stacO = stac;
2020-09-20 01:18:31 +02:00
DEBUG_PRINT(F("Connected AP clients: "));
2020-04-10 12:30:08 +02:00
DEBUG_PRINTLN(stac);
if (!WLED_CONNECTED && WLED_WIFI_CONFIGURED) { // trying to connect, but not connected
if (stac)
WiFi.disconnect(); // disable search so that AP can work
else
initConnection(); // restart search
}
}
}
if (forceReconnect) {
2020-09-20 01:18:31 +02:00
DEBUG_PRINTLN(F("Forcing reconnect."));
2020-04-10 12:30:08 +02:00
initConnection();
interfacesInited = false;
forceReconnect = false;
wasConnected = false;
return;
}
if (!Network.isConnected()) {
2020-04-10 12:30:08 +02:00
if (interfacesInited) {
2020-09-20 01:18:31 +02:00
DEBUG_PRINTLN(F("Disconnected!"));
2020-04-10 12:30:08 +02:00
interfacesInited = false;
initConnection();
}
if (millis() - lastReconnectAttempt > ((stac) ? 300000 : 20000) && WLED_WIFI_CONFIGURED)
initConnection();
if (!apActive && millis() - lastReconnectAttempt > 12000 && (!wasConnected || apBehavior == AP_BEHAVIOR_NO_CONN))
initAP();
} else if (!interfacesInited) { // newly connected
DEBUG_PRINTLN("");
2020-09-20 01:18:31 +02:00
DEBUG_PRINT(F("Connected! IP address: "));
DEBUG_PRINTLN(Network.localIP());
2020-04-10 12:30:08 +02:00
initInterfaces();
userConnected();
2020-05-28 02:20:02 +02:00
usermods.connected();
2020-04-10 12:30:08 +02:00
// shut down AP
if (apBehavior != AP_BEHAVIOR_ALWAYS && apActive) {
dnsServer.stop();
WiFi.softAPdisconnect(true);
apActive = false;
2020-09-20 01:18:31 +02:00
DEBUG_PRINTLN(F("Access point disabled."));
2020-04-10 12:30:08 +02:00
}
}
}
void WLED::handleStatusLED()
{
2021-01-17 00:20:31 +01:00
#if STATUSLED
2021-05-30 13:22:42 +02:00
if (pinManager.isPinAllocated(STATUSLED)) return; //lower priority if something else uses the same pin
2021-01-17 00:20:31 +01:00
ledStatusType = WLED_CONNECTED ? 0 : 2;
if (mqttEnabled && ledStatusType != 2) // Wi-Fi takes presendence over MQTT
ledStatusType = WLED_MQTT_CONNECTED ? 0 : 4;
if (ledStatusType) {
if (millis() - ledStatusLastMillis >= (1000/ledStatusType)) {
ledStatusLastMillis = millis();
ledStatusState = ledStatusState ? 0 : 1;
digitalWrite(STATUSLED, ledStatusState);
}
} else {
#ifdef STATUSLEDINVERTED
digitalWrite(STATUSLED, HIGH);
#else
digitalWrite(STATUSLED, LOW);
#endif
2021-01-17 00:20:31 +01:00
}
#endif
2021-05-30 13:22:42 +02:00
}