LEDLamp/LEDLamp.ino

#include "Arduino.h"
#include <ESP8266WebServer.h>
#include <WebSocketsServer.h>
#include <ESP8266mDNS.h>
#include <EEPROM.h>
#include <DNSServer.h>
#include <ArduinoJson.h>
#include <Adafruit_Neopixel.h>
#include "States.h"
#include "Commands.h"
#include "ConfigManager.h"
#include "HtmlPages.h"
#include "LEDStripManager.h"
#include "TimerManager.h"

AppState state = STATE_BOOT;
#define LED_COUNT 12  // Nbr of LEDs on stripe TODO: move to eeprom, configurable over wifi

unsigned long connectStart = 0;
const byte DNS_PORT = 53;

// AP Daten
const char *ap_ssid = "Wemos_Setup";
const char *ap_pass = "admin123";

ESP8266WebServer webServer(80);
WebSocketsServer webSocket(81);
DNSServer dnsServer;
ConfigManager configManager;
LEDStripManager ledMngr(LED_COUNT, LED_STRIP_DATA_PIN, configManager);
TimerManager timerManager(configManager);

// ---------- CAPTIVE PORTAL PAGE ----------
void handleSetupPage() {
	String mac = WiFi.macAddress();
	String html = getSetupPage(mac);
	webServer.send(200, "text/html", html);
}

// ---------- Wemos Control PAGE ----------
void handleSTAControlPage() {
	String mac = WiFi.macAddress();
	String html = getSTAControlPage(mac);
	webServer.send(200, "text/html", html);
}

// ---------- SAVE ----------
void handleSave() {
	Config cfg;
	cfg.version = CONFIG_VERSION;
	cfg = configManager.setToDefaultWiFiConfig(cfg);
	cfg = configManager.setToDefaultLEDConfig(cfg);
	cfg = configManager.setToDefaultTimerConfig(cfg);

	String ssid = webServer.arg("ssid");
	String pass = webServer.arg("pass");

	ssid.toCharArray(cfg.ssid, sizeof(cfg.ssid));
	pass.toCharArray(cfg.pass, sizeof(cfg.pass));
	cfg.wifiValid = true;
	configManager.saveConfig(cfg);

	webServer.send(200, "text/html", getConnectionSuccessPage());

	delay(1500);
	ESP.restart();
}

// ---------- NOT FOUND (CAPTIVE REDIRECT) ----------
void handleNotFound() {
	webServer.sendHeader("Location", "http://192.168.4.1/", true);
	webServer.send(302, "text/plain", "");
}

// ---------- START ACCESS POINT ----------
void startAP() {

	WiFi.mode(WIFI_AP);

	WiFi.softAP(ap_ssid, ap_pass);
	delay(500);

	IPAddress apIP = WiFi.softAPIP();
	Serial.print("AP IP: ");
	Serial.println(apIP);

	// DNS: ALLE Domains auf ESP IP umleiten
	dnsServer.start(DNS_PORT, "*", apIP);

	// Webserver Routes
	webServer.on("/", handleSetupPage);
	webServer.on("/save", HTTP_POST, handleSave);
	webServer.onNotFound(handleNotFound);

	webServer.begin();

	Serial.println("Captive Portal gestartet");
}

void webSocketEvent(uint8_t num, WStype_t type, uint8_t *payload, size_t length) {

	switch (type) {
		case WStype_CONNECTED: {
			IPAddress ip = webSocket.remoteIP(num);
			Serial.printf("WS Client %u verbunden von %d.%d.%d.%d\n", num, ip[0], ip[1], ip[2], ip[3]);
			webSocket.sendTXT(num, "Connected");
			if (digitalRead(LED_STRIP_POWER_PIN) == HIGH) {
				webSocket.sendTXT(num, "LED ON");
			} else {
				webSocket.sendTXT(num, "LED OFF");
			}
			break;
		}

		case WStype_DISCONNECTED:
			Serial.printf("WS Client %u getrennt\n", num);
			break;

		case WStype_TEXT: {
			String msg = String((char*) payload);
			Serial.print("WS empfangen: ");
			Serial.println(msg);

			JsonDocument doc; // e.g: {"cmd":"SWITCH_LED","val":"on"}
			deserializeJson(doc, msg);
			const char *cmd = doc["cmd"];

			if (strToCommand(cmd) == CMD_ESP_RESTART) {
				ESP.restart();

			} else if (strToCommand(cmd) == CMD_GET_CONFIG) {
				JsonDocument doc;
				String json;
				configManager.getConfig(doc);
				serializeJson(doc, json);
				webSocket.sendTXT(num, json);

			} else if (strToCommand(cmd) == CMD_SWITCH_LED) {

				const char *value = doc["val"];
				if (strcmp(value, "on") == 0) {
					Serial.println("LED ON");
					ledMngr.on();
					delay(20);
					if (digitalRead(LED_STRIP_POWER_PIN) == HIGH) {
						webSocket.sendTXT(num, "LED ON");
					}
				} else if (strcmp(value, "off") == 0) {
					Serial.println("LED OFF");
					ledMngr.off();
					delay(20);
					if (digitalRead(LED_STRIP_POWER_PIN) == LOW) {
						webSocket.sendTXT(num, "LED OFF");
					}
				}

			} else if (strToCommand(cmd) == CMD_CHG_MODE) {
				const char *value = doc["val"];
				LEDModes mode = parseMode(value);
				ledMngr.onModeChange(mode);

			} else if (strToCommand(cmd) == CMD_CHG_COLOR) {
				const char *value = doc["val"];
				const char *color = doc["clr"];
				unsigned int r, g, b, w;
				if (sscanf(color, "%u,%u,%u,%u", &r, &g, &b, &w) == 4) {
					ledMngr.onColorChange(value, r, g, b, w);
				}
			} else if (strToCommand(cmd) == CMD_CHG_BRIGHTNESS) {
				const char *value = doc["val"];
				unsigned int br;
				if (sscanf(value, "%u", &br) == 1) {
					ledMngr.onBrightnessChange(br);
				}
			} else if (strToCommand(cmd) == CMD_CHG_CFG_PARAM) {
				const char *value = doc["val"];
				const char *amount = doc["amt"];
				uint32_t amountVal;
				if (sscanf(amount, "%u", &amountVal) == 1) {
					ledMngr.onCfgParamChange(value, amountVal);
				}
			} else if (strToCommand(cmd) == CMD_CHG_TIMER_INTERVAL) {
				const char *interval = doc["interval"];
				const char *timerange = doc["timerange"];
				timerManager.onTimerIntervalChange(interval, timerange);

			} else if (strToCommand(cmd) == CMD_RESET_WIFI_CFG) {
				resetWifiConfiguration(num);

			} else {

				String s = "ACK UNKNOWN: " + msg;
				webSocket.sendTXT(num, s);
			}

			break;
		}

		default:
			break;
	}
}

void resetWifiConfiguration(uint8_t num) {
	Config cfg = configManager.getConfig();
	String ssid = "";
	String pass = "";
	ssid.toCharArray(cfg.ssid, sizeof(cfg.ssid));
	pass.toCharArray(cfg.pass, sizeof(cfg.pass));
	cfg.wifiValid = false;

	configManager.saveConfig(cfg);

	webSocket.sendTXT(num, "Wifi_Reset_Success");
	delay(200);

	EEPROM.commit();
	ESP.restart();
}

void setState(AppState newState) {
	Serial.printf("STATE %s -> %s\n", stateToString(state), stateToString(newState));
	state = newState;
}

void handleBoot() {
	if (configManager.getConfig().wifiValid) {
		WiFi.mode(WIFI_STA);
		WiFi.begin(configManager.getConfig().ssid, configManager.getConfig().pass);
		setState(STATE_CONNECTING);
	}
	else {
		startAP();
		setState(STATE_AP_MODE);
	}
}

void handleConnecting() {
	if (WiFi.status() == WL_CONNECTED) {
		startSTAWebServer();
		setState(STATE_STA_MODE);
		return;
	}

	if (millis() - connectStart > 10000) {
		Serial.println("Connect Timeout");
		startAP();
		setState(STATE_AP_MODE);
	}
}

void handleAPMode() {
	dnsServer.processNextRequest();
	webServer.handleClient();
}

void handleSTAMode() {
	webServer.handleClient();
	webSocket.loop();
	MDNS.update();

	static uint32_t lastNtpCheck = 0;

	if (WiFi.status() != WL_CONNECTED) {
		Serial.println("WLAN verloren");
		WiFi.begin(configManager.getConfig().ssid, configManager.getConfig().pass);
		connectStart = millis();
		setState(STATE_CONNECTING);
		return;
	}

	uint32_t now = millis();
	if (now - lastNtpCheck >= 5000) {
		lastNtpCheck = now;
		if (timerManager.isNowInTimeInterval()) {
			if (ledMngr.isOn()) {
				ledMngr.off();
			}
		} else {
			if (!ledMngr.isOn()) {
				ledMngr.on();
			}
		}
	}

	driveLEDStrip();
}

void handleError() {
	ledMngr.off();
}

void startSTAWebServer() {
	Serial.println("Starte STA Services");

	// Webseite
	webServer.on("/", handleSTAControlPage);

	// optional
	webServer.on("/save", HTTP_POST, handleSave);
	webServer.begin();

	// WebSocket
	webSocket.begin();
	webSocket.onEvent(webSocketEvent);

	Serial.print("HTTP Server: http://");
	Serial.println(WiFi.localIP());

	Serial.print("WebSocket: ws://");
	Serial.print(WiFi.localIP());
	Serial.println(":81/");

	if (MDNS.begin("LEDLamp")) {
		Serial.println("mDNS gestartet");
		MDNS.addService("http", "tcp", 80);
		MDNS.addService("ws", "tcp", 81);
		MDNS.addService("LEDLamp", "tcp", 80);
	}
}

void driveLEDStrip() {
	Config cfg = configManager.getConfig();

	switch (cfg.mode) {
		case LM_RAINBOW:
			ledMngr.setBrightness(cfg.brightness);
			ledMngr.rainbow();
			break;
		case LM_FLASH:
			ledMngr.flash();
			break;
		case LM_SPECTRAL:
			ledMngr.doSpectral();
			break;
		case LM_FADING:
			ledMngr.fade();
			break;
		default:
			break;
	}
}

// ---------- SETUP ----------
void setup() {
	Serial.begin(115200);

	configManager.loadConfig();
	ledMngr.begin();
	timerManager.begin();

	setState(STATE_BOOT);
	connectStart = millis();
}

// ---------- LOOP ----------
void loop() {

	switch (state) {
		case STATE_BOOT:
			handleBoot();
			break;

		case STATE_AP_MODE:
			handleAPMode();
			break;

		case STATE_CONNECTING:
			handleConnecting();
			break;

		case STATE_STA_MODE:
			handleSTAMode();
			break;

		case STATE_ERROR:
			handleError();
			break;
	}
}