El ciclo while de Arduino, en un medidor de reflejos
Intermedio
- 526componentes en el banco de trabajo
- 46placas funcionando ahora
- 1.00xtiempo real, en todas las placas
while (condition) { ... } ejecuta su bloque una y otra vez mientras la condición sea verdadera. La revisa antes de cada pasada, así que si la condición es falsa desde el principio, el bloque no se ejecuta ni una sola vez. Su trabajo más común en un Arduino es esperar: while (digitalRead(2) == HIGH) { } no hace nada, una y otra vez, hasta que se presiona el botón del pin 2.
El circuito de arriba es un medidor de reflejos. Presiona Ejecutar y espera. La lámpara verde se enciende en un momento aleatorio, y el monitor serie imprime cuántos milisegundos tardaste en presionar el botón. En nuestra ejecución, la lámpara se encendió 1.94 segundos después de Ejecutar, y una presionada un cuarto de segundo después imprimió "reaction: 251 ms". Si presionas antes de que se encienda la lámpara, imprime "too soon" y el zumbador gruñe.
Todo el juego son cuatro bucles while. Abajo verás cómo funcionan, en qué se diferencia while de for y do while, y las tres formas en que un bucle while sale mal, cada una ejecutada en un Uno con lo que imprimió.
Cuatro bucles while hacen un juego
Aquí está el corazón del sketch que se ejecuta arriba. El primer bucle es la espera aleatoria, y sigue mientras el tiempo desde started sea menor que wait. Dentro hay una revisión del botón que detecta una salida en falso, y un segundo bucle más pequeño, while (pressed()) delay(5);, espera a que sueltes antes de que comience otra ronda.
Cuando termina la espera, la lámpara se enciende y while (!pressed()) delay(1); es el tercer bucle: no hace nada más que esperar, un milisegundo a la vez, hasta que el botón baja. El tiempo que esperó es tu reflejo. El cuarto bucle, al final de la ronda, espera a que el botón vuelva a subir para que una presionada larga no cuente dos veces.
unsigned long wait = (unsigned long)random(1500, 4000);
unsigned long started = millis();
while (millis() - started < wait) {
if (pressed()) {
Serial.println("too soon");
growl();
while (pressed()) delay(5);
delay(500);
return;
}
delay(5);
}
digitalWrite(LAMP, HIGH);
unsigned long lit = millis();
while (!pressed()) delay(1);
unsigned long took = millis() - lit;while, for y do while
Usa for cuando sabes cuántas vueltas quieres dar, y while cuando solo sabes cuándo parar. Duplicar un número hasta que pase de 100 es trabajo para un while, porque nadie quiere calcular antes la cantidad de vueltas. El sketch de abajo imprimió 128.
do { ... } while (condition); es el mismo bucle al revés: el bloque se ejecuta primero y la prueba viene después, así que siempre se ejecuta al menos una vez. Abajo, x es 10, así que while (x < 5) nunca ejecutó su bloque y la versión con do lo ejecutó una vez e imprimió "do ran". Nota el punto y coma después de un do while; es el único bucle que lo necesita.
void setup() {
Serial.begin(9600);
int n = 1;
while (n < 100) {
n = n * 2;
}
Serial.println(n);
}
void loop() {
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Esperar un botón
El bucle vacío de abajo es el while más simple y útil que existe. Con el botón conectado del pin 2 a tierra y la resistencia pull-up activada, el pin lee HIGH hasta que se presiona, así que el bucle gira sin hacer nada hasta entonces. Presionamos a los 1.2 segundos e imprimió "pressed at 1199 ms".
Las llaves pueden estar vacías, pero no pueden faltar: while (digitalRead(BUTTON) == HIGH); con punto y coma hace lo mismo, y es tan fácil de leer mal que la mayoría escribe { } a propósito.
const int BUTTON = 2;
void setup() {
Serial.begin(9600);
pinMode(BUTTON, INPUT_PULLUP);
Serial.println("press the button");
while (digitalRead(BUTTON) == HIGH) {
}
Serial.print("pressed at ");
Serial.print(millis());
Serial.println(" ms");
}
void loop() {
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Bucles que nunca terminan
A while loop stops only when something inside it makes the condition false. Forget to change the counter and it never does. The sketch below never adds one to i, so it printed 0 six times in just over half a second and would have kept going for as long as the board had power.
Un punto y coma después de la condición hace lo mismo de forma más silenciosa. En while (i < 3); {, el punto y coma es todo el bucle y el bloque que va después queda fuera, así que i nunca puede cambiar. Ese sketch no imprimió nada, ni siquiera el "done" después del bucle, y la compilación no dio ninguna advertencia. Si tu sketch se detiene de golpe después de un rato, mira primero el final de esa línea.
A veces quieres un bucle que nunca termine. while (true) { } al final de setup() detiene un sketch a propósito: el nuestro imprimió "setup" y nunca imprimió el "loop" que loop() habría impreso.
void setup() {
Serial.begin(9600);
int i = 0;
while (i < 3) {
Serial.println(i);
delay(100);
}
}
void loop() {
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
break, y qué tan rápido gira un bucle
break sale de un bucle en el acto, lo que hace que while (true) con un break dentro sea una forma práctica cuando el motivo para parar se descubre a mitad de camino. Abajo, el bucle suma 1, 2, 3 y así hasta que el total pasa de 50, e imprimió "10 55": diez números, que suman 55.
Un bucle while vacío es muy rápido. Contando sus propias pasadas durante un segundo del reloj de la placa, el nuestro dio 353287 vueltas. Pon un analogRead() dentro y solo logró 9139, porque cada lectura tarda alrededor de una décima de milisegundo. Por eso un sketch que espera en un bucle while todavía nota rápido una presionada.
void setup() {
Serial.begin(9600);
int total = 0;
int n = 0;
while (true) {
n++;
total = total + n;
if (total > 50) break;
}
Serial.print(n);
Serial.print(" ");
Serial.println(total);
}
void loop() {
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
El bucle que congela todo
Mientras un bucle while espera, nada más en el sketch sucede. En el sketch de abajo, un LED parpadea e imprime el tiempo, y un bucle while espera cada vez que el botón se mantiene presionado. Imprimió "blink at 499" y "blink at 999", y luego mantuvimos el botón de 0.6 a 1.8 segundos. La siguiente línea fue "blink at 2299": el parpadeo simplemente se detuvo mientras el bucle esperaba.
Para el medidor de reflejos eso es exactamente lo correcto, porque no hay nada más que hacer. Para un sketch que debe seguir parpadeando, leyendo un sensor o escuchando el monitor serie, no esperes dentro de un bucle. Deja que loop() dé sus vueltas, revisa el botón con un if cada vez, y mide el tiempo con millis(), como muestra la página del parpadeo sin delay.
const int BUTTON = 2;
void setup() {
Serial.begin(9600);
pinMode(BUTTON, INPUT_PULLUP);
pinMode(13, OUTPUT);
}
void loop() {
digitalWrite(13, HIGH);
delay(250);
digitalWrite(13, LOW);
delay(250);
Serial.print("blink at ");
Serial.println(millis());
while (digitalRead(BUTTON) == LOW) {
}
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Abre este circuito en el editor. Arduino Uno: un medidor de reflejos, conectado tal como se ejecuta arriba en esta página. Cambia un componente o un valor y ejecútalo de nuevo.
Abrir el circuitoPreguntas
¿Cuál es la diferencia entre un bucle while y un bucle for?
Un bucle for sirve para un número conocido de pasadas y guarda su contador en sus propios corchetes. Un bucle while solo tiene una condición y se ejecuta hasta que esta sea falsa, lo que sirve para esperar un botón, un sensor o una entrada serie.
¿Cuál es la diferencia entre loop() y while?
loop() es la función que el Arduino llama una y otra vez después de setup(). while es una instrucción dentro de tu código. Un bucle while dentro de loop() retiene a loop() hasta que termina.
¿Por qué se queda atascado mi bucle while?
O bien nada dentro de él vuelve falsa la condición, o hay un punto y coma justo después de la condición, como en while (i < 3); que repite sobre nada para siempre. Imprime algo dentro del bucle para ver si está girando.
¿Cómo salgo de un bucle while en Arduino?
Vuelve falsa la condición desde dentro del bucle, o usa break, que sale del bucle de inmediato. return sale de toda la función donde está el bucle.
¿Cómo espero una presionada de botón en Arduino?
Con el botón del pin a tierra y pinMode(pin, INPUT_PULLUP), while (digitalRead(pin) == HIGH) { } espera hasta que se presiona. Nada más en el sketch se ejecuta mientras espera.
Sigue así
De dónde vienen los datos de esta página
Ármalo en la vida real
Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.