Wie kann ich brechen diese Schleife auf eine Taste drücken?

Ich habe das problem bisher ist, dass ich nicht beenden Sie die Schleife, nachdem es beginnt.

In Ihrem code haben, erstellen Sie die folgende Schleife:

for (int i = timer_value; i >= 0; i--){ //Begin the loop
    Serial.println(i);
    delay(1000);
}

Es ist im inneren eine Funktion, die aufgerufen wird, wenn die Taste gedrückt wird. Brechen aus der Schleife,
Sie einfach hinzufügen ein break; - Anweisung innerhalb dieser Schleife. Aber das problem ist, wie
überprüfen der Bedingung, dass wird Ihnen helfen, brechen aus der Schleife heraus?

Würden Sie brauchen, um zu überprüfen, wieder der pin Eingabe (über die digitalRead) innerhalb der Schleife. Aber
warum schauen Sie zwei mal den Zustand von einem einzigen button in einem einfachen Algorithmus?

Dass der Grund, warum ich schlage vor, Sie ein anderes nehmen auf Ihr problem, mit einer einzigen loop,
die loop() - Funktion, verwenden Sie einen Satz von drei Variablen:

• last_button_state für die Erkennung des übergangs Zustände der Schaltfläche
• count_down zu wissen, ob wir in ein count-down-oder nicht
• count_down_value den tatsächlichen Wert der countdown

Den letzten beiden Werte können zusammengefasst werden (z.B. durch setzen count_down zu -1 zu sagen
dass wir uns nicht in eine count-down-Zustand), aber ich habe diese beiden Variablen aus, für Klarheit.

#define BUTTON_PIN 42

void setup() {
    Serial.begin(9600);
    pinMode(BUTTON_PIN, INPUT);
}

//State variables
uint8_t last_button_state = LOW;
bool count_down;
uint8_t count_down_value;

void loop() {
    int pot_value;

    //Read the pushbutton input pin:
    uint8_t button_state = digitalRead(buttonPin);

    if (button_state != last_button_state) {
        Serial.println("BUTTON STATE CHANGED");
        //On button press
        if (button_state == HIGH) {
            Serial.println("BUTTON PRESS");
            //Starts the count down if the value of potentiometer is high enough
            pot_value = analogRead(A0);
            if (pot_value > 17) {
                Serial.println("POT IS HIGH ENOUGH");
                if (count_down == false) {
                    Serial.println("ENABLING THE COUNT DOWN");
                    count_down = true;
                    count_down_value = map(pot_value, 0, 1023, 0, 60);
                } else {
                    Serial.println("DISABLING THE COUNT DOWN");
                    count_down = false;
                }
            }
        } else {
            Serial.println("BUTTON RELEASE");
        }
    }
    Serial.println("STORING BUTTON STATE");
    //Save button state for next iteration
    last_button_state = button_state;

    //If the countdown is running
    if (count_down == true) {
        Serial.println("RUNNING COUNTDOWN");
        //If the last value has been shown, show last value and stop the countdown
        if (count_down_value == 0) {
            Serial.println("BOOM!");
            count_down = false;
        //Otherwise decrements the value
        } else {
            //Prints out the value
            Serial.println(count_down_value);
            //Wait
            delay(1000);
            --count_down_value;
        }
    }
    delay(500); //Not to flood output
}

Da würde ich erwarten, dass die folgende Ausgabe:

<Press button>
BUTTON STATE CHANGED
BUTTON PRESS
POT IS HIGH ENOUGH
ENABLING THE COUNT DOWN
STORING BUTTON STATE
RUNNING COUNTDOWN
142
STORING BUTTON STATE
RUNNING COUNTDOWN
141
<Release button>
BUTTON STATE CHANGED
BUTTON RELEASE
STORING BUTTON STATE
RUNNING COUNTDOWN
140
<Press button>
BUTTON STATE CHANGED
BUTTON PRESS
POT IS HIGH ENOUGH
DISABLING THE COUNT DOWN
STORING BUTTON STATE
STORING BUTTON STATE
<Release button>
BUTTON STATE CHANGED
BUTTON RELEASE
STORING BUTTON STATE
...

So, jetzt gibt es nur zwei mögliche Szenarien:

• Drücken Sie die Taste, countdown beginnt, countdown iteriert, countdown endet, und hält
• Drücken Sie die Taste, countdown beginnt, countdown iteriert, drücken Sie die Taste, countdown Stoppt

Wenn das potentiometer auf 0, ist die Schaltfläche deaktiviert.

InformationsquelleAutor zmo

Ich weiß, es ist schon eine Weile, da diese aktiv war, aber ein großes Problem, mit dem ich sehen kann mit der vorhergehenden Antwort ist die Verwendung von Verzögerungen, bei denen, wenn ich lese es richtig, es gibt 1,5 Sekunden zählt, statt 1 Sekunde.

Eine bessere Antwort würde die Zeit berechnen, die seit der letzten runtergezählt und dann ein count-down, wenn es 1 Sekunde oder höher. Es ist vielleicht etwas off, aber es ist viel näher an der 1 Sekunde.

Es löst auch ein weiteres Problem, dass der button kann nur bestehen zwischen diesen Verzögerungen, was eine kurze Zeit alle 1,5 Sekunden oder so, so könnten Sie müssen halten Sie die Taste für 1,5 Sekunden, um es zu stoppen, anstatt schieben Sie es einfach, um es zu stoppen.

Würde ich tun so etwas wie dieses:

const int  buttonPin = 2;   //The pin that the pushbutton is attached to
int buttonState = 0;        //Current state of the button
int lastButtonState = 0;    //Previous state of the button
int timer_value = 0;        //The timer that you want.
int last_count = 0;         //The time the counter last counted down.

void setup() {
    //initialize serial communication:
    Serial.begin(9600);
}

void loop() {
  //Read the pushbutton input pin:
  buttonState = digitalRead(buttonPin);

  //Compare the buttonState to its previous state
  if (buttonState != lastButtonState) {
    if (buttonState == HIGH) {
      //If the current state is HIGH then the button
      //went from off to on:
      if(timer_value) {
        //checks to see if countdown is in progress, if 0, there is no count down.
        timer_value=0;
      }
      else {
        //The timer is not running, therefore start it.
        int pot_value = analogRead(A0); //read potentiometer value
        if (pot_value > 17) { //i set it so, that it doesn't start before the value
                              //isn't greater than the 60th part of 1023
            int timer_value = map(pot_value, 0, 1023, 0, 60); //Mapping pot values to timer.
            last_count = millis();  //sets up the timer to start counting.
            Serial.println(timer_value);  //Outputs the start of the timer.
        }
      }
    }
    else {
      //If the current state is LOW then the button
      //went from on to off:
      Serial.println("off");
    }
  }
  //Save the current state as the last state,
  //for next time through the loop
  lastButtonState = buttonState;

  //Check to see if counting down
  if(timer_value){
    //The timer is runing.
    //Check to see if it is time to count
    //Calculate what time it was 1000ms (1 second a go) and see if it is the same time or later than the last count, if so, it needs to count down.
    if(millis() - 1000 >= last_count) {
      //Time to count down.
      timer_value--;
      Serial.println(timer_value);
    }
  }
}

Diese Weise wird die Schaltfläche aktiviert ist jede Schleife und die Schleife wird kontinuierlich laufen eher als Pause für das zweite zu warten, für Sie zu zählen, und er zählt jede Sekunde.

InformationsquelleAutor Jeffrey Black