Homescreen Working

KugelmühleSchaltplan/KugelmühleSchaltplan.kicad_pro

@@ -429,7 +429,7 @@
         "uuid": "08a39202-f0bc-425a-a79b-1d2766a907c0"
       }
     ],
-    "used_designators": "U1-2,SW1-3,J1",
+    "used_designators": "U1-2,SW1-3,Display1,J1",
     "variants": []
   },
   "sheets": [

KugelmühleSchaltplan/~KugelmühleSchaltplan.kicad_pcb.lck

@@ -0,0 +1 @@
+{"hostname":"JANNIS-PC","username":"janni"}

display_ui.cpp

@@ -2,7 +2,27 @@
 #include <Wire.h>
 #include <U8g2lib.h>
 
-// U8g2-Objekt bleibt gekapselt in dieser Datei
+// Bitmaps & Animation-Dateien aus Lopaka
+//#include "Clock.h"
+//#include "Clock.h"
+//#include "fire_flames.h"
+
+uint32_t lastDispTime = 0;
+
+// Statische Bitmap aus Lopaka
+static const unsigned char image_paint_27_bits[] U8X8_PROGMEM = {
+  0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,
+  0x00,0x00,0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
+  0x00,0x00,0x01,0x00
+};
+
+// Animations-Zähler
+//static uint8_t fire_flames_frame = 0;
+//static uint8_t Clock_frame = 0;
+
+// U8g2-Display-Objekt
 static U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
 
 void initDisplay() {
@@ -11,10 +31,86 @@ void initDisplay() {
   u8g2.begin();
 }
 
+// #############################################################
+// ANIMATIONEN BERECHNEN & ZEICHNEN
+// #############################################################
+static void updateAnimations() {
+  //fire_flames_frame = (millis() / 77) % 8;
+  //Clock_frame       = (millis() / 200) % 143;
+}
+
+static void drawAnimation_fire_flames() {
+  //u8g2.setDrawColor(1);
+ // u8g2.drawXBMP(80, 30, 21, 32, fire_flames_frames[fire_flames_frame]);
+}
+
+static void drawAnimation_Clock() {
+  //u8g2.setDrawColor(1);
+ // u8g2.drawXBMP(104, 40, 21, 21, Clock_frames[Clock_frame]);
+}
+
 // #############################################################
 // HAUPTANZEIGE
 // #############################################################
-static void drawHomeScreen(int currentSpeed, int curH, int curM, bool timeValid, bool timerActive) {
+static void drawHomeScreen(int currentSpeed, int curH, int curM, bool timeValid, bool timerActive, SystemSettings settings, int curTemp) {
+  u8g2.setFontMode(1);
+  u8g2.setBitmapMode(1);
+  u8g2.setDrawColor(1); // 1 = Weiß (an)
+
+  // 1. Feste Beschriftungen
+  u8g2.setFont(u8g2_font_5x7_tr);
+  u8g2.drawStr(7, 8, "Geschw");
+  u8g2.drawStr(7, 19, "Zeituhr");
+  u8g2.drawStr(7, 30, "Temp");
+
+  // 2. Dynamischer Wert: Geschwindigkeit
+  char speedBuf[10];
+  snprintf(speedBuf, sizeof(speedBuf), "%d", currentSpeed);
+  u8g2.drawStr(51, 8, speedBuf);
+
+  // 3. Dynamische Zeitschaltuhr: Start- und Endzeit
+  char startBuf[8];
+  char endBuf[8];
+  snprintf(startBuf, sizeof(startBuf), "%02d:%02d", settings.startHour, settings.startMin);
+  snprintf(endBuf, sizeof(endBuf), "%02d:%02d", settings.endHour, settings.endMin);
+  
+  u8g2.drawStr(51, 19, startBuf);
+  u8g2.drawLine(79, 16, 83, 16); // Bindestrich zwischen Zeiten
+  u8g2.drawStr(89, 19, endBuf);
+
+  // 4. Dynamische Temperatur (Ist & Soll/Max)
+  // Hinweis: Hier kannst du später deine reale Sensortemperatur übergeben
+  char curTempBuf[10];
+  snprintf(curTempBuf, sizeof(curTempBuf), "%d", curTemp);
+  u8g2.drawStr(52, 30, curTempBuf); 
+  u8g2.drawLine(67, 24, 67, 29); // Trennstrich
+  
+  char maxTempBuf[8];
+  snprintf(maxTempBuf, sizeof(maxTempBuf), "%d", settings.maxTemp);
+  u8g2.drawStr(74, 30, maxTempBuf);
+
+  // 5. Große aktuelle Uhrzeit unten links
+  u8g2.setFont(u8g2_font_6x10_tr);
+  char timeBuf[10];
+  if (timeValid) {
+    snprintf(timeBuf, sizeof(timeBuf), "%02d:%02d", curH, curM);
+  } else {
+    snprintf(timeBuf, sizeof(timeBuf), "--:--");
+  }
+  u8g2.drawStr(4, 60, timeBuf);
+
+  // 6. Lopaka Deko-Bitmap
+  u8g2.drawXBMP(28, 4, 16, 26, image_paint_27_bits);
+
+  // 7. Lopaka Animationen abspielen
+  //drawAnimation_fire_flames();
+  //drawAnimation_Clock();
+}
+
+// #############################################################
+// Zeitschaltuhr
+// #############################################################
+static void drawTimerScreen(TimeEditStep timeEditStep, uint8_t settingIdx, const SystemSettings& settings){
 
 }
 
@@ -24,17 +120,10 @@ static void drawHomeScreen(int currentSpeed, int curH, int curM, bool timeValid,
 static void drawSettingsScreen(uint8_t settingIdx, TimeEditStep timeEditStep, const SystemSettings& s) {
 
     if(timeEditStep != EDIT_NONE){
-        drawTimerScreen(TimeEditStep timeEditStep, uint8_t settingIdx, const SystemSettings& s);
+        drawTimerScreen(timeEditStep, settingIdx, s);
     }
 }
 
-// #############################################################
-// Zeitschaltuhr
-// #############################################################
-static void drawTimerScreen(TimeEditStep timeEditStep, uint8_t settingIdx, const SystemSettings& s){
-
-}
-
 // #############################################################
 // Main Funktion
 // #############################################################
@@ -43,15 +132,18 @@ void updateDisplay(bool inSettings,
                    TimeEditStep editStep, 
                    const SystemSettings& settings, 
                    int currentSpeed, 
-                   int curH, int curM, bool timeValid) {
+                   int curH, int curM, bool timeValid, int curTemp) {
+    if (millis() - lastDispTime >= 50) {
+       lastDispTime = millis();
   
         u8g2.clearBuffer();
 
         if (inSettings) {
             drawSettingsScreen(settingIdx, editStep, settings);
         }else{
-    drawHomeScreen(currentSpeed, curH, curM, timeValid, settings.timerEnabled);
+            drawHomeScreen(currentSpeed, curH, curM, timeValid, settings.timerEnabled, settings, curTemp);
         }
 
         u8g2.sendBuffer();
     }
+}

display_ui.h

@@ -10,4 +10,4 @@ void updateDisplay(bool inSettings,
                    TimeEditStep editStep, 
                    const SystemSettings& settings, 
                    int currentSpeed, 
-                   int curH, int curM, bool timeValid);
+                   int curH, int curM, bool timeValid, int curTemp);

jentest.ino

@@ -0,0 +1,393 @@
+#include <Arduino.h>
+#include <types.h>
+#include <display_ui.h>
+
+
+const char* ssid     = "Stockfeld";
+const char* password = "70691554384740972413";
+
+// NTP-Server & Zeitzone für Deutschland
+const char* ntpServer = "pool.ntp.org";
+const char* tzInfo    = "CET-1CEST,M3.5.0,M10.5.0/3";
+
+FastAccelStepperEngine engine = FastAccelStepperEngine();
+FastAccelStepper *stepper = NULL;
+
+// ################ Variabeln ################
+const uint32_t MAX_SPEED_HZ = 106000;
+const int32_t COLDTEMP_C = 50;
+
+bool clickPlus = 0;
+bool clickMinus = 0;
+bool clickStop = 0;
+bool holdPlus = 0;
+bool holdMinus = 0;
+bool holdStop = 0;
+
+bool shouldRun = true;
+int lastSpeed = 0;
+
+int32_t lastControl = 0;
+uint32_t lastPlotTime = 0;
+
+bool autoStop = false;
+bool bSettings = false;
+uint32_t curTemp = 0;
+
+struct tm timeinfo;
+
+TimeEditStep timeEditStep = EDIT_NONE;
+
+// fest in den Speicher schreiben
+Preferences prefs;
+
+SystemSettings settings;
+
+//#####################################
+//########### Hilfsfunktion ###########
+//#####################################
+
+// Überladung des Präfix-Operators (++timeEditStep)
+TimeEditStep& operator++(TimeEditStep& step) {
+  step = (step == EDIT_END_MIN) ? EDIT_NONE : static_cast<TimeEditStep>(step + 1);
+  return step;
+}
+
+// Werte aus dem Flash speicher laden 
+void loadSettings() {
+  // Namespace öffnen (Name max. 15 Zeichen, "true" = read-only)
+  prefs.begin("timer_cfg", true);
+
+  // Werte auslesen
+  settings.startHour    = prefs.getUChar("s_hour", 0);
+  settings.startMin     = prefs.getUChar("s_min", 0);
+  settings.endHour      = prefs.getUChar("e_hour", 0);
+  settings.endMin       = prefs.getUChar("e_min", 0);
+  settings.timerEnabled = prefs.getBool("t_on", false);
+  settings.maxTemp      = prefs.getShort("max_temp", 70);  
+  settings.accelRate    = prefs.getInt("accel_rate", 2000);
+
+  prefs.end();
+  Serial.println("[NVS] Einstellungen erfolgreich geladen.");
+}
+
+// Save Settings in Flash Speichern 
+void saveSettings() {
+  prefs.begin("timer_cfg", false); // "false" = Read/Write
+
+  prefs.putUChar("s_hour", settings.startHour);
+  prefs.putUChar("s_min", settings.startMin);
+  prefs.putUChar("e_hour", settings.endHour);
+  prefs.putUChar("e_min", settings.endMin);
+  prefs.putBool("t_on", settings.timerEnabled);
+  prefs.putShort("max_temp", settings.maxTemp);  
+  prefs.putInt("accel_rate", settings.accelRate);
+
+  prefs.end();
+  Serial.println("[NVS] Einstellungen im Flash gespeichert.");
+}
+
+void initWiFiAndTime() {
+  WiFi.begin(ssid, password);
+  
+  // Zeitzone und NTP-Server setzen
+  configTzTime(tzInfo, ntpServer);
+
+  // Warten auf Verbindung (optional mit Timeout)
+  int retries = 0;
+  while (WiFi.status() != WL_CONNECTED && retries < 20) {
+    delay(500);
+    retries++;
+  }
+}
+
+//#######################################################
+//####################### Setup #########################
+//#######################################################
+void setup() {
+  Serial.begin(115200);
+  delay(1000); // Zeit für USB-CDC-Verbindung geben
+
+  // Daten aus Flash speicher laden
+  loadSettings();
+
+  engine.init();
+  stepper = engine.stepperConnectToPin(stepPinStepper);
+  
+  if (stepper) {
+    stepper->setDirectionPin(dirPinStepper);
+    stepper->setEnablePin(enablePinStepper, true);
+    stepper->setAutoEnable(true);
+    stepper->setSpeedInHz(MAX_SPEED_HZ);
+  }
+
+  // Pin Config
+  pinMode(buttonPlus, INPUT_PULLUP);
+  pinMode(buttonMinus, INPUT_PULLUP);
+  pinMode(buttonStop, INPUT_PULLUP);
+
+  initWiFiAndTime();
+
+  initDisplay();
+
+  // Start Animation 
+}
+
+bool getCurrentTime(int &hour, int &minute, int &second) {
+  if (!getLocalTime(&timeinfo, 50)) { // 50ms Timeout
+    return false; // Noch keine NTP-Zeit synchronisiert
+  }
+  hour   = timeinfo.tm_hour;
+  minute = timeinfo.tm_min;
+  second = timeinfo.tm_sec;
+  return true;
+}
+
+// Rückgabe von Flanken (Klick) und Pegel (Halten)
+void getInputs(bool &clickPlus, bool &clickMinus, bool &clickStop, 
+               bool &holdPlus,  bool &holdMinus,  bool &holdStop) {
+  
+  // Physische Pegel einlesen (Active-Low)
+  bool curPlus  = (digitalRead(buttonPlus) == LOW);
+  bool curMinus = (digitalRead(buttonMinus) == LOW);
+  bool curStop  = (digitalRead(buttonStop) == LOW);
+
+  // Speicher für vorherigen Durchlauf
+  static bool lastPlus  = false;
+  static bool lastMinus = false;
+  static bool lastStop  = false;
+
+  // Nur bei Veränderung true (Sperre)
+  clickPlus  = (curPlus  && !lastPlus);
+  clickMinus = (curMinus && !lastMinus);
+  clickStop  = (curStop  && !lastStop);
+
+  // Dauerzustand (für Stepper-Handbetrieb)
+  holdPlus  = curPlus;
+  holdMinus = curMinus;
+  holdStop  = curStop;
+
+  // Zustand für nächsten Durchlauf merken
+  lastPlus  = curPlus;
+  lastMinus = curMinus;
+  lastStop  = curStop;
+}
+
+// Liefert die Aktuelle Temperatur in °C
+int getTempInC(uint8_t senTemp){
+  int milliVolt = analogReadMilliVolts(senTemp);
+  return ((milliVolt - 500)/10);
+}
+
+// Liefert true wenn der Timer aktuell Active ist und false wenn nicht aktiv
+bool isTimerActiveNow(int curH, int curM, int startH, int startM, int endH, int endM) {
+  int current = curH * 60 + curM;
+  int start   = startH * 60 + startM;
+  int end     = endH * 60 + endM;
+
+  // Fall A: Zeitfenster am selben Tag (z. B. 08:00 bis 16:00)
+  if (start <= end) {
+    return (current >= start && current < end);
+  }
+  // Fall B: Zeitfenster über Mitternacht (z. B. 22:00 bis 04:00)
+  else {
+    return (current >= start || current < end);
+  }
+}
+
+// Die Funktion behandelt das gesammte Einstellungs menu
+void setting(){
+  //######### Timer Edit #########
+  if (timeEditStep != EDIT_NONE) {
+    //PLUS GEDRÜCKT: Wert erhöhen
+    if (clickPlus || holdPlus) {
+      switch (timeEditStep) {
+        case EDIT_START_HOUR:
+          settings.startHour = (settings.startHour + 1) % 24;
+          break;
+        case EDIT_START_MIN:
+          settings.startMin = (settings.startMin + 5) % 60;
+          break;
+        case EDIT_END_HOUR:
+          settings.endHour = (settings.endHour + 1) % 24;
+          break;
+        case EDIT_END_MIN:
+          settings.endMin = (settings.endMin + 5) % 60;
+          break;
+        default: break;
+      }
+    }
+
+    // MINUS GEDRÜCKT: Wert verringern
+    if (clickMinus) {
+      switch (timeEditStep) {
+        case EDIT_START_HOUR:
+          settings.startHour = (settings.startHour == 0) ? 23 : settings.startHour - 1;
+          break;
+        case EDIT_START_MIN:
+          settings.startMin = (settings.startMin == 0) ? 59 : settings.startMin -5;
+          break;
+        case EDIT_END_HOUR:
+          settings.endHour = (settings.endHour == 0) ? 23 : settings.endHour - 1;
+          break;
+        case EDIT_END_MIN:
+          settings.endMin = (settings.endMin == 0) ? 59 : settings.endMin - 5;
+          break;
+        default: break;
+      }
+    }
+
+    // STOP GEDRÜCKT: Zum nächsten Wert springen
+    if (clickStop) {
+      ++timeEditStep;
+    }
+
+    return; // Wichtig: Rest der Funktion überspringen, solange editiert wird!
+  }
+
+  //######### Max Temp Edit #########
+  if(settings.editMaxTemp){
+    if(clickPlus){
+      settings.maxTemp = (settings.maxTemp + 5) % 140;
+    }
+    if(clickPlus){
+      settings.maxTemp = (settings.maxTemp == 0) ? -20 : settings.maxTemp - 5;
+    }
+    if(clickStop){
+      settings.editMaxTemp = false;
+    }
+    return; // Wichtig: Rest der Funktion überspringen, solange editiert wird!
+  }
+
+  //######### Beschleunigung Edit #########
+  if(settings.editAcc){
+    if(clickPlus){
+      settings.accelRate = (settings.accelRate + 1000) % 20000;
+    }
+    if(clickPlus){
+      settings.accelRate = (settings.accelRate == 0) ? 0 : settings.accelRate - 1000;
+    }
+    if(clickStop){
+      settings.editAcc = false;
+    }
+    return; // Wichtig: Rest der Funktion überspringen, solange editiert wird!
+  }
+  
+
+  //######### Menü #########
+  // Menü bewegen
+  if(clickPlus){
+   if(settings.settingIdx <= 2){
+      settings.settingIdx++; 
+    }
+  }
+  if(clickMinus){
+    if(settings.settingIdx >=1){
+      settings.settingIdx--;
+    }
+  }
+
+  // Stop zum bestätigen 
+  if (clickStop) {
+    if (settings.settingIdx == 0) {
+      // Zeitschaltuhr-Einstellung starten
+      timeEditStep = EDIT_START_HOUR;
+    } 
+    else if (settings.settingIdx == 1) {
+      // Zeitschaltuhr ON/OFF
+      settings.timerEnabled = !settings.timerEnabled;
+    }else if (settings.settingIdx == 2) {
+      // Temperatur Grenze einstellen
+      settings.editMaxTemp = true;
+    }else if (settings.settingIdx == 3) {
+      // Beschleunigung
+      settings.editAcc = true;
+    }else if (settings.settingIdx == 4) {
+      // Menü verlassen
+      bSettings = false;
+      // Einstellungen Speichern
+      saveSettings();
+    }
+  }
+}
+
+void printStatus(FastAccelStepper *stepper, int speed, int clickPlus, int clickMinus){
+  // Plotter-Ausgabe alle 50 ms (überflutet den Bus nicht)
+  if (millis() - lastPlotTime >= 50) {
+      lastPlotTime = millis();
+    
+    int32_t currentSpeed = stepper->getCurrentSpeedInUs() == 0 ? 0 : (1000000 / stepper->getCurrentSpeedInUs());
+    
+    // Format kompatibel für den Arduino Serial Plotter
+    Serial.print("Current_Speed_U/Min:");
+    Serial.print((60*currentSpeed)/3200);
+    Serial.print(" Accel_Control:");
+    Serial.print(speed);
+    Serial.print(" Btn_Up:");
+    Serial.print(clickPlus ? 5000 : 0);
+    Serial.print(" Btn_Down:");
+    Serial.print(clickMinus ? -5000 : 0);
+    Serial.println();
+  }
+}
+
+//#############################################################
+//#################### MAIN ###################################
+//#############################################################
+void loop() {
+  int32_t speed = 0;
+
+  if (!stepper) {
+    Serial.println("[HALT] Kein Stepper-Objekt aktiv.");
+    delay(1000);
+    return;
+  }
+
+  // Inputs 
+  getInputs(clickPlus, clickMinus, clickStop, holdPlus, holdMinus, holdStop);
+  curTemp = getTempInC(senTemp);
+
+  // zeitschaltuhr prüfen 
+  int curH, curM, curS;
+  if (settings.timerEnabled && getCurrentTime(curH, curM, curS)) {
+    shouldRun = isTimerActiveNow(curH, curM, settings.startHour, settings.startMin, settings.endHour, settings.endMin);
+  }
+
+  if(curTemp >= settings.maxTemp || !shouldRun){
+    autoStop = true;
+  }else if(curTemp <= COLDTEMP_C){
+    autoStop = false; 
+  }
+
+  // Main Control
+  if(bSettings){
+    setting();
+  }else if(clickStop || autoStop){
+    stepper->stopMove();
+    speed = 0;
+    if(clickStop && clickPlus){
+      bSettings = true; 
+    }
+  }else if(holdPlus){
+    speed = settings.accelRate;
+  }else if(holdMinus){
+    speed = -settings.accelRate;
+  }else{
+    speed = 0; 
+  }
+
+  // Action
+  if (speed != lastSpeed) {
+    stepper->moveByAcceleration(speed, true);
+    lastSpeed = speed;
+  }
+
+  int32_t currentSpeed = stepper->getCurrentSpeedInUs() == 0 ? 0 : (1000000 / stepper->getCurrentSpeedInUs());
+
+  bool timeIsValid = getCurrentTime(curH, curM, curS);
+  updateDisplay(bSettings, settings.settingIdx, timeEditStep, settings, currentSpeed, curH, curM, timeIsValid, curTemp);
+
+  // Status ausgabe auf Terminal
+  printStatus(stepper, speed, clickPlus, clickMinus);
+  
+}

main.ino

@@ -265,27 +265,6 @@ void setting(){
   }
 }
 
-void updateDisplay(){
-  if (millis() - lastDispTime >= 50) {
-    lastDispTime = millis();
-    int32_t currentSpeed = stepper->getCurrentSpeedInUs() == 0 ? 0 : (1000000 / stepper->getCurrentSpeedInUs());
-
-    // einstellungs fenster
-    if(bSettings){
-      // Mein Menu
-
-      // Uhrzeit
-
-      // Cursor mit settingIdx
-      //EDIT_START_HOUR
-      //EDIT_START_MIN
-      //EDIT_END_HOUR
-      //EDIT_END_MIN
-
-    }
-  }
-}
-
 void printStatus(FastAccelStepper *stepper, int speed, int clickPlus, int clickMinus){
   // Plotter-Ausgabe alle 50 ms (überflutet den Bus nicht)
   if (millis() - lastPlotTime >= 50) {
@@ -339,7 +318,7 @@ void loop() {
 
   // Main Control
   if(bSettings){
-    settings()
+    setting()
   }else if(clickStop || autoStop){
     stepper->stopMove();
     speed = 0;
@@ -360,7 +339,10 @@ void loop() {
     lastSpeed = speed;
   }
 
-  updateDisplay()
+  int32_t currentSpeed = stepper->getCurrentSpeedInUs() == 0 ? 0 : (1000000 / stepper->getCurrentSpeedInUs());
+
+  bool timeIsValid = getCurrentTime(curH, curM);
+  updateDisplay(bSettings, settings.settingIdx, timeEditStep, &settings, currentSpeed, timeIsValid, curTemp);
 
   // Status ausgabe auf Terminal
   printStatus(stepper, speed, clickPlus, clickMinus);

types.h

@@ -1,53 +1,23 @@
 #pragma once
 #include <Arduino.h>
 #include <FastAccelStepper.h>
+#include <Preferences.h>
 #include <WiFi.h>
 #include <time.h>
 
-const char* ssid     = "DEIN_WLAN_NAME";
-const char* password = "DEIN_PASSWORT";
-
-// NTP-Server & Zeitzone für Deutschland
-const char* ntpServer = "pool.ntp.org";
-const char* tzInfo    = "CET-1CEST,M3.5.0,M10.5.0/3";
-
-FastAccelStepperEngine engine = FastAccelStepperEngine();
-FastAccelStepper *stepper = NULL;
-
 // Pins
-#define dirPinStepper    D1   
+#define dirPinStepper    D8   
-#define enablePinStepper D2   
+#define enablePinStepper D7   
-#define stepPinStepper   D3   
+#define stepPinStepper   D9   
 
-#define buttonPlus   D7
+#define buttonPlus   D1
-#define buttonMinus D8
+#define buttonMinus D2
-#define buttonStop D9 
+#define buttonStop D3 
 
 #define senTemp D0 
 #define I2C_SDA D4 
 #define I2C_SCL D5 
 
-// ################ Variabeln ################
-const uint32_t MAX_SPEED_HZ = 106000;
-const int32_t COLDTEMP_C = 50;
-
-bool clickPlus = 0;
-bool clickMinus = 0;
-bool clickStop = 0;
-bool holdPlus = 0;
-bool holdMinus = 0;
-bool holdStop = 0;
-
-int32_t lastControl = 0;
-uint32_t lastPlotTime = 0;
-
-uint32_t lastDispTime = 0;
-bool autoStop = false;
-bool bSettings = false;
-uint32_t curTemp = 0;
-
-struct tm timeinfo;
-
 struct settings{
   int settingIdx = 0;
   int startHour = 0; 
@@ -59,7 +29,7 @@ struct settings{
   int16_t maxTemp = 70; //in °C 
   bool editAcc = false;
   int32_t accelRate = 2000; 
-}
+};
 
 enum TimeEditStep {
   EDIT_NONE = 0,    // Normales Menü (Navigation)
@@ -69,20 +39,20 @@ enum TimeEditStep {
   EDIT_END_MIN      // 4. End-Minute einstellen (0-59)
 };
 
-TimeEditStep timeEditStep = EDIT_NONE;
 
-// fest in den Speicher schreiben
-Preferences prefs;
 
 // Dein Einstellungs-Struct
 struct SystemSettings {
-  uint8_t startHour = 0;
+  int settingIdx = 0;
-  uint8_t startMin  = 0;
+  int startHour = 0; 
-  uint8_t endHour   = 0;
+  int startMin = 0; 
-  uint8_t endMin    = 0;
+  int endHour = 0; 
+  int endMin = 0;
   bool timerEnabled = false;
-  int16_t maxTemp = 70;
+  bool editMaxTemp = false;
+  int16_t maxTemp = 70; //in °C 
+  bool editAcc = false;
   int32_t accelRate = 2000; 
 };
 
-SystemSettings settings;
+