INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 0 Bewertungen - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Bedingung wird nicht wiederholt ausgeführt
27.03.2019, 14:20
Beitrag #1
Bedingung wird nicht wiederholt ausgeführt
Hallo die Runde,

ich bin aktuell mit einer Bedingung beschäftigt, die jeweils bis zum Reset nur ein mal ausgeführt wird.

Hierzu habe ich einen Digitalen Pin im Setup konfiguriert:
pinMode(Voll, INPUT_PULLUP);

Die seriell übermittelten Werte passen, der Pin (Voll) steht immer auf 1 (HIGH).

Wenn ich den Sketch nun laufen lasse, funktioniert das auch einwandfrei....allerdings nur jeweils 1 mal.
Obwohl der Pin immer auf HIGH steht, wird die Bedingung bei wiederholtem Aufruf nicht mehr richtig ausgeführt....es wird also nicht in die Func_Voll() gesprungen.
Dazu kommt, das die Bedingung der direkt vorher stehenden Nass-Abfrage immer richtig ausgeführt wird und immer richtig zur Func_Nass() gesprungen wird.

Irgendwie ist das Huh

Weiß jemand Rat?

Code:
while (1)
  {

    aktMillis = millis();

    Serial.print("Nass :");
    Serial.println(analogRead(Nass));
    Serial.print("Voll :");
    Serial.println(digitalRead(Voll));

    //Auslesen von A1 (Feuchtesensor), wenn der Messwert < Nass_Grenzwert ist, rufe Func_Nass auf
    if (analogRead(Nass) < Nass_Grenzwert) Func_Nass();

    //Auslesen von Digi Pin 3 (Schwimmerschalter), wenn Pin 3 = LOW ist, rufe Func_Voll auf
    if (digitalRead(Voll) == HIGH) Func_Voll();

Danke & Gruß

Lite
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
27.03.2019, 14:28 (Dieser Beitrag wurde zuletzt bearbeitet: 27.03.2019 14:29 von Hilgi.)
Beitrag #2
RE: Bedingung wird nicht wiederholt ausgeführt
Da du nicht den ganzen Code zeigst, finde ich es schwierig nachzuvollziehen was passiert.
Wenn es genau einfal funzt ist wohl eine Folgebedingung falsch, die können wir aber nur erahnen.
Bitte kompletten Code einpflegen....

Ich könnte mir vorstellen es hat was mit den millis() zu tun dessen auswertung nicht zu ersehen ist.
Vlt aber auch innerhalb deiner aufgerufenen Funktion eine endlosschleife eingebaut... Wer weiss....


Gruß

Nicht denken,...
...nachdenken... Rolleyes

Smarter - LiveData - KLAMM.de
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
27.03.2019, 14:30
Beitrag #3
RE: Bedingung wird nicht wiederholt ausgeführt
Ohne einen vollständigen Sketch können wir dazu nichts sagen. While(1) dürfte erstmal grundlegend ungünstig bis falsch sein.

Du hast doch eine Schleife: loop.

Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
27.03.2019, 16:05
Beitrag #4
RE: Bedingung wird nicht wiederholt ausgeführt
Hallo,

hier der kpl. Code.

Es geht um die Func_Voll, die am Anfang der Func_Anforderung angesprungen werden soll.

@Tommy: Wo habe ich da eine Loop?

Code:
[code]
//  BIBLIOTHEKEN EINBINDEN

//Watchdog Headerdatei einbinden
//#include <avr/wdt.h>

//OneButton Headerdatei einbinden
#include <OneButton.h>
//Pin 12 als Taster-Eingang
OneButton button(12, true);

//LiquidCrystal_I2C Headerdatei für das LCD-Display einbinden
#include <LiquidCrystal_I2C.h>

//LCD 16x2 an Adresse 0x3F konfigurieren oder falls es nicht geht, ggf. an 0x3F
LiquidCrystal_I2C lcd(0x27, 16, 2);

//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■​■■■■
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■​■■■■

//  ANALOGE PINS KONFIGURIEREN (A4 & A5 reserviert für den I2C-Bus)
//Analoger Pin A1 < Feuchtesensor
const byte Nass = 15;

//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■​■■■■
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■​■■■■

//  DIGITALE PINS KONFIGURIEREN
//Digi Pin 9 > Mosfet > MV4 (Rohwasser > Osmosefilter-System)
const byte Rohwasser = 2;

//Digi Pin 3 < Schwimmerschalter NC (Behälter VOLL)
const byte Voll = 3;

//Digi Pin 4 > Taster-LED (Anforderungstaster)
const byte TasterLED = 4;

//Digi Pin 5 > Mosfet > MV3 (Reinwasser > Glasbehälter)
const byte Reinwasser = 5;

//Digi Pin 6 > Mosfet > MV2 (Stehwasser > Abfluss)
const byte StehwasserSpuelung = 6;

//Digi Pin 1 > Mosfet > MV1 (Membranspülung > Abfluss)
const byte MembranSpuelung = 9;

//Digi Pin 13 > aktiver Piezo-Summer
const byte Piezo = 13;

//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■​■■■■
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■​■■■■

//  VARIABLEN DEKLARIEREN
//Aktuell abgelaufene Füllzeit des Behälters in millis
unsigned long Fuellzeit = 0;

//Zeitpunkt der letzten Reinwasserproduktion in millis
unsigned long LastReinwasser = 0;

//+++++++++++++++++++++++++++++++++++++++++++++++++++
//ZUM TEST EINIGE ZEITWERTE DEUTLICH VERRINGERT
//Die richtige Zeit muß am Ende IMMER 1000UL heißen
//+++++++++++++++++++++++++++++++++++++++++++++++++++

//Maximale Füllzeit (5min) des Behälters in millis
const unsigned long Fuellzeit_Grenzwert = (5 * 60 * 20UL); //6s

//Maximale Pausen-Zeit (15min) für Stehwasser in millis
const unsigned long Stehzeit_Grenzwert = (15 * 60 * 10UL); //9s

//Maximale Pausen-Zeit (6h) für Membranspülung in millis
const unsigned long Pause_Grenzwert = (6 * 60 * 60 * 1UL); //21,6s

//(20s) für Membranspüldauer für die Nachspülung in millis
const unsigned long Spuelzeit_Membran = (20 * 500UL); //10s

//(3min.) für Membranspüldauer beim Filterwechsel in millis
const unsigned long Filterwechsel_Membran = (3 * 60 * 50UL); //9s

//(2,5min) für Stehwasserspüldauer in millis
const unsigned long Spuelzeit_Stehw = (2.5 * 60 * 100UL); //15s

//(10min) für Stehwasserspüldauer beim Filterwechsel in millis
const unsigned long Filterwechsel_Stehw = (10 * 60 * 10UL); //6s

//Grenzwert für die Feuchtemessung
const int Nass_Grenzwert = 1010;

//(0,5s) Blinkinterval für die Taster-LED
const int Blink_Interval = (0.5 * 1000);

//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■​■■■■
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■​■■■■

//  SETUP
void setup() {


  Serial.begin(9600);


  // Watchdog-Timer auf 8 Sekunden setzen
  //  wdt_enable (WDTO_8S);

  //LCD initialisieren
  lcd.init();

  //Eingang für Schwimmerschalter
  pinMode(Voll, INPUT_PULLUP);

  //Mit internem Pullup-Widerstand (Anforderungs-Taster schaltet auf Masse)
  pinMode(12, INPUT_PULLUP);

  //Ausgang für Betriebs-LED
  pinMode(TasterLED, OUTPUT);

  //Ausgang über MosFet auf Magnetventil 1
  pinMode(MembranSpuelung, OUTPUT);

  //Ausgang über MosFet auf Magnetventil 2
  pinMode(StehwasserSpuelung, OUTPUT);

  //Ausgang über MosFet auf Magnetventil 3
  pinMode(Reinwasser, OUTPUT);

  //Ausgang über MosFet auf Magnetventil 4
  pinMode(Rohwasser, OUTPUT);

  //Ausgang für aktiven Piezo (Alarm für Feuchte-Behälter und Feuchte-Filter)
  pinMode (Piezo, OUTPUT);

  //Deklaration, bei welchen Clicks zu welcher Funktion gesprungen werden soll
  button.attachClick(Func_Anforderung);
  button.attachDoubleClick(Func_Filterwechsel);
  button.attachDuringLongPress(Func_Desinfektion);

} //Ende Setup

//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■​■■■■
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■​■■■■

//  HAUPTSCHLEIFE

void loop() {

  // Watchdog-Timer zurücksetzen
  //wdt_reset();

  //Alle Magnetventile ZU, Piezo aus, LCD und Taster-LED aus
  digitalWrite(Rohwasser, LOW);
  digitalWrite(Reinwasser, LOW);
  digitalWrite(MembranSpuelung, LOW);
  digitalWrite(StehwasserSpuelung, LOW);
  digitalWrite(Piezo, LOW);
  digitalWrite(TasterLED, LOW);
  lcd.clear();
  lcd.noBacklight ();

  //Überwachung des Tasters über OneButton
  button.tick();

  //Auslesen von A1 (Feuchtesensor)
  //Wenn der Messwert < Nass_Grenzwert ist, rufe Func_Nass auf
  if (analogRead(Nass) < Nass_Grenzwert) Func_Nass();


  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  //Dummy-Displayausgabe nur zum Test

  //Display löschen.
  lcd.clear();

  //LCD-Backlight einschalten
  lcd.backlight();

  //Cursor positionieren (Spalte , Zeile)
  lcd.setCursor ( 5, 0 );

  //Textausgabe
  lcd.print("TEST");

  //Cursor positionieren (Spalte , Zeile)
  lcd.setCursor ( 2, 1 );

  lcd.print ("Hauptschleife");
  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


} //Ende Loop

//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■​■■■■
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■​■■■■

//  FUNKTION WASSERAUSTRITT (NASS)
void Func_Nass() {

  //Display löschen.
  lcd.clear();

  //LCD-Backlight einschalten
  lcd.backlight();

  //Cursor positionieren (Spalte , Zeile)
  lcd.setCursor ( 5, 0 );

  //Textausgabe
  lcd.print("ALARM");

  //Cursor positionieren (Spalte , Zeile)
  lcd.setCursor ( 1, 1 );

  //Textausgabe
  lcd.print ("WASSERAUSTRITT");

  //Endlosschleife (System ist nur durch Beseitigung der Feuchtigkeit und Neustart/Reset in den Normalzustand zu bringen)
  while (1) {

    // Watchdog-Timer zurücksetzen
    //wdt_reset();

    //Alle Magnetventile ZU
    digitalWrite(Rohwasser, LOW);
    digitalWrite(MembranSpuelung, LOW);
    digitalWrite(StehwasserSpuelung, LOW);
    digitalWrite(Reinwasser, LOW);

    //Gib Laut
    digitalWrite(Piezo, HIGH);
    digitalWrite(TasterLED, HIGH);
    delay (250);
    digitalWrite(Piezo, LOW);
    digitalWrite(TasterLED, LOW);
    delay (200);

  } //Ende der while-Endlosschleife

} //Ende Func_Nass

//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■​■■■■
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■​■■■■

//  FUNKTION BEHÄLTER VOLL
void Func_Voll() {

  static unsigned long lastLED = 0;
  static byte LedStatus = LOW;
  static unsigned long lastMillis = 0;
  static unsigned long aktMillis = 0;
  static byte LCDStatus = 0;

  while (1)
  {

    aktMillis = millis();

    //################################################################################​###########################

    //Taster-LED blinken lassen
    if (LedStatus == LOW) {
      if (millis() - lastLED >= Blink_Interval) {
        digitalWrite(TasterLED, HIGH);
        lastLED = millis();
        LedStatus = HIGH;
      } //Ende von if
    } //Ende von if LOW
    else {
      if (millis() - lastLED >= Blink_Interval) {
        digitalWrite(TasterLED, LOW);
        LedStatus = LOW;
        lastLED = millis();
      } //Ende von if
    } //Ende von else

    //################################################################################​###########################

    // Watchdog-Timer zurücksetzen
    //wdt_reset();

    //Magnetventil schließen
    //MV3 schließen
    digitalWrite(Reinwasser, LOW);

    if (LCDStatus == 0) {

      //Display löschen.
      lcd.clear();

      //LCD-Backlight einschalten
      lcd.backlight();

      //Cursor positionieren (Spalte , Zeile)
      lcd.setCursor ( 1, 0 );

      //Textausgabe
      lcd.print("Beh\341lter voll");

      //Cursor positionieren (Spalte , Zeile)
      lcd.setCursor ( 1, 1 );

      //Textausgabe
      lcd.print ("Gehe in Standby");

      lastMillis = aktMillis;

      LCDStatus = 1;

    } //Ende von if LCDStatus

    //MV2 schließen
    digitalWrite(StehwasserSpuelung, LOW);

    //MV1 und MV4 verzögert schließen (Kurze Membran-Nachspülung)
    digitalWrite(MembranSpuelung, HIGH);
    digitalWrite(Rohwasser, HIGH);

    if (aktMillis - lastMillis >= Spuelzeit_Membran) {
      digitalWrite(Rohwasser, LOW);
      digitalWrite(MembranSpuelung, LOW);
      break;  //Abbruch der while-Endlosschleife und zurück zur Hauptschleife

    } //Ende der Abbruchbedingung
  } //Ende der while-Endlosschleife
} //Ende Func_Voll

//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■​■■■■
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■​■■■■

//  FUNKTION MANUELLE ANFORDERUNG ÜBER TASTER (Click)
//Status 0: Startvoraussetzung für die Membranspülung
//Status 1: Membranspülung ggf. durchgeführt
//Status 2: Stehwasserspülung ggf. durchgeführt
//Status 3: Reinwasser durchgeführt, Func beenden

void Func_Anforderung() {

  static unsigned long lastLED = 0;
  static byte LedStatus = LOW;
  static unsigned long lastMillis = 0;
  static unsigned long aktMillis = 0;
  static byte status = 0;

  //Endlosschleife (Ausstieg mit break)
  while (1)
  {

    aktMillis = millis();

    // Watchdog-Timer zurücksetzen
    //wdt_reset();

    Serial.print("Nass :");
    Serial.println(analogRead(Nass));
    Serial.print("Voll :");
    Serial.println(digitalRead(Voll));

    //Auslesen von A1 (Feuchtesensor), wenn der Messwert < Nass_Grenzwert ist, rufe Func_Nass auf
    if (analogRead(Nass) < Nass_Grenzwert) Func_Nass();

    //Auslesen von Digi Pin 3 (Schwimmerschalter), wenn Pin 3 = LOW ist, rufe Func_Voll auf
    if (digitalRead(Voll) == HIGH) Func_Voll();



    //################################################################################​###########################

    //Taster-LED blinken lassen
    if (LedStatus == LOW) {
      if (millis() - lastLED >= Blink_Interval) {
        digitalWrite(TasterLED, HIGH);
        lastLED = millis();
        LedStatus = HIGH;
      } //Ende von if
    } //Ende von if LOW
    else {
      if (millis() - lastLED >= Blink_Interval) {
        digitalWrite(TasterLED, LOW);
        LedStatus = LOW;
        lastLED = millis();
      } //Ende von if
    } //Ende von else

    //################################################################################​###########################

    //Membranspülung, wenn noch nicht ausgeführt & die Pause >= Pause_Grenzwert
    if (status == 0 && aktMillis - LastReinwasser >= Pause_Grenzwert)
    {

      digitalWrite(Reinwasser, LOW);
      digitalWrite(MembranSpuelung, HIGH);
      digitalWrite(Rohwasser, HIGH);

      status = 1;

      //Zeitstempel für die Fuellzeit
      lastMillis = aktMillis;

      //Display löschen.
      lcd.clear();

      //LCD-Backlight einschalten
      lcd.backlight();

      //Cursor positionieren (Spalte , Zeile)
      lcd.setCursor ( 3, 0 );

      //Textausgabe
      lcd.print("REINWASSER");

      //Cursor positionieren (Spalte , Zeile)
      lcd.setCursor ( 1, 1 );

      //Textausgabe
      lcd.print ("Membransp\365lung");

    } //Ende von if

    //################################################################################​###########################

    //Stehwasserspülung, wenn vorher Membranspülung ODER Stehwasserspülung nicht ausgeführt && LastReinwasser >= Stehzeit_Grenzwert
    if ((status == 1 && aktMillis - lastMillis >= Spuelzeit_Membran) || (status == 0 && aktMillis - LastReinwasser >= Stehzeit_Grenzwert))
    {

      digitalWrite(MembranSpuelung, LOW);
      digitalWrite(Rohwasser, HIGH);
      digitalWrite(StehwasserSpuelung, HIGH);

      status = 2;

      //Zeitstempel für LastReinwasser
      LastReinwasser = aktMillis;

      //Display löschen.
      lcd.clear();

      //LCD-Backlight einschalten
      lcd.backlight();

      //Cursor positionieren (Spalte , Zeile)
      lcd.setCursor ( 3, 0 );

      //Textausgabe
      lcd.print("REINWASSER");

      //Cursor positionieren (Spalte , Zeile)
      lcd.setCursor ( 1, 1 );

      //Textausgabe
      lcd.print ("Stehwassersp\365l.");

      lastMillis = aktMillis;

    } //Ende von if status

    //################################################################################​###########################

    //Reinwasser, wenn vorher ggf. Stehwasserspülung ODER Membranspülung nicht ausgeführt && Pause <= Stehzeit_Grenzwert
    if ((status == 2 &&  aktMillis - lastMillis >= Spuelzeit_Stehw) || (status == 0 && aktMillis - LastReinwasser < Stehzeit_Grenzwert))
    {

      digitalWrite(MembranSpuelung, LOW);
      digitalWrite(StehwasserSpuelung, LOW);
      digitalWrite(Rohwasser, HIGH);
      digitalWrite(Reinwasser, HIGH);

      status = 3;

      //Zeitstempel für die Fuellzeit
      Fuellzeit = aktMillis;

      //Zeitstempel für LastReinwasser
      LastReinwasser = millis();

      //Display löschen.
      lcd.clear();

      //LCD-Backlight einschalten
      lcd.backlight();

      //Cursor positionieren (Spalte , Zeile)
      lcd.setCursor ( 1, 0 );

      //Textausgabe
      lcd.print("Beh\341lter wird");

      //Cursor positionieren (Spalte , Zeile)
      lcd.setCursor ( 4, 1 );

      //Textausgabe
      lcd.print ("gef\365llt");

      lastMillis = aktMillis;

    } //Ende von if

    if (status == 3 && aktMillis - Fuellzeit >= Fuellzeit_Grenzwert) {
      //Zeitstempel für LastReinwasser
      LastReinwasser = millis();
      status = 0; //Status zurücksetzen
      break;  //Abbruch der while-Endlosschleife und zurück zur Hauptschleife

    } //Ende der Abbruchbedingung

  } //Ende der while-Endlosschleife
} //Ende von Func_Anforderung

//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■​■■■■
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■​■■■■

//  FUNKTION FILTERWECHSEL (DoubleClick)
void Func_Filterwechsel() {

  static unsigned long lastMillis = 0;
  static unsigned long lastLED = 0;
  static byte LedStatus = LOW;
  static unsigned long aktMillis = 0;
  static byte status = 0;  // 0 = Anfang, 1 = Membransp. aus, 2 = Stehw.-Sp. aus, 3 = fertig


  //Endlosschleife (Ausstieg mit break)
  while (1)
  {

    aktMillis = millis();

    //Watchdog-Timer zurücksetzen
    //wdt_reset();

    //Auslesen von A1 (Feuchtesensor), wenn der Messwert < Nass_Grenzwert ist, rufe Func_Nass auf
    if (analogRead(Nass) < Nass_Grenzwert) Func_Nass();

    //################################################################################​###########################

    //Taster-LED blinken lassen
    if (LedStatus == LOW) {
      if (millis() - lastLED >= Blink_Interval) {
        digitalWrite(TasterLED, HIGH);
        lastLED = millis();
        LedStatus = HIGH;
      } //Ende von if
    } //Ende von if LOW
    else {
      if (millis() - lastLED >= Blink_Interval) {
        digitalWrite(TasterLED, LOW);
        LedStatus = LOW;
        lastLED = millis();
      } //Ende von if
    } //Ende von else

    //################################################################################​###########################

    //Membranspülung

    switch (status) {

      case 0: //Start der Membranspülung

        lastMillis = aktMillis;

        //Magnetventile schalten
        digitalWrite(Reinwasser, LOW);
        digitalWrite(StehwasserSpuelung, LOW);
        digitalWrite(MembranSpuelung, HIGH);
        digitalWrite(Rohwasser, HIGH);

        status = 1;

        //Display löschen.
        lcd.clear();

        //LCD-Backlight einschalten
        lcd.backlight();

        //Cursor positionieren (Spalte , Zeile)
        lcd.setCursor ( 1, 0 );

        //Textausgabe
        lcd.print("FILTERWECHSEL");

        //Cursor positionieren (Spalte , Zeile)
        lcd.setCursor ( 1, 1 );

        //Textausgabe
        lcd.print ("Membransp\365lung");

        break;

      case 1: //Umschalten von Membran auf Stehwasser
        if (aktMillis - lastMillis >= Filterwechsel_Membran) {

          lastMillis = aktMillis;

          //Magnetventile schalten
          digitalWrite(MembranSpuelung, LOW);
          digitalWrite(StehwasserSpuelung, HIGH);

          status = 2;

          //Display löschen.
          lcd.clear();

          //LCD-Backlight einschalten
          lcd.backlight();

          //Cursor positionieren (Spalte , Zeile)
          lcd.setCursor ( 1, 0 );

          //Textausgabe
          lcd.print("FILTERWECHSEL");

          //Cursor positionieren (Spalte , Zeile)
          lcd.setCursor ( 1, 1 );

          //Textausgabe
          lcd.print ("Stehwassersp\365l.");

        }//Ende von if

        break;

      case 2: //Ende
        if (aktMillis - lastMillis >= Filterwechsel_Stehw) {

          //Magnetventile schalten
          digitalWrite(Rohwasser, LOW);
          digitalWrite(StehwasserSpuelung, LOW);

          status = 3;

          lcd.setCursor ( 1, 1 );
          lcd.print ("     Ende      ");

        }//Ende von if
        break;

    } //Ende Switch(status)

    if (status == 3) {
      //Zeitstempel für LastReinwasser
      LastReinwasser = millis();
      status = 0; //Status zurücksetzen
      break;  //Abbruch der while-Endlosschleife und zurück zur Hauptschleife

    } //Ende der Abbruchbedingung
  } //Ende der while-Endlosschleife
} //Ende Func_Filterwechsel

//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■​■■■■
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■​■■■■

//  FUNKTION MANUELLE DESINFEKTION DES FILTERSYSTEMS (LongPress)
//Zur Desinfektion muß das Handventil geschlossen werden, da das H2O2 zwingend durch die Membran muß.
//Zum Schließen muß die Steuerung kurz abgeschaltet werden, sonst bleibt das Rohwasser-Ventil immer auf.
//Nach der Desinfektion muß manuell die Funktion Filterwechsel ausgeführt werden.

void Func_Desinfektion() {

  //Endlosschleife (KEIN Ausstieg mit break)
  while (1)
  {
    // Watchdog-Timer zurücksetzen
    //wdt_reset();

    static unsigned long lastLED = 0;
    static byte LedStatus = LOW;
    static byte LCDStatus = 0;

    //Auslesen von A1 (Feuchtesensor), wenn der Messwert < Nass_Grenzwert ist, rufe Func_Nass auf
    if (analogRead(Nass) < Nass_Grenzwert) Func_Nass();

    //################################################################################​###########################

    //Taster-LED blinken lassen
    if (LedStatus == LOW) {
      if (millis() - lastLED >= Blink_Interval) {
        digitalWrite(TasterLED, HIGH);
        lastLED = millis();
        LedStatus = HIGH;
      } //Ende von if
    } //Ende von if LOW
    else {
      if (millis() - lastLED >= Blink_Interval) {
        digitalWrite(TasterLED, LOW);
        LedStatus = LOW;
        lastLED = millis();
      } //Ende von if
    } //Ende von else

    //################################################################################​###########################

    digitalWrite(Reinwasser, LOW);
    digitalWrite(MembranSpuelung, LOW);
    digitalWrite(StehwasserSpuelung, LOW);
    digitalWrite(Rohwasser, HIGH);

    if (LCDStatus == 0) {

      //Display löschen.
      lcd.clear();

      //LCD-Backlight einschalten
      lcd.backlight();

      //Cursor positionieren (Spalte , Zeile)
      lcd.setCursor ( 5, 0 );

      //Textausgabe
      lcd.print("ZYKLUS");

      //Cursor positionieren (Spalte , Zeile)
      lcd.setCursor ( 2, 1 );

      lcd.print ("Desinfektion");

      LCDStatus = 1;

    } //Ende von if

  } //Ende der while-Endlosschleife

} //Ende Func_Desinfektion
[/code]
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
27.03.2019, 16:14
Beitrag #5
RE: Bedingung wird nicht wiederholt ausgeführt
Du hast den Pin Voll auf INPUT_PULLUP, damit ist der unbetätigt HIGH, wie auch richtig im Kommentar steht.
//Auslesen von Digi Pin 3 (Schwimmerschalter), wenn Pin 3 = LOW ist, rufe Func_Voll auf
Code:
//Auslesen von Digi Pin 3 (Schwimmerschalter), wenn Pin 3 = LOW ist, rufe Func_Voll auf
//    if (digitalRead(Voll) == HIGH) Func_Voll();
    if (digitalRead(Voll) == LOW) Func_Voll();

Die Funktion loop() wird laufend neu aufgerufen, deshalb brauchst Du kein while(1).

Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
27.03.2019, 16:28 (Dieser Beitrag wurde zuletzt bearbeitet: 27.03.2019 17:31 von Lite.)
Beitrag #6
RE: Bedingung wird nicht wiederholt ausgeführt
An dem Pin hängt ein redundanter Schwimmerschalter (NC).

Den Schwimmerschalter habe ich noch nicht angeschlossen, also ist die Konstellation so, daß ich im Test auf HIGH abfrage...als wenn der Schwimmerschalter betätigt (open) wäre.
Der Schwimmerschalter signalisiert, daß der Behälter voll ist.
Wird nun der Taster zur Anforderung gedrückt, sollte erkannt werden, daß der Behälter voll ist und das funktioniert halt nur ein mal.

Du meinst mit der Loop die Hauptschleife?

Ich habe als Anfänger den Sketch in logische Funktionsblöcke zerlegt, um eine bessere Übersicht zu bekommen...der Herzinfakt wäre sonst wahrscheinlich schon eingetreten.

In der Loop wird dann nur der Taster ausgewertet und in die entsprehende Func gesprungen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
27.03.2019, 17:37
Beitrag #7
RE: Bedingung wird nicht wiederholt ausgeführt
(27.03.2019 16:28)Lite schrieb:  Du meinst mit der Loop die Hauptschleife?
Ja.

Du wirst irgendwo in den Tiefen Deiner while(1) hängen bleiben. Die drösel ich aber nicht auf.
Setze Dir gezielt Serial.print-Ausgaben rein, damit Du den Ablauf verfolgen kannst. Das ist der einzige Weg, den Fehler zu finden.

Gruß Tommy

"Wer den schnellen Erfolg sucht, sollte nicht programmieren, sondern Holz hacken." (Quelle unbekannt)
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
27.03.2019, 17:45
Beitrag #8
RE: Bedingung wird nicht wiederholt ausgeführt
Ich hatte schon an die 20 Serial-prints drin und der Ablauf scheint OK.
Er führt die Schritte alle aus und Voll ist auch immer HIGH.
Sowohl direkt vor der if-Abfrage, als auch direkt dahinter hatte ich eine hochzählende Variable per serial.print ausgegeben.
Die wurde Lückenlos hochgezählt....nur die Bedingung wurde nicht ausgeführt.
Die while(1) kann ich nirgends hängen sehen.

Dann such ich halt weiter..
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
Wink Solar Roboter- Servo dreht nach Stopp nicht weiter Stagneth.Alexander 37 1.551 20.08.2019 14:15
Letzter Beitrag: geist4711
  myport nicht gefunden? - Arduino und Visual Studio Stagneth.Alexander 3 211 04.08.2019 17:38
Letzter Beitrag: Tommy56
  Atmega 328 Sketchl läuft auf UNO3, alleine auf Breadboard nicht delay 9 530 02.08.2019 15:03
Letzter Beitrag: hotsystems
  Reaktionsspiel funktioniert nicht, wie es sollte... Stagneth.Alexander 27 1.112 21.07.2019 07:57
Letzter Beitrag: Stagneth.Alexander
Question Programm läuft nicht richtig CMeeep 22 1.411 04.07.2019 21:58
Letzter Beitrag: Franz54
  If...els if wird nich korrekt ausgeführt suterb 18 1.068 28.05.2019 13:51
Letzter Beitrag: Tommy56
  2 Sketche zusammenführen - korrelieren nicht Nicolai 11 1.057 24.05.2019 11:04
Letzter Beitrag: Nicolai
  Gelöst ==> Arduino Nano, Kommunikation mit PC bringt nicht korrekten ASCII moehrle 4 692 02.03.2019 22:04
Letzter Beitrag: hotsystems
  Typecasting oder nicht? Batucada 1 505 19.02.2019 18:51
Letzter Beitrag: Tommy56
  Ram Speicher bei Arduino Mega wird knapp unkreativ 22 1.491 02.02.2019 18:40
Letzter Beitrag: unkreativ

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste