While Schleife verlassen

Hallo, ich frag über Interrups 3 Tasten ab. (Taste auf/ Taste zu/ Taste automatisch)

Solange die Taste/Schalter automatisch gedrückt ist und keine andere Taste gedrückt wird soll er die while Schleife durchführen. Nur leider komm ich nie mehr aus dieser Schleife.
Desweiteren will die Abfrage des LDR in dieser Schleife auch nicht funktionieren…

#include <Bounce2.h>

const uint16_t helldunkelgrenze = 25; //LDR-Wert bei Wunsch-Helligkeit
const byte pinldr = A0; //LDR Spannungsteiler, LDR an Plus-Seite
const uint32_t wartedunkel = (uint32_t)60 * 100; //Millisekunden Wartezeit

int pinmotorhoch = 5;          //const byte pinmotorhoch = 6;          
int pinmotorrunter = 6;           //const byte pinmotorrunter = 7

int tasterAuf = 2;
int tasterZu = 3;
int tasterAuto = 4;

const bool _pushed = LOW; //Pegel bei gedrückten Taster
const bool _AN = HIGH;     //Pegel für aktives Relais

const bool _relased = !_pushed;
const bool _AUS = !_AN;

const byte pinendtasteroben = 10;  //12;
const byte pinendtasterunten = 11; //13;

bool automatisch = false;
bool auf = false;      
bool zu = false;

static uint32_t lastmillis = 0;
static bool sollzu = false;
uint32_t aktmillis = millis();

Bounce  myButtonauf  = Bounce();
Bounce  myButtonzu   = Bounce();
Bounce  myButtonauto = Bounce();

void setup() 
{
  Serial.begin(9600);
  pinMode(pinmotorhoch, OUTPUT);
  pinMode(pinmotorrunter, OUTPUT);
  digitalWrite(pinmotorhoch, _AUS);
  digitalWrite(pinmotorrunter, _AUS);
  
  pinMode(tasterAuf, INPUT_PULLUP);
  pinMode(tasterZu, INPUT_PULLUP);
  pinMode(tasterAuto, INPUT_PULLUP);

  pinMode(pinendtasteroben, INPUT_PULLUP);
  pinMode(pinendtasterunten, INPUT_PULLUP);
  
  myButtonauf.attach(tasterAuf);
  myButtonauf.interval(5); // 5ms zum Entprellen
  myButtonzu.attach(tasterZu);
  myButtonzu.interval(5); // 5ms zum Entprellen
  myButtonauto.attach(tasterAuto);
  myButtonauto.interval(5); // 5ms zum Entprellen

//  Serial.println(Bounce);
  Serial.println(zu);
  Serial.println(automatisch);
}

void loop() 
{
    
  //-------- Taster AUF --------
  myButtonauf.update();
  if (myButtonauf.fallingEdge()) 
  {
     if (auf == false) {        // Abfrage ob der unser logischer Schalter aus ist
      auf = true;              // sollte er aus sein, setzen wir auf auf true 
      zu = false;
      automatisch = false;
    }
    else {
      auf = false;             // sollte der an sein, setzen wir auf auf false
    }
  }
  
  //-------- Taster ZU --------
  myButtonzu.update();
  if (myButtonzu.fallingEdge()) 
  {
     if ( zu == false) {        // Abfrage ob der unser logischer Schalter aus ist
      zu = true;              // sollte er aus sein, setzen wir auf auf true 
      auf = false;
      automatisch = false;
    }
    else {
      zu = false;             // sollte der an sein, setzen wir auf auf false
    }
  }

  //-------- Taster AUTO --------
  myButtonauto.update();
  if (myButtonauto.fallingEdge()) 
  {
     if ( automatisch == false) {      // Abfrage ob der unser logischer Schalter aus ist
      automatisch = true;              // sollte er aus sein, setzen wir auf auf true 
      zu = false;
      auf = false;

    }
    else {
      automatisch = false;             // sollte der an sein, setzen wir auf auf false
    }
  }
delay(10);
 //---------------Textausgabe----------------
 /* Serial.print("Automatisch: ");
  Serial.println(automatisch); 
  Serial.print("auf: ");
  Serial.println(auf);
  Serial.print("zu: ");
  Serial.println(zu);
  delay(100); 
*/
 //----------Steuerung durch Tasten------------ 
  if (auf == true) 
  {           
    digitalWrite(pinmotorhoch, HIGH);   
  }
  if (auf == false) 
  {          
    digitalWrite(pinmotorhoch, LOW);
  }
   if (zu == true) 
  {           
    digitalWrite(pinmotorrunter, HIGH);   
  }
  if (zu == false) 
  {          
    digitalWrite(pinmotorrunter, LOW);
  }

  //---------------Automatische Steuerung-------------

while(automatisch == true )
  {
    uint16_t messwert = analogRead(pinldr);
  if (messwert > helldunkelgrenze ) {     // 27 < 517
    lastmillis = aktmillis;
    sollzu = true;
   // Serial.print("Sollzu:" );
   // Serial.println(sollzu);
    digitalWrite(pinmotorhoch, _AUS);
    digitalWrite(pinmotorrunter, _AN);
    //messwert = analogRead(pinldr);
   // myButtonauto.attach(tasterAuto);
  //  myButtonauto.interval(5); /
   myButtonauto.update();
    Serial.println(automatisch);
    Serial.println(auf);
 } 
  
else if (sollzu && aktmillis - lastmillis < wartedunkel) {
    sollzu = false;
    digitalWrite(pinmotorrunter, _AUS);
    digitalWrite(pinmotorhoch, _AN);
  }
  if (sollzu) {
    if (digitalRead(pinmotorrunter) == _AN && digitalRead(pinendtasterunten) == _pushed) {
      digitalWrite(pinmotorrunter, _AUS);
      Serial.print("TASTERUNTEN");
      Serial.println(pinendtasterunten);
    }
  } else {
    if (digitalRead(pinmotorhoch) == _AN && digitalRead(pinendtasteroben) == _pushed) {
      digitalWrite(pinmotorhoch, _AUS);
      Serial.print("TASTEROBEN");
      Serial.println(pinendtasteroben);
    }

   Serial.println(messwert);
   Serial.print("Sollzu:" );
    Serial.println(sollzu);
  }

  

  }            
}

Hi

Ich sehe keinen Interrupt (mach Dir Nichts daraus - Du brauchst hier auch Keine!!)
Auch lässt sich der Sketch schlecht lesen - drücke Mal STRG+T in der IDE.
Dann: Kommentare - bitte nicht so sparsam damit sein und wichtig: NICHT, was Du Da machst, sondern, was Du da machen willst.

In Deiner WHILE-Schleife wird die Bedingung, Die Du prüfst, nicht mehr angefasst - wenn Diese beim Eintritt in die WHILE true war, wird Sie Das die nächsten 100000 Jahre wohl bleiben.
Du musst die Variable der Bedingung auch innerhalb der WHILE verändern - eben, wenn Du aufhören willst.

MfG

Hi,
Danke wiedereinmal für die rasche Antwort
beenden will ich die Schleife wenn der Taster/Schalter "Auf" oder "zu" gedrückt wird. Nur wie frage ich diese Variablen nochmals ab?

und keine andere Taste gedrückt wird soll er die while Schleife durchführen. Nur leider komm ich nie mehr aus dieser Schleife.

Ja, um aus Schleifen heraus zu kommen, muss man sich schon was einfallen lasen...
z.B. darauf verzichten :o :o :o
(min. eine muss sein)

Ablaufsteuerung
Meine Standardantwort zu Ablaufsteuerungen:

Eine Stichworte Sammlung für Google Suchen:
Endlicher Automat,
ProtoThreads,
State Machine,
Multitasking,
Coroutinen,
Ablaufsteuerung,
Schrittkette,
BlinkWithoutDelay,

Automat (Informatik)
Blink Without Delay
Die Nachtwächter Erklärung

MicroBahner/MobaTools
Intervall Macro
Multitasking Macros
INTERVAL Ersatzstoff
CooperativeTask

Hi

Mache aus der WHILE eine einfache IF.
Wenn dann die Bedingung erfüllt ist, wird der Körper 1x ausgeführt.
loop() beginnt wieder von vorne, Deine Buttons werden abgefragt und wenn die Bedingung immer noch erfüllt ist, wird der Körper auch ein weiteres Mal ausgeführt.

Du hast in loop() schon eine Schleife, Die immer wieder durchlaufen wird.
Du musst ‘nur’ immer jeweils das ausführen, was ‘gerade jetzt’ von Belang ist.

Als Lesestoff hier im Forum die Nachtwächter-Erklärung, als Beispiel in der IDE ‘Blink_without_delay’.

  • die Links von Combie - genau Die willst Du verinnerlichen!

MfG