4559 lines
219 KiB
Arduino
4559 lines
219 KiB
Arduino
/************************************************************************************
|
|
* Dual-PID Controller Firmware (Zeitproportional)
|
|
* Version (Siehe unten im Code)
|
|
*
|
|
* Dieses Programm steuert Wasser- und Dampftemperatur über zwei unabhängige PID-Regler
|
|
* mit zeitproportionaler Ansteuerung der SSRs.
|
|
* Sensoren: MAX6675 (Dampf), NTC (Wasser).
|
|
* Funktionen: Eco-Modus, Profile, Fast-Heat-Up, WLAN-Weboberfläche, AutoTune,
|
|
* Wartungserinnerung, Werkseinstellungen, Hostname-Konfiguration.
|
|
*
|
|
* Compiler- und Hardware-Umgebung:
|
|
* - ESP8266: Wemos D1 mini, 4MB
|
|
* - Bibliotheken: Wire, Adafruit_GFX, Adafruit_SH110X, EEPROM, PID_v1, PID_AutoTune_v0,
|
|
* max6675, ESP8266WiFi, ESPAsyncTCP, ESPAsyncWebServer, ESP8266mDNS // Geändert!
|
|
************************************************************************************/
|
|
|
|
#include <Wire.h>
|
|
#include <Adafruit_GFX.h>
|
|
#include <Adafruit_SH110X.h>
|
|
#include <EEPROM.h>
|
|
#include <PID_v1.h>
|
|
#include <PID_AutoTune_v0.h> // Modifizierte AutoTune-Funktion - Muss als .zip eingebunden werden
|
|
#include "max6675.h"
|
|
#include <ESP8266WiFi.h>
|
|
// #include <ESP8266WebServer.h> // Entfernt
|
|
#include <ESPAsyncTCP.h> // Hinzugefügt
|
|
#include <ESPAsyncWebServer.h> // Hinzugefügt
|
|
#include <ESP8266mDNS.h>
|
|
#include <math.h> // Für isnan()
|
|
#include <FS.h> // Dateisystem-Basis
|
|
#include <LittleFS.h> // LittleFS-Implementierung
|
|
#include <WiFiUdp.h>
|
|
#include <NTPClient.h>
|
|
#include <time.h> // Für Zeitfunktionen (struct tm, mktime, etc.)
|
|
|
|
/************************************************************************************
|
|
* Hardware-Pinbelegung
|
|
************************************************************************************/
|
|
|
|
#define SSR_WASSER_PIN D2 // SSR für Wasser-Heizung
|
|
#define SSR_DAMPF_PIN D1 // SSR für Dampf-Heizung
|
|
#define SHOT_TIMER_PIN D8 // Input für Shot-Timer
|
|
#define OLED_SDA D3 // SDA-Leitung für OLED
|
|
#define OLED_SCK D4 // SCK-Leitung für OLED
|
|
#define ANALOG_NTC_PIN A0 // Analoger Eingang für den NTC-Sensor
|
|
|
|
// Display-Objekt (Adafruit SH1106G)
|
|
Adafruit_SH1106G display = Adafruit_SH1106G(128, 64, &Wire);
|
|
|
|
/************************************************************************************
|
|
* MAX6675 (Dampf-Temperatursensor)
|
|
************************************************************************************/
|
|
|
|
#define MAX6675_SCK D7 // Serial Clock
|
|
#define MAX6675_CS D6 // Chip Select
|
|
#define MAX6675_SO D5 // Serial Out
|
|
MAX6675 thermocouple(MAX6675_SCK, MAX6675_CS, MAX6675_SO);
|
|
|
|
/************************************************************************************
|
|
* Firmware-Informationen
|
|
************************************************************************************/
|
|
|
|
String version = "2.9.5-Async"; // Versionsnummer angepasst
|
|
String versionHersteller = "Thomas Müller";
|
|
String versionHerstellerMail =
|
|
"<a href='mailto:thomas@mueller.black' class='info-link'>thomas@mueller.black</a>";
|
|
String versionHerstellerWeb =
|
|
"<a href='https://raw-designs.de/' target='_blank' class='info-link'>https://raw-designs.de/</a> | "
|
|
"<a href='https://mueller.black/' target='_blank' class='info-link'>https://mueller.black/</a>";
|
|
|
|
// Demo-Modus: Hier können bestimmte Funktionen (WLAN-Anpassungen etc.) eingeschränkt werden.
|
|
// Entweder hier pauschal auf true setzen oder über IP-Adresse im Setup()-Teil auf true setzen lassen.
|
|
bool demoModus = false;
|
|
IPAddress demoModusIP(192, 168, 178, 67);
|
|
|
|
// Dieses Kennwort muss in einer Firmware-Binärdatei vorhanden sein, damit ein Update gültig ist.
|
|
static const char FIRMWARE_PASSWORD[] = "FWKennwort123";
|
|
static bool passwordFound = false;
|
|
static int passMatchPos = 0;
|
|
const int passLength = sizeof(FIRMWARE_PASSWORD) - 1;
|
|
|
|
/************************************************************************************
|
|
* Geräte-Infos
|
|
************************************************************************************/
|
|
|
|
char infoHersteller[50];
|
|
char infoModell[50];
|
|
char infoZusatz[50];
|
|
|
|
/************************************************************************************
|
|
* NTC-Sensor-Parameter (Wasser)
|
|
* - A0 wird verwendet, um die Temperatur über einen Spannungsteiler zu messen
|
|
************************************************************************************/
|
|
|
|
const double V_SUPPLY = 3.3; // Versorgungsspannung
|
|
const double ADC_REF = 3.3; // ADC-Referenz
|
|
const double R_FIXED = 3000.0; // Festwiderstand 3 kΩ
|
|
|
|
// Daten des NTC
|
|
const double T0 = 298.15; // Referenztemperatur in Kelvin (25°C)
|
|
const double R0 = 50000.0; // NTC-Widerstand bei 25°C
|
|
const double beta = 3950.0; // Beta-Wert
|
|
|
|
/************************************************************************************
|
|
* Temperatur-Profil-Struktur
|
|
* - Speichert Wasser- und Dampf-Setpoint, Eco-Einstellungen und Profilname
|
|
************************************************************************************/
|
|
|
|
struct TemperatureProfile {
|
|
double setpointWasser;
|
|
double setpointDampf;
|
|
int ecoModeMinutes;
|
|
bool dynamicEcoActive;
|
|
int dampfVerzoegerung;
|
|
char profileName[20];
|
|
};
|
|
|
|
/************************************************************************************
|
|
* PID-Regler-Konfiguration & Zeitproportionale Steuerung
|
|
************************************************************************************/
|
|
|
|
// PID Input/Output/Setpoint Variablen
|
|
double SetpointDampf, InputDampf, OutputDampf;
|
|
double SetpointWasser, InputWasser, OutputWasser;
|
|
double OffsetDampf = 0.0, OffsetWasser = 0.0;
|
|
|
|
// PID-Konstanten (Regelungsparameter)
|
|
double KpDampf = 3.0, KiDampf = 0.1, KdDampf = 0.5;
|
|
double KpWasser = 5.0, KiWasser = 0.2, KdWasser = 1.0;
|
|
|
|
// Zeitproportionale Steuerung
|
|
unsigned long windowSizeWasser; // Fenstergröße für Wasser-SSR (in ms)
|
|
unsigned long windowSizeDampf; // Fenstergröße für Dampf-SSR (in ms)
|
|
unsigned long windowStartTimeWasser; // Startzeit des aktuellen Fensters für Wasser
|
|
unsigned long windowStartTimeDampf; // Startzeit des aktuellen Fensters für Dampf
|
|
|
|
// PID-Regler Instanzen
|
|
// WICHTIG: Die Output-Grenzen werden in setup() auf die Fenstergröße gesetzt!
|
|
PID pidDampf(&InputDampf, &OutputDampf, &SetpointDampf, KpDampf, KiDampf, KdDampf, DIRECT);
|
|
PID pidWasser(&InputWasser, &OutputWasser, &SetpointWasser, KpWasser, KiWasser, KdWasser, DIRECT);
|
|
|
|
// Variablen für Sicherheitsabschaltung
|
|
double maxTempWasser = 110.0; // Standardwert, wie bisher hardcoded
|
|
double maxTempDampf = 180.0; // Standardwert, wie bisher hardcoded
|
|
|
|
// --- NTP Client Konfiguration ---
|
|
WiFiUDP ntpUDP;
|
|
// Zeitverschiebung UTC+1 (Berlin/CET), automatische Sommerzeit (CEST) wird über TZ_INFO gehandhabt
|
|
// Offset 0 hier, da TZ_INFO die Regeln enthält. Update-Intervall 60000ms = 1 Minute.
|
|
NTPClient timeClient(ntpUDP, "pool.ntp.org", 0, 60000);
|
|
bool timeSynced = false;
|
|
|
|
// Zeitzonen-String für Deutschland (CET/CEST)
|
|
const char* TZ_INFO = "CET-1CEST,M3.5.0,M10.5.0/3"; // Germany
|
|
|
|
// --- Für Shot-Statistik ---
|
|
struct ShotStats {
|
|
unsigned long totalShotsLogged = 0;
|
|
unsigned long totalDurationMs = 0;
|
|
unsigned long shotsToday = 0;
|
|
unsigned long shotsThisWeek = 0;
|
|
unsigned long shotsThisMonth = 0;
|
|
double averageDurationSec = 0.0;
|
|
time_t firstShotTimestamp = 0;
|
|
time_t lastShotTimestamp = 0;
|
|
bool historyAvailable = false; // Flag, ob Daten gelesen werden konnten
|
|
unsigned long shotsYesterday = 0;
|
|
unsigned long shotsLastWeek = 0; // Kalenderwoche
|
|
unsigned long shotsLastMonth = 0; // Kalendermonat
|
|
double avgShotsPerDay = 0.0; // Durchschnitt seit erstem Log
|
|
};
|
|
|
|
/************************************************************************************
|
|
* Standardwerte und Default-Einstellungen
|
|
************************************************************************************/
|
|
|
|
double defaultSetpointDampf = 165.0;
|
|
double defaultSetpointWasser = 93.0;
|
|
double defaultOffsetDampf = 0.0;
|
|
double defaultOffsetWasser = 0.0;
|
|
double defaultKpDampf = 3.0;
|
|
double defaultKiDampf = 0.1;
|
|
double defaultKdDampf = 0.5;
|
|
double defaultKpWasser = 5.0;
|
|
double defaultKiWasser = 0.2;
|
|
double defaultKdWasser = 1.0;
|
|
int defaultEcoModeMinutes = 0;
|
|
int defaultEcoModeTempWasser = 60;
|
|
int defaultEcoModeTempDampf = 60;
|
|
String defaultInfoHersteller = "";
|
|
String defaultInfoModell = "";
|
|
String defaultInfoZusatz = "";
|
|
int defaultDampfVerzoegerung = 0;
|
|
int dampfVerzoegerung = 0;
|
|
int defaultMaintenanceInterval = 0;
|
|
String defaultHostname = "Dual-PID";
|
|
unsigned long defaultWindowSizeWasser = 2000;
|
|
unsigned long defaultWindowSizeDampf = 2000;
|
|
|
|
/************************************************************************************
|
|
* Webserver und zugehörige Objekte
|
|
************************************************************************************/
|
|
|
|
// ESP8266WebServer server(80); // Webserver auf Port 80 // Entfernt
|
|
AsyncWebServer server(80); // Hinzugefügt
|
|
|
|
// MagicValue zum Erkennen bereits gespeicherter EEPROM-Daten
|
|
const char storageMagicValue[5] = "MGVE";
|
|
|
|
/************************************************************************************
|
|
* EEPROM Adressen für das Speichern/Laden von Werten
|
|
************************************************************************************/
|
|
const int EEPROM_SIZE = 1024; // Gesamtgröße des verwendeten EEPROM-Speichers
|
|
|
|
/************************************************************************************
|
|
* EEPROM Adressen für das Speichern/Laden von Werten
|
|
************************************************************************************/
|
|
|
|
const int EEPROM_ADDR_MAGICVALUE = 0; // 5 Bytes (char[5])
|
|
const int EEPROM_ADDR_SETPOINT_DAMPF = 5; // 8 Bytes (double)
|
|
const int EEPROM_ADDR_SETPOINT_WASSER = 13; // 8 Bytes
|
|
const int EEPROM_ADDR_OFFSET_DAMPF = 21; // 8 Bytes
|
|
const int EEPROM_ADDR_OFFSET_WASSER = 29; // 8 Bytes
|
|
const int EEPROM_ADDR_KP_DAMPF = 37; // 8 Bytes
|
|
const int EEPROM_ADDR_KI_DAMPF = 45; // 8 Bytes
|
|
const int EEPROM_ADDR_KD_DAMPF = 53; // 8 Bytes
|
|
const int EEPROM_ADDR_KP_WASSER = 61; // 8 Bytes
|
|
const int EEPROM_ADDR_KI_WASSER = 69; // 8 Bytes
|
|
const int EEPROM_ADDR_KD_WASSER = 77; // 8 Bytes
|
|
const int EEPROM_ADDR_ECOMODE_MINUTES = 85; // 4 Bytes (int)
|
|
const int EEPROM_ADDR_ECOMODE_TEMP_WASSER = 89; // 4 Bytes
|
|
const int EEPROM_ADDR_ECOMODE_TEMP_DAMPF = 93; // 4 Bytes
|
|
const int EEPROM_ADDR_INFO_HERSTELLER = 97; // 50 Bytes (char[50])
|
|
const int EEPROM_ADDR_INFO_MODELL = 147; // 50 Bytes
|
|
const int EEPROM_ADDR_INFO_ZUSATZ = 197; // 50 Bytes
|
|
const int EEPROM_ADDR_FASTHEATUP_DATA = 247; // 1 Byte (bool)
|
|
const int EEPROM_ADDR_RUNTIME = 248; // 4 Bytes (unsigned long)
|
|
const int EEPROM_ADDR_SHOTCOUNTER = 252; // 4 Bytes (unsigned long)
|
|
const int EEPROM_ADDR_DYNAMIC_ECO_MODE = 256; // 1 Byte (bool)
|
|
const int EEPROM_ADDR_PROFILE_1 = 257; // 50 Bytes für Profil 1 (struct TemperatureProfile)
|
|
const int EEPROM_ADDR_PROFILE_2 = 307; // 50 Bytes für Profil 2 (struct TemperatureProfile)
|
|
// --- AutoTune Parameter Wasser ---
|
|
const int EEPROM_ADDR_TUNING_STEP_WASSER = 357; // 8 Bytes (double)
|
|
const int EEPROM_ADDR_TUNING_NOISE_WASSER = 365; // 8 Bytes (double)
|
|
const int EEPROM_ADDR_TUNING_STARTVALUE_WASSER = 373; // 8 Bytes (double)
|
|
const int EEPROM_ADDR_TUNING_LOOKBACK_WASSER = 381; // 4 Bytes (unsigned int) -> Ende 384
|
|
// --- WiFi Konfiguration ---
|
|
const int EEPROM_ADDR_WIFI_CONFIG_MAGIC = 385; // 5 Bytes (char[5])
|
|
const int EEPROM_ADDR_WIFI_CONFIG_DATA = 390; // 113 Bytes (struct WiFiConfig) -> Ende ca. 503
|
|
// --- Sonstige Einstellungen ---
|
|
const int EEPROM_ADDR_STEAM_DELAY = 527; // 4 Bytes (int) -> Ende 530
|
|
// --- AutoTune Parameter Dampf ---
|
|
const int EEPROM_ADDR_TUNING_STEP_DAMPF = 531; // 8 Bytes (double)
|
|
const int EEPROM_ADDR_TUNING_NOISE_DAMPF = 539; // 8 Bytes (double)
|
|
const int EEPROM_ADDR_TUNING_STARTVALUE_DAMPF = 547; // 8 Bytes (double)
|
|
const int EEPROM_ADDR_TUNING_LOOKBACK_DAMPF = 555; // 4 Bytes (unsigned int) -> Ende 558
|
|
// --- Adressen für Übertemperatursicherung / Sicherheitsabschaltung ---
|
|
const int EEPROM_ADDR_MAX_TEMP_WASSER = 559; // 8 Bytes (double) -> Ende 566
|
|
const int EEPROM_ADDR_MAX_TEMP_DAMPF = 567; // 8 Bytes (double) -> Ende 574
|
|
// --- NEUE ADRESSEN ---
|
|
const int EEPROM_ADDR_MAINTENANCE_INTERVAL = 575; // 4 Bytes (int) -> Ende 578
|
|
const int EEPROM_ADDR_MAINTENANCE_INTERVAL_COUNTER = 579; // 4 Bytes (int) -> Ende 578 // Alte Adresse war 578, korrigiert zu 579
|
|
const int EEPROM_ADDR_HOSTNAME = 583; // 33 Bytes (char[33]) -> Ende 611
|
|
// --- Boost-Funktion
|
|
const int EEPROM_ADDR_BOOST_WASSER_ACTIVE = 612; // 1 Byte (bool) -> Ende 612
|
|
const int EEPROM_ADDR_BOOST_DAMPF_ACTIVE = 613; // 1 Byte (bool) -> Ende 613
|
|
// --- Zeitfenster-Größen für Dampf und Wasser
|
|
const int EEPROM_ADDR_WINDOWSIZE_WASSER = 614; // 4 Bytes (unsigned long) -> Ende 617
|
|
const int EEPROM_ADDR_WINDOWSIZE_DAMPF = 618; // 4 Bytes (unsigned long) -> Ende 621
|
|
// --- Heiz-Begrenzung oberhalb Setpoints
|
|
const int EEPROM_ADDR_PREVENTHEAT_WASSER = 622; // 1 Byte (bool) -> Ende 622
|
|
const int EEPROM_ADDR_PREVENTHEAT_DAMPF = 623; // 1 Byte (bool) -> Ende 623
|
|
|
|
|
|
/************************************************************************************
|
|
* Eco-Mode Variablen
|
|
************************************************************************************/
|
|
|
|
unsigned long lastShotTime = 0; // Wann wurde zuletzt ein Shot beendet
|
|
int ecoModeMinutes = 0; // Zeit (Minuten) bis Eco-Modus
|
|
bool ecoModeAktiv = 0; // Flag, ob Eco läuft
|
|
int ecoModeTempWasser = 50; // Zieltemp Wasser im Eco
|
|
int ecoModeTempDampf = 50; // Zieltemp Dampf im Eco
|
|
bool dynamicEcoActive = false;
|
|
unsigned long ecoModeActivatedTime = 0;
|
|
|
|
/************************************************************************************
|
|
* Wartungsmodus Variable
|
|
************************************************************************************/
|
|
bool wartungsModusAktiv = false; // Ist der Reinigungs-/Wartungsmodus aktiv?
|
|
int wartungsModusTemp = 35; // Zieltemp Wasser und Dampf im Wartungsmodus
|
|
|
|
/************************************************************************************
|
|
* Fast-Heat-Up Variablen
|
|
************************************************************************************/
|
|
|
|
bool fastHeatUpAktiv = 0; // Ist Fast-Heat-Up aktiviert?
|
|
bool fastHeatUpHeating = 0; // Wird gerade hochgeheizt (Wasser >130)?
|
|
int fastHeatUpSetpoint = 130;
|
|
|
|
/************************************************************************************
|
|
* Sicherheits- und Fehlerstatus
|
|
************************************************************************************/
|
|
|
|
bool wasserSensorError = false; // Flag für Fehler am Wassertemperatursensor
|
|
bool dampfSensorError = false; // Flag für Fehler am Dampftemperatursensor
|
|
bool wasserSafetyShutdown = false;
|
|
bool dampfSafetyShutdown = false;
|
|
|
|
/************************************************************************************
|
|
* Auto-Tune-Einstellungen
|
|
************************************************************************************/
|
|
|
|
// Parameter für Wasser
|
|
double tuningStepWasser;
|
|
double tuningNoiseWasser;
|
|
double tuningStartValueWasser;
|
|
unsigned int tuningLookBackWasser;
|
|
const double defaultTuningStepWasser = 500.0;
|
|
const double defaultTuningNoiseWasser = 1.0;
|
|
const double defaultTuningStartValueWasser = 1000.0;
|
|
const unsigned int defaultTuningLookBackWasser = 60;
|
|
|
|
// Parameter für Dampf
|
|
double tuningStepDampf;
|
|
double tuningNoiseDampf;
|
|
double tuningStartValueDampf;
|
|
unsigned int tuningLookBackDampf;
|
|
const double defaultTuningStepDampf = 300.0;
|
|
const double defaultTuningNoiseDampf = 1.0;
|
|
const double defaultTuningStartValueDampf = 1000.0;
|
|
const unsigned int defaultTuningLookBackDampf = 30;
|
|
|
|
PID_ATune* autoTuneWasser;
|
|
PID_ATune* autoTuneDampf;
|
|
bool autoTuneWasserActive = false;
|
|
bool autoTuneDampfActive = false;
|
|
|
|
// Boost-Feature
|
|
bool boostWasserActive = false;
|
|
const bool defaultBoostWasserActive = false;
|
|
bool boostDampfActive = false;
|
|
const bool defaultBoostDampfActive = false;
|
|
|
|
// Heizen oberhalb Setpoint verhindern
|
|
bool preventHeatAboveSetpointWasser = false; // Standardmäßig AUS
|
|
const bool defaultPreventHeatAboveSetpointWasser = false;
|
|
bool preventHeatAboveSetpointDampf = false; // Standardmäßig AUS
|
|
const bool defaultPreventHeatAboveSetpointDampf = false;
|
|
|
|
/************************************************************************************
|
|
* Shot-Timer Variablen
|
|
************************************************************************************/
|
|
|
|
unsigned long shotStartTime = 0;
|
|
unsigned long shotEndTime = 0;
|
|
bool shotActive = false;
|
|
unsigned long lastShotDurationMillis = 0; // Speichert die Dauer des letzten Shots in ms
|
|
|
|
/************************************************************************************
|
|
* Shot-Zähler und Betriebszeit
|
|
************************************************************************************/
|
|
|
|
unsigned long shotCounter = 0; // Shots > 20 Sekunden
|
|
unsigned long totalRuntime = 0; // Gesamt-Betriebszeit in Sekunden
|
|
unsigned long lastRuntimeSave = 0; // Wann zuletzt gespeichert
|
|
const unsigned long initialRuntimeSaveDelay = 10 * 60 * 1000UL; // 10 Minuten
|
|
const unsigned long subsequentRuntimeSaveInterval = 5 * 60 * 1000UL; // 5 Minuten
|
|
bool initialRuntimeSaveDone = false;
|
|
|
|
/************************************************************************************
|
|
* Wartungserinnerung Variablen
|
|
************************************************************************************/
|
|
int maintenanceInterval = 0; // Intervall in Shots (0 = deaktiviert)
|
|
unsigned long maintenanceIntervalCounter = 0; // Zähler für Wartungsintervall
|
|
bool displayMaintenanceMessage = false; // Flag, ob Meldung aktiv angezeigt wird
|
|
unsigned long maintenanceMessageStartTime = 0; // Startzeit der Meldungsanzeige
|
|
|
|
/************************************************************************************
|
|
* Verzögerungen für Anzeigen
|
|
************************************************************************************/
|
|
|
|
int delayInit1 = 1500; // Display-Bild am Anfang
|
|
int delayInit2 = 3000; // Warte für Anzeige
|
|
unsigned long previousMillis = 0; // für Intervall z.B. 250ms
|
|
const unsigned long interval = 250; // PID-Berechnungsintervall
|
|
|
|
/************************************************************************************
|
|
* LittleFS
|
|
************************************************************************************/
|
|
File fsUploadFile; // Globale Variable für die Datei während des Uploads
|
|
|
|
/************************************************************************************
|
|
* Hostname Variable
|
|
************************************************************************************/
|
|
char hostname[33] = "Dual-PID"; // Max 32 Zeichen + Nullterminator
|
|
|
|
/************************************************************************************
|
|
* WiFi Signal Bitmap (Display-Anzeige)
|
|
************************************************************************************/
|
|
|
|
static const unsigned char PROGMEM wifiSymbol[] = {
|
|
0x1f, 0xc0, 0x20, 0x20, 0x4f, 0x90, 0x90, 0x48,
|
|
0x27, 0x20, 0x08, 0x80, 0x02, 0x00
|
|
};
|
|
|
|
/************************************************************************************
|
|
* Gemeinsame Navigation (PROGMEM) - URLs angepasst
|
|
************************************************************************************/
|
|
|
|
static const char commonNav[] PROGMEM = R"rawliteral(
|
|
<nav>
|
|
<span class="hamburger" onclick="toggleMenu()">☰</span>
|
|
<div class="nav-links"> <a href="/">PID-Einstellung</a>
|
|
<a href="/PID-Tuning">PID-Tuning</a>
|
|
<a href="/Profile">Profile</a>
|
|
<a href="/Chart">Chart</a>
|
|
<a href="/Fast-Heat-Up">Fast-Heat-Up</a>
|
|
<a href="/ECO">Eco</a>
|
|
<a href="/Info">Info</a>
|
|
<a href="/Service">Service</a>
|
|
<a href="/Netzwerk">WiFi</a>
|
|
<a href="/Firmware">Firmware</a>
|
|
</div>
|
|
</span>
|
|
</nav>
|
|
)rawliteral";
|
|
|
|
/************************************************************************************
|
|
* WiFi-Konfigurationsstrukturen und Funktionen - Hostname hinzugefügt
|
|
************************************************************************************/
|
|
|
|
struct WiFiConfig {
|
|
char ssid[32] = "";
|
|
char password[64] = "";
|
|
bool useStaticIP = false;
|
|
IPAddress staticIP = IPAddress(192, 168, 4, 1);
|
|
IPAddress gateway = IPAddress(192, 168, 4, 1);
|
|
IPAddress subnet = IPAddress(255, 255, 255, 0);
|
|
IPAddress dns = IPAddress(8, 8, 8, 8);
|
|
// Hostname in WiFi-Config (obwohl global gespeichert, hier für Vollständigkeit)
|
|
// Wird nicht direkt hier gespeichert, sondern über globale Variable `hostname`
|
|
};
|
|
|
|
// Liest die WLAN-Konfiguration aus dem EEPROM
|
|
// Gibt true zurück, wenn eine gültige Konfiguration (SSID) geladen wurde
|
|
bool loadWiFiConfig(WiFiConfig& config) {
|
|
char magic[5] = { 0 };
|
|
EEPROM.get(EEPROM_ADDR_WIFI_CONFIG_MAGIC, magic);
|
|
|
|
// Lade Hostname (immer, auch wenn keine WiFi-Config da ist)
|
|
EEPROM.get(EEPROM_ADDR_HOSTNAME, hostname);
|
|
hostname[sizeof(hostname) - 1] = '\0'; // Nullterminierung sicherstellen
|
|
// Wenn Hostname leer ist (z.B. nach Reset), Default setzen
|
|
if (strlen(hostname) == 0) {
|
|
strncpy(hostname, defaultHostname.c_str(), sizeof(hostname) - 1);
|
|
hostname[sizeof(hostname) - 1] = '\0';
|
|
EEPROM.put(EEPROM_ADDR_HOSTNAME, hostname); // Default im EEPROM speichern
|
|
EEPROM.commit();
|
|
}
|
|
|
|
|
|
// Falls MagicValue nicht übereinstimmt, Standardwerte setzen
|
|
if (strncmp(magic, storageMagicValue, 4) != 0) {
|
|
strcpy(config.ssid, "");
|
|
strcpy(config.password, "");
|
|
config.useStaticIP = false;
|
|
config.staticIP = IPAddress(192, 168, 4, 1);
|
|
config.gateway = IPAddress(192, 168, 4, 1);
|
|
config.subnet = IPAddress(255, 255, 255, 0);
|
|
config.dns = IPAddress(8, 8, 8, 8);
|
|
return false; // Keine gültige Konfiguration gefunden
|
|
}
|
|
|
|
// Laden der gespeicherten Daten
|
|
EEPROM.get(EEPROM_ADDR_WIFI_CONFIG_DATA, config);
|
|
// Nullterminierung sicherstellen (wichtig!)
|
|
config.ssid[sizeof(config.ssid) - 1] = '\0';
|
|
config.password[sizeof(config.password) - 1] = '\0';
|
|
|
|
// Prüfen, ob SSID leer ist (kann nach AP-Modus-Erzwingung passieren)
|
|
return (strlen(config.ssid) > 0); // True, wenn SSID nicht leer ist
|
|
}
|
|
|
|
// Schreibt die WLAN-Konfiguration ins EEPROM
|
|
void saveWiFiConfig(const WiFiConfig& config) {
|
|
EEPROM.put(EEPROM_ADDR_WIFI_CONFIG_MAGIC, storageMagicValue);
|
|
EEPROM.put(EEPROM_ADDR_WIFI_CONFIG_DATA, config);
|
|
// Hostname wird separat gespeichert (in handleSaveWiFiConfig)
|
|
EEPROM.commit();
|
|
}
|
|
|
|
// Aktiviert den Access Point Modus und zeigt IP an
|
|
void startAPMode() {
|
|
WiFi.hostname(hostname);
|
|
WiFi.softAP("Dual-PID", "QuickMill"); // Setzt SSID "Dual-PID" und Passwort "QuickMill"
|
|
Serial.print(F("AP-Mode gestartet. SSID: Dual-PID, Passwort: QuickMill, IP: "));
|
|
Serial.println(WiFi.softAPIP());
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Webserver-Handler: WLAN-Konfigurations-Seite - Hostname hinzugefügt
|
|
* Async angepasst
|
|
************************************************************************************/
|
|
|
|
// === PROGMEM Teile bleiben gleich ===
|
|
static const char wifiPageChunk1[] PROGMEM = R"rawliteral(
|
|
<!DOCTYPE html><html><head><title>WLAN-Konfiguration</title><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'>
|
|
)rawliteral";
|
|
static const char wifiPageChunk2[] PROGMEM = R"rawliteral(</head>)rawliteral"; // Head Ende
|
|
static const char wifiPageChunk3_a[] PROGMEM = R"rawliteral(
|
|
<body><h1>WLAN-Konfiguration</h1><form action='/saveWiFiConfig' method='POST'><h3>Netzwerk</h3><div style='margin-bottom: 15px; padding-bottom: 10px; border-bottom: 1px solid rgba(255,255,255,0.1);'><label style='margin-right: 5px;'>Aktuelle Signalstärke:</label><span>)rawliteral";
|
|
static const char wifiPageChunk3_b[] PROGMEM = R"rawliteral(</span></div><label for='hostname'>Hostname:</label><input type='text' id='hostname' name='hostname' value=')rawliteral";
|
|
static const char wifiPageChunk3_c[] PROGMEM = R"rawliteral('' required><label for='ssid'>SSID:</label><input type='text' id='ssid' name='ssid' value=')rawliteral";
|
|
static const char wifiPageChunk4[] PROGMEM = R"rawliteral('' required><label for='password'>Passwort:</label><input type='password' id='password' name='password' value=')rawliteral";
|
|
static const char wifiPageChunk5_format[] PROGMEM = R"rawliteral(''><h3>IP-Einstellungen</h3><label><input type='radio' name='ipType' value='dhcp' %s> DHCP</label><label><input type='radio' name='ipType' value='static' %s> Statische IP</label><div id='staticFields' style='display:%s'>)rawliteral";
|
|
static const char wifiPageChunk6_ip[] PROGMEM = R"rawliteral(<label for='ip'>IP-Adresse:</label><input type='text' id='ip' name='ip' value=')rawliteral";
|
|
static const char wifiPageChunk7_gateway[] PROGMEM = R"rawliteral('><label for='gateway'>Gateway:</label><input type='text' id='gateway' name='gateway' value=')rawliteral";
|
|
static const char wifiPageChunk8_dns[] PROGMEM = R"rawliteral('><label for='dns'>DNS-Server:</label><input type='text' id='dns' name='dns' value=')rawliteral";
|
|
static const char wifiPageChunk9_subnet[] PROGMEM = R"rawliteral('><label for='subnet'>Subnetzmaske:</label><input type='text' id='subnet' name='subnet' value=')rawliteral";
|
|
static const char wifiPageChunk10_rest[] PROGMEM = R"rawliteral(''></div><input type='submit' value='Speichern'></form><form action='/forceAPMode' method='POST' style='margin-top: 20px;'><h3>AP-Modus</h3>Verwendung im Access Point-Modus (AP).<br><br>Netzwerk-Name: Dual-PID<br>Passwort: QuickMill<br>IP-Adresse: 192.168.4.1<br><input type='submit' value='AP-Modus verwenden'></form><script>document.querySelectorAll('input[name="ipType"]').forEach(radio => {radio.addEventListener('change', () => {document.getElementById('staticFields').style.display = radio.value === 'static' ? 'block' : 'none';});});document.addEventListener('DOMContentLoaded', () => { const initialIpType = document.querySelector('input[name="ipType"]:checked').value; document.getElementById('staticFields').style.display = initialIpType === 'static' ? 'block' : 'none'; });</script></body></html>)rawliteral";
|
|
|
|
// --- Hilfsfunktion zur Umrechnung von RSSI in Prozent (Approximation) ---
|
|
int calculateSignalPercentage(int rssi) {
|
|
int quality = 0;
|
|
if (rssi <= -100) {
|
|
quality = 0;
|
|
} else if (rssi >= -50) { // Guter Empfang
|
|
quality = 100;
|
|
} else {
|
|
// Lineare Skalierung zwischen -100dBm (0%) und -50dBm (100%)
|
|
quality = 2 * (rssi + 100);
|
|
}
|
|
return quality;
|
|
}
|
|
|
|
// Handler angepasst für AsyncWebServerRequest
|
|
void handleWiFiConfig(AsyncWebServerRequest *request) {
|
|
// EEPROM Lese-Logik (inkl. Hostname aus globaler Variable)
|
|
WiFiConfig currentConfig;
|
|
char magic[5] = { 0 };
|
|
EEPROM.get(EEPROM_ADDR_WIFI_CONFIG_MAGIC, magic);
|
|
bool configValid = (strncmp(magic, storageMagicValue, 4) == 0);
|
|
|
|
if (configValid) {
|
|
EEPROM.get(EEPROM_ADDR_WIFI_CONFIG_DATA, currentConfig);
|
|
// Nullterminierung sicherstellen
|
|
currentConfig.ssid[sizeof(currentConfig.ssid) - 1] = '\0';
|
|
currentConfig.password[sizeof(currentConfig.password) - 1] = '\0';
|
|
} else {
|
|
// Standardwerte, falls keine gültige Konfig im EEPROM
|
|
strcpy(currentConfig.ssid, "");
|
|
strcpy(currentConfig.password, "");
|
|
currentConfig.useStaticIP = false;
|
|
currentConfig.staticIP = IPAddress(192, 168, 4, 1);
|
|
currentConfig.gateway = IPAddress(192, 168, 4, 1);
|
|
currentConfig.subnet = IPAddress(255, 255, 255, 0);
|
|
currentConfig.dns = IPAddress(8, 8, 8, 8); // Default DNS
|
|
}
|
|
// Hostname ist in 'hostname' verfügbar
|
|
|
|
// --- Signalstärke ermitteln ---
|
|
char signalBuffer[50]; // Puffer für den Anzeigetext
|
|
if (WiFi.getMode() == WIFI_STA && WiFi.status() == WL_CONNECTED) {
|
|
long rssi = WiFi.RSSI();
|
|
int percentage = calculateSignalPercentage(rssi);
|
|
snprintf(signalBuffer, sizeof(signalBuffer), "%d dBm (%d%%)", (int)rssi, percentage);
|
|
} else if (WiFi.getMode() == WIFI_AP) {
|
|
strcpy(signalBuffer, "AP-Modus (keine Messung)");
|
|
} else {
|
|
strcpy(signalBuffer, "Nicht verbunden");
|
|
}
|
|
|
|
// Temporäre Puffer für Senden
|
|
char formatBuffer[256]; // Für snprintf_P
|
|
char ipBuffer[16]; // Für IP-Adressen-Formatierung
|
|
|
|
// ---- Beginn des Sendens mit AsyncResponseStream ----
|
|
AsyncResponseStream *response = request->beginResponseStream("text/html");
|
|
response->print(FPSTR(wifiPageChunk1));
|
|
response->print("<link rel=\"stylesheet\" href=\"/style.css\">\n");
|
|
response->print(FPSTR(wifiPageChunk2));
|
|
response->print(FPSTR(commonNav));
|
|
|
|
// --- Body und Netzwerk-Sektion ---
|
|
response->print(FPSTR(wifiPageChunk3_a));
|
|
response->print(signalBuffer);
|
|
response->print(FPSTR(wifiPageChunk3_b));
|
|
response->print(hostname);
|
|
response->print(FPSTR(wifiPageChunk3_c));
|
|
|
|
// SSID einfügen
|
|
if (strlen(currentConfig.ssid) == 0) {
|
|
response->print(F("SSID eingeben"));
|
|
} else {
|
|
response->print(currentConfig.ssid);
|
|
}
|
|
response->print(FPSTR(wifiPageChunk4));
|
|
|
|
// Passwort einfügen
|
|
if (!demoModus) {
|
|
if (strlen(currentConfig.password) == 0) {
|
|
response->print(F("Passwort eingeben"));
|
|
} else {
|
|
response->print(currentConfig.password);
|
|
}
|
|
} else {
|
|
response->print(F("********"));
|
|
}
|
|
|
|
// --- IP-Einstellungen ---
|
|
snprintf_P(formatBuffer, sizeof(formatBuffer), wifiPageChunk5_format,
|
|
currentConfig.useStaticIP ? "" : "checked",
|
|
currentConfig.useStaticIP ? "checked" : "",
|
|
currentConfig.useStaticIP ? "block" : "none");
|
|
response->print(formatBuffer);
|
|
|
|
// --- Statische IP Felder (NEUE REIHENFOLGE) ---
|
|
// 1. IP-Adresse
|
|
response->print(FPSTR(wifiPageChunk6_ip));
|
|
snprintf(ipBuffer, sizeof(ipBuffer), "%d.%d.%d.%d", currentConfig.staticIP[0], currentConfig.staticIP[1], currentConfig.staticIP[2], currentConfig.staticIP[3]);
|
|
response->print(ipBuffer);
|
|
|
|
// 2. Gateway
|
|
response->print(FPSTR(wifiPageChunk7_gateway));
|
|
snprintf(ipBuffer, sizeof(ipBuffer), "%d.%d.%d.%d", currentConfig.gateway[0], currentConfig.gateway[1], currentConfig.gateway[2], currentConfig.gateway[3]);
|
|
response->print(ipBuffer);
|
|
|
|
// 3. DNS-Server
|
|
response->print(FPSTR(wifiPageChunk8_dns));
|
|
snprintf(ipBuffer, sizeof(ipBuffer), "%d.%d.%d.%d", currentConfig.dns[0], currentConfig.dns[1], currentConfig.dns[2], currentConfig.dns[3]);
|
|
response->print(ipBuffer);
|
|
|
|
// 4. Subnetzmaske
|
|
response->print(FPSTR(wifiPageChunk9_subnet));
|
|
snprintf(ipBuffer, sizeof(ipBuffer), "%d.%d.%d.%d", currentConfig.subnet[0], currentConfig.subnet[1], currentConfig.subnet[2], currentConfig.subnet[3]);
|
|
response->print(ipBuffer);
|
|
|
|
// Rest der Seite
|
|
response->print(FPSTR(wifiPageChunk10_rest));
|
|
|
|
// ---- Ende des Sendens ----
|
|
request->send(response);
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler, um den AP-Modus per Knopfdruck zu erzwingen - Async angepasst
|
|
************************************************************************************/
|
|
|
|
// Die PROGMEM-Definitionen für die Bestätigungsseite bleiben bestehen
|
|
static const char forceAPHtml[] PROGMEM = R"rawliteral(
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<title>AP-Modus aktivieren</title><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'>
|
|
)rawliteral";
|
|
static const char forceAPHtml2[] PROGMEM = R"rawliteral(
|
|
</head>
|
|
)rawliteral";
|
|
static const char forceAPHtml3[] PROGMEM = R"rawliteral(
|
|
<body>
|
|
<h1>AP-Modus wird aktiviert...</h1>
|
|
<form><p>Die Einstellungen wurden gespeichert. Neustart im AP-Modus ...</p></form>
|
|
</body>
|
|
</html>
|
|
)rawliteral";
|
|
|
|
|
|
// --- Überarbeitete Funktion handleForceAPMode ---
|
|
void handleForceAPMode(AsyncWebServerRequest *request) {
|
|
// --- Logik zum Speichern der leeren Konfig (BLEIBT UNVERÄNDERT) ---
|
|
WiFiConfig emptyConfig;
|
|
if (!demoModus) { saveWiFiConfig(emptyConfig); }
|
|
|
|
// --- Senden der Bestätigungsseite mit AsyncResponseStream ---
|
|
AsyncResponseStream *response = request->beginResponseStream("text/html");
|
|
response->print(FPSTR(forceAPHtml));
|
|
response->print("<link rel=\"stylesheet\" href=\"/style.css\">\n");
|
|
response->print(FPSTR(forceAPHtml2));
|
|
response->print(FPSTR(commonNav));
|
|
response->print(FPSTR(forceAPHtml3));
|
|
request->send(response);
|
|
|
|
// --- Logik nach dem Senden (BLEIBT UNVERÄNDERT) ---
|
|
// Führe den Neustart nach einer Verzögerung aus, um sicherzustellen, dass die Antwort gesendet wurde
|
|
// Eine bessere Methode mit Async wäre ein Timer, aber delay() ist minimalinvasiv
|
|
delay(1000);
|
|
ESP.restart();
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler zum Speichern der WLAN-Konfiguration - Async angepasst
|
|
************************************************************************************/
|
|
|
|
// Die PROGMEM-Definitionen für die Bestätigungsseite bleiben bestehen
|
|
static const char saveConfigHtml[] PROGMEM = R"rawliteral(
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<title>Einstellungen gespeichert</title><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'>
|
|
)rawliteral";
|
|
|
|
static const char saveConfigHtml2[] PROGMEM = R"rawliteral(
|
|
</head>
|
|
)rawliteral";
|
|
|
|
static const char saveConfigHtml3[] PROGMEM = R"rawliteral(
|
|
<body>
|
|
<h1>Einstellungen gespeichert</h1>
|
|
<form><p>Die Einstellungen wurden gespeichert. Neustart ...</p></form>
|
|
</body>
|
|
</html>
|
|
)rawliteral";
|
|
|
|
// --- Funktion handleSaveWiFiConfig ---
|
|
void handleSaveWiFiConfig(AsyncWebServerRequest *request) {
|
|
// --- Daten validieren und auslesen ---
|
|
if (!request->hasParam("ssid", true)) // true checkt POST
|
|
{
|
|
request->send(400, F("text/plain"), F("Fehler: SSID fehlt!"));
|
|
return;
|
|
}
|
|
|
|
// --- Konfigurationsstruktur füllen ---
|
|
WiFiConfig newConfig;
|
|
|
|
// SSID und Passwort kopieren
|
|
strncpy(newConfig.ssid, request->getParam("ssid", true)->value().c_str(), sizeof(newConfig.ssid) - 1);
|
|
newConfig.ssid[sizeof(newConfig.ssid) - 1] = '\0';
|
|
|
|
if (request->hasParam("password", true)) {
|
|
strncpy(newConfig.password, request->getParam("password", true)->value().c_str(), sizeof(newConfig.password) - 1);
|
|
newConfig.password[sizeof(newConfig.password) - 1] = '\0';
|
|
} else {
|
|
newConfig.password[0] = '\0';
|
|
}
|
|
|
|
// IP-Typ bestimmen
|
|
if (request->hasParam("ipType", true)) {
|
|
newConfig.useStaticIP = (request->getParam("ipType", true)->value() == "static");
|
|
} else {
|
|
newConfig.useStaticIP = false; // Fallback
|
|
}
|
|
|
|
|
|
// Statische IP-Einstellungen parsen, falls ausgewählt
|
|
if (newConfig.useStaticIP) {
|
|
if (!request->hasParam("ip", true) || !request->hasParam("gateway", true) || !request->hasParam("subnet", true) || !request->hasParam("dns", true)) {
|
|
request->send(400, F("text/plain"), F("Fehler: Fehlende Felder für statische IP!"));
|
|
return;
|
|
}
|
|
|
|
bool ipOK = newConfig.staticIP.fromString(request->getParam("ip", true)->value());
|
|
bool gwOK = newConfig.gateway.fromString(request->getParam("gateway", true)->value());
|
|
bool subOK = newConfig.subnet.fromString(request->getParam("subnet", true)->value());
|
|
bool dnsOK = newConfig.dns.fromString(request->getParam("dns", true)->value());
|
|
|
|
if (!ipOK || !gwOK || !subOK || !dnsOK) {
|
|
Serial.println(F("WARNUNG: Mindestens ein Feld für statische IP hatte ein ungültiges Format."));
|
|
// Option B: Mit Defaultwerten speichern (fromString liefert oft 0.0.0.0 bei Fehler)
|
|
}
|
|
Serial.printf("Speichere statische IP: %s, GW: %s, Sub: %s, DNS: %s\n",
|
|
newConfig.staticIP.toString().c_str(),
|
|
newConfig.gateway.toString().c_str(),
|
|
newConfig.subnet.toString().c_str(),
|
|
newConfig.dns.toString().c_str());
|
|
|
|
} else {
|
|
Serial.println(F("Speichere Konfiguration für DHCP."));
|
|
}
|
|
|
|
// Hostname speichern
|
|
if (request->hasParam("hostname", true)) {
|
|
strncpy(hostname, request->getParam("hostname", true)->value().c_str(), sizeof(hostname) - 1);
|
|
hostname[sizeof(hostname) - 1] = '\0';
|
|
if (strlen(hostname) == 0) {
|
|
strncpy(hostname, defaultHostname.c_str(), sizeof(hostname) - 1);
|
|
hostname[sizeof(hostname) - 1] = '\0';
|
|
}
|
|
EEPROM.put(EEPROM_ADDR_HOSTNAME, hostname);
|
|
Serial.printf("Speichere Hostname: %s\n", hostname);
|
|
}
|
|
|
|
// --- Speichern (wenn nicht im Demo-Modus) ---
|
|
if (!demoModus) {
|
|
Serial.println("Schreibe WiFi-Konfiguration und Hostname ins EEPROM...");
|
|
saveWiFiConfig(newConfig);
|
|
// EEPROM.commit() ist in saveWiFiConfig und oben für Hostname
|
|
} else {
|
|
Serial.println("Demo-Modus aktiv: Einstellungen werden NICHT gespeichert.");
|
|
}
|
|
|
|
// --- Senden der Bestätigungsseite mit AsyncResponseStream ---
|
|
AsyncResponseStream *response = request->beginResponseStream("text/html");
|
|
response->print(FPSTR(saveConfigHtml));
|
|
response->print("<link rel=\"stylesheet\" href=\"/style.css\">\n");
|
|
response->print(FPSTR(saveConfigHtml2));
|
|
response->print(FPSTR(commonNav));
|
|
response->print(FPSTR(saveConfigHtml3));
|
|
request->send(response);
|
|
|
|
// --- Neustart einleiten ---
|
|
Serial.println("Einstellungen verarbeitet. Starte Neustart in 5 Sekunden...");
|
|
delay(5000);
|
|
ESP.restart();
|
|
}
|
|
|
|
// Prüfung der WiFi-Verbindung (Reconnect falls getrennt) - Unverändert
|
|
void checkWifiConnection() {
|
|
if (WiFi.status() != WL_CONNECTED) {
|
|
WiFi.reconnect();
|
|
if (WiFi.waitForConnectResult() != WL_CONNECTED) {
|
|
Serial.println(F("WiFi-Verbindung kann nicht hergestellt werden!"));
|
|
}
|
|
}
|
|
}
|
|
|
|
// WiFi-Symbol aufs Display zeichnen - Unverändert
|
|
void drawwifiSymbol(int16_t x, int16_t y) {
|
|
display.drawBitmap(x, y, wifiSymbol, 13, 7, SH110X_WHITE);
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler zum Rücksetzen der Betriebszeit - Async angepasst
|
|
************************************************************************************/
|
|
|
|
void handleResetRuntime(AsyncWebServerRequest *request) {
|
|
totalRuntime = 0;
|
|
EEPROM.put(EEPROM_ADDR_RUNTIME, totalRuntime);
|
|
EEPROM.commit();
|
|
request->redirect("/Info"); // Async redirect
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler zum Rücksetzen des Shotzählers - Async angepasst
|
|
************************************************************************************/
|
|
|
|
void handleResetShots(AsyncWebServerRequest *request) {
|
|
shotCounter = 0;
|
|
EEPROM.put(EEPROM_ADDR_SHOTCOUNTER, shotCounter);
|
|
EEPROM.commit();
|
|
request->redirect("/Info"); // Async redirect
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler zum Rücksetzen des Wartungszählers (über Shot-Zähler) - Async angepasst
|
|
************************************************************************************/
|
|
void handleResetMaintenance(AsyncWebServerRequest *request) {
|
|
maintenanceIntervalCounter = 0; // Wartungszähler-Reset auf 0
|
|
EEPROM.put(EEPROM_ADDR_MAINTENANCE_INTERVAL_COUNTER, maintenanceIntervalCounter);
|
|
EEPROM.commit();
|
|
displayMaintenanceMessage = false; // Meldung ggf. ausblenden
|
|
request->redirect("/Service"); // Async redirect
|
|
}
|
|
|
|
|
|
/************************************************************************************
|
|
* Handler für den Export der EEPROM-Einstellungen - Async angepasst
|
|
************************************************************************************/
|
|
void handleExportSettings(AsyncWebServerRequest *request) {
|
|
AsyncResponseStream *response = request->beginResponseStream("application/octet-stream", EEPROM_SIZE);
|
|
response->addHeader("Content-Disposition", "attachment; filename=\"dual_pid_settings.bin\"");
|
|
|
|
// EEPROM-Inhalt byteweise zum Stream schreiben
|
|
// Puffergröße klein halten, um Speicher zu sparen
|
|
const size_t bufferSize = 64;
|
|
byte buffer[bufferSize];
|
|
for (int i = 0; i < EEPROM_SIZE; i += bufferSize) {
|
|
size_t currentChunkSize = (EEPROM_SIZE - i < bufferSize) ? (EEPROM_SIZE - i) : bufferSize;
|
|
for (size_t j = 0; j < currentChunkSize; j++) {
|
|
buffer[j] = EEPROM.read(i + j);
|
|
yield(); // Wichtig für Netzwerkstabilität bei längeren Operationen
|
|
}
|
|
response->write(buffer, currentChunkSize);
|
|
yield();
|
|
}
|
|
request->send(response);
|
|
}
|
|
|
|
|
|
/************************************************************************************
|
|
* Handler für den Import der EEPROM-Einstellungen (Async Upload-Verarbeitung)
|
|
************************************************************************************/
|
|
|
|
// PROGMEM Chunks für die Import-Antwortseite (handleImportSettingsResponse)
|
|
static const char importDoneHtmlStart[] PROGMEM = R"rawliteral(
|
|
<!DOCTYPE html><html><head><title>Einstellungen Import</title><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'>
|
|
)rawliteral";
|
|
static const char importDoneHtmlHeadEnd[] PROGMEM = R"rawliteral(</head>)rawliteral";
|
|
static const char importDoneHtmlBodyStart[] PROGMEM = R"rawliteral(
|
|
<body><h1>Einstellungen Import</h1>
|
|
<form><p>)rawliteral"; // Endet vor {status_message}
|
|
static const char importDoneHtmlBodyEnd[] PROGMEM = R"rawliteral(</p></form>
|
|
</body></html>
|
|
)rawliteral"; // Beginnt nach {status_message}
|
|
|
|
// Globale Variablen bleiben gleich
|
|
static int eepromWriteAddress = 0;
|
|
static bool importSuccessful = false;
|
|
static String importStatusMessage = "";
|
|
|
|
// Diese Funktion wird AUFGERUFEN, wenn der Upload-Vorgang abgeschlossen ist (oder fehlschlägt)
|
|
// Sie sendet die Statusseite.
|
|
void handleImportSettingsResponse(AsyncWebServerRequest *request) {
|
|
AsyncResponseStream *response = request->beginResponseStream("text/html");
|
|
response->print(FPSTR(importDoneHtmlStart));
|
|
response->print("<link rel=\"stylesheet\" href=\"/style.css\">\n");
|
|
response->print(FPSTR(importDoneHtmlHeadEnd));
|
|
response->print(FPSTR(commonNav));
|
|
response->print(FPSTR(importDoneHtmlBodyStart));
|
|
|
|
// Statusmeldung senden (importStatusMessage ist globale String-Variable)
|
|
if (importStatusMessage.length() > 0) {
|
|
response->print(importStatusMessage);
|
|
}
|
|
|
|
response->print(FPSTR(importDoneHtmlBodyEnd));
|
|
request->send(response);
|
|
|
|
// Neustart-Logik bleibt unverändert
|
|
if (importSuccessful) {
|
|
Serial.println("Neustart in 5 Sekunden nach EEPROM-Import...");
|
|
delay(5000);
|
|
ESP.restart();
|
|
}
|
|
}
|
|
|
|
// Dies ist der Callback, der während des Uploads aufgerufen wird.
|
|
void handleImportUpload(AsyncWebServerRequest *request, String filename, size_t index, uint8_t *data, size_t len, bool final) {
|
|
// Demo-Modus Prüfung
|
|
if (demoModus) {
|
|
if (index == 0) { // Nur beim Start prüfen
|
|
importStatusMessage = F("Import im Demo-Modus nicht erlaubt!");
|
|
importSuccessful = false;
|
|
Serial.println("EEPROM Import im Demo Modus abgelehnt.");
|
|
// Sende sofort eine Fehlermeldung? Besser am Ende in handleImportSettingsResponse
|
|
}
|
|
return; // Keine weitere Verarbeitung im Demo Modus
|
|
}
|
|
|
|
if(index == 0){ // UPLOAD_FILE_START
|
|
Serial.printf("EEPROM Import Start: %s\n", filename.c_str());
|
|
eepromWriteAddress = 0; // Zähler zurücksetzen
|
|
importSuccessful = false; // Status zurücksetzen
|
|
importStatusMessage = ""; // Nachricht zurücksetzen
|
|
}
|
|
|
|
// Prüfen, ob bereits ein Fehler aufgetreten ist
|
|
if (importStatusMessage.length() > 0) {
|
|
return; // Beende die Verarbeitung für diesen Chunk
|
|
}
|
|
|
|
// Schreibe die empfangenen Bytes, aber schütze vor Überlauf
|
|
for (size_t i = 0; i < len; i++) {
|
|
if (eepromWriteAddress < EEPROM_SIZE) {
|
|
EEPROM.write(eepromWriteAddress, data[i]);
|
|
eepromWriteAddress++;
|
|
} else {
|
|
Serial.printf("FEHLER: Mehr als %d Bytes empfangen! Adresse: %d. Breche ab.\n", EEPROM_SIZE, eepromWriteAddress);
|
|
importStatusMessage = F("Importfehler: Empfangene Datei zu groß!");
|
|
goto end_write_processing_async; // Springe aus der Schleife
|
|
}
|
|
yield();
|
|
}
|
|
end_write_processing_async:; // Sprungziel für goto
|
|
|
|
if(final){ // UPLOAD_FILE_END
|
|
Serial.printf("EEPROM Import Ende. Verarbeitete Bytes: %d\n", eepromWriteAddress);
|
|
// FINALE GRÖSSENPRÜFUNG und Fehlerprüfung
|
|
if (importStatusMessage.length() > 0) {
|
|
Serial.println("Import nicht erfolgreich aufgrund vorheriger Fehler (z.B. Datei zu groß).");
|
|
importSuccessful = false;
|
|
} else if (eepromWriteAddress == EEPROM_SIZE) {
|
|
if (EEPROM.commit()) {
|
|
importSuccessful = true;
|
|
importStatusMessage = F("Einstellungen erfolgreich importiert! Neustart wird durchgeführt...");
|
|
} else {
|
|
Serial.println("FEHLER: EEPROM Commit fehlgeschlagen!");
|
|
importSuccessful = false;
|
|
importStatusMessage = F("Import fehlgeschlagen: EEPROM Commit Fehler!");
|
|
}
|
|
} else {
|
|
Serial.printf("FEHLER: Upload beendet, aber falsche Anzahl Bytes verarbeitet! Verarbeitet: %d, Erwartet: %d\n", eepromWriteAddress, EEPROM_SIZE);
|
|
importSuccessful = false;
|
|
importStatusMessage = F("Import fehlgeschlagen: Falsche Dateigröße!");
|
|
}
|
|
eepromWriteAddress = 0; // Bereinigung
|
|
|
|
// **WICHTIG**: Sende die Antwortseite *nachdem* der Upload abgeschlossen ist.
|
|
// Der ursprüngliche handleImportSettings wird hier aufgerufen.
|
|
handleImportSettingsResponse(request);
|
|
}
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler für die Import-Seite (nur zum Anzeigen der Seite, die den Upload auslöst)
|
|
* Diese Funktion wird nicht mehr benötigt, da der Upload direkt über POST an /importSettings geht
|
|
* und die Antwort nach dem Upload gesendet wird.
|
|
************************************************************************************/
|
|
// void handleImportSettings(AsyncWebServerRequest *request) { ... } // Diese Funktion ist nicht mehr nötig für POST
|
|
|
|
/************************************************************************************
|
|
* Funktion zum Zurücksetzen auf Werkseinstellungen
|
|
************************************************************************************/
|
|
void resetToDefaults() {
|
|
Serial.println("Zurücksetzen auf Werkseinstellungen...");
|
|
|
|
// PID & Offset
|
|
EEPROM.put(EEPROM_ADDR_SETPOINT_DAMPF, defaultSetpointDampf);
|
|
EEPROM.put(EEPROM_ADDR_SETPOINT_WASSER, defaultSetpointWasser);
|
|
EEPROM.put(EEPROM_ADDR_OFFSET_DAMPF, defaultOffsetDampf);
|
|
EEPROM.put(EEPROM_ADDR_OFFSET_WASSER, defaultOffsetWasser);
|
|
EEPROM.put(EEPROM_ADDR_KP_DAMPF, defaultKpDampf);
|
|
EEPROM.put(EEPROM_ADDR_KI_DAMPF, defaultKiDampf);
|
|
EEPROM.put(EEPROM_ADDR_KD_DAMPF, defaultKdDampf);
|
|
EEPROM.put(EEPROM_ADDR_KP_WASSER, defaultKpWasser);
|
|
EEPROM.put(EEPROM_ADDR_KI_WASSER, defaultKiWasser);
|
|
EEPROM.put(EEPROM_ADDR_KD_WASSER, defaultKdWasser);
|
|
EEPROM.put(EEPROM_ADDR_WINDOWSIZE_WASSER, defaultWindowSizeWasser);
|
|
EEPROM.put(EEPROM_ADDR_WINDOWSIZE_DAMPF, defaultWindowSizeDampf);
|
|
|
|
// Boost-Funktion
|
|
EEPROM.put(EEPROM_ADDR_BOOST_WASSER_ACTIVE, defaultBoostWasserActive);
|
|
EEPROM.put(EEPROM_ADDR_BOOST_DAMPF_ACTIVE, defaultBoostDampfActive);
|
|
|
|
// Heiz-Begrenzung
|
|
EEPROM.put(EEPROM_ADDR_PREVENTHEAT_WASSER, defaultPreventHeatAboveSetpointWasser);
|
|
EEPROM.put(EEPROM_ADDR_PREVENTHEAT_DAMPF, defaultPreventHeatAboveSetpointDampf);
|
|
|
|
// Eco Modus
|
|
EEPROM.put(EEPROM_ADDR_ECOMODE_MINUTES, defaultEcoModeMinutes);
|
|
EEPROM.put(EEPROM_ADDR_ECOMODE_TEMP_WASSER, defaultEcoModeTempWasser);
|
|
EEPROM.put(EEPROM_ADDR_ECOMODE_TEMP_DAMPF, defaultEcoModeTempDampf);
|
|
EEPROM.put(EEPROM_ADDR_DYNAMIC_ECO_MODE, false); // Default für Dynamic Eco
|
|
EEPROM.put(EEPROM_ADDR_STEAM_DELAY, defaultDampfVerzoegerung);
|
|
|
|
// Geräteinfo
|
|
char tempInfo[50];
|
|
strncpy(tempInfo, defaultInfoHersteller.c_str(), sizeof(tempInfo) - 1);
|
|
tempInfo[sizeof(tempInfo) - 1] = '\0';
|
|
EEPROM.put(EEPROM_ADDR_INFO_HERSTELLER, tempInfo);
|
|
strncpy(tempInfo, defaultInfoModell.c_str(), sizeof(tempInfo) - 1);
|
|
tempInfo[sizeof(tempInfo) - 1] = '\0';
|
|
EEPROM.put(EEPROM_ADDR_INFO_MODELL, tempInfo);
|
|
strncpy(tempInfo, defaultInfoZusatz.c_str(), sizeof(tempInfo) - 1);
|
|
tempInfo[sizeof(tempInfo) - 1] = '\0';
|
|
EEPROM.put(EEPROM_ADDR_INFO_ZUSATZ, tempInfo);
|
|
|
|
// Fast Heat Up
|
|
EEPROM.put(EEPROM_ADDR_FASTHEATUP_DATA, false); // Default für Fast Heat Up
|
|
|
|
// Profile (mit Default-Werten überschreiben)
|
|
TemperatureProfile defaultProfile;
|
|
defaultProfile.setpointWasser = defaultSetpointWasser;
|
|
defaultProfile.setpointDampf = defaultSetpointDampf;
|
|
defaultProfile.ecoModeMinutes = defaultEcoModeMinutes;
|
|
defaultProfile.dynamicEcoActive = false;
|
|
defaultProfile.dampfVerzoegerung = defaultDampfVerzoegerung;
|
|
strncpy(defaultProfile.profileName, "Unbenannt", sizeof(defaultProfile.profileName));
|
|
defaultProfile.profileName[sizeof(defaultProfile.profileName) - 1] = '\0';
|
|
EEPROM.put(EEPROM_ADDR_PROFILE_1, defaultProfile);
|
|
EEPROM.put(EEPROM_ADDR_PROFILE_2, defaultProfile);
|
|
|
|
// AutoTune Parameter
|
|
EEPROM.put(EEPROM_ADDR_TUNING_STEP_WASSER, defaultTuningStepWasser);
|
|
EEPROM.put(EEPROM_ADDR_TUNING_NOISE_WASSER, defaultTuningNoiseWasser);
|
|
EEPROM.put(EEPROM_ADDR_TUNING_STARTVALUE_WASSER, defaultTuningStartValueWasser);
|
|
EEPROM.put(EEPROM_ADDR_TUNING_LOOKBACK_WASSER, defaultTuningLookBackWasser);
|
|
EEPROM.put(EEPROM_ADDR_TUNING_STEP_DAMPF, defaultTuningStepDampf);
|
|
EEPROM.put(EEPROM_ADDR_TUNING_NOISE_DAMPF, defaultTuningNoiseDampf);
|
|
EEPROM.put(EEPROM_ADDR_TUNING_STARTVALUE_DAMPF, defaultTuningStartValueDampf);
|
|
EEPROM.put(EEPROM_ADDR_TUNING_LOOKBACK_DAMPF, defaultTuningLookBackDampf);
|
|
|
|
// Sicherheitslimits (verwenden die globalen Variablen, die beim Start initialisiert wurden)
|
|
EEPROM.put(EEPROM_ADDR_MAX_TEMP_WASSER, maxTempWasser); // Diese sollten eigentlich auch Defaults haben
|
|
EEPROM.put(EEPROM_ADDR_MAX_TEMP_DAMPF, maxTempDampf); // TODO: Eigene Defaults definieren?
|
|
|
|
// // WiFi Konfiguration löschen (erzwingt AP-Modus beim nächsten Start)
|
|
// char emptyMagic[5] = {0};
|
|
// EEPROM.put(EEPROM_ADDR_WIFI_CONFIG_MAGIC, emptyMagic);
|
|
|
|
// Hostname auf Standard
|
|
strncpy(hostname, defaultHostname.c_str(), sizeof(hostname) - 1);
|
|
hostname[sizeof(hostname) - 1] = '\0';
|
|
EEPROM.put(EEPROM_ADDR_HOSTNAME, hostname);
|
|
|
|
// Wartungsintervall zurücksetzen
|
|
EEPROM.put(EEPROM_ADDR_MAINTENANCE_INTERVAL_COUNTER, 0UL);
|
|
EEPROM.put(EEPROM_ADDR_MAINTENANCE_INTERVAL, defaultMaintenanceInterval);
|
|
|
|
// // Zähler zurücksetzen (optional, aber sinnvoll)
|
|
// EEPROM.put(EEPROM_ADDR_RUNTIME, 0UL);
|
|
// EEPROM.put(EEPROM_ADDR_SHOTCOUNTER, 0UL);
|
|
|
|
// Magic Value für allgemeine Einstellungen setzen (wichtig!)
|
|
EEPROM.put(EEPROM_ADDR_MAGICVALUE, storageMagicValue);
|
|
|
|
// Alle Änderungen ins EEPROM schreiben
|
|
if (EEPROM.commit()) {
|
|
Serial.println("Werkseinstellungen erfolgreich ins EEPROM geschrieben."); // Log hinzugefügt
|
|
} else {
|
|
Serial.println("FEHLER: Schreiben der Werkseinstellungen ins EEPROM fehlgeschlagen!");
|
|
}
|
|
|
|
// WICHTIG: Globale Variablen auch auf Default setzen, damit der laufende Betrieb korrekt ist
|
|
// bis zum Neustart (obwohl ein Neustart nach Reset empfohlen wird)
|
|
maintenanceInterval = defaultMaintenanceInterval;
|
|
maintenanceIntervalCounter = 0;
|
|
boostWasserActive = defaultBoostWasserActive;
|
|
boostDampfActive = defaultBoostDampfActive;
|
|
preventHeatAboveSetpointWasser = defaultPreventHeatAboveSetpointWasser;
|
|
preventHeatAboveSetpointDampf = defaultPreventHeatAboveSetpointDampf;
|
|
strncpy(hostname, defaultHostname.c_str(), sizeof(hostname) - 1);
|
|
hostname[sizeof(hostname) - 1] = '\0';
|
|
|
|
windowSizeWasser = defaultWindowSizeWasser;
|
|
windowSizeDampf = defaultWindowSizeDampf;
|
|
|
|
pidWasser.SetOutputLimits(0, windowSizeWasser);
|
|
pidDampf.SetOutputLimits(0, windowSizeDampf);
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler für das Zurücksetzen auf Werkseinstellungen - Async angepasst
|
|
************************************************************************************/
|
|
|
|
// PROGMEM Chunks für die Seite
|
|
static const char resetDoneHtmlStart[] PROGMEM = R"rawliteral(
|
|
<!DOCTYPE html><html><head><title>Werkseinstellungen</title><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'>
|
|
)rawliteral";
|
|
static const char resetDoneHtmlHeadEnd[] PROGMEM = R"rawliteral(</head>)rawliteral";
|
|
static const char resetDoneHtmlBody[] PROGMEM = R"rawliteral(
|
|
<body><h1>Werkseinstellungen</h1>
|
|
<form><p>Alle Einstellungen wurden auf die Werkseinstellungen zurückgesetzt. Das Gerät wird neu gestartet...</p></form>
|
|
</body></html>
|
|
)rawliteral";
|
|
|
|
// Überarbeitete Funktion
|
|
void handleResetDefaults(AsyncWebServerRequest *request) {
|
|
// Logik zum Resetten bleibt unverändert
|
|
if (!demoModus) {
|
|
resetToDefaults(); // Führt das eigentliche Reset durch
|
|
} else {
|
|
request->send(403, F("text/plain"), F("Reset im Demo-Modus nicht erlaubt."));
|
|
return;
|
|
}
|
|
|
|
// Bestätigungsseite senden (Async)
|
|
AsyncResponseStream *response = request->beginResponseStream("text/html");
|
|
response->print(FPSTR(resetDoneHtmlStart));
|
|
response->print("<link rel=\"stylesheet\" href=\"/style.css\">\n");
|
|
response->print(FPSTR(resetDoneHtmlHeadEnd));
|
|
response->print(FPSTR(commonNav));
|
|
response->print(FPSTR(resetDoneHtmlBody));
|
|
request->send(response);
|
|
|
|
// Neustart-Logik bleibt unverändert
|
|
delay(5000);
|
|
ESP.restart();
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Variable für Systemstartzeit (relevant für die Dampf-Verzögerung) - Unverändert
|
|
************************************************************************************/
|
|
|
|
unsigned long startupTime;
|
|
|
|
|
|
// Forward Deklarationen für Upload Handler
|
|
void handleFirmwareUploadProgress(AsyncWebServerRequest *request, String filename, size_t index, uint8_t *data, size_t len, bool final);
|
|
void handleFirmwareUpdateResponse(AsyncWebServerRequest *request);
|
|
void handleFileUploadProgress(AsyncWebServerRequest *request, String filename, size_t index, uint8_t *data, size_t len, bool final);
|
|
void handleFileUploadedResponse(AsyncWebServerRequest *request);
|
|
// void handleImportUpload(AsyncWebServerRequest *request, String filename, size_t index, uint8_t *data, size_t len, bool final); // Bereits deklariert/definiert
|
|
// void handleImportSettingsResponse(AsyncWebServerRequest *request); // Bereits deklariert/definiert
|
|
|
|
/************************************************************************************
|
|
* setup(): Initialisierung des Systems - Async angepasst
|
|
************************************************************************************/
|
|
|
|
void setup() {
|
|
Serial.begin(115200);
|
|
EEPROM.begin(EEPROM_SIZE); // Größe angepasst
|
|
|
|
pinMode(SSR_DAMPF_PIN, OUTPUT);
|
|
pinMode(SSR_WASSER_PIN, OUTPUT);
|
|
pinMode(SHOT_TIMER_PIN, INPUT_PULLUP);
|
|
|
|
// Initialisiere SSRs als AUS
|
|
digitalWrite(SSR_DAMPF_PIN, LOW);
|
|
digitalWrite(SSR_WASSER_PIN, LOW);
|
|
|
|
// Prüfen, ob MagicValue bereits im EEPROM liegt
|
|
char storedMagicValue[5] = { 0 };
|
|
bool magicValueVorhanden = false;
|
|
EEPROM.get(EEPROM_ADDR_MAGICVALUE, storedMagicValue);
|
|
|
|
if (strncmp(storedMagicValue, storageMagicValue, 4) == 0) {
|
|
magicValueVorhanden = true;
|
|
} else {
|
|
magicValueVorhanden = false;
|
|
}
|
|
|
|
// Werte aus dem EEPROM laden, wenn vorhanden, sonst mit Default-Werten initialisieren
|
|
if (magicValueVorhanden) {
|
|
EEPROM.get(EEPROM_ADDR_SETPOINT_DAMPF, SetpointDampf);
|
|
EEPROM.get(EEPROM_ADDR_SETPOINT_WASSER, SetpointWasser);
|
|
EEPROM.get(EEPROM_ADDR_OFFSET_DAMPF, OffsetDampf);
|
|
EEPROM.get(EEPROM_ADDR_OFFSET_WASSER, OffsetWasser);
|
|
EEPROM.get(EEPROM_ADDR_KP_DAMPF, KpDampf);
|
|
EEPROM.get(EEPROM_ADDR_KI_DAMPF, KiDampf);
|
|
EEPROM.get(EEPROM_ADDR_KD_DAMPF, KdDampf);
|
|
EEPROM.get(EEPROM_ADDR_KP_WASSER, KpWasser);
|
|
EEPROM.get(EEPROM_ADDR_KI_WASSER, KiWasser);
|
|
EEPROM.get(EEPROM_ADDR_KD_WASSER, KdWasser);
|
|
EEPROM.get(EEPROM_ADDR_ECOMODE_MINUTES, ecoModeMinutes);
|
|
EEPROM.get(EEPROM_ADDR_ECOMODE_TEMP_WASSER, ecoModeTempWasser);
|
|
EEPROM.get(EEPROM_ADDR_ECOMODE_TEMP_DAMPF, ecoModeTempDampf);
|
|
EEPROM.get(EEPROM_ADDR_INFO_HERSTELLER, infoHersteller);
|
|
EEPROM.get(EEPROM_ADDR_INFO_MODELL, infoModell);
|
|
EEPROM.get(EEPROM_ADDR_INFO_ZUSATZ, infoZusatz);
|
|
EEPROM.get(EEPROM_ADDR_DYNAMIC_ECO_MODE, dynamicEcoActive);
|
|
EEPROM.get(EEPROM_ADDR_FASTHEATUP_DATA, fastHeatUpAktiv);
|
|
EEPROM.get(EEPROM_ADDR_STEAM_DELAY, dampfVerzoegerung);
|
|
EEPROM.get(EEPROM_ADDR_TUNING_STEP_WASSER, tuningStepWasser);
|
|
EEPROM.get(EEPROM_ADDR_TUNING_NOISE_WASSER, tuningNoiseWasser);
|
|
EEPROM.get(EEPROM_ADDR_TUNING_STARTVALUE_WASSER, tuningStartValueWasser);
|
|
EEPROM.get(EEPROM_ADDR_TUNING_LOOKBACK_WASSER, tuningLookBackWasser);
|
|
EEPROM.get(EEPROM_ADDR_TUNING_STEP_DAMPF, tuningStepDampf);
|
|
EEPROM.get(EEPROM_ADDR_TUNING_NOISE_DAMPF, tuningNoiseDampf);
|
|
EEPROM.get(EEPROM_ADDR_TUNING_STARTVALUE_DAMPF, tuningStartValueDampf);
|
|
EEPROM.get(EEPROM_ADDR_TUNING_LOOKBACK_DAMPF, tuningLookBackDampf);
|
|
EEPROM.get(EEPROM_ADDR_MAX_TEMP_WASSER, maxTempWasser);
|
|
EEPROM.get(EEPROM_ADDR_MAX_TEMP_DAMPF, maxTempDampf);
|
|
EEPROM.get(EEPROM_ADDR_MAINTENANCE_INTERVAL, maintenanceInterval);
|
|
EEPROM.get(EEPROM_ADDR_BOOST_WASSER_ACTIVE, boostWasserActive);
|
|
EEPROM.get(EEPROM_ADDR_BOOST_DAMPF_ACTIVE, boostDampfActive);
|
|
EEPROM.get(EEPROM_ADDR_PREVENTHEAT_WASSER, preventHeatAboveSetpointWasser);
|
|
EEPROM.get(EEPROM_ADDR_PREVENTHEAT_DAMPF, preventHeatAboveSetpointDampf);
|
|
EEPROM.get(EEPROM_ADDR_WINDOWSIZE_WASSER, windowSizeWasser);
|
|
EEPROM.get(EEPROM_ADDR_WINDOWSIZE_DAMPF, windowSizeDampf);
|
|
|
|
infoHersteller[sizeof(infoHersteller) - 1] = '\0';
|
|
infoModell[sizeof(infoModell) - 1] = '\0';
|
|
infoZusatz[sizeof(infoZusatz) - 1] = '\0';
|
|
|
|
} else // Magic Value fehlt -> ALLES auf Default setzen
|
|
{
|
|
SetpointDampf = defaultSetpointDampf;
|
|
SetpointWasser = defaultSetpointWasser;
|
|
OffsetDampf = defaultOffsetDampf;
|
|
OffsetWasser = defaultOffsetWasser;
|
|
KpDampf = defaultKpDampf;
|
|
KiDampf = defaultKiDampf;
|
|
KdDampf = defaultKdDampf;
|
|
KpWasser = defaultKpWasser;
|
|
KiWasser = defaultKiWasser;
|
|
KdWasser = defaultKdWasser;
|
|
ecoModeMinutes = defaultEcoModeMinutes;
|
|
ecoModeTempWasser = defaultEcoModeTempWasser;
|
|
ecoModeTempDampf = defaultEcoModeTempDampf;
|
|
strncpy(infoHersteller, defaultInfoHersteller.c_str(), sizeof(infoHersteller) - 1); infoHersteller[sizeof(infoHersteller) - 1] = '\0';
|
|
strncpy(infoModell, defaultInfoModell.c_str(), sizeof(infoModell) - 1); infoModell[sizeof(infoModell) - 1] = '\0';
|
|
strncpy(infoZusatz, defaultInfoZusatz.c_str(), sizeof(infoZusatz) - 1); infoZusatz[sizeof(infoZusatz) - 1] = '\0';
|
|
dynamicEcoActive = false;
|
|
fastHeatUpAktiv = false;
|
|
dampfVerzoegerung = defaultDampfVerzoegerung;
|
|
tuningStepWasser = defaultTuningStepWasser;
|
|
tuningNoiseWasser = defaultTuningNoiseWasser;
|
|
tuningStartValueWasser = defaultTuningStartValueWasser;
|
|
tuningLookBackWasser = defaultTuningLookBackWasser;
|
|
tuningStepDampf = defaultTuningStepDampf;
|
|
tuningNoiseDampf = defaultTuningNoiseDampf;
|
|
tuningStartValueDampf = defaultTuningStartValueDampf;
|
|
tuningLookBackDampf = defaultTuningLookBackDampf;
|
|
maintenanceInterval = defaultMaintenanceInterval;
|
|
maintenanceIntervalCounter = 0;
|
|
boostWasserActive = defaultBoostWasserActive;
|
|
boostDampfActive = defaultBoostDampfActive;
|
|
preventHeatAboveSetpointWasser = defaultPreventHeatAboveSetpointWasser;
|
|
preventHeatAboveSetpointDampf = defaultPreventHeatAboveSetpointDampf;
|
|
windowSizeWasser = defaultWindowSizeWasser;
|
|
windowSizeDampf = defaultWindowSizeDampf;
|
|
// resetToDefaults schreibt Defaults ins EEPROM und setzt Magic Value
|
|
resetToDefaults();
|
|
}
|
|
|
|
// WiFi-Einstellungen laden und ggf. herstellen
|
|
WiFiConfig wifiConfig;
|
|
bool hasWiFiConfig = loadWiFiConfig(wifiConfig); // Lädt auch Hostname
|
|
|
|
WiFi.hostname(hostname); // Hostname setzen VOR begin/softAP
|
|
|
|
if (hasWiFiConfig) {
|
|
WiFi.mode(WIFI_STA);
|
|
|
|
if (wifiConfig.useStaticIP)
|
|
{
|
|
Serial.println(F("Verwende statische IP-Konfiguration:"));
|
|
Serial.print(F(" IP: ")); Serial.println(wifiConfig.staticIP);
|
|
Serial.print(F(" Gateway: ")); Serial.println(wifiConfig.gateway);
|
|
Serial.print(F(" Subnet: ")); Serial.println(wifiConfig.subnet);
|
|
Serial.print(F(" DNS: ")); Serial.println(wifiConfig.dns);
|
|
|
|
if (!WiFi.config(wifiConfig.staticIP, wifiConfig.gateway, wifiConfig.subnet, wifiConfig.dns)) {
|
|
Serial.println(F("FEHLER: Statische IP-Konfiguration fehlgeschlagen!"));
|
|
}
|
|
} else {
|
|
Serial.println(F("Verwende DHCP."));
|
|
}
|
|
|
|
Serial.printf("Verbinde mit SSID: %s, Hostname: %s\n", wifiConfig.ssid, hostname);
|
|
WiFi.begin(wifiConfig.ssid, wifiConfig.password);
|
|
int retries = 0;
|
|
|
|
while (WiFi.status() != WL_CONNECTED && retries < 20) {
|
|
delay(500);
|
|
Serial.print(F("."));
|
|
retries++;
|
|
yield();
|
|
}
|
|
|
|
if (WiFi.status() == WL_CONNECTED) {
|
|
Serial.print(F("\nErfolgreich verbunden! IP-Adresse: "));
|
|
Serial.println(WiFi.localIP());
|
|
|
|
timeClient.begin();
|
|
Serial.println("NTP Client gestartet.");
|
|
configTzTime(TZ_INFO, "pool.ntp.org");
|
|
Serial.printf("Zeitzone gesetzt: %s\n", TZ_INFO);
|
|
|
|
if (WiFi.localIP() == demoModusIP) {
|
|
demoModus = true;
|
|
Serial.println("INFO: Demo-Modus aktiviert (basierend auf IP-Adresse).");
|
|
}
|
|
|
|
if (MDNS.begin(hostname)) {
|
|
Serial.println("mDNS Responder gestartet");
|
|
MDNS.addService("http", "tcp", 80);
|
|
} else {
|
|
Serial.println("Fehler beim Starten des mDNS Responders!");
|
|
}
|
|
} else
|
|
{
|
|
Serial.println(F("\nKonnte keine Verbindung herstellen! Starte AP-Modus..."));
|
|
startAPMode();
|
|
}
|
|
} else
|
|
{
|
|
Serial.println("Keine WLAN-Konfiguration gefunden. Starte AP-Modus...");
|
|
startAPMode();
|
|
}
|
|
|
|
// Wartungszähler, Betriebszeit und Shotcounter aus EEPROM laden
|
|
EEPROM.get(EEPROM_ADDR_RUNTIME, totalRuntime);
|
|
if (totalRuntime == ULONG_MAX || totalRuntime > (86400UL * 365 * 10)) {
|
|
Serial.println("Ungültige Betriebszeit im EEPROM, setze auf 0.");
|
|
totalRuntime = 0;
|
|
EEPROM.put(EEPROM_ADDR_RUNTIME, totalRuntime); EEPROM.commit();
|
|
}
|
|
|
|
EEPROM.get(EEPROM_ADDR_SHOTCOUNTER, shotCounter);
|
|
if (shotCounter == ULONG_MAX || shotCounter > 1000000UL) {
|
|
Serial.println("Ungültiger Shotcounter im EEPROM, setze auf 0.");
|
|
shotCounter = 0;
|
|
EEPROM.put(EEPROM_ADDR_SHOTCOUNTER, shotCounter); EEPROM.commit();
|
|
}
|
|
|
|
EEPROM.get(EEPROM_ADDR_MAINTENANCE_INTERVAL_COUNTER, maintenanceIntervalCounter);
|
|
if (maintenanceIntervalCounter == ULONG_MAX || maintenanceIntervalCounter > 1000000UL) {
|
|
Serial.println("Ungültiger Wartungszähler im EEPROM, setze auf 0.");
|
|
maintenanceIntervalCounter = 0;
|
|
EEPROM.put(EEPROM_ADDR_MAINTENANCE_INTERVAL_COUNTER, maintenanceIntervalCounter); EEPROM.commit();
|
|
}
|
|
|
|
if (fastHeatUpAktiv) { fastHeatUpHeating = true; }
|
|
|
|
// OLED-Initialisierung
|
|
Wire.begin(OLED_SDA, OLED_SCK);
|
|
if (!display.begin(0x3C, true)) { Serial.println(F("Display konnte nicht initialisiert werden!")); }
|
|
|
|
display.clearDisplay();
|
|
display.setCursor(0, 0); display.setTextColor(SH110X_WHITE); display.setTextSize(1);
|
|
display.println(infoHersteller); display.println(infoModell); display.println(infoZusatz);
|
|
display.println(""); display.println(F("Dual-PID")); display.print(F("Version: ")); display.println(version);
|
|
display.println(F("von Thomas M\201ller"));
|
|
display.display(); delay(delayInit1);
|
|
|
|
// --- PID-Regler Konfiguration ---
|
|
if (windowSizeWasser == 0 || windowSizeWasser > 60000) { windowSizeWasser = defaultWindowSizeWasser; }
|
|
if (windowSizeDampf == 0 || windowSizeDampf > 60000) { windowSizeDampf = defaultWindowSizeDampf; }
|
|
pidWasser.SetOutputLimits(0, windowSizeWasser);
|
|
pidDampf.SetOutputLimits(0, windowSizeDampf);
|
|
pidDampf.SetTunings(KpDampf, KiDampf, KdDampf);
|
|
pidWasser.SetTunings(KpWasser, KiWasser, KdWasser);
|
|
pidDampf.SetMode(AUTOMATIC);
|
|
pidWasser.SetMode(AUTOMATIC);
|
|
windowStartTimeWasser = millis();
|
|
windowStartTimeDampf = millis();
|
|
|
|
// Anzeige zur WiFi-Verbindung
|
|
display.clearDisplay();
|
|
display.setCursor(0, 0); display.setTextColor(SH110X_WHITE); display.setTextSize(1);
|
|
display.println(infoHersteller); display.println(infoModell); display.println(infoZusatz);
|
|
display.println("");
|
|
if (WiFi.status() != WL_CONNECTED) {
|
|
display.println(F("WiFi: AP-Modus")); display.print(F("SSID: ")); display.println(hostname);
|
|
display.print(F("IP: ")); display.println(WiFi.softAPIP());
|
|
} else {
|
|
display.println(F("Webserver gestartet")); display.print(F("IP: ")); display.println(WiFi.localIP());
|
|
display.print(F("Host: ")); display.print(hostname); display.println(".local");
|
|
}
|
|
display.display(); delay(delayInit2);
|
|
|
|
// --- LittleFS Initialisierung ---
|
|
if (!LittleFS.begin()) {
|
|
Serial.println("LittleFS Mount fehlgeschlagen!");
|
|
display.clearDisplay(); display.setCursor(0, 0);
|
|
display.println("FEHLER:"); display.println("LittleFS konnte"); display.println("nicht initialisiert"); display.println("werden!");
|
|
display.display(); while (1) delay(100);
|
|
} else {
|
|
Serial.println("LittleFS erfolgreich gemountet.");
|
|
Dir dir = LittleFS.openDir("/");
|
|
Serial.println("Dateien im LittleFS:");
|
|
while (dir.next()) {
|
|
Serial.print(" - "); Serial.print(dir.fileName()); Serial.print(" ("); Serial.print(dir.fileSize()); Serial.println(" Bytes)");
|
|
}
|
|
Serial.println("--------------------");
|
|
}
|
|
|
|
// Routen für AsyncWebServer
|
|
server.on("/style.css", HTTP_GET, handleCss);
|
|
// Hauptseite
|
|
server.on("/", HTTP_GET, handleRoot);
|
|
server.on("/updateSettings", HTTP_POST, handleSettingsUpdate);
|
|
// Info
|
|
server.on("/Info", HTTP_GET, handleInfo);
|
|
server.on("/updateInfoSettings", HTTP_POST, handleInfoUpdate);
|
|
server.on("/downloadNutzungsstatistik", HTTP_GET, handleDownloadNutzungsstatistik);
|
|
server.on("/deleteStatistics", HTTP_POST, handleDeleteStatistics);
|
|
server.on("/toggleWartungsmodus", HTTP_POST, handleToggleWartungsmodus); // NEUE ROUTE
|
|
// Service
|
|
server.on("/Service", HTTP_GET, handleService);
|
|
// AutoTune
|
|
server.on("/AutoTune-Wasser", HTTP_POST, handleAutoTuneWasser); // POST zum Starten
|
|
server.on("/AutoTune-Dampf", HTTP_POST, handleAutoTuneDampf); // POST zum Starten
|
|
server.on("/updateAutotuneSettings", HTTP_POST, handleUpdateAutotuneSettings);
|
|
server.on("/PID-Tuning-Abbruch", HTTP_POST, handlePidTuningAbbruch);
|
|
server.on("/PID-Tuning", HTTP_GET, handlePidTuning); // GET zum Anzeigen der Seite
|
|
// ECO-Modus
|
|
server.on("/ECO", HTTP_GET, handleEco);
|
|
server.on("/updateEcoSettings", HTTP_POST, handleEcoUpdate);
|
|
// Firmware
|
|
server.on("/Firmware", HTTP_GET, handleFirmware);
|
|
// Firmware Upload: GET zeigt Seite, POST startet Upload (Antwort nach Upload), onUpload verarbeitet Daten
|
|
server.on("/update", HTTP_POST, handleFirmwareUpdateResponse, handleFirmwareUploadProgress);
|
|
// Fast-Heat-Up
|
|
server.on("/Fast-Heat-Up", HTTP_GET, handleFastHeatUp);
|
|
server.on("/updateFast-Heat-Up-Settings", HTTP_POST, handleFastHeatUpSettings);
|
|
// Dateimanager
|
|
server.on("/Dateimanager", HTTP_GET, handleFileManager);
|
|
// Datei Upload: GET zeigt Seite (Dateimanager), POST startet Upload, onUpload verarbeitet, Response nach Upload
|
|
server.on("/Datei-Upload", HTTP_POST, handleFileUploadedResponse, handleFileUploadProgress);
|
|
server.on("/Datei-Entfernen", HTTP_GET, handleFileDelete);
|
|
server.on("/Datei-Download", HTTP_GET, handleFileDownload);
|
|
// Chart
|
|
server.on("/Chart-Daten", HTTP_GET, handleChartData);
|
|
server.on("/Chart", HTTP_GET, handleCharts);
|
|
server.on("/chart.umd.min.js", HTTP_GET, handleServeChartJs);
|
|
// Netzwerk / WiFi
|
|
server.on("/Netzwerk", HTTP_GET, handleWiFiConfig);
|
|
server.on("/saveWiFiConfig", HTTP_POST, handleSaveWiFiConfig);
|
|
server.on("/forceAPMode", HTTP_POST, handleForceAPMode);
|
|
// Profile
|
|
server.on("/Profile", HTTP_GET, handleProfiles);
|
|
server.on("/saveProfile1", HTTP_POST, handleSaveProfile1);
|
|
server.on("/loadProfile1", HTTP_POST, handleLoadProfile1);
|
|
server.on("/saveProfile2", HTTP_POST, handleSaveProfile2);
|
|
server.on("/loadProfile2", HTTP_POST, handleLoadProfile2);
|
|
// Einstellungen Import & Export + Reset
|
|
server.on("/exportSettings", HTTP_GET, handleExportSettings);
|
|
// Einstellungen Import: GET zeigt Firmware-Seite, POST startet Upload, onUpload verarbeitet, Response nach Upload
|
|
server.on("/importSettings", HTTP_POST, handleImportSettingsResponse, handleImportUpload);
|
|
server.on("/resetDefaults", HTTP_POST, handleResetDefaults);
|
|
// Zähler & Wartung
|
|
server.on("/updateMaintenanceSettings", HTTP_POST, handleMaintenanceUpdate);
|
|
server.on("/resetRuntime", HTTP_POST, handleResetRuntime);
|
|
server.on("/resetShots", HTTP_POST, handleResetShots);
|
|
server.on("/resetMaintenance", HTTP_POST, handleResetMaintenance);
|
|
|
|
// Not Found Handler
|
|
server.onNotFound([](AsyncWebServerRequest *request){
|
|
request->send(404, "text/plain", "Seite nicht gefunden");
|
|
});
|
|
|
|
// Webserver starten
|
|
server.begin();
|
|
Serial.println(F("Async Webserver gestartet"));
|
|
startupTime = millis();
|
|
}
|
|
|
|
/************************************************************************************
|
|
* loop(): Hauptschleife - Async angepasst (server.handleClient() entfernt)
|
|
************************************************************************************/
|
|
|
|
void loop() {
|
|
unsigned long currentMillis = millis();
|
|
|
|
// Prüfen, ob Zeit bereits synchronisiert wurde
|
|
if (!timeSynced && WiFi.status() == WL_CONNECTED && timeClient.update()) { timeSynced = true; }
|
|
|
|
// --- Temperaturmessung und PID-Berechnung (im Intervall) ---
|
|
if (currentMillis - previousMillis >= interval) {
|
|
previousMillis = currentMillis;
|
|
|
|
// Temperaturmessung
|
|
InputDampf = round(thermocouple.readCelsius() + OffsetDampf);
|
|
InputWasser = round(readNTCTemperature() + OffsetWasser);
|
|
|
|
// --- Angepasste Sicherheitsüberprüfung Wasser ---
|
|
if (InputWasser < 0.0 || isnan(InputWasser)) {
|
|
wasserSensorError = true; // Echter Sensorfehler
|
|
wasserSafetyShutdown = false; // Kein Shutdown-Grund, da Wert ungültig
|
|
OutputWasser = 0; // Heizen stoppen
|
|
if (!wasserSensorError) { // Nur einmal loggen, wenn Fehler neu auftritt
|
|
Serial.println("WARNUNG: Wassertemperatursensor liefert ungültigen Wert!");
|
|
}
|
|
} else if (InputWasser > maxTempWasser) {
|
|
wasserSensorError = false; // Sensor liefert ja gültigen Wert
|
|
wasserSafetyShutdown = true; // Sicherheitsabschaltung aktiv!
|
|
OutputWasser = 0; // Heizen stoppen
|
|
if (!wasserSafetyShutdown) { // Nur einmal loggen, wenn Shutdown neu auftritt
|
|
Serial.printf("WARNUNG: Wassertemperatur (%.1f°C) über Sicherheitslimit (%.1f°C)! Sicherheitsabschaltung.\n", InputWasser, maxTempWasser);
|
|
}
|
|
} else {
|
|
if (wasserSensorError) Serial.println("INFO: Wassertemperatursensor wieder OK.");
|
|
wasserSensorError = false;
|
|
if (wasserSafetyShutdown) Serial.println("INFO: Wassertemperatur wieder im sicheren Bereich.");
|
|
wasserSafetyShutdown = false;
|
|
// --- NEUE BOOST LOGIK (oder normale PID-Berechnung) ---
|
|
bool activateBoost = boostWasserActive
|
|
&& !wartungsModusAktiv
|
|
&& !ecoModeAktiv
|
|
&& !autoTuneWasserActive
|
|
&& (InputWasser < (SetpointWasser * 0.95));
|
|
|
|
if (activateBoost) { OutputWasser = windowSizeWasser; }
|
|
else if (!autoTuneWasserActive) { pidWasser.Compute(); }
|
|
}
|
|
|
|
// --- Angepasste Sicherheitsüberprüfung Dampf ---
|
|
if (isnan(InputDampf) || InputDampf < 0.0) {
|
|
dampfSensorError = true; // Echter Sensorfehler
|
|
dampfSafetyShutdown = false; // Kein Shutdown-Grund, da Wert ungültig
|
|
OutputDampf = 0; // Heizen stoppen
|
|
if (!dampfSensorError) { // Nur einmal loggen
|
|
Serial.println("WARNUNG: Dampftemperatursensor liefert ungültigen Wert!");
|
|
}
|
|
} else if (InputDampf > maxTempDampf) {
|
|
dampfSensorError = false; // Sensor liefert ja gültigen Wert
|
|
dampfSafetyShutdown = true; // Sicherheitsabschaltung aktiv!
|
|
OutputDampf = 0; // Heizen stoppen
|
|
if (!dampfSafetyShutdown) { // Nur einmal loggen
|
|
Serial.printf("WARNUNG: Dampftemperatur (%.1f°C) über Sicherheitslimit (%.1f°C)! Sicherheitsabschaltung.\n", InputDampf, maxTempDampf);
|
|
}
|
|
} else {
|
|
if (dampfSensorError) Serial.println("INFO: Dampftemperatursensor wieder OK.");
|
|
dampfSensorError = false;
|
|
if (dampfSafetyShutdown) Serial.println("INFO: Dampftemperatur wieder im sicheren Bereich.");
|
|
dampfSafetyShutdown = false;
|
|
|
|
bool steamDelayActive = (dampfVerzoegerung > 0 && (millis() - startupTime < (unsigned long)dampfVerzoegerung * 60000UL));
|
|
|
|
if (steamDelayActive && !wartungsModusAktiv) { OutputDampf = 0; }
|
|
else {
|
|
bool activateBoostDampf = boostDampfActive
|
|
&& !wartungsModusAktiv
|
|
&& !ecoModeAktiv
|
|
&& !autoTuneDampfActive
|
|
&& (InputDampf < (SetpointDampf * 0.90));
|
|
|
|
if (activateBoostDampf) { OutputDampf = windowSizeDampf; }
|
|
else if (!autoTuneDampfActive) { pidDampf.Compute(); }
|
|
}
|
|
}
|
|
// AutoTune-Logik
|
|
handleAutoTune();
|
|
}
|
|
|
|
// --- Zeitproportionale SSR-Ansteuerung ---
|
|
unsigned long now = millis();
|
|
|
|
// --- Wasser SSR ---
|
|
if (wasserSensorError || wasserSafetyShutdown) { digitalWrite(SSR_WASSER_PIN, LOW); }
|
|
else {
|
|
if (now - windowStartTimeWasser > windowSizeWasser) { windowStartTimeWasser += windowSizeWasser; }
|
|
bool pidWantsHeat = (OutputWasser > 0) && (now < (windowStartTimeWasser + (unsigned long)OutputWasser));
|
|
bool preventOverheatActive = (preventHeatAboveSetpointWasser && (InputWasser > SetpointWasser)) || (ecoModeAktiv && (InputWasser > SetpointWasser));
|
|
if (pidWantsHeat && !preventOverheatActive) { digitalWrite(SSR_WASSER_PIN, HIGH); }
|
|
else { digitalWrite(SSR_WASSER_PIN, LOW); }
|
|
}
|
|
|
|
// --- Dampf SSR ---
|
|
if (dampfSensorError || dampfSafetyShutdown) { digitalWrite(SSR_DAMPF_PIN, LOW); }
|
|
else {
|
|
if (now - windowStartTimeDampf > windowSizeDampf) { windowStartTimeDampf += windowSizeDampf; }
|
|
bool pidWantsHeat = (OutputDampf > 0) && (now < (windowStartTimeDampf + (unsigned long)OutputDampf));
|
|
bool preventOverheatActive = (preventHeatAboveSetpointDampf && (InputDampf > SetpointDampf)) || (ecoModeAktiv && (InputDampf > SetpointDampf));
|
|
if (pidWantsHeat && !preventOverheatActive) { digitalWrite(SSR_DAMPF_PIN, HIGH); }
|
|
else { digitalWrite(SSR_DAMPF_PIN, LOW); }
|
|
}
|
|
|
|
// Shot-Timer
|
|
updateShotTimer();
|
|
|
|
// Eco-Modus
|
|
if (!autoTuneWasserActive && !autoTuneDampfActive && !wartungsModusAktiv) {
|
|
if (ecoModeMinutes > 0 && !shotActive) {
|
|
unsigned long currentTimeEco = millis();
|
|
if (currentTimeEco - lastShotTime > (ecoModeMinutes * 60UL * 1000UL)) {
|
|
if (!ecoModeAktiv) { ecoModeActivatedTime = currentTimeEco; }
|
|
ecoModeAktiv = true;
|
|
if (dynamicEcoActive) {
|
|
int minutesPassed = (currentTimeEco - ecoModeActivatedTime) / (60UL * 1000UL);
|
|
SetpointWasser = (ecoModeTempWasser - minutesPassed > 0 ? ecoModeTempWasser - minutesPassed : 0);
|
|
SetpointDampf = (ecoModeTempDampf - minutesPassed > 0 ? ecoModeTempDampf - minutesPassed : 0);
|
|
} else {
|
|
SetpointWasser = ecoModeTempWasser; SetpointDampf = ecoModeTempDampf;
|
|
}
|
|
} else {
|
|
if (ecoModeAktiv) {
|
|
EEPROM.get(EEPROM_ADDR_SETPOINT_WASSER, SetpointWasser);
|
|
EEPROM.get(EEPROM_ADDR_SETPOINT_DAMPF, SetpointDampf);
|
|
}
|
|
ecoModeAktiv = false; ecoModeActivatedTime = 0;
|
|
}
|
|
} else if (ecoModeAktiv) {
|
|
ecoModeAktiv = false; ecoModeActivatedTime = 0;
|
|
EEPROM.get(EEPROM_ADDR_SETPOINT_WASSER, SetpointWasser);
|
|
EEPROM.get(EEPROM_ADDR_SETPOINT_DAMPF, SetpointDampf);
|
|
}
|
|
}
|
|
|
|
// Display regelmäßig updaten
|
|
updateDisplay();
|
|
// server.handleClient(); // Entfernt für AsyncWebServer
|
|
MDNS.update(); // mDNS-Anfragen bearbeiten (bleibt bestehen)
|
|
|
|
// Betriebszeit zählen
|
|
static unsigned long lastRuntimeSecond = 0;
|
|
if (millis() - lastRuntimeSecond >= 1000) { totalRuntime++; lastRuntimeSecond = millis(); }
|
|
|
|
// Speichern der Betriebszeit und WiFi-Check
|
|
if (!demoModus)
|
|
{
|
|
unsigned long currentMillisLoop = millis();
|
|
unsigned long intervalToUse = initialRuntimeSaveDone ? subsequentRuntimeSaveInterval : initialRuntimeSaveDelay;
|
|
|
|
if (currentMillisLoop - lastRuntimeSave >= intervalToUse) {
|
|
EEPROM.put(EEPROM_ADDR_RUNTIME, totalRuntime);
|
|
EEPROM.commit();
|
|
lastRuntimeSave = currentMillisLoop;
|
|
if (!initialRuntimeSaveDone) {
|
|
initialRuntimeSaveDone = true; Serial.println("Betriebszeit: Erstes Speichern nach 10 Minuten erfolgt.");
|
|
} else { Serial.println("Betriebszeit: Regelmäßiges Speichern (alle 5 Minuten) erfolgt."); }
|
|
if (WiFi.getMode() == WIFI_STA) { checkWifiConnection(); }
|
|
}
|
|
}
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Liest die Temperatur vom NTC-Sensor (Wasser) über den Spannungsteiler (ADC) - Unverändert
|
|
************************************************************************************/
|
|
|
|
double readNTCTemperature() {
|
|
int adcValue = analogRead(A0);
|
|
// Prüfen auf ungültige ADC-Werte (können bei Problemen auftreten)
|
|
if (adcValue <= 0 || adcValue >= 1023) // 1023 ist max. Wert, kann auf Kurzschluss hindeuten
|
|
{
|
|
Serial.print("WARNUNG: Ungültiger ADC-Wert vom NTC-Sensor: ");
|
|
Serial.println(adcValue);
|
|
return NAN; // Not-a-Number als Fehlerwert zurückgeben
|
|
}
|
|
|
|
double sensorVoltage = adcValue * (ADC_REF / 1023.0);
|
|
// Vermeide Division durch Null, falls sensorVoltage == V_SUPPLY
|
|
if (sensorVoltage >= V_SUPPLY) {
|
|
Serial.println("WARNUNG: NTC-Spannung entspricht Versorgungsspannung, R_ntc wäre unendlich.");
|
|
return NAN; // Fehler
|
|
}
|
|
// Vermeide Division durch Null, falls sensorVoltage == 0 (bereits oben abgefangen, aber zur Sicherheit)
|
|
if (sensorVoltage <= 0) {
|
|
Serial.println("WARNUNG: NTC-Spannung ist 0 oder negativ.");
|
|
return NAN; // Fehler
|
|
}
|
|
|
|
double R_ntc = R_FIXED * ((V_SUPPLY / sensorVoltage) - 1.0);
|
|
|
|
// Prüfen auf negativen oder sehr kleinen Widerstandswert
|
|
if (R_ntc <= 0) {
|
|
Serial.print("WARNUNG: Berechneter NTC-Widerstand ungültig: ");
|
|
Serial.println(R_ntc);
|
|
return NAN; // Fehler
|
|
}
|
|
|
|
// Temperaturberechnung über die Beta-Gleichung
|
|
// log() erwartet einen positiven Wert
|
|
double log_R_R0 = log(R_ntc / R0);
|
|
double temp_inv_K = (1.0 / T0) + (1.0 / beta) * log_R_R0;
|
|
|
|
// Prüfen auf Division durch Null bei der Invertierung
|
|
if (temp_inv_K == 0) {
|
|
Serial.println("WARNUNG: Kehrwert der Kelvin-Temperatur ist 0.");
|
|
return NAN; // Fehler
|
|
}
|
|
|
|
double temperatureK = 1.0 / temp_inv_K;
|
|
double temperatureC = temperatureK - 273.15;
|
|
|
|
// Optional: Plausibilitätsprüfung des Ergebnisses
|
|
// if (temperatureC < -50 || temperatureC > 200) { // Beispielgrenzen
|
|
// Serial.print("WARNUNG: Berechnete NTC-Temperatur unplausibel: ");
|
|
// Serial.println(temperatureC);
|
|
// return NAN;
|
|
// }
|
|
|
|
return temperatureC;
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Aktualisiert das Display (Temperaturanzeige, Shot-Timer, Wartung etc.) - Angepasst
|
|
* Priorität: PID Tuning > Fast Heat Up > Aktiver Shot > Letzte Shot-Zeit > Wartung > Temp/Shutdown/Fehler
|
|
************************************************************************************/
|
|
void updateDisplay() {
|
|
|
|
// 0. Höchste Priorität: Wartungsmodus aktiv? -> Eigene Anzeige, dann Ende.
|
|
if (wartungsModusAktiv) {
|
|
display.clearDisplay();
|
|
display.setCursor(0, 0);
|
|
display.setTextSize(1);
|
|
display.setTextColor(SH110X_WHITE);
|
|
display.println(F("Wartungsmodus"));
|
|
display.println(F("ist aktiv!"));
|
|
display.println(F(""));
|
|
display.println(F("Temperaturen werden"));
|
|
display.println(F("auf "));
|
|
display.print(wartungsModusTemp);
|
|
display.print(F(" "));
|
|
display.print((char)247); // Grad-Symbol
|
|
display.print(F("C gehalten."));
|
|
|
|
// WiFi Symbol trotzdem anzeigen, falls verbunden
|
|
if (WiFi.status() == WL_CONNECTED) {
|
|
drawwifiSymbol(113, 0);
|
|
}
|
|
display.display();
|
|
return; // Funktion hier beenden
|
|
}
|
|
|
|
// 1. Höchste Priorität: PID Tuning aktiv? -> Eigene Anzeige, dann Ende.
|
|
if (autoTuneWasserActive || autoTuneDampfActive) {
|
|
display.clearDisplay();
|
|
display.setCursor(0, 0);
|
|
display.setTextSize(1);
|
|
display.setTextColor(SH110X_WHITE);
|
|
display.println(F("PID-Tuning aktiv:"));
|
|
display.println(autoTuneWasserActive ? F("Wasser-PID") : F("Dampf-PID"));
|
|
display.println("");
|
|
|
|
// Statusvariablen abfragen und anzeigen
|
|
int currentPeakCount = 0;
|
|
int currentPeakType = 0;
|
|
if (autoTuneWasserActive && autoTuneWasser != nullptr) { // Sicherstellen, dass Objekt existiert
|
|
currentPeakCount = autoTuneWasser->getPeakCount();
|
|
currentPeakType = autoTuneWasser->getPeakType();
|
|
} else if (autoTuneDampfActive && autoTuneDampf != nullptr) { // Sicherstellen, dass Objekt existiert
|
|
currentPeakCount = autoTuneDampf->getPeakCount();
|
|
currentPeakType = autoTuneDampf->getPeakType();
|
|
}
|
|
display.print(F("Cycle: "));
|
|
if (currentPeakCount < 0 || currentPeakCount > 10) {
|
|
// Falls kleiner 0 oder größer 10 (kann bei Start vorkommen)
|
|
display.print(F("0"));
|
|
} else {
|
|
// Zeigt an, wie viele Zyklen/Phasen erkannt wurden
|
|
display.print(currentPeakCount);
|
|
}
|
|
|
|
display.print(F(" von 5-10"));
|
|
display.println(); // Zeilenumbruch
|
|
display.print(F("Phase:"));
|
|
if (currentPeakType == 1) {
|
|
display.print(F("Heizen")); // Letztes war/suche Maximum
|
|
} else if (currentPeakType == -1) {
|
|
display.print(F("K\201hlen")); // Letztes war/suche Minimum
|
|
} else {
|
|
display.print(F("Init")); // Initialisierungsphase
|
|
}
|
|
display.println(); // Zeilenumbruch
|
|
if (autoTuneWasserActive) {
|
|
display.print("Temperatur:");
|
|
display.print((int)InputWasser);
|
|
display.print(F(" "));
|
|
display.print((char)247); // Grad-Symbol
|
|
display.print(F("C"));
|
|
}
|
|
if (autoTuneDampfActive) {
|
|
display.print("Temperatur:");
|
|
display.print((int)InputDampf);
|
|
display.print(F(" "));
|
|
display.print((char)247); // Grad-Symbol
|
|
display.print(F("C"));
|
|
}
|
|
// WiFi Symbol trotzdem anzeigen, falls verbunden
|
|
if (WiFi.status() == WL_CONNECTED) {
|
|
drawwifiSymbol(113, 0);
|
|
}
|
|
display.display();
|
|
return; // Funktion hier beenden
|
|
}
|
|
|
|
// --- Keine Tuning-Anzeige ---
|
|
display.clearDisplay();
|
|
|
|
// WiFi Symbol (immer anzeigen, wenn verbunden)
|
|
if (WiFi.status() == WL_CONNECTED) {
|
|
drawwifiSymbol(113, 0);
|
|
}
|
|
|
|
display.setCursor(0, 0);
|
|
display.setTextColor(SH110X_WHITE);
|
|
display.setTextSize(1);
|
|
|
|
// 2. Priorität: Fast-Heat-Up aktiv und relevant?
|
|
if (fastHeatUpHeating && !shotActive && !wasserSensorError && ((int)InputWasser < fastHeatUpSetpoint)) {
|
|
SetpointWasser = fastHeatUpSetpoint; // Setpoint temporär anpassen für Anzeige
|
|
display.println(F("Fast-Heat-Up aktiv:"));
|
|
display.println("");
|
|
display.println(F("20 Sek. Flushen,"));
|
|
display.println(F("wenn Temp. erreicht!"));
|
|
display.println(F(" ")); // Leere Zeile
|
|
display.println(F("Temperatur: "));
|
|
display.print((int)InputWasser);
|
|
display.print(F(" / "));
|
|
display.print((int)SetpointWasser); // Zeigt den F-H-U Setpoint
|
|
display.print(F(" "));
|
|
display.print((char)247); // Grad-Symbol
|
|
display.print(F("C"));
|
|
// Hier keine Dampfanzeige während Fast-Heat-Up, um Platz zu sparen
|
|
}
|
|
// 3. Kein Fast-Heat-Up: Was soll sonst angezeigt werden?
|
|
else {
|
|
// 3a. Priorität: Shot läuft *aktuell*?
|
|
if (shotActive) {
|
|
unsigned long elapsed = millis() - shotStartTime;
|
|
display.println(F("Shot-Timer:"));
|
|
display.println("");
|
|
display.setTextSize(3); // Größere Schrift für den Timer
|
|
// Zeige nur eine Nachkommastelle an
|
|
char buffer[6]; // Puffer für "xx.y" + Nullterminator
|
|
snprintf(buffer, sizeof(buffer), "%.1f", elapsed / 1000.0);
|
|
display.println(buffer);
|
|
display.setTextSize(1); // Zurück zur normalen Schriftgröße
|
|
display.println(F("Sekunden"));
|
|
fastHeatUpHeating = false; // Laufender Shot beendet F-H-U Anzeige visuell
|
|
}
|
|
// 3b. Priorität: Letzte Shot-Zeit anzeigen (für 2 Sekunden)?
|
|
else if (shotEndTime > 0 && millis() < shotEndTime + 2000) {
|
|
display.println(F("Bezugszeit:"));
|
|
display.println("");
|
|
display.setTextSize(3); // Größere Schrift
|
|
// Zeige nur eine Nachkommastelle an
|
|
char buffer[6];
|
|
snprintf(buffer, sizeof(buffer), "%.1f", lastShotDurationMillis / 1000.0);
|
|
display.println(buffer);
|
|
display.setTextSize(1); // Zurück zur normalen Schriftgröße
|
|
display.println(F("Sekunden"));
|
|
}
|
|
// 3c. Priorität: Wartungserinnerung anzeigen (für 6 Sekunden nach Trigger)
|
|
// Diese Bedingung wird nur erreicht, wenn kein Shot aktiv ist UND die letzte Shot-Zeit nicht angezeigt wird.
|
|
else if (displayMaintenanceMessage && millis() < maintenanceMessageStartTime + 6000) {
|
|
display.println(F("Erinnerung:")); // Titel
|
|
display.println(F("Reinigung /")); // Zeile 1
|
|
display.println(F("Wartung fällig!")); // Zeile 2
|
|
// Restliche Zeilen leer lassen oder für Details nutzen
|
|
display.println("");
|
|
display.println("");
|
|
display.println("");
|
|
}
|
|
// 3d. Standardanzeige: Temperaturen / Fehler / Sicherheitsabschaltung
|
|
else {
|
|
display.println(F("Temperaturen:")); // Titelzeile
|
|
display.println(""); // Leerzeile
|
|
|
|
// Wasser Temperatur / Sicherheitsabschaltung / Fehleranzeige
|
|
display.println(F("Wasser: ")); // Print, kein Zeilenumbruch
|
|
if (wasserSafetyShutdown) { // Prüfung 1: Sicherheitsabschaltung
|
|
display.print(F("Sicherheitsabsch."));
|
|
} else if (wasserSensorError) { // Prüfung 2: Echter Sensorfehler
|
|
display.print(F("Sensorfehler!"));
|
|
} else { // Prüfung 3: Alles OK -> Temperatur anzeigen
|
|
display.print((int)InputWasser);
|
|
display.print(F(" / "));
|
|
display.print((int)SetpointWasser);
|
|
display.print(F(" "));
|
|
display.print((char)247); // Grad-Symbol
|
|
display.print(F("C"));
|
|
// ECO-Modus Anzeige anhängen, falls aktiv
|
|
if (ecoModeAktiv && dynamicEcoActive) display.print(F(" (ECO+)"));
|
|
else if (ecoModeAktiv && !dynamicEcoActive) display.print(F(" (ECO)"));
|
|
}
|
|
display.println(""); // Zeilenumbruch nach der Wasserzeile
|
|
display.println(""); // Leere Zeile für Abstand
|
|
|
|
// Dampf Temperatur / Sicherheitsabschaltung / Fehleranzeige
|
|
display.println(F("Dampf: ")); // Print, kein Zeilenumbruch, 2 Leerzeichen für Ausrichtung
|
|
if (dampfSafetyShutdown) { // Prüfung 1: Sicherheitsabschaltung
|
|
display.print(F("Sicherheitsabsch."));
|
|
} else if (dampfSensorError) { // Prüfung 2: Echter Sensorfehler
|
|
display.print(F("Sensorfehler!"));
|
|
} else { // Prüfung 3: Alles OK -> Temperatur anzeigen (oder Verzögerung)
|
|
// Prüfen auf Startverzögerung (wie vorher)
|
|
bool steamDelayActive = (dampfVerzoegerung > 0 && (millis() - startupTime < (unsigned long)dampfVerzoegerung * 60000UL));
|
|
if (!steamDelayActive) // Wenn keine Verzögerung aktiv ist
|
|
{
|
|
display.print((int)InputDampf);
|
|
display.print(F(" / "));
|
|
display.print((int)SetpointDampf);
|
|
display.print(F(" "));
|
|
display.print((char)247); // Grad-Symbol
|
|
display.print(F("C"));
|
|
// ECO-Modus Anzeige anhängen, falls aktiv
|
|
if (ecoModeAktiv && dynamicEcoActive) display.print(F(" (ECO+)"));
|
|
else if (ecoModeAktiv && !dynamicEcoActive) display.print(F(" (ECO)"));
|
|
} else { // Wenn Startverzögerung aktiv ist
|
|
display.print(F("Startverz\x94gerung"));
|
|
}
|
|
}
|
|
// Kein println() am Ende der letzten Zeile nötig
|
|
} // Ende Standardanzeige (Temperaturen etc.)
|
|
} // Ende "Kein Fast-Heat-Up"
|
|
display.display(); // Display *immer* am Ende aktualisieren, egal was angezeigt wurde
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Verwaltet den Shot-Timer (wenn z.B. der Nutzer den Bezug aktiviert) - Wartungscheck hinzugefügt
|
|
************************************************************************************/
|
|
|
|
void updateShotTimer() {
|
|
// Wenn Wartungsmodus aktiv ist, diese Funktion sofort verlassen
|
|
if (wartungsModusAktiv) {
|
|
// Sicherstellen, dass ein evtl. laufender Shot als beendet gilt,
|
|
// falls der Modus während eines Shots aktiviert wird.
|
|
if (shotActive) {
|
|
shotActive = false;
|
|
shotStartTime = 0; // Zurücksetzen für Sauberkeit
|
|
shotEndTime = 0;
|
|
lastShotDurationMillis = 0;
|
|
}
|
|
return; // Verhindert die restliche Logik der Funktion
|
|
}
|
|
|
|
if (digitalRead(SHOT_TIMER_PIN) == HIGH) // Annahme: HIGH = Bezug aktiv
|
|
{
|
|
// Shot beginnt
|
|
if (!shotActive) {
|
|
shotActive = true;
|
|
shotStartTime = millis();
|
|
lastShotDurationMillis = 0; // Dauer für neuen Shot zurücksetzen
|
|
shotEndTime = 0; // Endzeit für neuen Shot zurücksetzen
|
|
displayMaintenanceMessage = false; // Sicherstellen, dass alte Meldung weg ist
|
|
}
|
|
} else // Annahme: LOW = Bezug inaktiv
|
|
{
|
|
// Shot endet
|
|
if (shotActive) {
|
|
unsigned long shotDuration = millis() - shotStartTime;
|
|
lastShotDurationMillis = shotDuration; // *** Letzte Dauer speichern ***
|
|
shotEndTime = millis(); // *** Endzeitpunkt speichern ***
|
|
|
|
// nur Shots > 20 Sekunden zählen
|
|
if (shotDuration > 20000) {
|
|
shotCounter++;
|
|
maintenanceIntervalCounter++;
|
|
|
|
// Shot in Log schreiben
|
|
logShot(shotDuration);
|
|
|
|
if (!demoModus) { // Nur speichern, wenn kein Demo-Modus
|
|
EEPROM.put(EEPROM_ADDR_SHOTCOUNTER, shotCounter);
|
|
EEPROM.put(EEPROM_ADDR_MAINTENANCE_INTERVAL_COUNTER, maintenanceIntervalCounter);
|
|
EEPROM.commit();
|
|
}
|
|
Serial.print(F("Shots: "));
|
|
Serial.println(shotCounter);
|
|
|
|
// Prüfen, ob Wartungsintervall erreicht ist
|
|
if (maintenanceInterval > 0 && maintenanceIntervalCounter >= maintenanceInterval) {
|
|
displayMaintenanceMessage = true; // Flag für Anzeige setzen
|
|
maintenanceMessageStartTime = millis(); // Startzeit für Anzeige merken
|
|
Serial.println("Wartungsintervall erreicht!");
|
|
}
|
|
}
|
|
shotActive = false; // Shot als beendet markieren
|
|
lastShotTime = millis(); // Wichtig für Eco-Modus (bleibt wie es ist)
|
|
// shotEndTime und delayDisplayUpdate werden nicht mehr benötigt (bzw. shotEndTime hat neue Bedeutung)
|
|
}
|
|
}
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Startet AutoTune für Wasser-PID (Angepasst für Zeitproportional)
|
|
************************************************************************************/
|
|
|
|
void startAutoTuneWasser() {
|
|
// Eco-Modus deaktivieren, falls aktiv
|
|
if (ecoModeAktiv) {
|
|
ecoModeAktiv = false;
|
|
// Ursprünglichen Setpoint wiederherstellen (aus EEPROM oder Profil)
|
|
EEPROM.get(EEPROM_ADDR_SETPOINT_WASSER, SetpointWasser);
|
|
// Optional: Auch Dampf-Setpoint wiederherstellen, falls Eco beide beeinflusst
|
|
EEPROM.get(EEPROM_ADDR_SETPOINT_DAMPF, SetpointDampf);
|
|
}
|
|
|
|
// Stelle sicher, dass der PID im Automatikmodus ist bevor Tuning beginnt
|
|
pidWasser.SetMode(AUTOMATIC);
|
|
|
|
// Sicherstellen, dass die Output-Grenzen korrekt gesetzt sind
|
|
pidWasser.SetOutputLimits(0, windowSizeWasser);
|
|
|
|
autoTuneWasser = new PID_ATune(&InputWasser, &OutputWasser);
|
|
// Verwende die Wasser-spezifischen Parameter
|
|
autoTuneWasser->SetOutputStep(tuningStepWasser); // Angepasst
|
|
autoTuneWasser->SetControlType(1); // DIRECT control (heating)
|
|
autoTuneWasser->SetNoiseBand(tuningNoiseWasser); // Angepasst
|
|
autoTuneWasser->SetLookbackSec((int)tuningLookBackWasser); // Angepasst (Cast zu int für Funktion)
|
|
|
|
// Setze den Startwert für den Output
|
|
// WICHTIG: AutoTune manipuliert OutputWasser direkt. Die zeitproportionale
|
|
// Logik in loop() wird diesen Wert verwenden, um den SSR zu steuern.
|
|
OutputWasser = tuningStartValueWasser; // Angepasst
|
|
|
|
// KEIN direktes digitalWrite mehr hier! Die loop() übernimmt das.
|
|
|
|
autoTuneWasserActive = true;
|
|
Serial.println("Starte AutoTune für Wasser (Zeitproportional)...");
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Startet AutoTune für Dampf-PID (Angepasst für Zeitproportional)
|
|
************************************************************************************/
|
|
|
|
void startAutoTuneDampf() {
|
|
// Eco-Modus deaktivieren, falls aktiv
|
|
if (ecoModeAktiv) {
|
|
ecoModeAktiv = false;
|
|
// Ursprünglichen Setpoint wiederherstellen (aus EEPROM oder Profil)
|
|
EEPROM.get(EEPROM_ADDR_SETPOINT_DAMPF, SetpointDampf);
|
|
// Optional: Auch Wasser-Setpoint wiederherstellen, falls Eco beide beeinflusst
|
|
EEPROM.get(EEPROM_ADDR_SETPOINT_WASSER, SetpointWasser);
|
|
}
|
|
|
|
// Stelle sicher, dass der PID im Automatikmodus ist bevor Tuning beginnt
|
|
pidDampf.SetMode(AUTOMATIC);
|
|
|
|
// Sicherstellen, dass die Output-Grenzen korrekt gesetzt sind
|
|
pidDampf.SetOutputLimits(0, windowSizeDampf);
|
|
|
|
autoTuneDampf = new PID_ATune(&InputDampf, &OutputDampf);
|
|
// Verwende die Dampf-spezifischen Parameter
|
|
autoTuneDampf->SetOutputStep(tuningStepDampf); // Angepasst
|
|
autoTuneDampf->SetControlType(1); // DIRECT control (heating)
|
|
autoTuneDampf->SetNoiseBand(tuningNoiseDampf); // Angepasst
|
|
autoTuneDampf->SetLookbackSec((int)tuningLookBackDampf); // Angepasst (Cast zu int für Funktion)
|
|
|
|
// Setze den Startwert für den Output
|
|
// WICHTIG: AutoTune manipuliert OutputDampf direkt. Die zeitproportionale
|
|
// Logik in loop() wird diesen Wert verwenden, um den SSR zu steuern.
|
|
OutputDampf = tuningStartValueDampf; // Angepasst
|
|
|
|
// KEIN direktes digitalWrite mehr hier! Die loop() übernimmt das.
|
|
|
|
autoTuneDampfActive = true;
|
|
Serial.println("Starte AutoTune für Dampf (Zeitproportional)...");
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Stoppt AutoTune für Wasser - Unverändert
|
|
************************************************************************************/
|
|
|
|
void stopAutoTuneWasser() {
|
|
if (autoTuneWasserActive) {
|
|
autoTuneWasserActive = false;
|
|
delete autoTuneWasser;
|
|
autoTuneWasser = nullptr;
|
|
// Setze PID zurück in den Normalbetrieb (ggf. Output auf 0)
|
|
pidWasser.SetMode(AUTOMATIC); // Sicherstellen, dass PID wieder normal läuft
|
|
OutputWasser = 0; // Optional: Output zurücksetzen
|
|
// Stelle sicher, dass SSR ausgeschaltet ist
|
|
digitalWrite(SSR_WASSER_PIN, LOW);
|
|
Serial.println("AutoTune Wasser gestoppt.");
|
|
}
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Stoppt AutoTune für Dampf - Unverändert
|
|
************************************************************************************/
|
|
|
|
void stopAutoTuneDampf() {
|
|
if (autoTuneDampfActive) {
|
|
autoTuneDampfActive = false;
|
|
delete autoTuneDampf;
|
|
autoTuneDampf = nullptr;
|
|
// Setze PID zurück in den Normalbetrieb (ggf. Output auf 0)
|
|
pidDampf.SetMode(AUTOMATIC); // Sicherstellen, dass PID wieder normal läuft
|
|
OutputDampf = 0; // Optional: Output zurücksetzen
|
|
// Stelle sicher, dass SSR ausgeschaltet ist
|
|
digitalWrite(SSR_DAMPF_PIN, LOW);
|
|
Serial.println("AutoTune Dampf gestoppt.");
|
|
}
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Überwacht die AutoTune-Prozesse (Dampf/Wasser)
|
|
* - Prüft auf Sensorfehler ODER Sicherheitsabschaltung vor Ausführung
|
|
* - Display-Logik ist in updateDisplay() ausgelagert
|
|
************************************************************************************/
|
|
void handleAutoTune() {
|
|
// --- AutoTune Wasser ---
|
|
if (autoTuneWasserActive) {
|
|
// Erweiterte Prüfung auf Sensorfehler ODER Sicherheitsabschaltung während des Tunings
|
|
if (wasserSensorError || wasserSafetyShutdown) {
|
|
// Logge den spezifischen Grund für den Abbruch
|
|
if (wasserSensorError) {
|
|
Serial.println("FEHLER: Wassertemperatursensor während AutoTune ausgefallen! Breche Tuning ab.");
|
|
} else { // Muss wasserSafetyShutdown sein
|
|
Serial.println("WARNUNG: Sicherheitslimit Wasser während AutoTune überschritten! Breche Tuning ab.");
|
|
}
|
|
stopAutoTuneWasser(); // Ruft Funktion auf, die Flag zurücksetzt, Speicher freigibt und SSR ausschaltet
|
|
return; // Verlasse die Funktion für diesen Durchlauf, um Runtime() nicht auszuführen
|
|
}
|
|
|
|
// Nur wenn kein Fehler/Shutdown vorliegt, führe AutoTune->Runtime() aus.
|
|
// Diese Funktion berechnet und SETZT OutputWasser für den nächsten Schritt!
|
|
if (autoTuneWasser->Runtime() == 1) // Runtime() gibt 1 zurück, wenn Tuning abgeschlossen
|
|
{
|
|
// Tuning abgeschlossen, Werte holen
|
|
KpWasser = autoTuneWasser->GetKp();
|
|
KiWasser = autoTuneWasser->GetKi();
|
|
KdWasser = autoTuneWasser->GetKd();
|
|
|
|
// WICHTIG: PID-Tunings sofort anwenden
|
|
pidWasser.SetTunings(KpWasser, KiWasser, KdWasser);
|
|
|
|
// Neue Werte im EEPROM speichern
|
|
EEPROM.put(EEPROM_ADDR_KP_WASSER, KpWasser);
|
|
EEPROM.put(EEPROM_ADDR_KI_WASSER, KiWasser);
|
|
EEPROM.put(EEPROM_ADDR_KD_WASSER, KdWasser);
|
|
EEPROM.commit();
|
|
|
|
Serial.println("AutoTune Wasser erfolgreich abgeschlossen.");
|
|
Serial.printf("Neue Werte: Kp=%.2f, Ki=%.2f, Kd=%.2f\n", KpWasser, KiWasser, KdWasser);
|
|
|
|
// AutoTune-Prozess korrekt beenden
|
|
stopAutoTuneWasser();
|
|
}
|
|
// Hinweis: Die Display-Anzeige für laufendes Tuning wird in updateDisplay() gehandhabt.
|
|
}
|
|
|
|
// --- AutoTune Dampf ---
|
|
if (autoTuneDampfActive) {
|
|
// Erweiterte Prüfung auf Sensorfehler ODER Sicherheitsabschaltung während des Tunings
|
|
if (dampfSensorError || dampfSafetyShutdown) {
|
|
// Logge den spezifischen Grund für den Abbruch
|
|
if (dampfSensorError) {
|
|
Serial.println("FEHLER: Dampftemperatursensor während AutoTune ausgefallen! Breche Tuning ab.");
|
|
} else { // Muss dampfSafetyShutdown sein
|
|
Serial.println("WARNUNG: Sicherheitslimit Dampf während AutoTune überschritten! Breche Tuning ab.");
|
|
}
|
|
stopAutoTuneDampf(); // Ruft Funktion auf, die Flag zurücksetzt, Speicher freigibt und SSR ausschaltet
|
|
return; // Verlasse die Funktion für diesen Durchlauf, um Runtime() nicht auszuführen
|
|
}
|
|
|
|
// Nur wenn kein Fehler/Shutdown vorliegt, führe AutoTune->Runtime() aus.
|
|
// Diese Funktion berechnet und SETZT OutputDampf für den nächsten Schritt!
|
|
if (autoTuneDampf->Runtime() == 1) // Runtime() gibt 1 zurück, wenn Tuning abgeschlossen
|
|
{
|
|
// Tuning abgeschlossen, Werte holen
|
|
KpDampf = autoTuneDampf->GetKp();
|
|
KiDampf = autoTuneDampf->GetKi();
|
|
KdDampf = autoTuneDampf->GetKd();
|
|
|
|
// WICHTIG: PID-Tunings sofort anwenden
|
|
pidDampf.SetTunings(KpDampf, KiDampf, KdDampf);
|
|
|
|
// Neue Werte im EEPROM speichern
|
|
EEPROM.put(EEPROM_ADDR_KP_DAMPF, KpDampf);
|
|
EEPROM.put(EEPROM_ADDR_KI_DAMPF, KiDampf);
|
|
EEPROM.put(EEPROM_ADDR_KD_DAMPF, KdDampf);
|
|
EEPROM.commit();
|
|
|
|
Serial.println("AutoTune Dampf erfolgreich abgeschlossen.");
|
|
Serial.printf("Neue Werte: Kp=%.2f, Ki=%.2f, Kd=%.2f\n", KpDampf, KiDampf, KdDampf);
|
|
|
|
// AutoTune-Prozess korrekt beenden
|
|
stopAutoTuneDampf();
|
|
}
|
|
// Hinweis: Die Display-Anzeige für laufendes Tuning wird in updateDisplay() gehandhabt.
|
|
}
|
|
}
|
|
|
|
/************************************************************************************
|
|
* PROGMEM Chunks für die Info-Seite (/Info)
|
|
************************************************************************************/
|
|
|
|
// --- Kopfzeile ---
|
|
static const char infoHtmlHead[] PROGMEM = R"rawliteral(
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<title>Info</title><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'>
|
|
)rawliteral";
|
|
static const char infoHtmlHeadEnd[] PROGMEM = R"rawliteral(
|
|
</head>
|
|
)rawliteral";
|
|
|
|
// --- Geräteinfo Formular ---
|
|
static const char infoChunk_BodyStart[] PROGMEM = R"rawliteral(
|
|
<body>
|
|
<h1>Info</h1>
|
|
<form action='/updateInfoSettings' method='POST'>
|
|
<h3>Geräteinfo</h3>
|
|
Die Geräteinformationen werden beim Start der Maschine, bzw. PID-Controllers im Display angezeigt.
|
|
<br><br>
|
|
<label for='hersteller'>Hersteller:</label>
|
|
<input type='text' id='hersteller' name='hersteller' value=')rawliteral"; // Endet vor Hersteller-Wert
|
|
static const char infoChunk_AfterHersteller[] PROGMEM = R"rawliteral('>
|
|
<label for='modell'>Modell:</label>
|
|
<input type='text' id='modell' name='modell' value=')rawliteral"; // Endet vor Modell-Wert
|
|
static const char infoChunk_AfterModell[] PROGMEM = R"rawliteral('>
|
|
<label for='zusatz'>Zusatz (z.B. Limited Edition):</label>
|
|
<input type='text' id='zusatz' name='zusatz' value=')rawliteral"; // Endet vor Zusatz-Wert
|
|
static const char infoChunk_AfterZusatz[] PROGMEM = R"rawliteral('>
|
|
<input type='submit' value='Einstellungen speichern'>
|
|
</form>
|
|
)rawliteral"; // Ende Geräteinfo-Formular
|
|
|
|
// --- Betriebszeit Reset Formular ---
|
|
static const char infoChunk_RuntimeResetForm[] PROGMEM = R"rawliteral(
|
|
<form action='/resetRuntime' method='POST'>
|
|
<h3>Betriebszeit:</h3>
|
|
)rawliteral"; // Endet vor formatierter Betriebszeit
|
|
static const char infoChunk_AfterRuntime[] PROGMEM = R"rawliteral(<br>
|
|
<input type='submit' value='Zurücksetzen'>
|
|
</form>
|
|
)rawliteral"; // Ende Betriebszeit-Reset-Formular
|
|
|
|
// --- Shot Zähler Reset Formular ---
|
|
static const char infoChunk_ShotCounterResetForm[] PROGMEM = R"rawliteral(
|
|
<form action='/resetShots' method='POST'>
|
|
<h3>Shots: (Bezüge über 20 Sekunden)</h3>
|
|
Anzahl: )rawliteral"; // Endet vor Shot-Zähler-Wert
|
|
static const char infoChunk_ShotCounterFormEnd[] PROGMEM = R"rawliteral(<br>
|
|
<input type='submit' value='Zurücksetzen'>
|
|
</form>
|
|
)rawliteral"; // Ende Shot-Zähler-Reset-Formular
|
|
|
|
// --- Statistik Chunks ---
|
|
static const char infoChunk_StatsStart[] PROGMEM = R"rawliteral(
|
|
<form method='GET' action='/downloadNutzungsstatistik' target='_blank'enctype='multipart/form-data'>
|
|
<h3>Statistik</h3>
|
|
<p>
|
|
)rawliteral"; // Start Statistik-Sektion
|
|
static const char infoChunk_StatsTotal[] PROGMEM = R"rawliteral(Bezüge in der Statistik: )rawliteral";
|
|
static const char infoChunk_StatsAvg[] PROGMEM = R"rawliteral(<br>Durchschnittliche Bezugsdauer: )rawliteral";
|
|
static const char infoChunk_StatsAvgPerDay[] PROGMEM = R"rawliteral(<br>Durchschnittliche Bezüge pro Tag: )rawliteral";
|
|
|
|
static const char infoChunk_StatsToday[] PROGMEM = R"rawliteral(<br><br><b>Anzahl Bezüge:</b></br>Heute: )rawliteral";
|
|
static const char infoChunk_StatsYesterday[] PROGMEM = R"rawliteral(<br>Gestern: )rawliteral";
|
|
static const char infoChunk_StatsWeek[] PROGMEM = R"rawliteral(<br>Diese Woche: )rawliteral";
|
|
static const char infoChunk_StatsLastWeek[] PROGMEM = R"rawliteral(<br>Letzte Woche: )rawliteral";
|
|
static const char infoChunk_StatsMonth[] PROGMEM = R"rawliteral(<br>Dieses Monat: )rawliteral";
|
|
static const char infoChunk_StatsLastMonth[] PROGMEM = R"rawliteral(<br>Letzes Monat: )rawliteral";
|
|
static const char infoChunk_StatsFirst[] PROGMEM = R"rawliteral(<br><br>Erster geloggter Bezug: )rawliteral";
|
|
|
|
static const char infoChunk_StatsLast[] PROGMEM = R"rawliteral(<br>Letzter geloggter Bezug: )rawliteral";
|
|
static const char infoChunk_StatsTimeError[] PROGMEM = R"rawliteral(<br><small>(Datum/Zeit-basierte Zähler benötigen aktive WLAN-Verbindung und NTP-Synchronisation)</small>)rawliteral";
|
|
// --- Statistik Download
|
|
static const char infoChunk_StatsDownloadButton[] PROGMEM = R"rawliteral(
|
|
<br><button type='submit' >Nutzungsverlauf herunterladen</button>
|
|
)rawliteral";
|
|
// --- Statistik Löschen
|
|
static const char infoChunk_DeleteStatsForm[] PROGMEM = R"rawliteral(
|
|
<form action='/deleteStatistics' method='POST' onsubmit='return confirm("Sicher, dass die aktuelle Nutzungsstatistik (Nutzungsstatistik.csv) entfernt werden soll?");'>
|
|
<h3>Nutzungsstatistik zurücksetzen</h3>
|
|
Die aktuelle Statistik wird gelöscht und es kann eine neue Statistik begonnen werden.</br>
|
|
<button type='submit' class='danger'>Zurücksetzen</button>
|
|
</form>
|
|
)rawliteral";
|
|
static const char infoChunk_StatsEnd[] PROGMEM = R"rawliteral(
|
|
</form>
|
|
)rawliteral"; // Ende Statistik-Sektion (mit Verlauf)
|
|
static const char infoChunk_StatsNotAvailable[] PROGMEM = R"rawliteral(
|
|
<form>
|
|
<h3>Shot-Verlauf Statistik</h3>
|
|
<p>Kein Shot-Verlauf gefunden oder Datei ist leer.</p>
|
|
<p><small>(Bezüge werden erst nach erfolgreicher NTP-Zeitsynchronisation geloggt.<br>Hierzu wird eine Internetverbindung benötigt!)</small></p>
|
|
</form>
|
|
)rawliteral"; // Meldung, falls kein Verlauf da
|
|
|
|
// --- Systeminfo Chunks (Angepasst für NTP-Status) ---
|
|
static const char infoChunk_SysInfoStart[] PROGMEM = R"rawliteral(
|
|
<form>
|
|
<h3>Systeminfo</h3>
|
|
Freier Heap: )rawliteral"; // Endet VOR dem Heap-Wert
|
|
// NEU/Angepasst: Nach dem Heap-Wert und vor dem NTP-Statuswert
|
|
static const char infoChunk_AfterFreeHeap[] PROGMEM = R"rawliteral( Bytes<br>
|
|
NTP Zeit synchronisiert: )rawliteral"; // Endet VOR dem NTP-Status (Ja/Nein)
|
|
// NEU: Nach dem NTP-Statuswert und vor der SDK-Version
|
|
static const char infoChunk_AfterNTPStatus[] PROGMEM = R"rawliteral(<br>
|
|
SDK-Version: )rawliteral"; // Endet VOR dem SDK-Wert
|
|
|
|
// Bestehende Chunks für restliche Systeminfos
|
|
static const char infoChunk_AfterSDK[] PROGMEM = R"rawliteral(<br>
|
|
Core-Version: )rawliteral";
|
|
static const char infoChunk_AfterCore[] PROGMEM = R"rawliteral(<br>
|
|
Boot-Version: )rawliteral";
|
|
static const char infoChunk_AfterBoot[] PROGMEM = R"rawliteral(<br>
|
|
Chip-ID: )rawliteral";
|
|
static const char infoChunk_AfterChipID[] PROGMEM = R"rawliteral(<br>
|
|
CPU-Takt: )rawliteral";
|
|
static const char infoChunk_AfterCPU[] PROGMEM = R"rawliteral( MHz<br>
|
|
Letzter Reset-Grund: )rawliteral";
|
|
static const char infoChunk_AfterResetReason[] PROGMEM = R"rawliteral(<br>
|
|
<br>
|
|
Sketch-Größe: )rawliteral";
|
|
static const char infoChunk_AfterSketchSize[] PROGMEM = R"rawliteral( Bytes<br>
|
|
Freier Sketch-Speicher: )rawliteral";
|
|
static const char infoChunk_AfterFreeSketch[] PROGMEM = R"rawliteral( Bytes<br>
|
|
Flash-Größe (Chip): )rawliteral";
|
|
static const char infoChunk_End[] PROGMEM = R"rawliteral( Bytes<br>
|
|
</form>
|
|
</body>
|
|
</html>
|
|
)rawliteral"; // Ende Systeminfo und HTML-Seite
|
|
|
|
/************************************************************************************
|
|
* Handler für die Info-Seite - Inkl. NTP-Status, Download-Button,
|
|
* neuer Statistiken und Lösch-Button
|
|
************************************************************************************/
|
|
void handleInfo(AsyncWebServerRequest *request)
|
|
{
|
|
char buffer[40];
|
|
char dateBuffer[25];
|
|
char tempStringCopyBuffer[50];
|
|
|
|
AsyncResponseStream *response = request->beginResponseStream("text/html");
|
|
|
|
// --- Kopfzeile, Styles, Navigation senden ---
|
|
response->print(FPSTR(infoHtmlHead));
|
|
response->print("<link rel=\"stylesheet\" href=\"/style.css\">\n");
|
|
response->print(FPSTR(infoHtmlHeadEnd));
|
|
response->print(FPSTR(commonNav));
|
|
|
|
// --- Geräteinfo Formular ---
|
|
response->print(FPSTR(infoChunk_BodyStart));
|
|
strncpy(tempStringCopyBuffer, infoHersteller, sizeof(tempStringCopyBuffer) - 1); tempStringCopyBuffer[sizeof(tempStringCopyBuffer) - 1] = '\0';
|
|
if (strlen(tempStringCopyBuffer) > 0) { response->print(tempStringCopyBuffer); }
|
|
response->print(FPSTR(infoChunk_AfterHersteller));
|
|
|
|
strncpy(tempStringCopyBuffer, infoModell, sizeof(tempStringCopyBuffer) - 1); tempStringCopyBuffer[sizeof(tempStringCopyBuffer) - 1] = '\0';
|
|
if (strlen(tempStringCopyBuffer) > 0) { response->print(tempStringCopyBuffer); }
|
|
response->print(FPSTR(infoChunk_AfterModell));
|
|
|
|
strncpy(tempStringCopyBuffer, infoZusatz, sizeof(tempStringCopyBuffer) - 1); tempStringCopyBuffer[sizeof(tempStringCopyBuffer) - 1] = '\0';
|
|
if (strlen(tempStringCopyBuffer) > 0) { response->print(tempStringCopyBuffer); }
|
|
response->print(FPSTR(infoChunk_AfterZusatz));
|
|
|
|
// --- Betriebszeit Reset Formular ---
|
|
response->print(FPSTR(infoChunk_RuntimeResetForm));
|
|
unsigned long totalSeconds = totalRuntime; unsigned long days = totalSeconds / 86400; unsigned long hours = (totalSeconds % 86400) / 3600; unsigned long minutes = (totalSeconds % 3600) / 60;
|
|
snprintf(buffer, sizeof(buffer), "%lu", days); response->print(buffer); response->print(F(" Tag(e), "));
|
|
snprintf(buffer, sizeof(buffer), "%lu", hours); response->print(buffer); response->print(F(" Stunde(n) und "));
|
|
snprintf(buffer, sizeof(buffer), "%lu", minutes); response->print(buffer); response->print(F(" Minuten"));
|
|
response->print(FPSTR(infoChunk_AfterRuntime));
|
|
|
|
// --- Shot Zähler Reset Formular ---
|
|
response->print(FPSTR(infoChunk_ShotCounterResetForm));
|
|
snprintf(buffer, sizeof(buffer), "%lu", shotCounter); response->print(buffer);
|
|
response->print(FPSTR(infoChunk_ShotCounterFormEnd));
|
|
|
|
// --- Shot-Verlauf Statistik ---
|
|
ShotStats stats = calculateShotStatistics();
|
|
|
|
if (stats.historyAvailable) {
|
|
response->print(FPSTR(infoChunk_StatsStart));
|
|
response->print(FPSTR(infoChunk_StatsTotal)); snprintf(buffer, sizeof(buffer), "%lu", stats.totalShotsLogged); response->print(buffer);
|
|
response->print(FPSTR(infoChunk_StatsAvg)); snprintf(buffer, sizeof(buffer), "%.1f", stats.averageDurationSec); response->print(buffer); response->print(F(" s"));
|
|
response->print(FPSTR(infoChunk_StatsAvgPerDay)); snprintf(buffer, sizeof(buffer), "%.1f", stats.avgShotsPerDay); response->print(buffer);
|
|
response->print(FPSTR(infoChunk_StatsToday)); snprintf(buffer, sizeof(buffer), "%lu", stats.shotsToday); response->print(buffer);
|
|
response->print(FPSTR(infoChunk_StatsYesterday)); snprintf(buffer, sizeof(buffer), "%lu", stats.shotsYesterday); response->print(buffer);
|
|
response->print(FPSTR(infoChunk_StatsWeek)); snprintf(buffer, sizeof(buffer), "%lu", stats.shotsThisWeek); response->print(buffer);
|
|
response->print(FPSTR(infoChunk_StatsLastWeek)); snprintf(buffer, sizeof(buffer), "%lu", stats.shotsLastWeek); response->print(buffer);
|
|
response->print(FPSTR(infoChunk_StatsMonth)); snprintf(buffer, sizeof(buffer), "%lu", stats.shotsThisMonth); response->print(buffer);
|
|
response->print(FPSTR(infoChunk_StatsLastMonth)); snprintf(buffer, sizeof(buffer), "%lu", stats.shotsLastMonth); response->print(buffer);
|
|
|
|
if (stats.firstShotTimestamp > 0) {
|
|
response->print(FPSTR(infoChunk_StatsFirst)); struct tm first_tm; localtime_r(&stats.firstShotTimestamp, &first_tm); strftime(dateBuffer, sizeof(dateBuffer), "%d.%m.%Y %H:%M", &first_tm); response->print(dateBuffer); response->print(F(" Uhr"));
|
|
}
|
|
if (stats.lastShotTimestamp > 0) {
|
|
response->print(FPSTR(infoChunk_StatsLast)); struct tm last_tm; localtime_r(&stats.lastShotTimestamp, &last_tm); strftime(dateBuffer, sizeof(dateBuffer), "%d.%m.%Y %H:%M", &last_tm); response->print(dateBuffer); response->print(F(" Uhr"));
|
|
}
|
|
|
|
time_t now_t_stats; time(&now_t_stats); struct tm now_tm_stats; localtime_r(&now_t_stats, &now_tm_stats);
|
|
if (now_tm_stats.tm_year <= (2023 - 1900)) { response->print(FPSTR(infoChunk_StatsTimeError)); }
|
|
|
|
response->print(FPSTR(infoChunk_StatsDownloadButton));
|
|
response->print(FPSTR(infoChunk_StatsEnd));
|
|
|
|
} else {
|
|
response->print(FPSTR(infoChunk_StatsNotAvailable));
|
|
}
|
|
|
|
response->print(FPSTR(infoChunk_DeleteStatsForm));
|
|
|
|
// --- Systeminfo ---
|
|
response->print(FPSTR(infoChunk_SysInfoStart));
|
|
snprintf(buffer, sizeof(buffer), "%u", ESP.getFreeHeap()); response->print(buffer);
|
|
response->print(FPSTR(infoChunk_AfterFreeHeap));
|
|
response->print(timeSynced ? F("Ja") : F("Nein"));
|
|
response->print(FPSTR(infoChunk_AfterNTPStatus));
|
|
const char* sdkVersion = ESP.getSdkVersion(); if (sdkVersion && strlen(sdkVersion) > 0) { response->print(sdkVersion); } else { response->print(F("N/A")); }
|
|
response->print(FPSTR(infoChunk_AfterSDK)); String coreVersionStr = ESP.getCoreVersion(); strncpy(tempStringCopyBuffer, coreVersionStr.c_str(), sizeof(tempStringCopyBuffer) - 1); tempStringCopyBuffer[sizeof(tempStringCopyBuffer) - 1] = '\0'; if (strlen(tempStringCopyBuffer) > 0) response->print(tempStringCopyBuffer);
|
|
response->print(FPSTR(infoChunk_AfterCore)); snprintf(buffer, sizeof(buffer), "%u", ESP.getBootVersion()); response->print(buffer);
|
|
response->print(FPSTR(infoChunk_AfterBoot));
|
|
#ifdef ESP32
|
|
uint64_t chipid = ESP.getEfuseMac(); snprintf(buffer, sizeof(buffer), "%04X%08X", (uint16_t)(chipid >> 32), (uint32_t)chipid);
|
|
#else
|
|
snprintf(buffer, sizeof(buffer), "%08X", ESP.getChipId());
|
|
#endif
|
|
response->print(buffer);
|
|
response->print(FPSTR(infoChunk_AfterChipID)); snprintf(buffer, sizeof(buffer), "%u", ESP.getCpuFreqMHz()); response->print(buffer);
|
|
response->print(FPSTR(infoChunk_AfterCPU)); String resetReasonStr = ESP.getResetReason(); strncpy(tempStringCopyBuffer, resetReasonStr.c_str(), sizeof(tempStringCopyBuffer) - 1); tempStringCopyBuffer[sizeof(tempStringCopyBuffer) - 1] = '\0'; if (strlen(tempStringCopyBuffer) > 0) response->print(tempStringCopyBuffer);
|
|
response->print(FPSTR(infoChunk_AfterResetReason)); snprintf(buffer, sizeof(buffer), "%u", ESP.getSketchSize()); response->print(buffer);
|
|
response->print(FPSTR(infoChunk_AfterSketchSize)); snprintf(buffer, sizeof(buffer), "%u", ESP.getFreeSketchSpace()); response->print(buffer);
|
|
response->print(FPSTR(infoChunk_AfterFreeSketch)); snprintf(buffer, sizeof(buffer), "%u", ESP.getFlashChipSize()); response->print(buffer);
|
|
response->print(FPSTR(infoChunk_End));
|
|
|
|
// --- Abschluss ---
|
|
request->send(response);
|
|
}
|
|
|
|
/************************************************************************************
|
|
* PROGMEM Chunks für die Service-Seite (/Service)
|
|
************************************************************************************/
|
|
|
|
// --- Kopfzeile ---
|
|
static const char serviceHtmlHead[] PROGMEM = R"rawliteral(
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<title>Service</title><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'>
|
|
)rawliteral";
|
|
// </head> bleibt gleich
|
|
static const char serviceHtmlHeadEnd[] PROGMEM = R"rawliteral(
|
|
</head>
|
|
)rawliteral";
|
|
|
|
static const char serviceChunk_BodyStart[] PROGMEM = R"rawliteral(
|
|
<body>
|
|
<h1>Service & Wartung</h1>
|
|
)rawliteral";
|
|
|
|
// --- Wartung Intervall Formular (ehemals infoChunk_MaintenanceForm) ---
|
|
static const char serviceChunk_MaintenanceForm[] PROGMEM = R"rawliteral(
|
|
<form action='/updateMaintenanceSettings' method='POST'>
|
|
<h3>Reinigung & Wartung</h3>
|
|
Zeigt nach der eingestellten Anzahl von Bezügen eine Reinigungs-/ Wartungserinnerung im Display an.<br>
|
|
<label for='maintenanceInterval'>Anzahl an Bezügen bis Erinnerung: (0 = deaktiviert)</label>
|
|
<input type='text' id='maintenanceInterval' name='maintenanceInterval' value=')rawliteral"; // Endet vor Wartungsintervall-Wert
|
|
static const char serviceChunk_AfterMaintInterval[] PROGMEM = R"rawliteral('>
|
|
<input type='submit' value='Einstellungen speichern'>
|
|
</form>
|
|
)rawliteral"; // Ende Wartungsintervall-Formular
|
|
|
|
// --- Wartungsmodus Sektion (ehemals infoChunk_Wartung...) ---
|
|
static const char serviceChunk_WartungStart[] PROGMEM = R"rawliteral(
|
|
<form action='/toggleWartungsmodus' method='POST'>
|
|
<h3>Wartungsmodus (Entkalkung)</h3>
|
|
<p>Aktiviert einen Modus zur einfachen Entkalkung der Maschine.<br>
|
|
Im Wartungsmodus ist das Heizen von Wasser und Dampf deaktiviert.<br>
|
|
Bezüge werden in diesem Modus nicht gezählt.</p>
|
|
<p><b>Aktueller Status:</b> )rawliteral"; // Endet vor dem Status (Aktiv/Inaktiv)
|
|
static const char serviceChunk_WartungButton[] PROGMEM = R"rawliteral(</p>
|
|
<button type='submit'>Wartungsmodus )rawliteral"; // Endet vor dem Button-Text (Aktivieren/Deaktivieren)
|
|
static const char serviceChunk_WartungEnd[] PROGMEM = R"rawliteral(</button>
|
|
</form>
|
|
)rawliteral"; // Ende Wartungsmodus-Formular
|
|
|
|
// --- Wartungszähler Reset Formular (ehemals infoChunk_MaintenanceResetForm) ---
|
|
static const char serviceChunk_MaintenanceResetForm[] PROGMEM = R"rawliteral(
|
|
<form action='/resetMaintenance' method='POST'>
|
|
<h3>Wartungszähler zurücksetzen</h3>
|
|
Aktueller Zählerstand: )rawliteral"; // Endet vor Wartungszähler-Wert
|
|
static const char serviceChunk_AfterMaintCounter[] PROGMEM = R"rawliteral(<br>
|
|
<br>
|
|
Setzt den Zähler für die Reinigungs- & Wartungserinnerung zurück.<br>
|
|
Dies ist nach der erfolgreichen Durchführung notwendig,<br>
|
|
damit die Meldung nicht nach jedem Bezug erneut scheint.<br>
|
|
<input type='submit' value='Zurücksetzen'>
|
|
</form>
|
|
)rawliteral"; // Ende Wartungszähler-Reset-Formular
|
|
|
|
static const char serviceChunk_BodyEnd[] PROGMEM = R"rawliteral(
|
|
</body>
|
|
</html>
|
|
)rawliteral";
|
|
|
|
/************************************************************************************
|
|
* Handler für die Service-Seite (/Service)
|
|
************************************************************************************/
|
|
void handleService(AsyncWebServerRequest *request) {
|
|
char buffer[20];
|
|
|
|
AsyncResponseStream *response = request->beginResponseStream("text/html");
|
|
|
|
// --- Kopfzeile, Styles, Navigation senden ---
|
|
response->print(FPSTR(serviceHtmlHead));
|
|
response->print("<link rel=\"stylesheet\" href=\"/style.css\">\n");
|
|
response->print(FPSTR(serviceHtmlHeadEnd));
|
|
response->print(FPSTR(commonNav));
|
|
|
|
// --- Body Start ---
|
|
response->print(FPSTR(serviceChunk_BodyStart));
|
|
|
|
// --- Wartung Intervall Formular ---
|
|
response->print(FPSTR(serviceChunk_MaintenanceForm));
|
|
snprintf(buffer, sizeof(buffer), "%d", maintenanceInterval); response->print(buffer);
|
|
response->print(FPSTR(serviceChunk_AfterMaintInterval));
|
|
|
|
// --- Wartungsmodus Sektion ---
|
|
response->print(FPSTR(serviceChunk_WartungStart));
|
|
response->print(wartungsModusAktiv ? F("Aktiv") : F("Inaktiv"));
|
|
response->print(FPSTR(serviceChunk_WartungButton));
|
|
response->print(wartungsModusAktiv ? F("Deaktivieren") : F("Aktivieren"));
|
|
response->print(FPSTR(serviceChunk_WartungEnd));
|
|
|
|
// --- Wartungszähler Reset Formular ---
|
|
response->print(FPSTR(serviceChunk_MaintenanceResetForm));
|
|
snprintf(buffer, sizeof(buffer), "%lu", maintenanceIntervalCounter); response->print(buffer);
|
|
response->print(FPSTR(serviceChunk_AfterMaintCounter));
|
|
|
|
// --- Body Ende ---
|
|
response->print(FPSTR(serviceChunk_BodyEnd));
|
|
|
|
// --- Abschluss ---
|
|
request->send(response);
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler für die Eco-Modus-Konfiguration - Heap-Optimiert mit Chunked Sending
|
|
************************************************************************************/
|
|
|
|
// --- PROGMEM Chunks für handleEco ---
|
|
// Kopfzeile bleibt gleich wie im Original `ecoHtml`
|
|
static const char ecoHtmlHead[] PROGMEM = R"rawliteral(
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<title>Eco-Modus</title><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'>
|
|
)rawliteral";
|
|
// </head> bleibt gleich wie im Original `ecoHtml2`
|
|
static const char ecoHtmlHeadEnd[] PROGMEM = R"rawliteral(
|
|
</head>
|
|
)rawliteral";
|
|
|
|
// Aufteilung von ecoHtml3 in Chunks
|
|
static const char ecoChunk_BodyStart[] PROGMEM = R"rawliteral(
|
|
<body>
|
|
<h1>Eco-Modus</h1>
|
|
<form action='/updateEcoSettings' method='POST'>
|
|
<h3>Eco-Modus</h3>
|
|
Der Eco-Modus senkt die voreingestellten Temperaturen nach der angegebenen Zeit auf die Eco-Temperaturen ab.<br>
|
|
<label for='ecoMode'>Eco-Modus (Minuten, 0 = deaktiviert):</label>
|
|
<input type='text' id='ecoMode' name='ecoMode' value=')rawliteral"; // Endet vor {ECO_MODE}
|
|
static const char ecoChunk_AfterEcoMode[] PROGMEM = R"rawliteral('>
|
|
<label for='ecoModeTempWasser'>Eco-Temperatur Wasser:</label>
|
|
<input type='text' id='ecoModeTempWasser' name='ecoModeTempWasser' value=')rawliteral"; // Endet vor {ECO_MODE_TEMP_WASSER}
|
|
static const char ecoChunk_AfterTempW[] PROGMEM = R"rawliteral('>
|
|
<label for='ecoModeTempDampf'>Eco-Temperatur Dampf:</label>
|
|
<input type='text' id='ecoModeTempDampf' name='ecoModeTempDampf' value=')rawliteral"; // Endet vor {ECO_MODE_TEMP_DAMPF}
|
|
static const char ecoChunk_AfterTempD[] PROGMEM = R"rawliteral('>
|
|
<div style='margin-bottom:15px;'>
|
|
<br>
|
|
<h3>Dynamischer Eco-Modus</h3>
|
|
<label for='fast-heat-up-aktivieren' style='display:inline-block; margin-right:10px;'>
|
|
Dynamischen Eco-Modus aktivieren (ECO+):
|
|
<input type='checkbox' id='dynamicEcoMode' name='dynamicEcoMode' value='1')rawliteral"; // Endet vor {DYNAMIC_ECO_MODE_CHECKBOX}
|
|
static const char ecoChunk_AfterDynCheck[] PROGMEM = R"rawliteral(>
|
|
</label>
|
|
</div>
|
|
<div style='margin-top:15px;'>
|
|
Der dynamische Eco-Modus verhindert, dass die Maschine bis in die Unendlichkeit eine gewisse Temperatur aufrecht erhält.<br>
|
|
Er senkt die Temperatur pro Minute um ein weiteres Grad ab, bis letzlich das Heizen vollständig beendet wird.<br>
|
|
Der dynamische Eco-Modus ist nur in Kombination mit dem Eco-Modus nutzbar!<br>
|
|
<br>
|
|
<b>Beispiel für eine praktische Anwendung:</b><br>
|
|
Peter hat an seiner Maschine den Eco-Modus auf 45 Minuten gestellt, mit Eco-Temperatur von 60 Grad. Nun kommt ihm etwas dazwischen und er kommt erst bei Minute 60 an die Maschine, um sich einen Espresso zuzubereiten. Die Maschine ist nun allerdings schon auf 60 Grad herabgekühlt und er muss erneut das Aufheizen abwarten ...<br>
|
|
Markus passiert das gleiche, doch er hat den dynamischen Eco-Modus mit einer initialen Eco-Temperatur von 95 Grad aktiviert - Seine Maschine ist nun zumindest noch bei 80 Grad.<br>
|
|
Markus muss zwar auch warten, kann jedoch noch vor Peter einen Espresso trinken.
|
|
</div><br>
|
|
<h3>Verzögerung für Dampf</h3>
|
|
<label for='dampfDelay'>Aufheizen für Dampf verzögern (Minuten, 0 = deaktiviert):</label>
|
|
<input type='text' id='dampfDelay' name='dampfDelay' value=')rawliteral"; // Endet vor {DAMPF_DELAY}
|
|
static const char ecoChunk_AfterDampfDelay[] PROGMEM = R"rawliteral('>
|
|
<br><b style='color: #FFCC00;'>ACHTUNG:</b><br>
|
|
Um Konflikte zu vermeiden, sollte der Wert geringer sein, als der des Eco-Modus, falls dieser aktiviert ist!
|
|
<br>
|
|
<input type='submit' value='Einstellungen speichern'>
|
|
</form>
|
|
</body>
|
|
</html>
|
|
)rawliteral";
|
|
|
|
|
|
void handleEco(AsyncWebServerRequest *request)
|
|
{
|
|
char buffer[12];
|
|
|
|
AsyncResponseStream *response = request->beginResponseStream("text/html");
|
|
|
|
response->print(FPSTR(ecoHtmlHead));
|
|
response->print("<link rel=\"stylesheet\" href=\"/style.css\">\n");
|
|
response->print(FPSTR(ecoHtmlHeadEnd));
|
|
response->print(FPSTR(commonNav));
|
|
|
|
response->print(FPSTR(ecoChunk_BodyStart));
|
|
snprintf(buffer, sizeof(buffer), "%d", ecoModeMinutes); response->print(buffer);
|
|
response->print(FPSTR(ecoChunk_AfterEcoMode));
|
|
snprintf(buffer, sizeof(buffer), "%d", ecoModeTempWasser); response->print(buffer);
|
|
response->print(FPSTR(ecoChunk_AfterTempW));
|
|
snprintf(buffer, sizeof(buffer), "%d", ecoModeTempDampf); response->print(buffer);
|
|
response->print(FPSTR(ecoChunk_AfterTempD));
|
|
if (dynamicEcoActive) { response->print(F(" checked")); }
|
|
response->print(FPSTR(ecoChunk_AfterDynCheck));
|
|
snprintf(buffer, sizeof(buffer), "%d", dampfVerzoegerung); response->print(buffer);
|
|
response->print(FPSTR(ecoChunk_AfterDampfDelay));
|
|
|
|
request->send(response);
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler für die Fast-Heat-Up Seite - Heap-Optimiert mit Chunked Sending
|
|
************************************************************************************/
|
|
|
|
// --- PROGMEM Chunks für handleFastHeatUp ---
|
|
// Kopfzeile bleibt gleich wie im Original `fhuHtml`
|
|
static const char fhuHtmlHead[] PROGMEM = R"rawliteral(
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<title>Fast-Heat-Up-Modus</title><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'>
|
|
)rawliteral";
|
|
// </head> bleibt gleich wie im Original `fhuHtml2`
|
|
static const char fhuHtmlHeadEnd[] PROGMEM = R"rawliteral(
|
|
</head>
|
|
)rawliteral";
|
|
|
|
// Aufteilung von fhuHtml3 in Chunks
|
|
// Teil 1: Bis zum Ende des <input type='checkbox' ... value='1' Teils
|
|
static const char fhuChunk1[] PROGMEM = R"rawliteral(
|
|
<body>
|
|
<h1>Fast-Heat-Up-Modus</h1>
|
|
<form action='/updateFast-Heat-Up-Settings' method='POST'>
|
|
<h3>Fast-Heat-Up-Modus</h3>
|
|
<div style='margin-bottom:15px;'>
|
|
<label for='fast-heat-up-aktivieren' style='display:inline-block; margin-right:10px;'>
|
|
Fast-Heat-Up aktivieren:
|
|
</label>
|
|
<input type='checkbox' id='fast-heat-up-aktivieren' name='fastHeatUpAktiv' value='1')rawliteral"; // Endet direkt vor {FASTHEATUP_MODE_CHECKBOX}
|
|
|
|
// Teil 2: Vom '>' nach der Checkbox bis zum Ende
|
|
static const char fhuChunk2[] PROGMEM = R"rawliteral(>
|
|
</div>
|
|
<div style='margin-top:15px;'>
|
|
Der Fast-Heat-Up-Modus ermöglicht es, die Maschine noch schneller aufzuheizen.<br>
|
|
Der Kessel wird beim Start auf 130 Grad Celsius erhitzt.<br>
|
|
Nachdem die Temperatur erreicht ist, muss ein Flush von ca. 20 Sekunden durchgeführt werden.<br>
|
|
<br>
|
|
<b style='color: #FFCC00;'>ACHTUNG:</b><br>
|
|
Bitte beachten, dass auf der Seite PID-Einstellung eventuell die max. Wassertemperatur der Sicherheitsabschaltung angepasst werden muss!<br>
|
|
</div>
|
|
<input type='submit' value='Einstellungen speichern' style='margin-top:20px;'>
|
|
</form>
|
|
</body>
|
|
</html>
|
|
)rawliteral";
|
|
|
|
|
|
void handleFastHeatUp(AsyncWebServerRequest *request)
|
|
{
|
|
AsyncResponseStream *response = request->beginResponseStream("text/html");
|
|
|
|
response->print(FPSTR(fhuHtmlHead));
|
|
response->print("<link rel=\"stylesheet\" href=\"/style.css\">\n");
|
|
response->print(FPSTR(fhuHtmlHeadEnd));
|
|
response->print(FPSTR(commonNav));
|
|
|
|
response->print(FPSTR(fhuChunk1));
|
|
if (fastHeatUpAktiv) { response->print(F(" checked")); }
|
|
response->print(FPSTR(fhuChunk2));
|
|
|
|
request->send(response);
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler zum Speichern der Fast-Heat-Up-Einstellung - URL angepasst
|
|
************************************************************************************/
|
|
|
|
void handleFastHeatUpSettings(AsyncWebServerRequest *request) {
|
|
// Parameter über POST holen
|
|
if (request->hasParam("fastHeatUpAktiv", true)) { // true = POST Parameter
|
|
fastHeatUpAktiv = true;
|
|
} else {
|
|
fastHeatUpAktiv = false;
|
|
}
|
|
|
|
EEPROM.put(EEPROM_ADDR_FASTHEATUP_DATA, fastHeatUpAktiv);
|
|
EEPROM.commit();
|
|
|
|
request->redirect("/Fast-Heat-Up"); // Async redirect
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler für CSS-Datei
|
|
************************************************************************************/
|
|
void handleCss(AsyncWebServerRequest *request) {
|
|
// Prüfen, ob die Datei existiert
|
|
if(LittleFS.exists("/style.css")){
|
|
// Datei senden, mit korrektem MIME-Typ 'text/css'
|
|
// Das letzte 'false' verhindert Caching auf Client-Seite (optional, für Entwicklung gut)
|
|
// Für Produktion kann man es auf 'true' setzen oder weglassen, damit der Browser cacht.
|
|
request->send(LittleFS, "/style.css", "text/css");
|
|
} else {
|
|
// Datei nicht gefunden
|
|
request->send(404, "text/plain", "CSS Datei nicht gefunden");
|
|
}
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler für Root (PID-Einstellungen) - Heap-Optimiert mit Chunked Sending
|
|
************************************************************************************/
|
|
|
|
// --- PROGMEM Chunks für handleRoot ---
|
|
// Kopfzeile bleibt gleich wie im Original `rootHtml`
|
|
static const char rootHtmlHead[] PROGMEM = R"rawliteral(
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<title>PID-Einstellung</title><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'>
|
|
)rawliteral";
|
|
// </head> bleibt gleich wie im Original `rootHtml2`
|
|
static const char rootHtmlHeadEnd[] PROGMEM = R"rawliteral(
|
|
</head>
|
|
)rawliteral";
|
|
|
|
// Aufteilung von rootHtml3 in Chunks
|
|
static const char rootChunk_BodyStart[] PROGMEM = R"rawliteral(
|
|
<body>
|
|
<h1>PID-Einstellung</h1>
|
|
)rawliteral";
|
|
// Nach {SENSOR_ERROR_MESSAGES} bis value='{WASSER}'
|
|
static const char rootChunk_FormStart[] PROGMEM = R"rawliteral(
|
|
<form action='/updateSettings' method='POST'>
|
|
<h3>Temperatur: Wasser / Kessel</h3>
|
|
<label for='wasser'>Setpoint (°C):</label>
|
|
<input type='text' id='wasser' name='wasser' value=')rawliteral";
|
|
// Nach {WASSER} bis value='{OFFSET_WASSER}'
|
|
static const char rootChunk_AfterWasser[] PROGMEM = R"rawliteral('>
|
|
<label for='offsetWasser'>Offset (°C):</label>
|
|
<input type='text' id='offsetWasser' name='offsetWasser' value=')rawliteral";
|
|
// Nach {OFFSET_WASSER} bis {BOOST_WASSER_CHECKED}
|
|
static const char rootChunk_AfterOffsetW[] PROGMEM = R"rawliteral('>
|
|
<label for='boostWasser' style='display:inline-block; margin-right:10px;'>
|
|
Boost-Funktion:
|
|
</label>
|
|
<input type='checkbox' id='boostWasser' name='boostWasser' value='1')rawliteral"; // Endet direkt vor dem checked Attribut
|
|
// Nach {BOOST_WASSER_CHECKED} bis {PREVENTHEAT_WASSER_CHECKED}
|
|
static const char rootChunk_AfterBoostW[] PROGMEM = R"rawliteral(>
|
|
<br>
|
|
<small style='color: #ccc;'>(Volle Heizleistung erzwingen bis 95% der Zieltemperatur)</small>
|
|
<br>
|
|
<label for='preventHeatWasser' style='display:inline-block; margin-right:10px;'>
|
|
Heizen oberhalb Setpoint verhindern:
|
|
</label>
|
|
<input type='checkbox' id='preventHeatWasser' name='preventHeatWasser' value='1')rawliteral"; // Endet direkt vor dem checked Attribut
|
|
// Nach {PREVENTHEAT_WASSER_CHECKED} bis value='{DAMPF}'
|
|
static const char rootChunk_AfterPreventW[] PROGMEM = R"rawliteral(>
|
|
<br>
|
|
<small style='color: #ccc;'>(Kein Heizen, wenn Temp. > Sollwert)</small>
|
|
<br><br>
|
|
<h3>Temperatur: Dampf / Thermoblock</h3>
|
|
<label for='dampf'>Setpoint (°C):</label>
|
|
<input type='text' id='dampf' name='dampf' value=')rawliteral";
|
|
// Nach {DAMPF} bis value='{OFFSET_DAMPF}'
|
|
static const char rootChunk_AfterDampf[] PROGMEM = R"rawliteral('>
|
|
<label for='offsetDampf'>Offset (°C):</label>
|
|
<input type='text' id='offsetDampf' name='offsetDampf' value=')rawliteral";
|
|
// Nach {OFFSET_DAMPF} bis {BOOST_DAMPF_CHECKED}
|
|
static const char rootChunk_AfterOffsetD[] PROGMEM = R"rawliteral('>
|
|
<label for='boostDampf' style='display:inline-block; margin-right:10px;'>
|
|
Boost-Funktion:
|
|
</label>
|
|
<input type='checkbox' id='boostDampf' name='boostDampf' value='1')rawliteral"; // Endet direkt vor dem checked Attribut
|
|
// Nach {BOOST_DAMPF_CHECKED} bis {PREVENTHEAT_DAMPF_CHECKED}
|
|
static const char rootChunk_AfterBoostD[] PROGMEM = R"rawliteral(>
|
|
<br>
|
|
<small style='color: #ccc;'>(Volle Heizleistung erzwingen bis 90% der Zieltemperatur)</small>
|
|
<br>
|
|
<label for='preventHeatDampf' style='display:inline-block; margin-right:10px;'>
|
|
Heizen oberhalb Setpoint verhindern:
|
|
</label>
|
|
<input type='checkbox' id='preventHeatDampf' name='preventHeatDampf' value='1')rawliteral"; // Endet direkt vor dem checked Attribut
|
|
// Nach {PREVENTHEAT_DAMPF_CHECKED} bis value='{KP_WASSER}'
|
|
static const char rootChunk_AfterPreventD[] PROGMEM = R"rawliteral(>
|
|
<br>
|
|
<small style='color: #ccc;'>(Kein Heizen, wenn Temp. > Sollwert)</small>
|
|
<br><br>
|
|
<h3>PID-Parameter: Wasser / Kessel</h3>
|
|
<label for='kpWasser'>Kp:</label>
|
|
<input type='text' id='kpWasser' name='kpWasser' value=')rawliteral";
|
|
// Nach {KP_WASSER} bis value='{KI_WASSER}'
|
|
static const char rootChunk_AfterKpW[] PROGMEM = R"rawliteral('>
|
|
<label for='kiWasser'>Ki:</label>
|
|
<input type='text' id='kiWasser' name='kiWasser' value=')rawliteral";
|
|
// Nach {KI_WASSER} bis value='{KD_WASSER}'
|
|
static const char rootChunk_AfterKiW[] PROGMEM = R"rawliteral('>
|
|
<label for='kdWasser'>Kd:</label>
|
|
<input type='text' id='kdWasser' name='kdWasser' value=')rawliteral";
|
|
// Nach {KD_WASSER} bis value='{WINDOW_SIZE_WASSER}'
|
|
static const char rootChunk_AfterKdW[] PROGMEM = R"rawliteral('>
|
|
<label for='windowSizeWasser'>Zeitfenster (ms):</label>
|
|
<input type='text' id='windowSizeWasser' name='windowSizeWasser' value=')rawliteral";
|
|
// Nach {WINDOW_SIZE_WASSER} bis value='{KP_DAMPF}'
|
|
static const char rootChunk_AfterWindowW[] PROGMEM = R"rawliteral('>
|
|
</br>
|
|
<h3>PID-Parameter: Dampf / Thermoblock</h3>
|
|
<label for='kpDampf'>Kp:</label>
|
|
<input type='text' id='kpDampf' name='kpDampf' value=')rawliteral";
|
|
// Nach {KP_DAMPF} bis value='{KI_DAMPF}'
|
|
static const char rootChunk_AfterKpD[] PROGMEM = R"rawliteral('>
|
|
<label for='kiDampf'>Ki:</label>
|
|
<input type='text' id='kiDampf' name='kiDampf' value=')rawliteral";
|
|
// Nach {KI_DAMPF} bis value='{KD_DAMPF}'
|
|
static const char rootChunk_AfterKiD[] PROGMEM = R"rawliteral('>
|
|
<label for='kdDampf'>Kd:</label>
|
|
<input type='text' id='kdDampf' name='kdDampf' value=')rawliteral";
|
|
// Nach {KD_DAMPF} bis value='{WINDOW_SIZE_DAMPF}'
|
|
static const char rootChunk_AfterKdD[] PROGMEM = R"rawliteral('>
|
|
<label for='windowSizeDampf'>Zeitfenster (ms):</label>
|
|
<input type='text' id='windowSizeDampf' name='windowSizeDampf' value=')rawliteral";
|
|
// Nach {WINDOW_SIZE_DAMPF} bis value='{MAX_TEMP_WASSER}'
|
|
static const char rootChunk_AfterWindowD[] PROGMEM = R"rawliteral('>
|
|
</br>
|
|
<h3>Sicherheitsabschaltung</h3>
|
|
Die Sicherheitsabschaltung bietet eine softwareseitige Übertemperatursicherung,<br>
|
|
ersetzt jedoch keine hardwareseitige Lösung durch z.B. Bimetall Temperaturschalter!<br>
|
|
Bei der Verwendung von Fast-Heat-Up muss der Wert für die Maximaltemperatur angepasst werden!<br>
|
|
<br>
|
|
<label for='maxTempWasser'>Max. Temp Wasser (°C):</label>
|
|
<input type='text' id='maxTempWasser' name='maxTempWasser' value=')rawliteral";
|
|
// Nach {MAX_TEMP_WASSER} bis value='{MAX_TEMP_DAMPF}'
|
|
static const char rootChunk_AfterMaxW[] PROGMEM = R"rawliteral('>
|
|
<label for='maxTempDampf'>Max. Temp Dampf (°C):</label>
|
|
<input type='text' id='maxTempDampf' name='maxTempDampf' value=')rawliteral";
|
|
// Nach {MAX_TEMP_DAMPF} bis Ende
|
|
static const char rootChunk_FormEnd[] PROGMEM = R"rawliteral('>
|
|
<input type='submit' value='Einstellungen speichern'>
|
|
</form>
|
|
</body>
|
|
</html>
|
|
)rawliteral";
|
|
|
|
|
|
// Überarbeitete Funktion handleRoot
|
|
void handleRoot(AsyncWebServerRequest *request) {
|
|
char buffer[20];
|
|
|
|
AsyncResponseStream *response = request->beginResponseStream("text/html");
|
|
response->print(FPSTR(rootHtmlHead));
|
|
response->print("<link rel=\"stylesheet\" href=\"/style.css\">\n");
|
|
response->print(FPSTR(rootHtmlHeadEnd));
|
|
response->print(FPSTR(commonNav));
|
|
|
|
response->print(FPSTR(rootChunk_BodyStart));
|
|
|
|
// --- Dynamische Fehlermeldungen generieren und senden ---
|
|
String errorMessageHtml = "";
|
|
if (demoModus) { errorMessageHtml = "<div class=\"sensor-error-message\"><b>Demo-Betrieb:</b><br>Es sind keine Sensoren angeschlossen und daher keine Temperaturwerte verfügbar.</div>"; }
|
|
else if (wasserSensorError && dampfSensorError) { errorMessageHtml = "<div class=\"sensor-error-message\">Die Daten der Temperatursensoren sind derzeit nicht verfügbar!<br>Bitte Temperatur-Sensoren prüfen!</div>"; }
|
|
else if (wasserSensorError) { errorMessageHtml = "<div class=\"sensor-error-message\">Temperaturwert für Wasser nicht verfügbar</div>"; }
|
|
else if (dampfSensorError) { errorMessageHtml = "<div class=\"sensor-error-message\">Temperaturwert für Dampf nicht verfügbar</div>"; }
|
|
if (errorMessageHtml.length() > 0) { response->print(errorMessageHtml); }
|
|
|
|
// Formular Schritt für Schritt aufbauen
|
|
response->print(FPSTR(rootChunk_FormStart)); snprintf(buffer, sizeof(buffer), "%d", (int)SetpointWasser); response->print(buffer);
|
|
response->print(FPSTR(rootChunk_AfterWasser)); snprintf(buffer, sizeof(buffer), "%.2f", OffsetWasser); response->print(buffer);
|
|
response->print(FPSTR(rootChunk_AfterOffsetW)); if (boostWasserActive) response->print(F(" checked"));
|
|
response->print(FPSTR(rootChunk_AfterBoostW)); if (preventHeatAboveSetpointWasser) response->print(F(" checked"));
|
|
response->print(FPSTR(rootChunk_AfterPreventW)); snprintf(buffer, sizeof(buffer), "%d", (int)SetpointDampf); response->print(buffer);
|
|
response->print(FPSTR(rootChunk_AfterDampf)); snprintf(buffer, sizeof(buffer), "%.2f", OffsetDampf); response->print(buffer);
|
|
response->print(FPSTR(rootChunk_AfterOffsetD)); if (boostDampfActive) response->print(F(" checked"));
|
|
response->print(FPSTR(rootChunk_AfterBoostD)); if (preventHeatAboveSetpointDampf) response->print(F(" checked"));
|
|
response->print(FPSTR(rootChunk_AfterPreventD)); snprintf(buffer, sizeof(buffer), "%.2f", KpWasser); response->print(buffer);
|
|
response->print(FPSTR(rootChunk_AfterKpW)); snprintf(buffer, sizeof(buffer), "%.2f", KiWasser); response->print(buffer);
|
|
response->print(FPSTR(rootChunk_AfterKiW)); snprintf(buffer, sizeof(buffer), "%.2f", KdWasser); response->print(buffer);
|
|
response->print(FPSTR(rootChunk_AfterKdW)); snprintf(buffer, sizeof(buffer), "%lu", windowSizeWasser); response->print(buffer);
|
|
response->print(FPSTR(rootChunk_AfterWindowW)); snprintf(buffer, sizeof(buffer), "%.2f", KpDampf); response->print(buffer);
|
|
response->print(FPSTR(rootChunk_AfterKpD)); snprintf(buffer, sizeof(buffer), "%.2f", KiDampf); response->print(buffer);
|
|
response->print(FPSTR(rootChunk_AfterKiD)); snprintf(buffer, sizeof(buffer), "%.2f", KdDampf); response->print(buffer);
|
|
response->print(FPSTR(rootChunk_AfterKdD)); snprintf(buffer, sizeof(buffer), "%lu", windowSizeDampf); response->print(buffer);
|
|
response->print(FPSTR(rootChunk_AfterWindowD)); snprintf(buffer, sizeof(buffer), "%.2f", maxTempWasser); response->print(buffer);
|
|
response->print(FPSTR(rootChunk_AfterMaxW)); snprintf(buffer, sizeof(buffer), "%.2f", maxTempDampf); response->print(buffer);
|
|
response->print(FPSTR(rootChunk_FormEnd));
|
|
|
|
request->send(response);
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Schreibt die Werte in den EEPROM (PID/Eco) - Unverändert
|
|
************************************************************************************/
|
|
|
|
void handleSettingsUpdate(AsyncWebServerRequest *request) {
|
|
bool valueChanged = false;
|
|
|
|
// --- Werte aus POST Request lesen ---
|
|
// Sicherheitslimits
|
|
if (request->hasParam("maxTempWasser", true)) {
|
|
float newVal = request->getParam("maxTempWasser", true)->value().toFloat();
|
|
if (newVal != maxTempWasser) { maxTempWasser = newVal; EEPROM.put(EEPROM_ADDR_MAX_TEMP_WASSER, maxTempWasser); valueChanged = true; }
|
|
}
|
|
if (request->hasParam("maxTempDampf", true)) {
|
|
float newVal = request->getParam("maxTempDampf", true)->value().toFloat();
|
|
if (newVal != maxTempDampf) { maxTempDampf = newVal; EEPROM.put(EEPROM_ADDR_MAX_TEMP_DAMPF, maxTempDampf); valueChanged = true; }
|
|
}
|
|
// Setpoints
|
|
if (request->hasParam("wasser", true)) {
|
|
float newVal = request->getParam("wasser", true)->value().toFloat();
|
|
if (newVal != SetpointWasser) { SetpointWasser = newVal; EEPROM.put(EEPROM_ADDR_SETPOINT_WASSER, SetpointWasser); valueChanged = true; }
|
|
}
|
|
if (request->hasParam("dampf", true)) {
|
|
float newVal = request->getParam("dampf", true)->value().toFloat();
|
|
if (newVal != SetpointDampf) { SetpointDampf = newVal; EEPROM.put(EEPROM_ADDR_SETPOINT_DAMPF, SetpointDampf); valueChanged = true; }
|
|
}
|
|
// Offsets
|
|
if (request->hasParam("offsetWasser", true)) {
|
|
float newVal = request->getParam("offsetWasser", true)->value().toFloat();
|
|
if (newVal != OffsetWasser) { OffsetWasser = newVal; EEPROM.put(EEPROM_ADDR_OFFSET_WASSER, OffsetWasser); valueChanged = true; }
|
|
}
|
|
if (request->hasParam("offsetDampf", true)) {
|
|
float newVal = request->getParam("offsetDampf", true)->value().toFloat();
|
|
if (newVal != OffsetDampf) { OffsetDampf = newVal; EEPROM.put(EEPROM_ADDR_OFFSET_DAMPF, OffsetDampf); valueChanged = true; }
|
|
}
|
|
// PID Wasser
|
|
if (request->hasParam("kpWasser", true)) {
|
|
float newVal = request->getParam("kpWasser", true)->value().toFloat();
|
|
if (newVal != KpWasser) { KpWasser = newVal; EEPROM.put(EEPROM_ADDR_KP_WASSER, KpWasser); valueChanged = true; }
|
|
}
|
|
if (request->hasParam("kiWasser", true)) {
|
|
float newVal = request->getParam("kiWasser", true)->value().toFloat();
|
|
if (newVal != KiWasser) { KiWasser = newVal; EEPROM.put(EEPROM_ADDR_KI_WASSER, KiWasser); valueChanged = true; }
|
|
}
|
|
if (request->hasParam("kdWasser", true)) {
|
|
float newVal = request->getParam("kdWasser", true)->value().toFloat();
|
|
if (newVal != KdWasser) { KdWasser = newVal; EEPROM.put(EEPROM_ADDR_KD_WASSER, KdWasser); valueChanged = true; }
|
|
}
|
|
// PID Dampf
|
|
if (request->hasParam("kpDampf", true)) {
|
|
float newVal = request->getParam("kpDampf", true)->value().toFloat();
|
|
if (newVal != KpDampf) { KpDampf = newVal; EEPROM.put(EEPROM_ADDR_KP_DAMPF, KpDampf); valueChanged = true; }
|
|
}
|
|
if (request->hasParam("kiDampf", true)) {
|
|
float newVal = request->getParam("kiDampf", true)->value().toFloat();
|
|
if (newVal != KiDampf) { KiDampf = newVal; EEPROM.put(EEPROM_ADDR_KI_DAMPF, KiDampf); valueChanged = true; }
|
|
}
|
|
if (request->hasParam("kdDampf", true)) {
|
|
float newVal = request->getParam("kdDampf", true)->value().toFloat();
|
|
if (newVal != KdDampf) { KdDampf = newVal; EEPROM.put(EEPROM_ADDR_KD_DAMPF, KdDampf); valueChanged = true; }
|
|
}
|
|
// Boost Flags
|
|
bool newBoostWasser = request->hasParam("boostWasser", true);
|
|
if (newBoostWasser != boostWasserActive) { boostWasserActive = newBoostWasser; EEPROM.put(EEPROM_ADDR_BOOST_WASSER_ACTIVE, boostWasserActive); valueChanged = true; }
|
|
bool newBoostDampf = request->hasParam("boostDampf", true);
|
|
if (newBoostDampf != boostDampfActive) { boostDampfActive = newBoostDampf; EEPROM.put(EEPROM_ADDR_BOOST_DAMPF_ACTIVE, boostDampfActive); valueChanged = true; }
|
|
|
|
// Prevent Heat Above Setpoint Flags
|
|
bool newPreventHeatWasser = request->hasParam("preventHeatWasser", true);
|
|
if (newPreventHeatWasser != preventHeatAboveSetpointWasser) { preventHeatAboveSetpointWasser = newPreventHeatWasser; EEPROM.put(EEPROM_ADDR_PREVENTHEAT_WASSER, preventHeatAboveSetpointWasser); valueChanged = true; Serial.printf("PreventHeat Wasser %s\n", preventHeatAboveSetpointWasser ? "aktiviert" : "deaktiviert"); }
|
|
bool newPreventHeatDampf = request->hasParam("preventHeatDampf", true);
|
|
if (newPreventHeatDampf != preventHeatAboveSetpointDampf) { preventHeatAboveSetpointDampf = newPreventHeatDampf; EEPROM.put(EEPROM_ADDR_PREVENTHEAT_DAMPF, preventHeatAboveSetpointDampf); valueChanged = true; Serial.printf("PreventHeat Dampf %s\n", preventHeatAboveSetpointDampf ? "aktiviert" : "deaktiviert"); }
|
|
|
|
unsigned long newWindowSizeWasser = windowSizeWasser;
|
|
if (request->hasParam("windowSizeWasser", true)) {
|
|
char* endptr;
|
|
unsigned long val = strtoul(request->getParam("windowSizeWasser", true)->value().c_str(), &endptr, 10);
|
|
if (*endptr == '\0' && val > 0 && val <= 60000) { newWindowSizeWasser = val; }
|
|
else { Serial.printf("WARNUNG: Ungültiger Wert für windowSizeWasser empfangen: %s\n", request->getParam("windowSizeWasser", true)->value().c_str()); }
|
|
}
|
|
if (newWindowSizeWasser != windowSizeWasser) {
|
|
windowSizeWasser = newWindowSizeWasser; EEPROM.put(EEPROM_ADDR_WINDOWSIZE_WASSER, windowSizeWasser);
|
|
pidWasser.SetOutputLimits(0, windowSizeWasser); valueChanged = true; Serial.printf("Fenstergröße Wasser aktualisiert auf: %lu ms\n", windowSizeWasser);
|
|
}
|
|
|
|
unsigned long newWindowSizeDampf = windowSizeDampf;
|
|
if (request->hasParam("windowSizeDampf", true)) {
|
|
char* endptr;
|
|
unsigned long val = strtoul(request->getParam("windowSizeDampf", true)->value().c_str(), &endptr, 10);
|
|
if (*endptr == '\0' && val > 0 && val <= 60000) { newWindowSizeDampf = val; }
|
|
else { Serial.printf("WARNUNG: Ungültiger Wert für windowSizeDampf empfangen: %s\n", request->getParam("windowSizeDampf", true)->value().c_str()); }
|
|
}
|
|
if (newWindowSizeDampf != windowSizeDampf) {
|
|
windowSizeDampf = newWindowSizeDampf; EEPROM.put(EEPROM_ADDR_WINDOWSIZE_DAMPF, windowSizeDampf);
|
|
pidDampf.SetOutputLimits(0, windowSizeDampf); valueChanged = true; Serial.printf("Fenstergröße Dampf aktualisiert auf: %lu ms\n", windowSizeDampf);
|
|
}
|
|
|
|
// --- EEPROM speichern und PID aktualisieren ---
|
|
if (valueChanged) {
|
|
if (EEPROM.commit()) { Serial.println("Einstellungen erfolgreich in EEPROM gespeichert."); }
|
|
else { Serial.println("FEHLER: EEPROM Commit fehlgeschlagen!"); }
|
|
}
|
|
|
|
pidDampf.SetTunings(KpDampf, KiDampf, KdDampf);
|
|
pidWasser.SetTunings(KpWasser, KiWasser, KdWasser);
|
|
|
|
request->redirect("/"); // Async redirect
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler für die Firmware & Einstellungen Seite - Heap-Optimiert
|
|
************************************************************************************/
|
|
|
|
// --- PROGMEM Chunks für handleFirmware ---
|
|
static const char firmwareHtmlHead[] PROGMEM = R"rawliteral(
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<title>Firmware & Einstellungen</title><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'>
|
|
</head>
|
|
)rawliteral"; // Head inklusive </head>
|
|
|
|
static const char firmwareBodyStart[] PROGMEM = R"rawliteral(
|
|
<body>
|
|
<h1>Firmware & Einstellungen</h1>
|
|
<form>
|
|
<h3>Firmware-Info</h3>
|
|
Firmware-Version: )rawliteral"; // Endet vor {FIRMWAREVERSION}
|
|
static const char firmwareInfoChunk2[] PROGMEM = R"rawliteral(<br>
|
|
Hersteller: )rawliteral"; // Endet vor {SWHERSTELLER}
|
|
static const char firmwareInfoChunk3[] PROGMEM = R"rawliteral(<br>
|
|
E-Mail: )rawliteral"; // Endet vor {SWHERSTELLERMAIL}
|
|
static const char firmwareInfoChunk4[] PROGMEM = R"rawliteral(<br>
|
|
Website: )rawliteral"; // Endet vor {SWHERSTELLERWEBSITE}
|
|
static const char firmwareInfoChunkEnd[] PROGMEM = R"rawliteral(<br>
|
|
</form>
|
|
)rawliteral"; // Ende Firmware-Info Sektion
|
|
|
|
static const char firmwareUpdateSection[] PROGMEM = R"rawliteral(
|
|
<form method='POST' action='/update' enctype='multipart/form-data'>
|
|
<h3>Firmware-Update</h3>
|
|
Das Firmware-Update kann durch den Upload einer .bin-Datei durchgeführt werden.<br>
|
|
Nach dem Update wird ein automatischer Neustart durchgeführt.<br>
|
|
Sollte der Neustart nicht erfolgen, so kann dieser auch durch kurzzeitiges Trennen der Stromversorgung erfolgen.<br>
|
|
<br>
|
|
<input type='file' name='firmware' accept='.bin'>
|
|
<br>
|
|
<button>Update starten</button>
|
|
</form>
|
|
)rawliteral";
|
|
|
|
static const char firmwareFileManagerSection[] PROGMEM = R"rawliteral(
|
|
<form method='GET' action='/Dateimanager' target='_blank'enctype='multipart/form-data'>
|
|
<h3>Dateimanager</h3>
|
|
Verwaltung von Dateien des Systems.<br>
|
|
<button type='submit' >Dateimanager</button>
|
|
</form>
|
|
)rawliteral";
|
|
|
|
static const char firmwareExportSection[] PROGMEM = R"rawliteral(
|
|
<form method='GET' action='/exportSettings' enctype='multipart/form-data'>
|
|
<h3>Einstellungen exportieren</h3>
|
|
Sicherung aller aktuellen Einstellungen in einer Datei.<br>
|
|
<button type='submit' >Exportieren</button>
|
|
</form>
|
|
)rawliteral";
|
|
|
|
static const char firmwareImportSection[] PROGMEM = R"rawliteral(
|
|
<form method='POST' action='/importSettings' enctype='multipart/form-data'>
|
|
<h3>Einstellungen importieren</h3>
|
|
Alle Einstellungen aus einer zuvor exportierten .bin-Datei wiederherstellen.<br><br>
|
|
<b style='color: #FFCC00;'>ACHTUNG:</b><br>
|
|
Dieser Vorgang überschreibt ALLE aktuellen Einstellungen!<br>
|
|
Nach dem Import einfolgt ein automatischer Neustart.<br>
|
|
<br>
|
|
<input type='file' name='settings' accept='.bin' required>
|
|
<br>
|
|
<button>Import & Neustart</button>
|
|
</form>
|
|
)rawliteral";
|
|
|
|
static const char firmwareResetSection[] PROGMEM = R"rawliteral(
|
|
<form action='/resetDefaults' method='POST' onsubmit='return confirmResetDefaults();'>
|
|
<h3>Werkseinstellungen</h3>
|
|
Setzt ALLE Einstellungen (mit Ausnahme der WiFi-Konfiguration, der Shot- und Betriebsstundenzähler) auf die Standardwerte zurück.<br><br>
|
|
<b style='color: #FFCC00;'>ACHTUNG:</b><br>
|
|
Es ist zu empfehlen, vorher einen Export der Einstellungen durchzuführen.
|
|
<br>
|
|
<button type='submit' class='danger'>Werkseinstellungen laden</button>
|
|
</form>
|
|
)rawliteral";
|
|
|
|
static const char firmwareBodyEnd[] PROGMEM = R"rawliteral(
|
|
</body>
|
|
</html>
|
|
)rawliteral";
|
|
|
|
|
|
void handleFirmware(AsyncWebServerRequest *request) {
|
|
|
|
AsyncResponseStream *response = request->beginResponseStream("text/html");
|
|
|
|
response->print(FPSTR(firmwareHtmlHead));
|
|
response->print("<link rel=\"stylesheet\" href=\"/style.css\">\n");
|
|
response->print(FPSTR(commonNav));
|
|
|
|
response->print(FPSTR(firmwareBodyStart));
|
|
if (version.length() > 0) { response->print(version); }
|
|
response->print(FPSTR(firmwareInfoChunk2)); if (versionHersteller.length() > 0) { response->print(versionHersteller); }
|
|
response->print(FPSTR(firmwareInfoChunk3)); if (versionHerstellerMail.length() > 0) { response->print(versionHerstellerMail); }
|
|
response->print(FPSTR(firmwareInfoChunk4)); if (versionHerstellerWeb.length() > 0) { response->print(versionHerstellerWeb); }
|
|
response->print(FPSTR(firmwareInfoChunkEnd));
|
|
|
|
response->print(FPSTR(firmwareUpdateSection));
|
|
response->print(FPSTR(firmwareFileManagerSection));
|
|
response->print(FPSTR(firmwareExportSection));
|
|
response->print(FPSTR(firmwareImportSection));
|
|
response->print(FPSTR(firmwareResetSection));
|
|
response->print(FPSTR(firmwareBodyEnd));
|
|
|
|
request->send(response);
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler für AutTune Wasser
|
|
************************************************************************************/
|
|
// --- PROGMEM Chunks für handleAutoTuneWasser ---
|
|
static const char autotuneWasserHtmlHead[] PROGMEM = R"rawliteral(
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<title>AutoTune Wasser</title><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'>
|
|
</head>
|
|
)rawliteral";
|
|
|
|
static const char autotuneWasserBodyStart[] PROGMEM = R"rawliteral(
|
|
<body>
|
|
<h1>PID-Tuning</h1>
|
|
)rawliteral";
|
|
|
|
static const char autotuneWasserStartSuccess[] PROGMEM = R"rawliteral(
|
|
<form action='/PID-Tuning-Abbruch' method='POST' >
|
|
<p>AutoTune gestartet: Wasser-PID</p>
|
|
<br>
|
|
<input type='submit' value='PID-Tuning abbrechen'>
|
|
</form>
|
|
)rawliteral";
|
|
|
|
static const char autotuneWasserAlreadyActive[] PROGMEM = R"rawliteral(
|
|
<form action='/PID-Tuning-Abbruch' method='POST' >
|
|
<p style="color: red;">AutoTune ist bereits aktiv!</p>
|
|
<br>
|
|
<input type='submit' value='PID-Tuning abbrechen'>
|
|
</form>
|
|
)rawliteral";
|
|
|
|
static const char autotuneWasserBodyEnd[] PROGMEM = R"rawliteral(
|
|
</body>
|
|
</html>
|
|
)rawliteral";
|
|
|
|
void handleAutoTuneWasser(AsyncWebServerRequest *request) {
|
|
AsyncResponseStream *response = request->beginResponseStream("text/html");
|
|
|
|
response->print(FPSTR(autotuneWasserHtmlHead));
|
|
response->print("<link rel=\"stylesheet\" href=\"/style.css\">\n");
|
|
response->print(FPSTR(commonNav));
|
|
response->print(FPSTR(autotuneWasserBodyStart));
|
|
|
|
if (!autoTuneWasserActive && !autoTuneDampfActive) {
|
|
if (wartungsModusAktiv) {
|
|
wartungsModusAktiv = false;
|
|
EEPROM.get(EEPROM_ADDR_SETPOINT_WASSER, SetpointWasser);
|
|
EEPROM.get(EEPROM_ADDR_SETPOINT_DAMPF, SetpointDampf);
|
|
Serial.println("Wartungsmodus automatisch deaktiviert durch Start von PID-Tuning.");
|
|
}
|
|
startAutoTuneWasser();
|
|
response->print(FPSTR(autotuneWasserStartSuccess));
|
|
} else {
|
|
response->print(FPSTR(autotuneWasserAlreadyActive));
|
|
}
|
|
|
|
response->print(FPSTR(autotuneWasserBodyEnd));
|
|
request->send(response);
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler für AutTune Dampf
|
|
************************************************************************************/
|
|
|
|
// --- PROGMEM Chunks für handleAutoTuneDampf ---
|
|
static const char autotuneDampfHtmlHead[] PROGMEM = R"rawliteral(
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<title>AutoTune Dampf</title><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'>
|
|
</head>
|
|
)rawliteral";
|
|
|
|
// BodyStart, AlreadyActive und BodyEnd können von handleAutoTuneWasser wiederverwendet werden
|
|
// (autotuneWasserBodyStart, autotuneWasserAlreadyActive, autotuneWasserBodyEnd)
|
|
|
|
static const char autotuneDampfStartSuccess[] PROGMEM = R"rawliteral(
|
|
<form action='/PID-Tuning-Abbruch' method='POST' >
|
|
<p>AutoTune gestartet: Dampf-PID</p>
|
|
<br>
|
|
<input type='submit' value='PID-Tuning abbrechen'>
|
|
</form>
|
|
)rawliteral";
|
|
|
|
void handleAutoTuneDampf(AsyncWebServerRequest *request) {
|
|
AsyncResponseStream *response = request->beginResponseStream("text/html");
|
|
|
|
response->print(FPSTR(autotuneDampfHtmlHead));
|
|
response->print("<link rel=\"stylesheet\" href=\"/style.css\">\n");
|
|
response->print(FPSTR(commonNav));
|
|
response->print(FPSTR(autotuneWasserBodyStart)); // Wiederverwendet
|
|
|
|
if (!autoTuneWasserActive && !autoTuneDampfActive) {
|
|
if (wartungsModusAktiv) {
|
|
wartungsModusAktiv = false;
|
|
EEPROM.get(EEPROM_ADDR_SETPOINT_WASSER, SetpointWasser);
|
|
EEPROM.get(EEPROM_ADDR_SETPOINT_DAMPF, SetpointDampf);
|
|
Serial.println("Wartungsmodus automatisch deaktiviert durch Start von PID-Tuning.");
|
|
}
|
|
startAutoTuneDampf();
|
|
response->print(FPSTR(autotuneDampfStartSuccess));
|
|
} else {
|
|
response->print(FPSTR(autotuneWasserAlreadyActive));
|
|
}
|
|
|
|
response->print(FPSTR(autotuneWasserBodyEnd));
|
|
request->send(response);
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler zum Speichern der AutoTune-Einstellungen - ausgelagert
|
|
************************************************************************************/
|
|
void handleUpdateAutotuneSettings(AsyncWebServerRequest *request) {
|
|
bool changed = false;
|
|
|
|
// --- Wasser Parameter ---
|
|
if (request->hasParam("tuningStepWasser", true)) { tuningStepWasser = request->getParam("tuningStepWasser", true)->value().toFloat(); EEPROM.put(EEPROM_ADDR_TUNING_STEP_WASSER, tuningStepWasser); changed = true; }
|
|
if (request->hasParam("tuningNoiseWasser", true)) { tuningNoiseWasser = request->getParam("tuningNoiseWasser", true)->value().toFloat(); EEPROM.put(EEPROM_ADDR_TUNING_NOISE_WASSER, tuningNoiseWasser); changed = true; }
|
|
if (request->hasParam("tuningStartValueWasser", true)) { tuningStartValueWasser = request->getParam("tuningStartValueWasser", true)->value().toFloat(); EEPROM.put(EEPROM_ADDR_TUNING_STARTVALUE_WASSER, tuningStartValueWasser); changed = true; }
|
|
if (request->hasParam("tuningLookBackWasser", true)) {
|
|
int lookbackInt = request->getParam("tuningLookBackWasser", true)->value().toInt();
|
|
if (lookbackInt >= 0) { tuningLookBackWasser = (unsigned int)lookbackInt; EEPROM.put(EEPROM_ADDR_TUNING_LOOKBACK_WASSER, tuningLookBackWasser); changed = true; }
|
|
}
|
|
|
|
// --- Dampf Parameter ---
|
|
if (request->hasParam("tuningStepDampf", true)) { tuningStepDampf = request->getParam("tuningStepDampf", true)->value().toFloat(); EEPROM.put(EEPROM_ADDR_TUNING_STEP_DAMPF, tuningStepDampf); changed = true; }
|
|
if (request->hasParam("tuningNoiseDampf", true)) { tuningNoiseDampf = request->getParam("tuningNoiseDampf", true)->value().toFloat(); EEPROM.put(EEPROM_ADDR_TUNING_NOISE_DAMPF, tuningNoiseDampf); changed = true; }
|
|
if (request->hasParam("tuningStartValueDampf", true)) { tuningStartValueDampf = request->getParam("tuningStartValueDampf", true)->value().toFloat(); EEPROM.put(EEPROM_ADDR_TUNING_STARTVALUE_DAMPF, tuningStartValueDampf); changed = true; }
|
|
if (request->hasParam("tuningLookBackDampf", true)) {
|
|
int lookbackInt = request->getParam("tuningLookBackDampf", true)->value().toInt();
|
|
if (lookbackInt >= 0) { tuningLookBackDampf = (unsigned int)lookbackInt; EEPROM.put(EEPROM_ADDR_TUNING_LOOKBACK_DAMPF, tuningLookBackDampf); changed = true; }
|
|
}
|
|
|
|
if (changed) {
|
|
if (!EEPROM.commit()) { Serial.println("FEHLER: EEPROM Commit für AutoTune-Settings fehlgeschlagen!"); }
|
|
else { Serial.println("AutoTune-Parameter gespeichert."); }
|
|
}
|
|
|
|
request->redirect("/PID-Tuning");
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler für PID-Tuning
|
|
************************************************************************************/
|
|
|
|
// --- PROGMEM Chunks für handlePidTuning ---
|
|
static const char pidTuningPageHtmlHead[] PROGMEM = R"rawliteral(
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<title>PID-Tuning</title><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'>
|
|
</head>
|
|
)rawliteral";
|
|
|
|
static const char pidTuningPageBodyStart[] PROGMEM = R"rawliteral(
|
|
<body>
|
|
)rawliteral";
|
|
|
|
static const char pidTuningPageAbortForm[] PROGMEM = R"rawliteral(
|
|
<form action='/PID-Tuning-Abbruch' method='POST' >
|
|
<h3>Laufendes PID-Tuning abbrechen?</h3>
|
|
<input type='submit' value='Abbrechen'>
|
|
</form></br>
|
|
)rawliteral";
|
|
|
|
static const char pidTuningPageIntro[] PROGMEM = R"rawliteral(
|
|
<h1>PID-Tuning</h1>
|
|
<form>Das automatische PID-Tuning dient dazu, die optimalen Parameter für den PID-Regler (Proportional-, Integral- und Differentialanteil) selbständig zu ermitteln. Dabei analysiert das System mithilfe von Algorithmen das Regelverhalten (z. B. Reaktion auf einen Testimpuls) und passt Kp, Ki und Kd so an, dass gewünschte Kriterien wie kurze Einschwingzeit, geringe Überschwingung und stabile Regelung erreicht werden
|
|
<br><br>
|
|
Ein AutoTune-Vorgang kann durchaus bis zu 60 Minuten in Anspruch nehmen!
|
|
<br><br>
|
|
<b style='color: #FFCC00;'>WICHTIG:</b><br>
|
|
Vor dem Start des PID-Tunings sollte die Maschine die gewünschte Betriebstemperatur erreicht haben und stabil sein.<br>
|
|
Andernfalls könnten die automatisch ermittelten PID-Werte für diesen Temperaturbereich ungenau oder nicht optimal sein.
|
|
<br><br>
|
|
</form>
|
|
<form action='/AutoTune-Wasser' method='POST' >
|
|
<h3>Automatisches PID-Tuning für Wasser</h3>
|
|
Automatische Ermittlung der PID-Werte für Wasser / Kessel<br>
|
|
<input type='submit' value='Tuning starten'>
|
|
</form>
|
|
<form action='/AutoTune-Dampf' method='POST' >
|
|
<h3>Automatisches PID-Tuning für Dampf</h3>
|
|
Automatische Ermittlung der PID-Werte für Dampf / Thermoblock<br>
|
|
<input type='submit' value='Tuning starten'>
|
|
</form>
|
|
)rawliteral";
|
|
|
|
// --- Chunks für das Parameter-Formular ---
|
|
static const char pidTuningPageParamsFormStart[] PROGMEM = R"rawliteral(
|
|
<form action='/updateAutotuneSettings' method='POST'>
|
|
<h3>AutoTune-Parameter (Zeitproportional)</h3>
|
|
Hier können die AutoTune-Parameter geändert werden.<br>Änderungen sollten mit Vorsicht durchgeführt werden!<br><br>
|
|
<h3>Parameter Wasser / Kessel</h3>
|
|
<label for='tuningStepWasser'>Step (Output 0-)rawliteral"; // Endet vor {WINDOW_SIZE_WASSER}
|
|
static const char pidTuningPageParamsW1[] PROGMEM = R"rawliteral():</label>
|
|
<input type='text' id='tuningStepWasser' name='tuningStepWasser' value=')rawliteral"; // Endet vor {TUNING_STEP_WASSER}
|
|
static const char pidTuningPageParamsW2[] PROGMEM = R"rawliteral('>
|
|
<label for='tuningNoiseWasser'>Noise (°C):</label>
|
|
<input type='text' id='tuningNoiseWasser' name='tuningNoiseWasser' value=')rawliteral"; // Endet vor {TUNING_NOISE_WASSER}
|
|
static const char pidTuningPageParamsW3[] PROGMEM = R"rawliteral('>
|
|
<label for='tuningStartValueWasser'>StartValue (Output 0-)rawliteral"; // Endet vor {WINDOW_SIZE_WASSER}
|
|
static const char pidTuningPageParamsW4[] PROGMEM = R"rawliteral():</label>
|
|
<input type='text' id='tuningStartValueWasser' name='tuningStartValueWasser' value=')rawliteral"; // Endet vor {TUNING_STARTVALUE_WASSER}
|
|
static const char pidTuningPageParamsW5[] PROGMEM = R"rawliteral('>
|
|
<label for='tuningLookBackWasser'>LookBack (Sekunden):</label>
|
|
<input type='text' id='tuningLookBackWasser' name='tuningLookBackWasser' value=')rawliteral"; // Endet vor {TUNING_LOOKBACK_WASSER}
|
|
static const char pidTuningPageParamsDStart[] PROGMEM = R"rawliteral('>
|
|
<br><h3>Parameter Dampf / Thermoblock</h3>
|
|
<label for='tuningStepDampf'>Step (Output 0-)rawliteral"; // Endet vor {WINDOW_SIZE_DAMPF}
|
|
static const char pidTuningPageParamsD1[] PROGMEM = R"rawliteral():</label>
|
|
<input type='text' id='tuningStepDampf' name='tuningStepDampf' value=')rawliteral"; // Endet vor {TUNING_STEP_DAMPF}
|
|
static const char pidTuningPageParamsD2[] PROGMEM = R"rawliteral('>
|
|
<label for='tuningNoiseDampf'>Noise (°C):</label>
|
|
<input type='text' id='tuningNoiseDampf' name='tuningNoiseDampf' value=')rawliteral"; // Endet vor {TUNING_NOISE_DAMPF}
|
|
static const char pidTuningPageParamsD3[] PROGMEM = R"rawliteral('>
|
|
<label for='tuningStartValueDampf'>StartValue (Output 0-)rawliteral"; // Endet vor {WINDOW_SIZE_DAMPF}
|
|
static const char pidTuningPageParamsD4[] PROGMEM = R"rawliteral():</label>
|
|
<input type='text' id='tuningStartValueDampf' name='tuningStartValueDampf' value=')rawliteral"; // Endet vor {TUNING_STARTVALUE_DAMPF}
|
|
static const char pidTuningPageParamsD5[] PROGMEM = R"rawliteral('>
|
|
<label for='tuningLookBackDampf'>LookBack (Sekunden):</label>
|
|
<input type='text' id='tuningLookBackDampf' name='tuningLookBackDampf' value=')rawliteral"; // Endet vor {TUNING_LOOKBACK_DAMPF}
|
|
static const char pidTuningPageParamsFormEnd[] PROGMEM = R"rawliteral('>
|
|
<input type='submit' value='Parameter speichern'>
|
|
</form>
|
|
)rawliteral";
|
|
|
|
static const char pidTuningPageExplanation[] PROGMEM = R"rawliteral(
|
|
<br><hr><br>
|
|
<form>
|
|
<h3>Erklärung der Parameter (Zeitproportional):</h3>
|
|
<p><strong>Noise (°C):</strong><br>
|
|
Beobachte das "Zittern" der Temperaturanzeige, wenn die Temperatur (nahe am Zielwert) stabil ist.<br>Wenn sie z.B. um +/- 0.5°C schwankt, setze Noise auf <code>1.0</code>.<br>Dieser Wert definiert ein Toleranzband, um das Sensorrauschen zu ignorieren.</p>
|
|
<p><strong>StartValue (ms):</strong><br>
|
|
Schätze, wie viel Heizzeit (in Millisekunden, innerhalb des eingestellten Zeitfensters (siehe PID-Einstellung) nötig ist, um die Zieltemperatur konstant zu halten.<br>Dies ist die durchschnittliche Heizzeit im stabilen Zustand (z.B. <code>250</code> ms).</p>
|
|
<p><strong>Step (ms):</strong><br>
|
|
Die Größe des "Sprungs" der Heizzeit (in ms) nach oben/unten um den <code>StartValue</code>, den AutoTune nutzt, um die Temperatur zum Schwingen zu zwingen.<br>Muss groß genug für eine Reaktion sein, aber nicht 0-100% (z.B. <code>500</code> ms).</p>
|
|
<p><strong>LookBack (s):</strong><br>
|
|
AutoTune erzeugt eine langsame Welle der Temperatur. Miss (in einem Testlauf) oder schätze, wie lange eine volle Welle dauert (Spitze zu Spitze, in Sekunden).<br>Setze Lookback auf einen Wert, der *deutlich länger* ist als diese Dauer (z.B. 1.5x so lang; Welle=130s => Lookback=<code>180</code>s).<br>Dieser Wert muss *vor* dem Start festgelegt werden und sagt AutoTune, wie weit es zurückschauen soll, um die Welle zu messen.</p>
|
|
<p><strong>Kontrolle per Chart:</strong><br>
|
|
Während AutoTune läuft, beobachte das Temperaturchart.<br>Wenn sich dort eine langsame, regelmäßige Welle (wie ein \"langgezogener Sinus\") um den Sollwert entwickelt, ist das ein gutes Zeichen, dass der Prozess funktioniert.</p>
|
|
</form>
|
|
</body>
|
|
</html>
|
|
)rawliteral";
|
|
|
|
// --- handlePidTuning ---
|
|
void handlePidTuning(AsyncWebServerRequest *request) {
|
|
char buffer[20];
|
|
|
|
AsyncResponseStream *response = request->beginResponseStream("text/html");
|
|
|
|
response->print(FPSTR(pidTuningPageHtmlHead));
|
|
response->print("<link rel=\"stylesheet\" href=\"/style.css\">\n");
|
|
response->print(FPSTR(commonNav));
|
|
response->print(FPSTR(pidTuningPageBodyStart));
|
|
|
|
if (autoTuneWasserActive || autoTuneDampfActive) { response->print(FPSTR(pidTuningPageAbortForm)); }
|
|
|
|
response->print(FPSTR(pidTuningPageIntro));
|
|
|
|
// Parameter-Formular
|
|
response->print(FPSTR(pidTuningPageParamsFormStart)); snprintf(buffer, sizeof(buffer), "%lu", windowSizeWasser); response->print(buffer);
|
|
response->print(FPSTR(pidTuningPageParamsW1)); snprintf(buffer, sizeof(buffer), "%.2f", tuningStepWasser); response->print(buffer);
|
|
response->print(FPSTR(pidTuningPageParamsW2)); snprintf(buffer, sizeof(buffer), "%.2f", tuningNoiseWasser); response->print(buffer);
|
|
response->print(FPSTR(pidTuningPageParamsW3)); snprintf(buffer, sizeof(buffer), "%lu", windowSizeWasser); response->print(buffer);
|
|
response->print(FPSTR(pidTuningPageParamsW4)); snprintf(buffer, sizeof(buffer), "%.2f", tuningStartValueWasser); response->print(buffer);
|
|
response->print(FPSTR(pidTuningPageParamsW5)); snprintf(buffer, sizeof(buffer), "%u", tuningLookBackWasser); response->print(buffer);
|
|
|
|
response->print(FPSTR(pidTuningPageParamsDStart)); snprintf(buffer, sizeof(buffer), "%lu", windowSizeDampf); response->print(buffer);
|
|
response->print(FPSTR(pidTuningPageParamsD1)); snprintf(buffer, sizeof(buffer), "%.2f", tuningStepDampf); response->print(buffer);
|
|
response->print(FPSTR(pidTuningPageParamsD2)); snprintf(buffer, sizeof(buffer), "%.2f", tuningNoiseDampf); response->print(buffer);
|
|
response->print(FPSTR(pidTuningPageParamsD3)); snprintf(buffer, sizeof(buffer), "%lu", windowSizeDampf); response->print(buffer);
|
|
response->print(FPSTR(pidTuningPageParamsD4)); snprintf(buffer, sizeof(buffer), "%.2f", tuningStartValueDampf); response->print(buffer);
|
|
response->print(FPSTR(pidTuningPageParamsD5)); snprintf(buffer, sizeof(buffer), "%u", tuningLookBackDampf); response->print(buffer);
|
|
response->print(FPSTR(pidTuningPageParamsFormEnd));
|
|
|
|
response->print(FPSTR(pidTuningPageExplanation));
|
|
|
|
request->send(response);
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler für die Antwort nach Abbruch des PID-Tunings - Heap-Optimiert
|
|
************************************************************************************/
|
|
|
|
// PROGMEM Chunks für die Seite (Namen angepasst für Klarheit)
|
|
static const char abortPidTuningHtmlStart[] PROGMEM = R"rawliteral(
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<title>Info</title><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'>
|
|
)rawliteral";
|
|
static const char abortPidTuningHtmlHeadEnd[] PROGMEM = R"rawliteral(</head>)rawliteral";
|
|
static const char abortPidTuningHtmlBody[] PROGMEM = R"rawliteral(
|
|
<body>
|
|
<h1>PID-Tuning Abbruch</h1>
|
|
<form>
|
|
<h3>Das PID-Tuning wurde erfolgreich abgebrochen.</h3>
|
|
<p>Der Normalbetrieb wird nun fortgesetzt.</p>
|
|
</form>
|
|
</body>
|
|
</html>
|
|
)rawliteral";
|
|
|
|
// --- Neue Funktion handlePidTuningAbbruch ---
|
|
void handlePidTuningAbbruch(AsyncWebServerRequest *request) {
|
|
// Seite senden
|
|
AsyncResponseStream *response = request->beginResponseStream("text/html");
|
|
response->print(FPSTR(abortPidTuningHtmlStart));
|
|
response->print("<link rel=\"stylesheet\" href=\"/style.css\">\n");
|
|
response->print(FPSTR(abortPidTuningHtmlHeadEnd));
|
|
response->print(FPSTR(commonNav));
|
|
response->print(FPSTR(abortPidTuningHtmlBody));
|
|
request->send(response);
|
|
|
|
// Eigentliche Abbruch-Logik
|
|
stopAutoTuneWasser();
|
|
stopAutoTuneDampf();
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Speichert Eco-Einstellungen - URL angepasst
|
|
************************************************************************************/
|
|
|
|
void handleEcoUpdate(AsyncWebServerRequest *request) {
|
|
// Parameter aus POST holen
|
|
if (request->hasParam("ecoMode", true)) ecoModeMinutes = request->getParam("ecoMode", true)->value().toInt();
|
|
if (request->hasParam("ecoModeTempWasser", true)) ecoModeTempWasser = request->getParam("ecoModeTempWasser", true)->value().toInt();
|
|
if (request->hasParam("ecoModeTempDampf", true)) ecoModeTempDampf = request->getParam("ecoModeTempDampf", true)->value().toInt();
|
|
dynamicEcoActive = request->hasParam("dynamicEcoMode", true);
|
|
if (request->hasParam("dampfDelay", true)) dampfVerzoegerung = request->getParam("dampfDelay", true)->value().toInt();
|
|
|
|
EEPROM.put(EEPROM_ADDR_ECOMODE_MINUTES, ecoModeMinutes);
|
|
EEPROM.put(EEPROM_ADDR_ECOMODE_TEMP_WASSER, ecoModeTempWasser);
|
|
EEPROM.put(EEPROM_ADDR_ECOMODE_TEMP_DAMPF, ecoModeTempDampf);
|
|
EEPROM.put(EEPROM_ADDR_DYNAMIC_ECO_MODE, dynamicEcoActive);
|
|
EEPROM.put(EEPROM_ADDR_STEAM_DELAY, dampfVerzoegerung);
|
|
EEPROM.commit();
|
|
|
|
if (ecoModeMinutes == 0) {
|
|
ecoModeAktiv = false; ecoModeActivatedTime = 0;
|
|
EEPROM.get(EEPROM_ADDR_SETPOINT_WASSER, SetpointWasser);
|
|
EEPROM.get(EEPROM_ADDR_SETPOINT_DAMPF, SetpointDampf);
|
|
}
|
|
|
|
request->redirect("/ECO");
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Speichert Geräte-Infos
|
|
************************************************************************************/
|
|
|
|
void handleInfoUpdate(AsyncWebServerRequest *request) {
|
|
bool changed = false;
|
|
if (request->hasParam("hersteller", true)) { strncpy(infoHersteller, request->getParam("hersteller", true)->value().c_str(), sizeof(infoHersteller) - 1); infoHersteller[sizeof(infoHersteller) - 1] = '\0'; EEPROM.put(EEPROM_ADDR_INFO_HERSTELLER, infoHersteller); changed = true; }
|
|
if (request->hasParam("modell", true)) { strncpy(infoModell, request->getParam("modell", true)->value().c_str(), sizeof(infoModell) - 1); infoModell[sizeof(infoModell) - 1] = '\0'; EEPROM.put(EEPROM_ADDR_INFO_MODELL, infoModell); changed = true; }
|
|
if (request->hasParam("zusatz", true)) { strncpy(infoZusatz, request->getParam("zusatz", true)->value().c_str(), sizeof(infoZusatz) - 1); infoZusatz[sizeof(infoZusatz) - 1] = '\0'; EEPROM.put(EEPROM_ADDR_INFO_ZUSATZ, infoZusatz); changed = true; }
|
|
|
|
if (changed) { EEPROM.commit(); }
|
|
|
|
request->redirect("/Info");
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Speichert das Wartungsintervall
|
|
************************************************************************************/
|
|
|
|
void handleMaintenanceUpdate(AsyncWebServerRequest *request) {
|
|
bool changed = false;
|
|
if (request->hasParam("maintenanceInterval", true)) {
|
|
int newInterval = request->getParam("maintenanceInterval", true)->value().toInt();
|
|
if (newInterval < 0) newInterval = 0;
|
|
if (newInterval != maintenanceInterval) { maintenanceInterval = newInterval; EEPROM.put(EEPROM_ADDR_MAINTENANCE_INTERVAL, maintenanceInterval); changed = true; Serial.printf("Wartungsintervall gesetzt auf: %d Shots\n", maintenanceInterval); }
|
|
}
|
|
|
|
if (changed) { EEPROM.commit(); }
|
|
|
|
request->redirect("/Service");
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler für JSON-Chart-Daten (/Chart-Daten) - Heap-Optimiert
|
|
************************************************************************************/
|
|
void handleChartData(AsyncWebServerRequest *request) {
|
|
// Build JSON string (can be large, consider AsyncJson library for very complex cases)
|
|
String json = "{";
|
|
json += "\"wasser\":" + String(InputWasser, 1) + ",";
|
|
json += "\"setpointwasser\":" + String(SetpointWasser, 1) + ",";
|
|
json += "\"dampf\":" + String(InputDampf, 1) + ",";
|
|
json += "\"setpointdampf\":" + String(SetpointDampf, 1);
|
|
json += "}";
|
|
request->send(200, "application/json", json);
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler für Temperatur-Charts (Live) - URL angepasst
|
|
* Lädt chart.js bevorzugt aus LittleFS, sonst CDN, sonst Fehler.
|
|
* NEU: Auswahl für maximale Datenpunkte hinzugefügt.
|
|
************************************************************************************/
|
|
|
|
// Teil 1: HTML-Start, Meta-Tags (bleibt gleich)
|
|
static const char chartsHtml_HeadStart[] PROGMEM = R"rawliteral(
|
|
<!DOCTYPE html>
|
|
<html lang="de">
|
|
<head>
|
|
<title>Temperatur-Chart</title>
|
|
<meta charset="UTF-8">
|
|
<meta name='theme-color' content='#111111'>
|
|
<meta name='viewport' content='width=device-width, initial-scale=1.0'>
|
|
)rawliteral";
|
|
|
|
// Teil 2: Schließendes Head-Tag (bleibt gleich)
|
|
static const char chartsHtml_HeadEnd[] PROGMEM = "</head>\n";
|
|
|
|
// *** NEU: Selektoren-UI als eigener Chunk ***
|
|
static const char chartsHtml_SelectorsUI[] PROGMEM = R"rawliteral(
|
|
<div class="chart-selectors-container">
|
|
<div class="update-rate-selector">
|
|
<label for="updateRate">Aktualisierungsrate:</label>
|
|
<select id="updateRate">
|
|
<option value="1000">1 Sekunde</option>
|
|
<option value="2000">2 Sekunden</option>
|
|
<option value="3000">3 Sekunden</option>
|
|
<option value="5000">5 Sekunden</option>
|
|
<option value="10000">10 Sekunden</option>
|
|
<option value="15000" selected>15 Sekunden</option>
|
|
<option value="30000">30 Sekunden</option>
|
|
<option value="45000">45 Sekunden</option>
|
|
<option value="60000">60 Sekunden</option>
|
|
</select>
|
|
</div>
|
|
<div class="datapoint-limit-selector">
|
|
<label for="datapointLimit">Max. Datenpunkte:</label>
|
|
<select id="datapointLimit">
|
|
<option value="30">30</option>
|
|
<option value="50">50</option>
|
|
<option value="100" selected>100</option>
|
|
<option value="150">150</option>
|
|
<option value="200">200</option>
|
|
<option value="300">300</option>
|
|
<option value="500">500</option>
|
|
</select>
|
|
</div>
|
|
</div>
|
|
)rawliteral";
|
|
|
|
// Teil 3: Body-Start, Titel, *Platzhalter für Selektoren*, Placeholder für Sensorfehler, Chart-Container-Div
|
|
static const char chartsHtml_BodyStartAndUI[] PROGMEM = R"rawliteral(
|
|
<h1 class="chart-title">Temperatur-Chart</h1>
|
|
|
|
{SELECTOR_UI_PLACEHOLDER}
|
|
|
|
{SENSOR_ERROR_MESSAGES_PLACEHOLDER}
|
|
<div class="chart-container">
|
|
)rawliteral";
|
|
|
|
// Teil 4: Der eigentliche Chart.js Initialisierungs- und Update-Code
|
|
// (Wird im nächsten Schritt angepasst)
|
|
static const char chartsHtml_ChartJSCode[] PROGMEM = R"rawliteral(
|
|
const ctx = document.getElementById('combinedChart').getContext('2d');
|
|
let currentSetpointDampf = 0; let currentSetpointWasser = 0;
|
|
const wasserColor = '#00AEEF'; const dampfColor = '#F7941D';
|
|
const setpointWasserColor = 'rgba(0, 174, 239, 0.7)';
|
|
const setpointDampfColor = 'rgba(247, 148, 29, 0.7)';
|
|
const gridColor = 'rgba(255, 255, 255, 0.1)'; const textColor = '#E0E0E0';
|
|
|
|
// *** NEU: Variable für max. Datenpunkte ***
|
|
let maxDataPoints = parseInt(document.getElementById('datapointLimit').value, 10) || 100; // Init mit Dropdown-Wert oder Fallback
|
|
|
|
const combinedChart = new Chart(ctx, {
|
|
type: 'line', data: { labels: [],
|
|
datasets: [
|
|
{ label: 'Wasser IST', data: [], borderColor: wasserColor, backgroundColor: 'rgba(0, 174, 239, 0.1)', borderWidth: 2, fill: 'start', tension: 0.4, pointRadius: 0, pointHoverRadius: 6, pointHitRadius: 10, pointHoverBackgroundColor: wasserColor },
|
|
{ label: 'Dampf IST', data: [], borderColor: dampfColor, backgroundColor: 'rgba(247, 148, 29, 0.1)', borderWidth: 2, fill: 'start', tension: 0.4, pointRadius: 0, pointHoverRadius: 6, pointHitRadius: 10, pointHoverBackgroundColor: dampfColor },
|
|
{ label: 'Wasser SOLL', data: [], borderColor: setpointWasserColor, borderWidth: 1.5, borderDash: [6, 3], fill: false, tension: 0.1, pointRadius: 0, pointHoverRadius: 0 },
|
|
{ label: 'Dampf SOLL', data: [], borderColor: setpointDampfColor, borderWidth: 1.5, borderDash: [6, 3], fill: false, tension: 0.1, pointRadius: 0, pointHoverRadius: 0 }
|
|
]
|
|
}, options: { responsive: true, maintainAspectRatio: false, animation: false, interaction: { intersect: false, mode: 'index' },
|
|
scales: {
|
|
x: { type: 'category', title: { display: true, text: 'Uhrzeit', color: textColor, font: { size: 13, weight: '300' } }, ticks: { color: textColor, font: { size: 11 }, maxRotation: 0, autoSkip: true, maxTicksLimit: 8 }, grid: { color: gridColor, drawBorder: false } },
|
|
y: { suggestedMin: 0, suggestedMax: 180, title: { display: true, text: 'Temperatur (°C)', color: textColor, font: { size: 13, weight: '300' } }, ticks: { color: textColor, font: { size: 11 }, stepSize: 20, callback: function(value, index, values) { return value + ' °C'; } }, grid: { color: gridColor, drawBorder: false } }
|
|
}, plugins: {
|
|
legend: { position: 'bottom', align: 'center', labels: { color: textColor, font: { size: 12 }, usePointStyle: true, pointStyle: 'rectRounded', boxWidth: 15, padding: 15 } },
|
|
tooltip: { enabled: true, mode: 'index', intersect: false, backgroundColor: 'rgba(0, 0, 0, 0.85)', titleColor: '#ffffff', titleFont: { size: 13, weight: 'bold' }, bodyColor: '#dddddd', bodyFont: { size: 12 }, bodySpacing: 4, borderColor: 'rgba(255, 255, 255, 0.1)', borderWidth: 1, padding: 10, cornerRadius: 8, displayColors: true, boxPadding: 4,
|
|
callbacks: { label: function(context) { let label = context.dataset.label || ''; if (label) { label += ': '; } if (context.parsed.y !== null) { label += context.parsed.y.toFixed(1) + ' °C'; } return label; } }
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
let updateInterval = parseInt(document.getElementById('updateRate').value, 10) || 15000; // Init mit Dropdown-Wert oder Fallback
|
|
let intervalId = null;
|
|
|
|
function fetchData() {
|
|
fetch('/Chart-Daten').then(response => { if (!response.ok) { console.error('Netzwerkantwort war nicht ok:', response.statusText); throw new Error('Network response was not ok'); } return response.json(); })
|
|
.then(data => {
|
|
if (data.setpointwasser !== undefined) currentSetpointWasser = data.setpointwasser; if (data.setpointdampf !== undefined) currentSetpointDampf = data.setpointdampf;
|
|
const now = new Date(); const timeLabel = now.toLocaleTimeString('de-DE');
|
|
const labels = combinedChart.data.labels; const datasets = combinedChart.data.datasets;
|
|
labels.push(timeLabel);
|
|
datasets[0].data.push(data.wasser); datasets[1].data.push(data.dampf); datasets[2].data.push(currentSetpointWasser); datasets[3].data.push(currentSetpointDampf);
|
|
|
|
// *** HIER die Variable verwenden ***
|
|
while (labels.length > maxDataPoints) {
|
|
labels.shift();
|
|
datasets.forEach(dataset => { dataset.data.shift(); });
|
|
}
|
|
combinedChart.update('none');
|
|
}).catch(err => { console.error("Fehler beim Abrufen der Daten:", err); });
|
|
}
|
|
|
|
function startFetching() { if (intervalId) { clearInterval(intervalId); intervalId = null; } fetchData(); intervalId = setInterval(fetchData, updateInterval); console.log(`Chart-Aktualisierung gestartet: Intervall ${updateInterval / 1000} Sekunden.`); }
|
|
|
|
// Event Listener für Update-Rate
|
|
document.getElementById('updateRate').addEventListener('change', function(event) { const newInterval = parseInt(event.target.value, 10); if (!isNaN(newInterval) && newInterval > 0) { updateInterval = newInterval; startFetching(); } });
|
|
|
|
// *** NEU: Event Listener für Max. Datenpunkte ***
|
|
document.getElementById('datapointLimit').addEventListener('change', function(event) {
|
|
const newLimit = parseInt(event.target.value, 10);
|
|
if (!isNaN(newLimit) && newLimit > 0) {
|
|
maxDataPoints = newLimit;
|
|
console.log(`Maximale Datenpunkte geändert auf: ${maxDataPoints}`);
|
|
// Optional: Sofortiges Kürzen der Daten, wenn nötig (siehe unten)
|
|
// const currentLength = combinedChart.data.labels.length;
|
|
// if (currentLength > maxDataPoints) {
|
|
// const excess = currentLength - maxDataPoints;
|
|
// combinedChart.data.labels.splice(0, excess);
|
|
// combinedChart.data.datasets.forEach(dataset => { dataset.data.splice(0, excess); });
|
|
// combinedChart.update('none');
|
|
// }
|
|
}
|
|
});
|
|
|
|
startFetching(); // Initialen Fetch und Intervall starten
|
|
)rawliteral";
|
|
|
|
// Teil 5: Schließendes Body- und HTML-Tag (bleibt gleich)
|
|
static const char chartsHtml_BodyEnd[] PROGMEM = R"rawliteral(
|
|
</body>
|
|
</html>
|
|
)rawliteral";
|
|
|
|
void handleCharts(AsyncWebServerRequest *request)
|
|
{
|
|
bool chartJsLocal = LittleFS.exists("/chart.umd.min.js");
|
|
bool isConnected = (WiFi.status() == WL_CONNECTED);
|
|
String chartJsUrl = "";
|
|
bool canLoadChartJs = false;
|
|
|
|
if (chartJsLocal) { chartJsUrl = "/chart.umd.min.js"; canLoadChartJs = true; Serial.println("Chart-Handler: Verwende lokale chart.umd.min.js"); }
|
|
else if (isConnected) { chartJsUrl = "https://cdn.jsdelivr.net/npm/chart.js@4.4.2/dist/chart.umd.min.js"; canLoadChartJs = true; Serial.println("Chart-Handler: Lade chart.umd.min.js vom CDN."); }
|
|
else { canLoadChartJs = false; Serial.println("Chart-Handler: Kann chart.js nicht laden."); }
|
|
|
|
AsyncResponseStream *response = request->beginResponseStream("text/html");
|
|
|
|
response->print(FPSTR(chartsHtml_HeadStart));
|
|
response->print("<link rel=\"stylesheet\" href=\"/style.css\">\n");
|
|
|
|
if (canLoadChartJs) {
|
|
response->printf("<script src=\"%s\"></script>\n", chartJsUrl.c_str());
|
|
}
|
|
response->print(FPSTR(chartsHtml_HeadEnd));
|
|
response->print("<body>\n");
|
|
response->print(FPSTR(commonNav));
|
|
response->print("<main class=\"chart-page-content\">\n");
|
|
|
|
if (canLoadChartJs) {
|
|
String bodyStart = FPSTR(chartsHtml_BodyStartAndUI);
|
|
String selectorsUI = FPSTR(chartsHtml_SelectorsUI);
|
|
bodyStart.replace(F("{SELECTOR_UI_PLACEHOLDER}"), selectorsUI);
|
|
|
|
String errorMessageHtml = "";
|
|
if (demoModus) { errorMessageHtml = "<div class=\"sensor-error-message\"><b>Demo-Betrieb:</b><br>Es sind keine Sensoren angeschlossen und daher keine Temperaturwerte verfügbar.</div>"; }
|
|
else if (wasserSensorError && dampfSensorError) { errorMessageHtml = "<div class=\"sensor-error-message\">Die Daten der Temperatursensoren sind derzeit nicht verfügbar!<br>Bitte Temperatur-Sensoren prüfen!</div>"; }
|
|
else if (wasserSensorError) { errorMessageHtml = "<div class=\"sensor-error-message\">Temperaturwert für Wasser nicht verfügbar</div>"; }
|
|
else if (dampfSensorError) { errorMessageHtml = "<div class=\"sensor-error-message\">Temperaturwert für Dampf nicht verfügbar</div>"; }
|
|
bodyStart.replace(F("{SENSOR_ERROR_MESSAGES_PLACEHOLDER}"), errorMessageHtml);
|
|
|
|
response->print(bodyStart);
|
|
response->print("<canvas id=\"combinedChart\"></canvas>");
|
|
response->print("</div>\n"); // Schließt chart-container
|
|
response->print("<script>\n");
|
|
response->print(FPSTR(chartsHtml_ChartJSCode));
|
|
response->print("</script>\n");
|
|
} else {
|
|
// Fehlerfall HTML generieren
|
|
response->print("<h1 class='chart-title'>Temperatur-Chart</h1>\n");
|
|
response->print("<div class='chart-error-box'>");
|
|
response->print("<h2>Chart kann nicht angezeigt werden</h2>");
|
|
response->print("<p>Die Chart-Bibliothek (chart.umd.min.js) wurde weder im Dateisystem gefunden, noch besteht eine Internetverbindung zum Laden vom CDN.</p>");
|
|
response->print("<p>Bitte laden Sie die Datei <a href='https://cdn.jsdelivr.net/npm/chart.js@4.4.2/dist/chart.umd.min.js' target='_blank'>chart.umd.min.js</a> herunter und laden Sie sie über den <a href='/Dateimanager' target='_blank'>Dateimanager</a> hoch, oder verbinden Sie das Gerät mit dem Internet.</p>");
|
|
response->print("</div>\n");
|
|
}
|
|
response->print("</main>\n");
|
|
response->print(FPSTR(chartsHtml_BodyEnd));
|
|
request->send(response);
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Profil-Funktionen (Anzeige) - Heap-Optimiert mit Chunked Sending & Leer-Check
|
|
************************************************************************************/
|
|
|
|
// --- PROGMEM Chunks für handleProfiles ---
|
|
// Kopfzeile bleibt gleich wie im Original `profilesHtml`
|
|
static const char profilesHtmlHead[] PROGMEM = R"rawliteral(
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<title>Profile</title><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'>
|
|
)rawliteral";
|
|
// </head> bleibt gleich wie im Original `profilesHtml2`
|
|
static const char profilesHtmlHeadEnd[] PROGMEM = R"rawliteral(
|
|
</head>
|
|
)rawliteral";
|
|
|
|
// Aufteilung von profilesHtml3 in Chunks
|
|
static const char profilesChunk_Intro[] PROGMEM = R"rawliteral(
|
|
<body>
|
|
<h1>Temperaturprofile</h1>
|
|
<form>
|
|
Es können zwei unabhängige Profile angelegt oder geladen werden.<br>
|
|
<br>
|
|
<b>In den Profilen werden gespeichert:</b><br>
|
|
- Setpoint Wasser<br>
|
|
- Setpoint Dampf<br>
|
|
- Eco-Modus-Einstellungen<br>
|
|
- Aufheizen für Dampf verzögern<br>
|
|
- Profilname<br>
|
|
</form>
|
|
<form action='/saveProfile1' method='POST'>
|
|
<h3>Profil 1 (Name: )rawliteral"; // Endet vor dem 1. {PROFILE1NAME}
|
|
static const char profilesChunk_P1_Val[] PROGMEM = R"rawliteral()</h3>
|
|
<label for='profileName1'>Neuen Profilnamen eingeben:</label>
|
|
<input type='text' id='profileName1' name='profileName' value=')rawliteral"; // Endet vor dem 2. {PROFILE1NAME}
|
|
static const char profilesChunk_P1_EndForm[] PROGMEM = R"rawliteral(' maxlength='19'>
|
|
<input type='submit' value='Speichern in Profil 1'>
|
|
</form>
|
|
<form action='/loadProfile1' method='POST'>
|
|
<h3>Profil 1 laden</h3>
|
|
Temperatureinstellungen aus <b>Profil 1</b> laden.<br>
|
|
<input type='submit' value='Profil 1 laden'>
|
|
</form>
|
|
<form action='/saveProfile2' method='POST'>
|
|
<h3>Profil 2 (Name: )rawliteral"; // Endet vor dem 1. {PROFILE2NAME}
|
|
static const char profilesChunk_P2_Val[] PROGMEM = R"rawliteral()</h3>
|
|
<label for='profileName2'>Neuen Profilnamen eingeben:</label>
|
|
<input type='text' id='profileName2' name='profileName' value=')rawliteral"; // Endet vor dem 2. {PROFILE2NAME}
|
|
static const char profilesChunk_P2_EndForm[] PROGMEM = R"rawliteral(' maxlength='19'>
|
|
<input type='submit' value='Speichern in Profil 2'>
|
|
</form>
|
|
<form action='/loadProfile2' method='POST'>
|
|
<h3>Profil 2 laden</h3>
|
|
Temperatureinstellungen aus <b>Profil 2</b> laden<br>
|
|
<input type='submit' value='Profil 2 laden'>
|
|
</form>
|
|
</body>
|
|
</html>
|
|
)rawliteral";
|
|
|
|
void handleProfiles(AsyncWebServerRequest *request)
|
|
{
|
|
TemperatureProfile p1, p2;
|
|
EEPROM.get(EEPROM_ADDR_PROFILE_1, p1); p1.profileName[sizeof(p1.profileName) - 1] = '\0';
|
|
EEPROM.get(EEPROM_ADDR_PROFILE_2, p2); p2.profileName[sizeof(p2.profileName) - 1] = '\0';
|
|
|
|
AsyncResponseStream *response = request->beginResponseStream("text/html");
|
|
|
|
response->print(FPSTR(profilesHtmlHead));
|
|
response->print("<link rel=\"stylesheet\" href=\"/style.css\">\n");
|
|
response->print(FPSTR(profilesHtmlHeadEnd));
|
|
response->print(FPSTR(commonNav));
|
|
|
|
response->print(FPSTR(profilesChunk_Intro));
|
|
if (strlen(p1.profileName) > 0) { response->print(p1.profileName); }
|
|
response->print(FPSTR(profilesChunk_P1_Val));
|
|
if (strlen(p1.profileName) > 0) { response->print(p1.profileName); }
|
|
response->print(FPSTR(profilesChunk_P1_EndForm));
|
|
|
|
if (strlen(p2.profileName) > 0) { response->print(p2.profileName); }
|
|
response->print(FPSTR(profilesChunk_P2_Val));
|
|
if (strlen(p2.profileName) > 0) { response->print(p2.profileName); }
|
|
response->print(FPSTR(profilesChunk_P2_EndForm));
|
|
|
|
request->send(response);
|
|
}
|
|
|
|
// Speichert aktuelles Setup in Profil 1 - URL angepasst
|
|
void handleSaveProfile1(AsyncWebServerRequest *request) {
|
|
TemperatureProfile p;
|
|
EEPROM.get(EEPROM_ADDR_PROFILE_1, p);
|
|
|
|
if (request->hasParam("profileName", true)) {
|
|
strncpy(p.profileName, request->getParam("profileName", true)->value().c_str(), sizeof(p.profileName) - 1);
|
|
p.profileName[sizeof(p.profileName) - 1] = '\0';
|
|
}
|
|
|
|
EEPROM.get(EEPROM_ADDR_SETPOINT_WASSER, p.setpointWasser);
|
|
EEPROM.get(EEPROM_ADDR_SETPOINT_DAMPF, p.setpointDampf);
|
|
p.ecoModeMinutes = ecoModeMinutes;
|
|
p.dynamicEcoActive = dynamicEcoActive;
|
|
p.dampfVerzoegerung = dampfVerzoegerung;
|
|
|
|
EEPROM.put(EEPROM_ADDR_PROFILE_1, p);
|
|
EEPROM.commit();
|
|
|
|
request->redirect("/Profile");
|
|
}
|
|
|
|
|
|
// Lädt Profil 1 in die aktuellen Parameter - URL angepasst
|
|
void handleLoadProfile1(AsyncWebServerRequest *request) {
|
|
TemperatureProfile p;
|
|
EEPROM.get(EEPROM_ADDR_PROFILE_1, p);
|
|
|
|
SetpointWasser = p.setpointWasser;
|
|
SetpointDampf = p.setpointDampf;
|
|
ecoModeMinutes = p.ecoModeMinutes;
|
|
dynamicEcoActive = p.dynamicEcoActive;
|
|
dampfVerzoegerung = p.dampfVerzoegerung;
|
|
|
|
EEPROM.put(EEPROM_ADDR_SETPOINT_WASSER, SetpointWasser);
|
|
EEPROM.put(EEPROM_ADDR_SETPOINT_DAMPF, SetpointDampf);
|
|
EEPROM.put(EEPROM_ADDR_ECOMODE_MINUTES, ecoModeMinutes);
|
|
EEPROM.put(EEPROM_ADDR_DYNAMIC_ECO_MODE, dynamicEcoActive);
|
|
EEPROM.put(EEPROM_ADDR_STEAM_DELAY, dampfVerzoegerung);
|
|
EEPROM.commit();
|
|
|
|
ecoModeAktiv = false; ecoModeActivatedTime = 0;
|
|
|
|
request->redirect("/Profile");
|
|
}
|
|
|
|
// Speichert aktuelles Setup in Profil 2 - Async angepasst
|
|
void handleSaveProfile2(AsyncWebServerRequest *request) {
|
|
TemperatureProfile p;
|
|
EEPROM.get(EEPROM_ADDR_PROFILE_2, p);
|
|
|
|
if (request->hasParam("profileName", true)) {
|
|
strncpy(p.profileName, request->getParam("profileName", true)->value().c_str(), sizeof(p.profileName) - 1);
|
|
p.profileName[sizeof(p.profileName) - 1] = '\0';
|
|
}
|
|
|
|
EEPROM.get(EEPROM_ADDR_SETPOINT_WASSER, p.setpointWasser);
|
|
EEPROM.get(EEPROM_ADDR_SETPOINT_DAMPF, p.setpointDampf);
|
|
p.ecoModeMinutes = ecoModeMinutes;
|
|
p.dynamicEcoActive = dynamicEcoActive;
|
|
p.dampfVerzoegerung = dampfVerzoegerung;
|
|
|
|
EEPROM.put(EEPROM_ADDR_PROFILE_2, p);
|
|
EEPROM.commit();
|
|
|
|
request->redirect("/Profile");
|
|
}
|
|
|
|
// Lädt Profil 2 in die aktuellen Parameter - Async angepasst
|
|
void handleLoadProfile2(AsyncWebServerRequest *request) {
|
|
TemperatureProfile p;
|
|
EEPROM.get(EEPROM_ADDR_PROFILE_2, p);
|
|
|
|
SetpointWasser = p.setpointWasser;
|
|
SetpointDampf = p.setpointDampf;
|
|
ecoModeMinutes = p.ecoModeMinutes;
|
|
dynamicEcoActive = p.dynamicEcoActive;
|
|
dampfVerzoegerung = p.dampfVerzoegerung;
|
|
|
|
EEPROM.put(EEPROM_ADDR_SETPOINT_WASSER, SetpointWasser);
|
|
EEPROM.put(EEPROM_ADDR_SETPOINT_DAMPF, SetpointDampf);
|
|
EEPROM.put(EEPROM_ADDR_ECOMODE_MINUTES, ecoModeMinutes);
|
|
EEPROM.put(EEPROM_ADDR_DYNAMIC_ECO_MODE, dynamicEcoActive);
|
|
EEPROM.put(EEPROM_ADDR_STEAM_DELAY, dampfVerzoegerung);
|
|
EEPROM.commit();
|
|
|
|
ecoModeAktiv = false; ecoModeActivatedTime = 0;
|
|
|
|
request->redirect("/Profile");
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler für die Dateimanager-Seite (/Dateimanager) - Heap-Optimiert
|
|
************************************************************************************/
|
|
|
|
// --- PROGMEM Chunks für handleFileManager ---
|
|
static const char fileMgrHead[] PROGMEM = R"rawliteral(
|
|
<!DOCTYPE html><html lang='de'><head><meta charset='UTF-8'><title>Dateimanager</title>
|
|
<style>
|
|
body { font-family: sans-serif; background-color: #f0f0f0; margin: 15px; }
|
|
ul { list-style: none; padding: 0; }
|
|
li { margin-bottom: 8px; background: #fff; padding: 8px 12px; border: 1px solid #ccc; border-radius: 4px; display: flex; align-items: center; justify-content: space-between; }
|
|
li span { flex-grow: 1; margin-right: 15px; }
|
|
.file-actions { display: flex; align-items: center; gap: 5px; }
|
|
a.button-like, input[type='submit'] { text-decoration: none; background: #eee; padding: 4px 8px; border: 1px solid #ccc; border-radius: 3px; color: #333; cursor: pointer; font-size: 0.9em; }
|
|
a.button-like:hover, input[type='submit']:hover { background: #ddd; }
|
|
form { margin: 0; padding: 0; border: none; display: inline; }
|
|
hr { margin: 20px 0; }
|
|
</style>
|
|
</head><body>
|
|
<h1>Dateimanager (LittleFS)</h1>
|
|
<h2>Vorhandene Dateien</h2>
|
|
<ul>
|
|
)rawliteral"; // Endet nach <ul>
|
|
|
|
static const char fileMgrListItemStart[] PROGMEM = R"rawliteral(<li><span>)rawliteral"; // Start eines Listeneintrags + Span
|
|
static const char fileMgrListItemMid1[] PROGMEM = R"rawliteral( ( )rawliteral"; // Nach Dateiname, vor Größe
|
|
static const char fileMgrListItemMid2[] PROGMEM = R"rawliteral( Bytes)</span><div class='file-actions'><a href='/Datei-Download?name=)rawliteral"; // Nach Größe, bis vor Download-Dateiname
|
|
static const char fileMgrListItemMid3[] PROGMEM = R"rawliteral(' class='button-like' download>Download</a><form action='/Datei-Entfernen' method='GET'><input type='hidden' name='name' value=')rawliteral"; // Nach Download-Dateiname, bis vor Delete-Dateiname
|
|
static const char fileMgrListItemEnd[] PROGMEM = R"rawliteral('><input type='submit' value='Entfernen'></form></div></li>)rawliteral"; // Nach Delete-Dateiname, bis Ende <li>
|
|
|
|
static const char fileMgrNoFiles[] PROGMEM = R"rawliteral(<li><i>Keine Dateien im Dateisystem gefunden.</i></li>)rawliteral";
|
|
static const char fileMgrListError[] PROGMEM = R"rawliteral(<li><i>Fehler beim Auflisten der Dateien.</i></li>)rawliteral";
|
|
static const char fileMgrOpenError[] PROGMEM = R"rawliteral(<li><i>Fehler beim Öffnen des Root-Verzeichnisses.</i></li>)rawliteral";
|
|
|
|
static const char fileMgrListEnd[] PROGMEM = R"rawliteral(</ul><hr>)rawliteral"; // Ende der Liste + Trennlinie
|
|
|
|
static const char fileMgrUploadForm[] PROGMEM = R"rawliteral(
|
|
<h2>Datei hochladen</h2>
|
|
<form method='POST' action='/Datei-Upload' enctype='multipart/form-data'>
|
|
<input type='file' name='upload' required><br><br>
|
|
<input type='submit' value='Datei Hochladen'>
|
|
</form>
|
|
)rawliteral";
|
|
|
|
static const char fileMgrInfoStart[] PROGMEM = R"rawliteral(<hr><h2>Info</h2>)rawliteral";
|
|
static const char fileMgrInfoTotal[] PROGMEM = R"rawliteral(Gesamtspeicher: )rawliteral";
|
|
static const char fileMgrInfoUsed[] PROGMEM = R"rawliteral( Bytes<br>Belegt: )rawliteral";
|
|
static const char fileMgrInfoFree[] PROGMEM = R"rawliteral( Bytes<br>Frei: )rawliteral";
|
|
static const char fileMgrInfoEnd[] PROGMEM = R"rawliteral( Bytes<br>)rawliteral";
|
|
static const char fileMgrInfoError[] PROGMEM = R"rawliteral(Fehler beim Abrufen der Dateisystem-Informationen.<br>)rawliteral";
|
|
|
|
static const char fileMgrBodyEnd[] PROGMEM = R"rawliteral(</body></html>)rawliteral";
|
|
|
|
|
|
void handleFileManager(AsyncWebServerRequest *request) {
|
|
Serial.println("Anfrage für /Dateimanager empfangen (Async).");
|
|
char buffer[20];
|
|
|
|
AsyncResponseStream *response = request->beginResponseStream("text/html");
|
|
|
|
response->print(FPSTR(fileMgrHead));
|
|
|
|
// --- Dateien auflisten ---
|
|
int fileCount = 0;
|
|
Dir dir = LittleFS.openDir("/");
|
|
while (dir.next()) {
|
|
fileCount++;
|
|
String currentFileName = dir.fileName();
|
|
size_t currentFileSize = dir.fileSize();
|
|
|
|
response->print(FPSTR(fileMgrListItemStart)); if (currentFileName.length() > 0) response->print(currentFileName.c_str());
|
|
response->print(FPSTR(fileMgrListItemMid1)); snprintf(buffer, sizeof(buffer), "%d", currentFileSize); response->print(buffer);
|
|
response->print(FPSTR(fileMgrListItemMid2)); if (currentFileName.length() > 0) response->print(currentFileName.c_str());
|
|
response->print(FPSTR(fileMgrListItemMid3)); if (currentFileName.length() > 0) response->print(currentFileName.c_str());
|
|
response->print(FPSTR(fileMgrListItemEnd));
|
|
}
|
|
|
|
if (fileCount == 0) {
|
|
File root = LittleFS.open("/", "r");
|
|
if (root) { File file = root.openNextFile(); if (!file) { response->print(FPSTR(fileMgrNoFiles)); } else { response->print(FPSTR(fileMgrListError)); file.close(); } root.close(); }
|
|
else { response->print(FPSTR(fileMgrOpenError)); }
|
|
}
|
|
|
|
response->print(FPSTR(fileMgrListEnd));
|
|
response->print(FPSTR(fileMgrUploadForm));
|
|
response->print(FPSTR(fileMgrInfoStart));
|
|
FSInfo fs_info;
|
|
if (LittleFS.info(fs_info)) {
|
|
response->print(FPSTR(fileMgrInfoTotal)); snprintf(buffer, sizeof(buffer), "%u", fs_info.totalBytes); response->print(buffer);
|
|
response->print(FPSTR(fileMgrInfoUsed)); snprintf(buffer, sizeof(buffer), "%u", fs_info.usedBytes); response->print(buffer);
|
|
response->print(FPSTR(fileMgrInfoFree)); snprintf(buffer, sizeof(buffer), "%u", fs_info.totalBytes - fs_info.usedBytes); response->print(buffer);
|
|
response->print(FPSTR(fileMgrInfoEnd));
|
|
} else { response->print(FPSTR(fileMgrInfoError)); }
|
|
response->print(FPSTR(fileMgrBodyEnd));
|
|
|
|
request->send(response);
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler während des Datei-Uploads
|
|
************************************************************************************/
|
|
void handleFileUploadProgress(AsyncWebServerRequest *request, String filename, size_t index, uint8_t *data, size_t len, bool final) {
|
|
if(index == 0){ // UPLOAD_FILE_START
|
|
// Basisschutz gegen Pfadmanipulation
|
|
if (filename.indexOf('/') != -1 && filename.indexOf('/') == 0) {
|
|
filename = filename.substring(filename.lastIndexOf('/') + 1);
|
|
}
|
|
filename = "/" + filename; // Immer im Root speichern
|
|
|
|
Serial.printf("Datei Upload Start: %s\n", filename.c_str());
|
|
fsUploadFile = LittleFS.open(filename, "w");
|
|
if (!fsUploadFile) {
|
|
Serial.println("Konnte Datei für Upload nicht erstellen/öffnen!");
|
|
// Hier könnte man den Request abbrechen, z.B. request->send(500, ...); return;
|
|
}
|
|
}
|
|
|
|
if (fsUploadFile) { // UPLOAD_FILE_WRITE
|
|
size_t bytesWritten = fsUploadFile.write(data, len);
|
|
if (bytesWritten != len) {
|
|
Serial.printf("Fehler beim Schreiben! Erwartet: %d, Geschrieben: %d\n", len, bytesWritten);
|
|
fsUploadFile.close();
|
|
LittleFS.remove(fsUploadFile.name()); // Versuch, unvollständige Datei zu löschen
|
|
// Den Request hier informieren?
|
|
// request->send(500, "text/plain", "Fehler beim Schreiben der Datei");
|
|
// return; // Verhindert weitere Verarbeitung
|
|
}
|
|
} else {
|
|
// Kann passieren, wenn UPLOAD_FILE_START fehlgeschlagen ist
|
|
if (len > 0) { // Nur loggen, wenn tatsächlich Daten kamen
|
|
Serial.println("Datei Upload WRITE, aber keine Datei geöffnet!");
|
|
}
|
|
}
|
|
|
|
if (final) { // UPLOAD_FILE_END
|
|
if (fsUploadFile) {
|
|
String finalName = fsUploadFile.name(); // Name merken vor dem Schließen
|
|
fsUploadFile.close();
|
|
Serial.printf("Datei Upload Ende: %s. Gesamtgröße: %d Bytes\n", finalName.c_str(), index + len);
|
|
} else {
|
|
Serial.println("Datei Upload END, aber keine Datei geöffnet!");
|
|
}
|
|
// Die Antwort wird im handleFileUploadedResponse Handler gesendet, der nach `final=true` aufgerufen wird.
|
|
}
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler NACHDEM der Upload abgeschlossen (oder fehlgeschlagen) ist
|
|
************************************************************************************/
|
|
void handleFileUploadedResponse(AsyncWebServerRequest *request) {
|
|
// Redirect zurück zum Dateimanager.
|
|
request->redirect("/Dateimanager");
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler zum Herunterladen einer Datei
|
|
************************************************************************************/
|
|
void handleFileDownload(AsyncWebServerRequest *request) {
|
|
if (!request->hasParam("name")) {
|
|
request->send(400, "text/plain", "FEHLER: Dateiname zum Herunterladen fehlt!");
|
|
return;
|
|
}
|
|
|
|
String filenameParam = request->getParam("name")->value();
|
|
String filePath = filenameParam;
|
|
|
|
if (!filePath.startsWith("/")) { filePath = "/" + filePath; }
|
|
if (filePath == "/") { request->send(400, "text/plain", "FEHLER: Root-Verzeichnis kann nicht heruntergeladen werden."); return; }
|
|
|
|
Serial.printf("Download-Anfrage für: %s (Parameter: %s)\n", filePath.c_str(), filenameParam.c_str());
|
|
|
|
if (LittleFS.exists(filePath)) {
|
|
// Async sendFile sendet die Datei effizient
|
|
request->send(LittleFS, filePath, "application/octet-stream", true); // true = force download
|
|
Serial.printf("Datei '%s' zum Senden übergeben.\n", filePath.c_str());
|
|
} else {
|
|
Serial.println("Datei zum Herunterladen nicht gefunden!");
|
|
request->send(404, "text/plain", "FEHLER: Datei nicht gefunden.");
|
|
}
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler zum Löschen einer Datei
|
|
************************************************************************************/
|
|
void handleFileDelete(AsyncWebServerRequest *request) {
|
|
if (!request->hasParam("name")) {
|
|
request->send(400, "text/plain", "FEHLER: Dateiname zum Löschen fehlt!");
|
|
return;
|
|
}
|
|
|
|
String filename = request->getParam("name")->value();
|
|
if (!filename.startsWith("/")) { filename = "/" + filename; }
|
|
if (filename == "/") { request->send(400, "text/plain", "FEHLER: Root-Verzeichnis kann nicht gelöscht werden."); return; }
|
|
|
|
Serial.printf("Versuche Datei zu löschen: %s\n", filename.c_str());
|
|
|
|
if (LittleFS.exists(filename)) {
|
|
if (LittleFS.remove(filename)) {
|
|
Serial.println("Datei erfolgreich gelöscht.");
|
|
request->redirect("/Dateimanager");
|
|
} else {
|
|
Serial.println("Fehler beim Löschen der Datei!");
|
|
request->send(500, "text/plain", "FEHLER: Datei konnte nicht gelöscht werden.");
|
|
}
|
|
} else {
|
|
Serial.println("Datei zum Löschen nicht gefunden!");
|
|
request->send(404, "text/plain", "FEHLER: Datei nicht gefunden.");
|
|
}
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler zum Ausliefern der lokalen Chart.js Datei aus LittleFS
|
|
************************************************************************************/
|
|
void handleServeChartJs(AsyncWebServerRequest *request) {
|
|
const char* chartJsPath = "/chart.umd.min.js";
|
|
if (LittleFS.exists(chartJsPath)) {
|
|
request->send(LittleFS, chartJsPath, "text/javascript");
|
|
Serial.println("Lokale chart.umd.min.js ausgeliefert (Async).");
|
|
} else {
|
|
Serial.println("Angeforderte lokale chart.umd.min.js nicht gefunden!");
|
|
request->send(404, "text/plain", "Chart.js nicht gefunden");
|
|
}
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler für den Firmware-Upload-Prozess (während des Uploads)
|
|
************************************************************************************/
|
|
void handleFirmwareUploadProgress(AsyncWebServerRequest *request, String filename, size_t index, uint8_t *data, size_t len, bool final) {
|
|
if(index == 0){ // UPLOAD_FILE_START
|
|
Serial.printf("Firmware Update gestartet: %s\n", filename.c_str());
|
|
passwordFound = false;
|
|
passMatchPos = 0;
|
|
|
|
// Prüfe, ob genügend Speicher vorhanden ist
|
|
// ESP.getFreeSketchSpace() gibt den freien Platz zurück. Update.begin prüft intern nochmals.
|
|
size_t updateSize = (ESP.getFreeSketchSpace() - 0x1000) & 0xFFFFF000;
|
|
if (!Update.begin(updateSize)) {
|
|
Update.printError(Serial);
|
|
// Update kann nicht gestartet werden, hier den Request informieren?
|
|
// z.B. globale Variable setzen und in handleFirmwareUpdateResponse auswerten
|
|
Update.end(false); // Markiere Update als fehlgeschlagen
|
|
return; // Verhindere weitere Verarbeitung
|
|
}
|
|
}
|
|
|
|
// Verarbeite Daten nur, wenn Update.begin erfolgreich war
|
|
if(Update.isRunning()) {
|
|
// Prüfen auf Firmware-Passwort während des Schreibens
|
|
for (size_t i = 0; i < len; i++) {
|
|
char c = (char)data[i];
|
|
if (!passwordFound) {
|
|
if (c == FIRMWARE_PASSWORD[passMatchPos]) {
|
|
passMatchPos++;
|
|
if (passMatchPos == passLength) {
|
|
passwordFound = true;
|
|
Serial.println("Firmware-Kennwort gefunden!");
|
|
}
|
|
} else {
|
|
passMatchPos = (c == FIRMWARE_PASSWORD[0]) ? 1 : 0;
|
|
}
|
|
}
|
|
yield();
|
|
}
|
|
|
|
// Daten in den Flash schreiben
|
|
if (Update.write(data, len) != len) {
|
|
Update.printError(Serial);
|
|
// Fehler beim Schreiben, Update abbrechen
|
|
Update.end(false);
|
|
return; // Verhindere weitere Verarbeitung
|
|
}
|
|
}
|
|
|
|
if (final) { // UPLOAD_FILE_END
|
|
if(Update.isRunning()) { // Nur abschließen, wenn Update noch lief
|
|
if (!passwordFound) {
|
|
Serial.println("Kennwort nicht in Firmware gefunden! Update wird abgebrochen.");
|
|
Update.end(false);
|
|
} else {
|
|
if (Update.end(true)) {
|
|
Serial.printf("Update erfolgreich: %u Bytes\n", index + len);
|
|
} else {
|
|
Update.printError(Serial);
|
|
}
|
|
}
|
|
} else {
|
|
Serial.println("Update Ende empfangen, aber Update lief nicht mehr (vermutlich Fehler zuvor).");
|
|
}
|
|
// Die Antwort wird im handleFirmwareUpdateResponse Handler gesendet.
|
|
}
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler für die Antwort nach einem Firmware-Update - Heap-Optimiert
|
|
************************************************************************************/
|
|
|
|
// PROGMEM Chunks für die Seite
|
|
static const char updateDoneHtmlStart[] PROGMEM = R"rawliteral(
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<title>Firmware-Update</title><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'><meta name='theme-color' content='#000000'><meta name='viewport' content='width=device-width, initial-scale=1.0'>
|
|
)rawliteral";
|
|
static const char updateDoneHtmlHeadEnd[] PROGMEM = R"rawliteral(
|
|
</head>
|
|
)rawliteral";
|
|
static const char updateDoneHtmlBodyStart[] PROGMEM = R"rawliteral(
|
|
<head>
|
|
<meta http-equiv="refresh" content="30;url=/" />
|
|
<script>
|
|
setTimeout(function() {
|
|
window.location.href = "/";
|
|
}, 30000);
|
|
</script>
|
|
<body>
|
|
<h1>)rawliteral"; // Endet vor {status_message}
|
|
static const char updateDoneHtmlBodyEnd[] PROGMEM = R"rawliteral(</h1>
|
|
<form><p>Weiterleitung zur Startseite in 30 Sekunden ...</p></form>
|
|
</body>
|
|
</html>
|
|
)rawliteral"; // Beginnt nach {status_message}
|
|
|
|
void handleFirmwareUpdateResponse(AsyncWebServerRequest *request) {
|
|
String statusMessage;
|
|
// Status basiert auf dem letzten Update-Versuch
|
|
if (!passwordFound && !Update.hasError()) { // Explizit prüfen, ob Fehler durch Passwort war
|
|
statusMessage = F("Update abgebrochen! Die Firmware konnte nicht validiert werden.");
|
|
} else if (Update.hasError()) {
|
|
statusMessage = F("Update fehlgeschlagen!");
|
|
// Optional: Detailliertere Fehlermeldung von Update.getError() holen
|
|
// statusMessage += " (Fehlercode: " + String(Update.getError()) + ")";
|
|
} else {
|
|
statusMessage = F("Update erfolgreich!");
|
|
}
|
|
|
|
// Seite senden
|
|
AsyncResponseStream *response = request->beginResponseStream("text/html");
|
|
response->print(FPSTR(updateDoneHtmlStart));
|
|
response->print("<link rel=\"stylesheet\" href=\"/style.css\">\n");
|
|
response->print(FPSTR(updateDoneHtmlHeadEnd));
|
|
response->print(FPSTR(commonNav));
|
|
response->print(FPSTR(updateDoneHtmlBodyStart));
|
|
if (statusMessage.length() > 0) { response->print(statusMessage); }
|
|
response->print(FPSTR(updateDoneHtmlBodyEnd));
|
|
request->send(response);
|
|
|
|
// Neustart-Logik
|
|
if (!Update.hasError() && passwordFound) { // Nur neustarten bei Erfolg
|
|
delay(1000);
|
|
ESP.restart();
|
|
}
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Schreibt einen gültigen Shot (Dauer > 20s) in die CSV-Logdatei.
|
|
* Dateiname: Nutzungsstatistik.csv
|
|
* Format: UnixTimestamp,DauerInMs
|
|
************************************************************************************/
|
|
void logShot(unsigned long durationMs) {
|
|
// Nur loggen, wenn Zeit synchronisiert ist (prüft Jahr > 2023)
|
|
time_t now_t;
|
|
time(&now_t); // Holt aktuelle Zeit (Unix Timestamp) vom System
|
|
struct tm timeinfo;
|
|
localtime_r(&now_t, &timeinfo); // Konvertiert in lokale Zeit
|
|
|
|
if (timeinfo.tm_year > (2023 - 1900)) { // tm_year ist Jahre seit 1900
|
|
// *** DATEINAME GEÄNDERT ***
|
|
File logFile = LittleFS.open("/Nutzungsstatistik.csv", "a"); // "a" = Append
|
|
if (!logFile) {
|
|
// *** DATEINAME IN FEHLERMELDUNG GEÄNDERT ***
|
|
Serial.println("FEHLER: Konnte Nutzungsstatistik.csv zum Schreiben nicht öffnen!");
|
|
return;
|
|
}
|
|
|
|
String logEntry = String(now_t) + "," + String(durationMs) + "\n";
|
|
if (logFile.print(logEntry)) {
|
|
// Serial.printf("Shot geloggt: %lu ms (Timestamp: %lu)\n", durationMs, now_t); // Optional: Debug-Ausgabe
|
|
} else {
|
|
// *** DATEINAME IN FEHLERMELDUNG GEÄNDERT ***
|
|
Serial.println("FEHLER: Konnte nicht in Nutzungsstatistik.csv schreiben!");
|
|
}
|
|
logFile.close();
|
|
} else {
|
|
Serial.println("WARNUNG: NTP Zeit noch nicht synchronisiert, Shot nicht geloggt.");
|
|
}
|
|
}
|
|
|
|
// --- Hilfsfunktionen für Datumsvergleiche ---
|
|
|
|
bool isSameDay(time_t timestamp, time_t now) {
|
|
struct tm ts_tm, now_tm;
|
|
localtime_r(×tamp, &ts_tm);
|
|
localtime_r(&now, &now_tm);
|
|
return (ts_tm.tm_year == now_tm.tm_year && ts_tm.tm_mon == now_tm.tm_mon && ts_tm.tm_mday == now_tm.tm_mday);
|
|
}
|
|
|
|
bool isSameWeek(time_t timestamp, time_t now) {
|
|
struct tm ts_tm, now_tm;
|
|
localtime_r(×tamp, &ts_tm);
|
|
localtime_r(&now, &now_tm);
|
|
int ts_wday = (ts_tm.tm_wday == 0) ? 6 : ts_tm.tm_wday - 1; // Mo=0..So=6
|
|
int now_wday = (now_tm.tm_wday == 0) ? 6 : now_tm.tm_wday - 1;
|
|
time_t ts_monday_start_of_day = timestamp - ts_tm.tm_hour * 3600 - ts_tm.tm_min * 60 - ts_tm.tm_sec - ts_wday * 86400;
|
|
time_t now_monday_start_of_day = now - now_tm.tm_hour * 3600 - now_tm.tm_min * 60 - now_tm.tm_sec - now_wday * 86400;
|
|
return (ts_monday_start_of_day == now_monday_start_of_day);
|
|
}
|
|
|
|
bool isSameMonth(time_t timestamp, time_t now) {
|
|
struct tm ts_tm, now_tm;
|
|
localtime_r(×tamp, &ts_tm);
|
|
localtime_r(&now, &now_tm);
|
|
return (ts_tm.tm_year == now_tm.tm_year && ts_tm.tm_mon == now_tm.tm_mon);
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Liest die Log-Datei (Nutzungsstatistik.csv) und berechnet Statistiken.
|
|
* Gibt eine ShotStats-Struktur zurück.
|
|
************************************************************************************/
|
|
ShotStats calculateShotStatistics() {
|
|
ShotStats stats; // Initialisiert alle Felder mit 0/false
|
|
|
|
time_t now_t;
|
|
time(&now_t);
|
|
struct tm timeinfo;
|
|
localtime_r(&now_t, &timeinfo);
|
|
// Prüfe, ob die *aktuelle* Zeit gültig erscheint (wichtig für relative Vergleiche wie Gestern etc.)
|
|
bool timeValid = (timeinfo.tm_year > (2023 - 1900)); // Beispiel: Prüft ob Jahr > 2023
|
|
|
|
File logFile = LittleFS.open("/Nutzungsstatistik.csv", "r");
|
|
if (!logFile || logFile.size() == 0) {
|
|
if (logFile) logFile.close();
|
|
stats.historyAvailable = false;
|
|
// Serial.println("Statistik: Log-Datei nicht gefunden oder leer."); // Optional: Debug-Ausgabe
|
|
return stats;
|
|
}
|
|
|
|
stats.historyAvailable = true; // Datei existiert und ist > 0 Bytes
|
|
|
|
int lineCounter = 0; // Zähler für yield()
|
|
while (logFile.available()) {
|
|
String line = logFile.readStringUntil('\n');
|
|
line.trim();
|
|
if (line.length() == 0) continue;
|
|
|
|
int commaIndex = line.indexOf(',');
|
|
if (commaIndex != -1) {
|
|
// strtoull verwenden, um mögliche Überläufe bei 32-Bit time_t zu vermeiden
|
|
time_t timestamp = (time_t)strtoull(line.substring(0, commaIndex).c_str(), NULL, 10);
|
|
unsigned long durationMs = strtoul(line.substring(commaIndex + 1).c_str(), NULL, 10);
|
|
|
|
if (timestamp > 0 && durationMs > 0) { // Grundlegende Prüfung der gelesenen Werte
|
|
stats.totalShotsLogged++;
|
|
stats.totalDurationMs += durationMs;
|
|
|
|
// Ersten und letzten Zeitstempel aktualisieren
|
|
if (stats.firstShotTimestamp == 0 || timestamp < stats.firstShotTimestamp) {
|
|
stats.firstShotTimestamp = timestamp;
|
|
}
|
|
if (timestamp > stats.lastShotTimestamp) {
|
|
stats.lastShotTimestamp = timestamp;
|
|
}
|
|
|
|
// Zeitbasierte Zähler nur füllen, wenn aktuelle Zeit gültig ist
|
|
if (timeValid) {
|
|
if (isSameDay(timestamp, now_t)) { stats.shotsToday++; }
|
|
if (isSameWeek(timestamp, now_t)) { stats.shotsThisWeek++; }
|
|
if (isSameMonth(timestamp, now_t)) { stats.shotsThisMonth++; }
|
|
|
|
// --- NEUE ZÄHLER AKTUALISIEREN ---
|
|
if (isYesterday(timestamp, now_t)) { stats.shotsYesterday++; }
|
|
if (isLastWeek(timestamp, now_t)) { stats.shotsLastWeek++; }
|
|
if (isLastMonth(timestamp, now_t)) { stats.shotsLastMonth++; }
|
|
}
|
|
} else {
|
|
Serial.printf("WARNUNG: Ungültige Zeile in Log übersprungen: %s\n", line.c_str());
|
|
}
|
|
} else {
|
|
Serial.printf("WARNUNG: Komma in Logzeile nicht gefunden: %s\n", line.c_str());
|
|
}
|
|
lineCounter++;
|
|
if (lineCounter % 50 == 0)
|
|
yield(); // Watchdog bei großen Dateien vermeiden
|
|
}
|
|
logFile.close();
|
|
|
|
// Berechnungen nach dem Lesen der Datei
|
|
if (stats.totalShotsLogged > 0) {
|
|
stats.averageDurationSec = (double)stats.totalDurationMs / 1000.0 / stats.totalShotsLogged;
|
|
|
|
// --- Durchschnitt Shots/Tag ---
|
|
if (stats.firstShotTimestamp > 0 && timeValid && now_t > stats.firstShotTimestamp) {
|
|
unsigned long secondsElapsed = now_t - stats.firstShotTimestamp;
|
|
unsigned long daysElapsed = secondsElapsed / 86400UL; // Ganze Tage seit erstem Shot
|
|
if (daysElapsed == 0) { daysElapsed = 1; } // Mindestens 1 Tag annehmen, um Division durch 0 zu vermeiden
|
|
stats.avgShotsPerDay = (double)stats.totalShotsLogged / daysElapsed;
|
|
}
|
|
}
|
|
return stats;
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler zum Erstellen und Senden des formatierten Verlaufs (aus Nutzungsstatistik.csv)
|
|
* als TXT-Datei.
|
|
************************************************************************************/
|
|
void handleDownloadNutzungsstatistik(AsyncWebServerRequest *request) {
|
|
File logFile = LittleFS.open("/Nutzungsstatistik.csv", "r");
|
|
|
|
if (!logFile) { request->send(404, "text/plain", "Fehler: Log-Datei nicht gefunden."); return; }
|
|
if (logFile.size() == 0) { logFile.close(); request->send(200, "text/plain", "Nutzungsstatistik ist leer."); return; }
|
|
|
|
AsyncResponseStream *response = request->beginResponseStream("text/plain; charset=utf-8");
|
|
response->addHeader("Content-Disposition", "attachment; filename=\"Nutzungsverlauf.txt\"");
|
|
|
|
char lineBuffer[100]; char dateBuffer[25]; char durationBuffer[10];
|
|
|
|
response->print("Datum, Uhrzeit, Dauer (s)\n");
|
|
response->print("--------------------------\n");
|
|
|
|
int lineCount = 0;
|
|
while (logFile.available()) {
|
|
String line = logFile.readStringUntil('\n'); line.trim(); if (line.length() == 0) continue;
|
|
int commaIndex = line.indexOf(',');
|
|
if (commaIndex != -1) {
|
|
time_t timestamp = (time_t)strtoull(line.substring(0, commaIndex).c_str(), NULL, 10); // Verwende strtoull
|
|
unsigned long durationMs = strtoul(line.substring(commaIndex + 1).c_str(), NULL, 10);
|
|
if (timestamp > 0 && durationMs > 0) {
|
|
struct tm timeinfo; localtime_r(×tamp, &timeinfo);
|
|
strftime(dateBuffer, sizeof(dateBuffer), "%d.%m.%Y, %H:%M:%S", &timeinfo);
|
|
snprintf(durationBuffer, sizeof(durationBuffer), "%.1f", durationMs / 1000.0);
|
|
snprintf(lineBuffer, sizeof(lineBuffer), "%s, %s\n", dateBuffer, durationBuffer);
|
|
response->print(lineBuffer);
|
|
lineCount++; if (lineCount % 20 == 0) { yield(); }
|
|
}
|
|
}
|
|
yield();
|
|
}
|
|
logFile.close();
|
|
request->send(response); // Send the response stream
|
|
Serial.printf("Formatierter Verlauf mit %d Zeilen gesendet.\n", lineCount);
|
|
}
|
|
|
|
|
|
/************************************************************************************
|
|
* Hilfsfunktionen zum Erstellen der Statistik-Daten
|
|
************************************************************************************/
|
|
|
|
// Prüft, ob der timestamp am Vortag von 'now' liegt
|
|
bool isYesterday(time_t timestamp, time_t now) {
|
|
time_t yesterday_t = now - 86400UL; // Zeitstempel für vor 24 Stunden
|
|
struct tm ts_tm, yest_tm;
|
|
localtime_r(×tamp, &ts_tm); // Konvertiert Timestamp in lokale Zeit-Struktur
|
|
localtime_r(&yesterday_t, &yest_tm); // Konvertiert Zeitstempel von Gestern
|
|
// Prüfen, ob Jahr, Monat und Tag übereinstimmen
|
|
return (ts_tm.tm_year == yest_tm.tm_year && ts_tm.tm_mon == yest_tm.tm_mon && ts_tm.tm_mday == yest_tm.tm_mday);
|
|
}
|
|
|
|
// Prüft, ob der timestamp in der Kalenderwoche *vor* der von 'now' liegt (Annahme: Woche beginnt Montag)
|
|
bool isLastWeek(time_t timestamp, time_t now) {
|
|
struct tm ts_tm, now_tm;
|
|
localtime_r(×tamp, &ts_tm);
|
|
localtime_r(&now, &now_tm);
|
|
|
|
// Berechne den Start der aktuellen Woche (Montag 00:00:00)
|
|
int now_wday = (now_tm.tm_wday == 0) ? 6 : now_tm.tm_wday - 1; // Korrigiert Wochentag Mo=0..So=6
|
|
time_t startOfThisWeek = now - (now_tm.tm_hour * 3600) - (now_tm.tm_min * 60) - now_tm.tm_sec - (now_wday * 86400UL);
|
|
|
|
// Berechne den Start der letzten Woche (Montag 00:00:00)
|
|
time_t startOfLastWeek = startOfThisWeek - (7 * 86400UL);
|
|
|
|
// Prüfe, ob der Timestamp in der letzten Woche liegt (>= Start der letzten Woche UND < Start dieser Woche)
|
|
return (timestamp >= startOfLastWeek && timestamp < startOfThisWeek);
|
|
}
|
|
|
|
|
|
// Prüft, ob der timestamp im Kalendermonat *vor* dem von 'now' liegt
|
|
bool isLastMonth(time_t timestamp, time_t now) {
|
|
struct tm ts_tm, now_tm;
|
|
localtime_r(×tamp, &ts_tm);
|
|
localtime_r(&now, &now_tm);
|
|
|
|
int lastMonth = now_tm.tm_mon - 1; // Monat vor dem aktuellen
|
|
int lastMonthYear = now_tm.tm_year; // Jahr des letzten Monats (Standard: aktuelles Jahr)
|
|
|
|
if (lastMonth < 0) { // Sonderfall: Aktueller Monat ist Januar (tm_mon = 0)
|
|
lastMonth = 11; // Letzter Monat war Dezember (tm_mon = 11)
|
|
lastMonthYear = now_tm.tm_year - 1; // im vorherigen Jahr
|
|
}
|
|
|
|
// Prüfe, ob Jahr und Monat des Timestamps mit dem letzten Monat übereinstimmen
|
|
return (ts_tm.tm_year == lastMonthYear && ts_tm.tm_mon == lastMonth);
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler zum Löschen der Nutzungsstatistik-Datei (/Nutzungsstatistik.csv)
|
|
************************************************************************************/
|
|
void handleDeleteStatistics(AsyncWebServerRequest *request) {
|
|
const char* statsFilename = "/Nutzungsstatistik.csv";
|
|
Serial.printf("Anfrage zum Löschen von '%s' erhalten.\n", statsFilename);
|
|
|
|
bool success = false;
|
|
if (LittleFS.exists(statsFilename)) {
|
|
if (LittleFS.remove(statsFilename)) {
|
|
Serial.printf("Datei '%s' erfolgreich gelöscht.\n", statsFilename);
|
|
success = true;
|
|
// shotCounter = 0; EEPROM.put(EEPROM_ADDR_SHOTCOUNTER, shotCounter); // Optional Zähler resetten
|
|
} else { Serial.printf("FEHLER: Datei '%s' konnte nicht gelöscht werden!\n", statsFilename); }
|
|
} else { Serial.printf("Datei '%s' nicht gefunden, nichts zu löschen.\n", statsFilename); success = true; }
|
|
|
|
request->redirect("/Info");
|
|
}
|
|
|
|
/************************************************************************************
|
|
* Handler zum Umschalten des Wartungsmodus
|
|
************************************************************************************/
|
|
void handleToggleWartungsmodus(AsyncWebServerRequest *request) {
|
|
wartungsModusAktiv = !wartungsModusAktiv;
|
|
if(!wartungsModusAktiv) {
|
|
EEPROM.get(EEPROM_ADDR_SETPOINT_WASSER, SetpointWasser);
|
|
EEPROM.get(EEPROM_ADDR_SETPOINT_DAMPF, SetpointDampf);
|
|
} else {
|
|
SetpointWasser = wartungsModusTemp;
|
|
SetpointDampf = wartungsModusTemp;
|
|
}
|
|
Serial.print("Wartungsmodus: "); Serial.println(wartungsModusAktiv ? "aktiviert" : "deaktiviert");
|
|
|
|
request->redirect("/Service");
|
|
} |