# data[].attributes.headline
Estructuras de Repetición y Control en Arduino. 

# data[].attributes.subject
Estructuras de Repetición y Control en Arduino. 

# data[].attributes.body
Clasificación de las estructuras (Repetición y Control):

Las estructuras de control dentro del IDE de Arduino te ayudarán a crear los programas para tus proyectos con la placa Arduino.
Existen dos tipos de estructura de control dentro de la programación de Arduino, las cuales son:
Estructura de decisión:

if:  es un estamento que se utiliza para probar si una determinada condición se ha alcanzado, como por ejemplo averiguar si un valor analógico está por encima de un cierto número, y ejecutar una serie de declaraciones.

if… else:  viene a ser un estructura que se ejecuta en respuesta a la idea “si esto no se cumple haz esto otro”.

else: puede ir precedido de otra condición de manera que se pueden establecer varias estructuras condicionales de tipo unas dentro de las otras (anidamiento) de forma que sean mutuamente excluyentes pudiéndose ejecutar a la vez.

switch..case: Al igual que if, switch..case controla el flujo del programa especificando en el programa que código se debe ejecutar en función de unas variables.

break: es la palabra usada para salir del switch. Si no hay break en cada case, se ejecutará la siguiente instrucción case hasta que encuentre un break o alcance el final de la instrucción.

default es la palabra que se usa para ejecutar el bloque en caso que ninguna de las condiciones se cumpla.

# data[].attributes.body
Estructuras de repetición:

for: La declaración for se usa para repetir un bloque de sentencias encerradas entre llaves un número determinado de veces.

while: Un bucle del tipo while es un bucle de ejecución continua mientras se cumpla la expresión colocada entre paréntesis en la cabecera del bucle.

do..while: El bucle do while funciona de la misma manera que el bucle while, con la salvedad de que la condición se prueba al final del bucle, por lo que el bucle siempre se ejecutará al menos una vez.

goto: transfiere el flujo de programa a un punto del programa que está etiquetado.

break: se usa en las instrucciones do, for, while para salir del bucle de una forma diferente a la indicada en el bucle.

continue: se usa en las instrucciones do, for, while para saltar el resto de las instrucciones que están entre llaves y se vaya a la siguiente ejecución del bucle comprobando la expresión condicional.

# data[].attributes.body
En programación, las estructuras de control permiten modificar el flujo de ejecución de las instrucciones de un programa.

Con las estructuras de control se puede:

De acuerdo con una condición, ejecutar un grupo u otro de sentencias (If-Then-Else)

De acuerdo con el valor de una variable, ejecutar un grupo u otro de sentencias (Select-Case)

Ejecutar un grupo de sentencias mientras se cumpla una condición (Do-While)

Ejecutar un grupo de sentencias hasta que se cumpla una condición (Do-Until)

Ejecutar un grupo de sentencias un número determinado de veces (For-Next)

Las estructuras de control en el entorno de programación de Arduino son herramientas que se utilizan para elegir una secuencia o un camino alternativo dentro de la estructura del software. Esto quiere decir que, son instrucciones que permiten romper la secuencia metódica de los códigos, ya que existe una expresión lógica con la cual se debe decidir si se elige una ruta u otra para que ambas puedan llegar más adelante al mismo final del proceso.

Para obtener una mejor administración y lectura del código de programación es necesario utilizar en forma correcta la tabulación en cada estructura. Esto ayudará a encontrar más rápidos los errores o las secuencias que se quieren repetir.

# data[].attributes.body
Estructura de Repetición
Estas estructuras de bucles son herramientas que permiten ejecutar las instrucciones que tiene el programa de manera repetida.

for: Podrás repetir las secuencias de los códigos que se encuentren entre llaves las veces que indiques en el IDE de Arduino.

while: Con esta herramienta podrás ejecutar el bucle de forma continua y todas las veces que sea necesario, siempre que se cumpla con la condición establecida al comienzo de bucle entre paréntesis.

do while: Este bucle se usa de la misma manera que la sentencia mencionada antes, while. Pero en este caso la condición para que se repita la estructura se encuentra al final del bloque, encerrado entre paréntesis.

# data[].attributes.body
Estructuras de decisión
Este tipo de estructura se refiere al camino que debe realizar el programa cuando existe una variable que divide la secuencia de los códigos en dos. Para ello, se evalúa una condición y devuelve un valor (verdadero o falso) para tomar la decisión de qué instrucciones ejecutar, según la respuesta.
if: Deberás utilizar esta herramienta cuando quieras conocer si una variable alcanzó una determinada condición.
else: Con esta herramienta de estructura de control se pueden elegir varias condiciones que sean excluyentes entre sí cuando se produce una situación determinada.
switch - case: Es posible utilizar esta estructura cuando se necesita que el programa decida sobre una instrucción precisa.

# data[].attributes.body
For:

for (initialization; condition; increment) {

// statement(s);

}

# data[].attributes.body
while:
Su estructura es:

while (condition) { // la condición debe ser TRUE o FALSE

// statement(s)

}

# data[].attributes.body
do while: Su sintaxis es

do {

// statement block

} while (condition);

# data[].attributes.body
goto:

for (byte r = 0; r < 255; r++) {

for (byte g = 255; g > 0; g--) {

for (byte b = 0; b < 255; b++) {

if (analogRead(0) > 250) {

goto bailout;

}

// más declaraciones de códigos del programa

}

}

}

bailout:

# data[].attributes.body
continue

for (int x = 0; x <= 255; x ++) {

if (x > 40 && x < 120) { // crear salto en los valores

continue;

}

analogWrite(PWMpin, x);

delay(50);

}

# data[].attributes.body
if: Su sintaxis es:

if (condition) { // Siendo condition una expresión de TRUE o FALSE.

//statement(s)

# data[].attributes.body
Else:

if (condition1) {

// do Thing A

}

else if (condition2) {

// do Thing B

}

else {

// do Thing C

}

# data[].attributes.body
switch - case
Su sintaxis se establece de la siguiente manera:

switch (var) {

case label1:

// statements

break;

case label2:

// statements

break;

default:

// statements

break;

}

# data[].attributes.body
break

Cuando necesites salir de la estructura de control vas a tener que usar esta sentencia. Se debe usar con do, for o while.
Por Ejemplo:
Un código de ejemplo es:

int threshold = 40;

for (int x = 0; x < 255; x++) {

analogWrite(PWMpin, x);

sens = analogRead(sensorPin);

if (sens > threshold) { // rescatar en la detección del sensor

x = 0;

break;

}

delay(50);

}

# data[].attributes.body
if: deberás utilizar esta herramienta cuando quieras conocer si una variable alcanzó una determinada condición.

Por ejemplo:

if (x > 120) digitalWrite(LEDpin, HIGH);

if (x > 120)

digitalWrite(LEDpin, HIGH);

if (x > 120) {digitalWrite(LEDpin, HIGH);}

if (x > 120) {

digitalWrite(LEDpin1, HIGH);

digitalWrite(LEDpin2, HIGH);

}

// todo está correcto