Comment puis-je briser cette boucle sur un bouton de la presse?

Le problème que j'ai est que je ne peut pas sortir de la boucle après son démarrage.

Dans votre code, vous créez la boucle suivante:

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

Il est à l'intérieur d'une fonction qui est appelée lorsque le bouton est enfoncé. Pour sortir de la boucle,
il vous suffit d'ajouter un break; déclaration à l'intérieur de cette boucle. Mais le problème est de savoir comment
pour vérifier l'état qui va vous aider à sortir de la boucle?

Vous auriez besoin de vérifier à nouveau la broche d'entrée (à l'aide de la digitalRead) à l'intérieur de la boucle. Mais
pourquoi vérifier deux fois l'état d'un bouton unique à l'intérieur d'un algorithme simple?

C'est pourquoi je vous suggère une autre de prendre sur votre problème, en utilisant un seul loop,
le loop() fonction, l'utilisation d'un ensemble de trois variables d'état:

• last_button_state pour détecter les états de transition de la touche
• count_down pour savoir si nous sommes dans un compte à rebours ou pas
• count_down_value la valeur réelle du compte à rebours

Les deux dernières valeurs pourraient être fusionnés en un seul (par exemple, définir count_down à -1 à dire
que nous ne sommes pas dans un compte à rebours de l'état), mais j'ai laissé ces deux variables d'état pour plus de clarté.

#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
}

Là je m'attends à la sortie suivante:

<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
...

Alors maintenant, il y a seulement deux scénarios possibles:

• Appuyez sur le bouton, le compte à rebours commence, compte à rebours itère, compte à rebours se termine et s'arrête
• Appuyez sur le bouton, le compte à rebours commence, compte à rebours itère, appuyez sur le bouton, le compte à rebours s'arrête

Si le potentiomètre est à 0, le bouton est désactivé.

Je sais qu'il a été un moment depuis que cela a été actif, mais un gros problème que je peux voir avec la réponse précédente est l'utilisation de retards, où si je suis le lire correctement, il donne de 1,5 seconde compte, au lieu de 1 seconde.

Une meilleure réponse serait de calculer le temps écoulé depuis la dernière compté puis si elle est de 1 seconde ou plus. Il pourrait être un peu hors sujet, mais il est beaucoup plus proche du 1 seconde.

Elle résout également un autre problème est que le bouton ne peut exister entre ces retards, donnant un court laps de temps toutes les 1,5 seconde ou deux, de sorte que vous pourriez avoir besoin pour maintenir enfoncé le bouton pendant 1,5 secondes pour l'arrêter, plutôt que de simplement pousser à arrêter.

Je voudrais faire quelque chose de plus comme ceci:

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);
    }
  }
}

De cette façon, le bouton est coché chaque boucle et la boucle est exécuté en permanence plutôt que de la pause pour la deuxième attente du compte à rebours et le calcul de chaque seconde.