Luftfeuchteschaltung mit kleinem Untermenü und Interrupt

Hallo ihr lieben,

erstmal vorweg... ich bin noch ein ziemlicher Neuling :confused:

ich hab ein Problem mit meinem Untermenü.
Mein Programm sieht wie folgt aus:

Ein LCD gibt Temperatur und Feuchte in der oberen Zeile aus. In der unteren wird die soll Luftfeuchte und Hysterese angezeigt.
Durch drücken auf den Interrupt-Enter-Button, wird das Hauptmenü geöffnet und mit zwei Analog-Buttons jeweils das Untermenü ausgewählt.
Nun soll, wenn ich mich im Hauptmenü befinde, durch drücken des Interrupt-Enter-Button die möglichkeit bestehen, den Wert des Untermenüs zu ändern (später, wenn alles klappt, wird dieser Wert im EEPROM abgespeichert.

Leider wird beim Drücken von Enter im Hauptmenü, der Wert des Untermenüs nicht verändert.
Weiß auch leider nicht wie ich das realisieren kann.

Hier der zusammengebastelte Code:

#include "DHT.h"
#include <EEPROM.h>
#include <Wire.h> 
#include <LiquidCrystal_I2C.h>

//Definiere LCD Pinbelegung
LiquidCrystal_I2C lcd(0x27,16,2);
//DHT Initialisierung
DHT sensor1(11, DHT22);

const int relayPin = 6;

//Variablen t = Temperatur, h = Luftfeuchtigkeit
double t, h; 
//Variablen hys = Hysterese (+-4), sollH = soll Luftfeuchtigkeit(50%)
int hys = 4, sollH = 50;
//Variablen für die Interrupt-Routine
volatile unsigned long alteZeit=0, entprellZeit=20, cal=0;
//Variable für die Zeitsteuerung der Serial Ausgabe
unsigned long previousMillis = 0;
//Variablen für das Hauptmenü und Untermenüs
int merker = 0, pos = 1, subPos1, subPos2;

void setup() {
  // Serielle Ausgabe starten
  Serial.begin(9600);         //Initialisiere Sensoren
  sensor1.begin();
  lcd.init();                 // initialize the lcd 
  lcd.init();
  lcd.backlight();
  pinMode(2, INPUT);          // Pin 2 ist INT0
  digitalWrite(2, HIGH);      // interner Pull up Widerstand auf 5V
  attachInterrupt(0, interruptRoutine, LOW);
  // Pin 2 (INT 0) geht auf LOW (0V) dann interruptRoutine aufrufen
  pinMode(A0,INPUT);          // Taste 0 hoch  
  digitalWrite(A0,HIGH);      // interner pullup Widerstand
  pinMode(A1,INPUT);          // Taste 1 runter
  digitalWrite(A1,HIGH);
  pinMode(A2,INPUT);          // Taste 2 Zurück
  digitalWrite(A2,HIGH);
  pinMode(relayPin, OUTPUT);  //Relay-Pin als Ausgang definieren

}

void loop() {
  //empfange Temperaturdaten und speichere
  t = sensor1.readTemperature(); 
  //empfange Luftfeuchtedaten und speichere
  h = sensor1.readHumidity();
  //Regelbetrieb
  if(cal==0){
      merker = 1;
      lcd.setCursor(0,0);
      lcd.print("H:");
      lcd.print(h);
      lcd.setCursor(7,0);
      lcd.print(" ");
      lcd.setCursor(8,0);
      lcd.print("T:");
      lcd.print(t);
      lcd.setCursor(15,0);
      lcd.print(" ");
      lcd.setCursor(0,1);
      lcd.print("sH:");
      lcd.print(sollH);
      lcd.setCursor(5,1);
      lcd.print("   ");
      lcd.setCursor(8,1);
      lcd.print("Hys:");
      lcd.print(hys);
    }
  //Menü
  if(cal==1) {
      //durch drücken auf ESC, zurück zum Regelbetrieb
      if(readButton(A2)){ 
        cal = 0;
        merker = 0;
        pos = 1;
        subPos1 = 0;
        subPos2 = 0;
        lcd.clear();
        }
      //LCD ausgabe Hauptmenü
      lcd.setCursor(2,0);
      lcd.print("set sollH = ");
      lcd.print(sollH);
      
      lcd.setCursor(2,1);
      lcd.print("set hys = ");
      lcd.print(hys);
      
      
      
      if(pos == 1 && cal == 1){
        subPos2 = 0;
        subPos1 = 1;
        
        lcd.setCursor(0,1);
        lcd.print("  ");
        lcd.setCursor(0,0);
        lcd.print("> ");
        if(pos == 1 && subPos1 == 1) {
          if(digitalRead(2) == LOW){
            subPos1 = 2;
            if(readButton(A0) && subPos1 == 2){
              sollH += 1;  
            }
            if(readButton(A1) && subPos1 == 2){
              sollH -= 1;  
            }
          }
        }
      }
      
      if(pos == 2 && cal == 1){ 
        subPos2 = 1;
        subPos1 = 0;
        
        lcd.setCursor(0,0);
        lcd.print("  ");
        lcd.setCursor(0,1);
        lcd.print("> ");
        if(readButton(2)){
          subPos2 = 2;
          }
        }
        
      
      if(readButton(A0)){ 
        pos = 1;      
      }
      
      if(readButton(A1)){ 
        pos = 2;  
      }
      
    }
  //*******************
  //Relaisesteuerung
  //*******************
  if (h < sollH - hys && digitalRead(relayPin) == HIGH){
    digitalWrite(relayPin, LOW);
    }
  if (h > sollH + hys && digitalRead(relayPin) == LOW){
    digitalWrite(relayPin, HIGH);
    }
  
  //**********************
  //Serial Ausgabe
  //**********************
  if (millis() - previousMillis > 1000) {
        previousMillis = millis();   // aktuelle Zeit abspeichern
        if (isnan(h) || isnan(t)) {
        Serial.println("Failed to read from DHT sensor!");
        return;
          }else{
        Serial.print("Temperatur: ");
        Serial.println(t);
        Serial.print("Luftfeuchte: ");
        Serial.println(h);
          }
        if(digitalRead(relayPin) == LOW){Serial.println("Relay an!");
          }else{Serial.println("Relay aus!");
          }
        if(cal == 1){Serial.println("Menue gestartet");
          }else{Serial.println("Menue gestoppt");
          }
        Serial.print("Untermenue 1: ");
        Serial.println(subPos1);
        Serial.print("Untermenue 2: ");
        Serial.println(subPos2);
        Serial.println("***********************");
        Serial.println("");
    }
  }
  


void interruptRoutine() {
  if((millis() - alteZeit) > entprellZeit) { 
    // innerhalb der entprellZeit nichts machen
    if(pos == 1 && subPos1 == 1 && cal == 1){
      subPos1 = 2;
      }
    alteZeit = millis(); // letzte Schaltzeit merken 
    //lcd.clear();
    cal = 1; // Einstellmodus wechseln   
  }
}
  
int readButton(int pin) {     // Taste einlesen
  if(analogRead(pin) < 500) { // Analog Eingang abfragen
    delay(entprellZeit);            
    if(analogRead(pin) < 500)
      return 1;               // war gedrückt
  }
  return 0;                   // war nicht gedrückt
}
  
  
  int eepromReadInt(int adr) {  
// Integer aus dem EEPROM lesen
byte low, high;
  low=EEPROM.read(adr);
  high=EEPROM.read(adr+1);
  return low + ((high << 8)&0xFF00);
} //eepromReadInt

void eepromWriteInt(int adr, int wert) {
// Integer in das EEPROM schreiben
byte low, high;
  low=wert&0xFF;
  high=(wert >> 8)&0xFF;
  EEPROM.write(adr, low); // dauert 3,3ms
  EEPROM.write(adr+1, high);
  return;
} //eepromWriteInt

Hoffe Ihr könnt mir weiterhelfen

VG
Swacy

Willkommen im Forum!

Wie würde Jurs sinngemäß sagen: "Wer so schnarchlangsame Dinge wie Taster per Interrupt abfragt macht grundlegend was falsch."
Und er hat recht!

Also schmeiß erst mal das Interrupt-Gedönse raus und frag den Taster in der Loop ab. Entprellen nicht vergessen, schau Dir dazu die Debouce-Beispiele an.

Und dann wird's schon besser.

Erstmal vielen vielen Dank für deine schnelle Antwort.

Hat mir auch sehr weitergeholfen.

Zur Entprellung:

Um den Taster nicht Hardware seitig zu entprellen, könnte ich doch auch diesen analog verwenden, den pinMode auf HIGH setzen und eine Abfrage starten, ob der Taster unter 500 gesetzt wurde.

So sollte das gemeint sein:

int readButton(int pin) {     // Taste einlesen
  if(analogRead(pin) < 500) { // Analog Eingang abfragen
    delay(entprellZeit);            
    if(analogRead(pin) < 500)
      return 1;               // war gedrückt
  }
  return 0;                   // war nicht gedrückt
}

Jo, das geht auch so, aber analog ist unnötig.

Pullup aktivieren und Taster nach Low schalten ist komfortabel, digitalread auch einfacher im Handling als erst analog einlesen und dann abfragen.

Bist also auf dem richtigen Weg!