3.

-CONTROL DE FLUJO
1.-INTRODUCCIÓN A LAS ESTRUCTURAS DE
CONTROL DE FLUJO
Las estructuras de control de flujo en el lenguaje C son herramientas fundamentales que permiten
dirigir el camino que toma la ejecución de un programa. Estas estructuras determinan cómo y
cuándo se ejecutan ciertas partes del código en función de condiciones o la repetición de bloques
de código hasta que se cumpla una condición específica. Las estructuras de control de flujo se
dividen principalmente en tres categorías: decisiones, bucles y control de salto.
Decisiones: Permiten que el programa tome decisiones y ejecute bloques de código específicos
basándose en ciertas condiciones. Las estructuras de decisión en C incluyen:
if : Ejecuta un bloque de código si, y solo si, una condición específica es verdadera.

if-else : Permite una ruta alternativa de ejecución si la condición del if no se cumple.

switch : Facilita la selección entre múltiples alternativas basándose en el valor de una variable,
simplificando múltiples if-else anidados cuando se trata de comparar la misma variable contra
diferentes valores.
Bucles (Ciclos): Facilitan la ejecución repetida de un bloque de código mientras se cumpla una
Bucles (Ciclos): Facilitan la ejecución repetida de un bloque de código mientras se cumpla una
condición determinada. Existen tres tipos principales de bucles en C:

while : Ejecuta un bloque de código repetidamente mientras una condición específica sea
verdadera.

do-while : Similar al bucle while , pero garantiza que el bloque de código se ejecute al menos una
vez, ya que la condición se evalúa al final del bucle.

for : Permite la inicialización de una variable de control, la evaluación de una condición y la

modificación de la variable de control en una única declaración, lo que lo hace especialmente útil
para ejecutar un bloque de código un número determinado de veces.
Control de Salto: Proporciona la capacidad de transferir la ejecución a otra parte del programa
directamente, lo que puede ser útil para salir de bucles o saltar a secciones específicas del código.
Las instrucciones de control de salto en C incluyen:

break : Termina inmediatamente el bucle más interno ( for , while , o do-while ) o la instrucción
switch en la que se encuentra, trasladando el control a la instrucción siguiente a este bloque.

continue : Omite las instrucciones restantes dentro del ciclo actual del bucle más cercano ( for ,
while , o do-while ) y procede con la próxima iteración del bucle.

goto : Transfiere el control a una parte específica del programa indicada por una etiqueta. Aunque
es poderoso, su uso es generalmente desaconsejado debido a que puede hacer el código más
difícil de leer y mantener.

2.- CONDICIONAL SIMPLE

Las sentencias condicionales son las sentencias que se ejecutan cuando la condición es verdadera.
La sintaxis de la sentencia condicional que contiene la palabra "if" en C es:

if (condicion) { // Bloque de código que se ejecuta si la condición es verdadera }

En C, la condición dentro de los paréntesis se evalúa. Si el resultado es distinto de cero (lo que se
considera verdadero en C), el bloque de código dentro de las llaves se ejecuta. Si la condición es
cero (considerada falsa), el bloque de código se omite.

EJEMPLO

#include <stdio.h> void app_main() { int numero = 5; if (numero > 0) { printf("El número
es positivo.\n"); } }
En este programa, se declara una variable numero con el valor 5 . La sentencia condicional if
verifica si numero es mayor que 0 . Dado que 5 es mayor que 0 , la condición se evalúa como
verdadera, por lo que el programa ejecuta la instrucción dentro del bloque if , imprimiendo en la
consola el mensaje "El número es positivo." .

EJEMPLO

#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" void

app_main() { int numero; printf("Por favor, ingrese un número: "); vTaskDelay(4000 /
portTICK_PERIOD_MS); scanf("%d", &numero); if (numero < 0) { printf("El número es
negativo."); } }

Este programa comienza incluyendo el archivo de cabecera stdio.h , necesario para las funciones
de entrada/salida como printf y scanf . Luego, declara una variable entera numero para
almacenar el número que el usuario ingresará.
Utiliza printf para solicitar al usuario que ingrese un número y scanf para leer el número
ingresado desde la entrada estándar (teclado), almacenando el valor en la variable numero .
Después, con la sentencia if , verifica si el valor de numero es menor que 0 . Si esta condición se
cumple, significa que el número es negativo, y el programa imprime el mensaje "El número es
negativo." utilizando printf . Si el número es cero o positivo, el programa termina sin imprimir
ningún mensaje adicional.
3.- CONDICIONAL DOBLE Y MULTIPLE(ESCALERA)

La sintaxis de la sentencia condicional que contiene las palabras "if-else" en C es:

if (condicion) { // Bloque de código que se ejecuta si la condición es verdadera } else

{ // Bloque de código que se ejecuta si la condición es falsa }

En esta estructura, primero se evalúa la condicion dentro del paréntesis después de if . Si la

condición es verdadera (es decir, se evalúa a un valor distinto de cero), entonces se ejecuta el
bloque de código dentro del primer conjunto de llaves {} que sigue al if . Si la condición es falsa
(es decir, se evalúa a cero), entonces se omite el bloque de código después del if y en su lugar se
ejecuta el bloque de código dentro de las llaves {} que siguen al else .

EJEMPLO

#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" void

app_main() { int numero; printf("Ingrese un número:\n "); vTaskDelay(4000 /
portTICK_PERIOD_MS); scanf("%d", &numero); if (numero % 2 == 0) { printf("El número es
par.\n"); } else { printf("El número es impar.\n"); } }

En este programa, primero se solicita al usuario que ingrese un número. Luego, el programa utiliza
la operación de módulo ( % ) para determinar el residuo de dividir numero por 2 . Si el residuo es
0 , significa que el número es par y el programa imprime "El número es par.". Si el residuo no es
0 , entonces el número es impar, y el programa imprime "El número es impar.".

EJEMPLO
Cualquier valor diferente que cero es considerado true

#include <stdio.h> void app_main() { float a = -2.5; if (a) { printf("Bloque if.\n"); }

else { printf("Bloque else.\n"); } }
CONDICIONAL MULTIPLE

La estructura de escalera condicional (o escalera de "if") se muestra en el Código

if (condicion1) { // Bloque de código que se ejecuta si condicion1 es verdadera } else

if (condicion2) { // Bloque de código que se ejecuta si condicion2 es verdadera } else
if (condicion3) { // Bloque de código que se ejecuta si condicion3 es verdadera } else {
// Bloque de código que se ejecuta si ninguna de las condiciones anteriores es verdadera
}

Esta estructura permite evaluar múltiples condiciones de forma secuencial. Primero se evalúa
Esta estructura permite evaluar múltiples condiciones de forma secuencial. Primero se evalúa
condicion1 ; si es verdadera, se ejecuta el bloque de código asociado y se ignoran las demás
condiciones. Si condicion1 es falsa, se evalúa condicion2 , y así sucesivamente. Si ninguna de las
condiciones especificadas es verdadera, se ejecuta el bloque de código en la sección else al final
de la escalera de "if". Esto permite manejar múltiples casos de manera ordenada y eficiente.

EJEMPLO

#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" void

app_main() { int edad; printf("Ingrese su edad:\n "); vTaskDelay(4000 /
portTICK_PERIOD_MS); scanf("%d", &edad); if (edad < 13) { printf("Eres un niño.\n"); }
else if (edad < 18) { printf("Eres un adolescente.\n"); } else if (edad < 60) {
printf("Eres un adulto.\n"); } else { printf("Eres un adulto mayor.\n"); } }
4.- EJECUCIÓN POR CASOS (SWITCH CASE)
La estructura switch en C es una forma de ramificación que permite ejecutar diferentes bloques de
código basándose en el valor de una expresión. Es una alternativa a una serie de sentencias if-
else cuando se trata de comparar el mismo valor con diferentes constantes. La sintaxis general de
un switch es la siguiente:

switch (expresion) { case constante1: // Bloque de código para constante1 break; case
constante2: // Bloque de código para constante2 break; ... default: // Bloque de código
por defecto break; }

Donde:
expresion: Es una expresión que se evalúa una vez. El resultado de la expresión se compara con los
valores de cada case .
case: Se utiliza para definir un bloque de código que se ejecuta solo si el resultado de la expresión
coincide con el valor de ese case . Puede haber tantas sentencias case como sea necesario.
coincide con el valor de ese case . Puede haber tantas sentencias case como sea necesario.
break: Se utiliza al final de cada bloque de case para terminar la ejecución del bloque de código
del switch y continuar con la ejecución del código que sigue después del switch . Sin break , la
ejecución continuaría con el siguiente bloque de case , lo cual se conoce como "fall through".
default: Este bloque de código es opcional y se ejecuta si ninguno de los case coincide con la
expresión. Es similar a la cláusula else en una estructura condicional if-else .

Ejemplo de uso de switch

#include <stdio.h> void app_main() { char grado = 'B'; switch (grado) { case 'A':
printf("Excelente\n"); break; case 'B': printf("Muy bien\n"); break; case 'C':
printf("Bien\n"); break; case 'D': printf("Pasaste\n"); break; case 'F': printf("Mejor
intenta de nuevo\n"); break; default: printf("Grado inválido\n"); } }

EJERCICIO 1.- Crear un programa que reciba temperatura corporal (mediante el puerto serial) de un
a persona y encienda un led rojo si tiene fiebre, encienda un led verde si no tiene fiebre. Nota
temperatura mayor a 37 fiebre

#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include

"driver/gpio.h" void app_main() { float temperatura; gpio_set_direction(2,
GPIO_MODE_OUTPUT); gpio_set_direction(4, GPIO_MODE_OUTPUT); gpio_set_level(2,0);
gpio_set_level(4,0); printf("ingrese su temperatura:\n"); vTaskDelay(5000/
portTICK_PERIOD_MS); scanf("%f",&temperatura); if (temperatura > 37.0) { printf("Tienes
fiebre"); gpio_set_level(2, 1); } else { printf("No tienes fiebre");
gpio_set_level(4,1); } }
5.- BUCLE MIENTRAS (WHILE)

OPERADOR ++ EN EL LENGUAJE C
El operador ++ en C es conocido como el operador de incremento. Su propósito es aumentar en
uno el valor de la variable a la que se aplica. Este operador puede usarse de dos maneras: como
prefijo ( ++var ) y como sufijo ( var++ ), y aunque ambos incrementan la variable en uno, su
comportamiento difiere ligeramente cuando se utilizan en expresiones.

Operador de Incremento como Prefijo ( ++var )

Operador de Incremento como Prefijo ( )
Cuando se utiliza como prefijo, el operador incrementa el valor de la variable antes de que se
evalúe la expresión en la que se encuentra. Esto significa que el valor incrementado se utiliza en el
resto de la operación.

Ejemplo de ++ como Prefijo:

int a = 5; int b = ++a; // Aquí, 'a' se incrementa a 6 antes de asignarse a 'b', por lo
tanto, 'b' también es 6.

Operador de Incremento como Sufijo ( var++ )

Cuando se utiliza como sufijo, el operador incrementa el valor de la variable después de que el
valor actual se haya utilizado en la expresión. En otras palabras, primero se toma el valor actual de
la variable para usarlo en la operación, y luego se incrementa.

Ejemplo de ++ como Sufijo:

int a = 5; int b = a++; // Aquí, el valor original de 'a' (5) se asigna a 'b'. Después
de esa asignación, 'a' se incrementa a 6.

ESTRUCTURA WHILE
La estructura while en C es una sentencia de control de flujo que permite ejecutar repetidamente
un bloque de código mientras una condición dada sea verdadera. La sintaxis básica de un bucle
while es la siguiente:

while (condicion) { // Bloque de código que se ejecuta mientras la condición sea

verdadera }

Donde:
condicion: Es una expresión que se evalúa antes de cada iteración del bucle. Si la condición se
evalúa como verdadera (es decir, cualquier valor distinto de cero), el bloque de código dentro del
bucle se ejecuta. Si la condición se evalúa como falsa (es decir, cero), la ejecución del programa
bucle se ejecuta. Si la condición se evalúa como falsa (es decir, cero), la ejecución del programa
continúa con la primera instrucción después del bloque del bucle while .
Es fundamental asegurar que la condición eventualmente se vuelva falsa. De lo contrario, el bucle
se convertirá en un bucle infinito, lo que significa que el bloque de código dentro del while se
ejecutará indefinidamente.

Ejemplo de uso de while

#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" void

app_main() { int contador = 1; while (contador <= 5) { printf("Iteración %d\n",
contador); // Incrementamos el contador en cada iteración contador++; } }

#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" void

app_main() { int contador = 1; int s = 0; while (contador <= 5) { s = s + contador
contador++; } printf("Valor de s:%d\n", s); }

EJERCICIO 2 Escribir un programa que reciba un numero por el puerto serial y realice parpadeos de
un led cada segundo. La cantidad de parpadeos es igual el numero ingresado

#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include

"driver/gpio.h" void app_main() { float num; int count = 1; gpio_set_direction(2,
GPIO_MODE_OUTPUT); gpio_set_level(2,0); printf("ingrese un número:\n"); vTaskDelay(5000/
portTICK_PERIOD_MS); scanf("%f",&num); while (count <= num){ gpio_set_level(2,1);
vTaskDelay(1000/portTICK_PERIOD_MS); gpio_set_level(2,0); vTaskDelay(1000/
portTICK_PERIOD_MS); count++; } }
6.- BUCLE PARA (FOR)
La estructura for en C es una sentencia de control de flujo que permite ejecutar un bloque de
código repetidas veces con una sintaxis concisa, que integra en un solo lugar la inicialización, la
condición de continuación y la expresión de incremento o actualización. Es especialmente útil
cuando se conoce de antemano el número de iteraciones que se desea realizar. La sintaxis general
de un bucle for es la siguiente:

for (inicialización; condición; incremento) { // Bloque de código a ejecutar en cada

iteración }

Donde:
inicialización: Se ejecuta una sola vez antes de la primera iteración del bucle. Generalmente se
utiliza para inicializar la variable de control del bucle.
condición: Antes de cada iteración, se evalúa esta expresión. Si la condición se evalúa como
verdadera (distinta de cero), el bucle continúa y se ejecuta el bloque de código. Si la condición es
falsa (cero), el bucle termina y continúa la ejecución con la instrucción siguiente al
falsa (cero), el bucle termina y continúa la ejecución con la instrucción siguiente al for .
incremento: Se ejecuta después de cada iteración del bucle. Suele utilizarse para actualizar la
variable de control del bucle. Esta expresión puede incrementar o decrementar una variable, o
cambiar el estado del bucle de alguna otra manera para eventualmente hacer que la condición sea
falsa y terminar el bucle.

Ejemplo de uso de for

#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" void

app_main() { int i; for (i = 0; i < 5; i++) { printf("El valor de i es: %d\n", i); } }

En este ejemplo, el bucle for se utiliza para imprimir los números del 0 al 4. La variable de control
i se inicializa en 0, y la condición para continuar el bucle es que i sea menor que 5. Después de
cada iteración, i se incrementa en 1 gracias a la expresión de incremento i++ . Una vez que i
alcanza 5, la condición se evalúa como falsa, y el bucle termina.
EJEMPLO
La operación de actualización puede ser un decremento como en el siguiente código:

#include <stdio.h> void app_main() { for (int a = 2; a >= 0; a--) { printf("Dentro del
bucle for, a = %d \n",a); } printf("Fuera del bucle for\n"); }

EJEMPLO
La variable definida en la parte de inicialización del bucle for no es accesible fuera del cuerpo del
bucle for.
bucle for.

#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" void

app_main() { for (int a = 2; a >= 0; a--) { printf("Inside for-loop, a = %d \n",a); }
printf("\nOutside for-loop %d\n",a); }

#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" void

app_main() { for (int a = 2; a >= 0; a--) { printf("Inside for-loop, a = %d \n",a); }
printf("\nOutside for-loop %d\n",a); }

EJEMPLO
Una variable local fuera de la estructura del bucle for puede ser utilizada como índice de conteo
como en el Código siguiente:

#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" void

app_main() { int a; for (a = 0; a < 3; a++) { printf("Dentro del bucle for, a = %d \n",
a); } printf("\nFuera del bucle for, a = %d \n", a); }

EEJEMPLO
La parte de inicialización del bucle for puede escribirse fuera de la estructura del bucle for, como en
el Código siguiente:

#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" void

app_main() { int a = 0; for ( ; a < 3; a++) { printf("Dentro del bucle for, a = %d \n",
 app_main() { int a 0; for ( ; a < 3; a ) { printf("Dentro del bucle for, a = %d \n",
a); } printf("\nFuera del bucle for\n"); }

EJEMPLO
En el Código siguiente, tanto la parte de inicialización como la de actualización del bucle for se
escriben fuera del encabezado del bucle for.

#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" void

app_main() { int a = 0; for (; a < 3;) { printf("Dentro del bucle for, a = %d \n", a);
a++; } printf("\nFuera del bucle for\n"); }

EJEMPLO
Más de una variable puede ser utilizada en el encabezado del bucle for.

#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" void

app_main() { for (int a = 0, b = 0; a < 3 && b < 3; a++, b++) { printf("Dentro del bucle
for, a = %d ", a); printf("b = %d \n", b); } printf("\nFuera del bucle for\n"); }

EJEMPLO
En este ejemplo, se utiliza el OR lógico || en la parte condicional del bucle for.

#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" void

app_main() { for (int a = 0, b = 0; a < 3 || b < 4; a++, b++) { printf("Dentro del bucle
for, a = %d ", a); printf("b = %d \n", b); } printf("\nFuera del bucle for\n"); }
En este caso, el bucle for continúa ejecutándose mientras al menos una de las condiciones ( a < 3
o b < 4 ) sea verdadera. Esto significa que el bucle no se detendrá hasta que ambas a sean
mayores o iguales a 3 y b sea mayor o igual a 4, debido al uso del operador lógico OR ( || ).

EJEMPLO
El operador lógico && produce falso si uno de los operandos se evalúa como falso.

#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" void

app_main() { for (int a = 0, b = 0; a < 3 && b < 785; a++, b = b+2) { printf("Dentro del
bucle for, a = %d ", a); printf("b = %d \n", b); } printf("\nFuera del bucle for\n"); }

Este código ilustra cómo el bucle for se detiene cuando cualquiera de las condiciones ( a < 3 y b
< 785 ) deja de ser verdadera. El bucle incrementa a en 1 y b en 2 en cada iteración, lo que
significa que el bucle se detendrá tan pronto como a alcance 3, ya que esta condición se cumplirá
antes de que b alcance 785, demostrando así el funcionamiento del operador lógico AND ( && ): el
bucle se detiene cuando al menos una de las condiciones se evalúa como falsa.

EJEMPLO
Se puede crear un bucle infinito utilizando la estructura en el Código siguinete:

#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" void

app_main() { for (; ; ) { printf("Bucle infinito\n"); } }

Ventajas del bucle for

Concisión: El bucle for permite agrupar en una sola línea la inicialización, la condición de
terminación y la actualización de la variable de control, lo que lo hace muy útil para escribir bucles
de manera concisa y clara.
Facilidad de lectura: Al tener todos los elementos que controlan el bucle ( inicialización ,
condición , incremento ) en un solo lugar, los bucles for son fáciles de leer y entender,
especialmente en casos donde la cantidad de iteraciones es conocida o se basa en el tamaño de
una estructura de datos.
Uso común en iteración sobre estructuras de datos: El bucle for es ampliamente utilizado para
iterar sobre arrays y otras estructuras de datos, donde se necesita procesar cada elemento de la
estructura de manera secuencial.

SENTENCIAS CONTINUE Y BREAK EN BUCLES

La instrucción continue se utiliza para omitir el resto de las instrucciones cuando se cumple una
condición, y la ejecución del programa regresa al inicio del bucle.
El uso de la instrucción continue en el bucle while se ilustra en la Fig siguiente:
El uso de la instrucción continue en el bucle for se ilustra en la Fig siguiente:

EJEMPLO
En este ejemplo, utilizamos la instrucción continue en un bucle for .
 #include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" void
app_main() { for(int a = 0; a < 7; a++) { if(a == 3) continue; printf("a=%d \n", a); } }

Cuando a==3 , la función printf() no se ejecuta, y la ejecución del programa regresa al inicio del
bucle. Esto significa que en el momento en que a es igual a 3, el bucle omitirá las instrucciones
restantes dentro de su cuerpo (en este caso, la llamada a printf() ) y procederá inmediatamente a
la siguiente iteración del bucle, incrementando a y evaluando la condición del bucle nuevamente.
Como resultado, el número 3 no se imprimirá, pero se continuarán imprimiendo los demás
números de 0 a 6, excluyendo el 3.

EJEMPLO
En este ejemplo, utilizamos la instrucción continue en un bucle while .

#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" void

app_main() { int a = 0; while(a < 5) { a++; printf("se ejecuta la parte superior del
bucle while, a = %d\n", a); if(a == 3) { printf("\nse ejecuta la instrucción
\"continue\", a = %d\n", a); printf("se omite la parte inferior del bucle while\n\n");
continue; } printf("se ejecuta la parte inferior del bucle while, ya que a = %d\n", a);
} printf("\nFuera del bucle while\n"); }

Cuando a==3 , el resto del código no se ejecuta, y la ejecución del programa regresa al inicio del
bucle. Esto significa que después de incrementar a a 3 y ejecutar las instrucciones hasta el
continue , el bucle while omitirá las instrucciones restantes en su cuerpo y continuará con la
siguiente iteración. En este caso, implica que después de imprimir que la instrucción continue se
ha ejecutado y que se omite la parte inferior del bucle while , el control regresa al inicio del bucle
while para evaluar su condición con el valor actualizado de a . Como resultado, ciertas partes del
 para evaluar su condición con el valor actualizado de . Como resultado, ciertas partes del
código se omiten cuando a es igual a 3, demostrando cómo la instrucción continue puede
alterar el flujo de control dentro de un bucle.

SENTENCIA BREAK
La instrucción break se utiliza para salir del bucle cuando se cumple una condición.
El uso de la instrucción break en el bucle while se ilustra en la Figura siguiente:

El uso de la instrucción break en el bucle for se ilustra en la Figura siguiente:

En estos ejemplos, la instrucción break permite terminar la ejecución del bucle de manera
inmediata cuando se cumple una condición específica, sin importar la estructura del bucle en el que
se encuentra (ya sea while o for ). Esto es útil para interrumpir un ciclo basado en condiciones
que pueden no estar ligadas directamente a la condición de iteración del bucle, proporcionando
una herramienta flexible para controlar el flujo de ejecución del programa.

EJEMPLO
En este ejemplo, utilizamos la instrucción break dentro de un bucle while .

#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" void

 #include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" void
app_main() { int a = 2; while(1) // Este bucle se ejecuta indefinidamente hasta que se
encuentre una instrucción break { printf("Dentro del bucle while, a = %d \n", a); a = a
+ 2; if (a > 8) break; // Se sale del bucle cuando a es mayor que 8 } printf("\nFuera
del bucle while, a = %d ", a); }

En este código, el bucle while se ejecuta indefinidamente debido a que su condición es siempre
verdadera ( while(1) ). Sin embargo, dentro del bucle, la variable a se incrementa en 2 en cada
iteración. Cuando a supera el valor de 8, la instrucción break se ejecuta, lo que causa que el bucle
se termine de inmediato. Después de salir del bucle, se imprime el valor de a fuera del bucle,
demostrando que el programa continúa su ejecución después del bucle while . Este patrón es útil
en situaciones donde se necesita ejecutar un bucle hasta que se cumpla una condición específica,
que puede no ser conocida antes de entrar al bucle.

EJEMPLO
Break dentro de un bucle for:

#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" void

app_main() { int a; for(a = 0; a < 7; a++) // Inicia un bucle for que itera mientras a
sea menor que 7 { if(a == 3) // Si a es igual a 3, ejecuta el código dentro del bloque
if { printf("Saliendo del bucle for, a = %d \n", a); // Imprime un mensaje y el valor de
a break; // Sale del bucle for } printf("Dentro del bucle for, a = %d \n", a); //
Imprime el valor de a si no se ha salido del bucle } printf("\nFuera del bucle for, a =
%d ", a); // Imprime el valor de a después de salir del bucle for }

En este código, se utiliza un bucle for para iterar desde 0 hasta 6 (inclusive), con la variable a
sirviendo como contador. La instrucción if dentro del bucle verifica si a es igual a 3. Si esta
condición se cumple, el programa imprime un mensaje indicando que se va a salir del bucle for
condición se cumple, el programa imprime un mensaje indicando que se va a salir del bucle
debido a la ejecución de la instrucción break , y luego sale del bucle. Si a no es igual a 3, el
programa imprime el valor actual de a dentro del bucle. Después de salir del bucle (ya sea
naturalmente después de alcanzar el final de las iteraciones o debido a la instrucción break ), se
imprime el valor de a fuera del bucle for .

ANIDACIÓN DE ESTRUCTURAS DE CONTROL DE

FLUJO

ANIDACIÓN EN FOR
Los bucles for pueden utilizarse de manera anidada, lo que significa que un bucle for puede
contener dentro de su cuerpo otro bucle for . Esta estructura permite realizar tareas que requieren
iteraciones dentro de otras iteraciones, como procesar los elementos de matrices
multidimensionales o generar combinaciones de valores. La estructura básica de los bucles for
anidados se muestra a continuación:

for(init1; condition1; update1) // Bucle externo { // Instrucciones del bucle externo an

tes del bucle interno for(init2; condition2; update2) // Bucle interno { // Instruccione
s del bucle interno } // Instrucciones del bucle externo después del bucle interno }

Donde:
init1 , condition1 , y update1 son la inicialización, la condición de continuación, y la
actualización para el bucle externo, respectivamente.
actualización para el bucle externo, respectivamente.
init2 , condition2 , y update2 son la inicialización, la condición de continuación, y la
actualización para el bucle interno, respectivamente.
Ejemplo práctico:
Supongamos que queremos imprimir una tabla de multiplicar de 2x3, podríamos hacerlo con
bucles for anidados de la siguiente manera:

#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" void

app_main() { int i, j; for(i = 1; i <= 2; i++) // Bucle externo para las filas { for(j =
1; j <= 3; j++) // Bucle interno para las columnas { printf("%d x %d = %d\t", i, j,
i*j); // Imprime el producto de i y j } printf("\n"); // Nueva línea después de cada
fila } }

Este código imprimirá la tabla de multiplicar para los números 1 y 2, mostrando los productos de 1
y 2 por los números 1, 2, y 3 en formato de tabla.

ANIDAMIENTO EN BUCLE WHILE

Los bucles while pueden anidarse de la misma manera que los bucles for , permitiendo que un
bucle while contenga dentro de su cuerpo otro bucle while . Esta estructura se utiliza para
realizar tareas que requieren múltiples niveles de iteración, como procesar elementos en estructuras
de datos complejas o realizar operaciones repetitivas dentro de otras operaciones repetitivas. La
estructura básica de los bucles while anidados se muestra a continuación:

while(condition1) // Bucle externo { // Instrucciones del bucle externo antes del bucle
interno while(condition2) // Bucle interno { // Instrucciones del bucle interno } // Ins
trucciones del bucle externo después del bucle interno }
Donde condition1 es la condición que controla el bucle externo y condition2 es la condición que
controla el bucle interno.
Ejemplo práctico:
Supongamos que queremos imprimir los números del 1 al 3 en tres filas, usando bucles while
anidados. Aquí hay un ejemplo de cómo podríamos hacerlo:

#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" void

app_main() { int i = 1; while(i <= 3) { // Bucle externo para las filas int j = 1;
while(j <= 3) { // Bucle interno para las columnas printf("%d ", j); // Imprime el
número de la columna j++; } printf("\n"); // Nueva línea después de cada fila i++; } }

Este código imprimirá tres filas de números, con cada fila conteniendo los números del 1 al 3. Los
bucles while anidados son especialmente útiles cuando el número de iteraciones de los bucles
internos depende de los valores o condiciones establecidas en el bucle externo.

EJERCICIO 1
Secuencia de LEDs
Objetivo: Crear una secuencia de encendido y apagado de LEDs utilizando un bucle for .
Materiales:
ESP32
4 LEDs
Resistencias de 220 ohmios
Resistencias de 220 ohmios
Cables de conexión
Descripción:
Conecta los LEDs a diferentes pines GPIO del ESP32 a través de resistencias. Utiliza un bucle for
para encender cada LED secuencialmente durante 500 ms y luego apagarlo antes de pasar al
siguiente LED.

#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include

"driver/gpio.h" void app_main() { int led1 = 14; for (int i = 0 ; i < 4 ; i++){
gpio_set_direction(led1 + i, GPIO_MODE_OUTPUT); gpio_set_level(led1 + i,0); }
printf("Hello, Wokwi!\n"); while (1) { for (int i = 0 ; i < 4 ; i++){
gpio_set_level(led1 + i , 1); vTaskDelay(500 / portTICK_PERIOD_MS); gpio_set_level(led1
+ i ,0); } } }
EJERCICIO 2
Control de brillo de un LED con botón
Objetivo: Aumentar el brillo de un LED cada vez que se presiona un botón, utilizando un bucle for
para modificar el ciclo de trabajo de la señal PWM.
Materiales:
ESP32
1 LED
1 botón
Resistencias de 220 ohmios y 10k ohmios
Descripción:
Conecta el LED a un pin que soporte PWM y el botón a otro pin como entrada. Cada vez que se
detecte una presión de botón, incrementa el ciclo de trabajo del PWM en un 20% hasta que alcance
el 100% y luego vuelva a empezar.

#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include

"driver/gpio.h" void app_main() { int t=0; gpio_set_direction(14,GPIO_MODE_INPUT);
gpio_set_direction(2,GPIO_MODE_OUTPUT); gpio_pullup_en(14); gpio_set_level(2,0);
printf("Hello, Wokwi!\n"); while (true) { gpio_set_level(2,1); vTaskDelay((t) /
portTICK_PERIOD_MS); gpio_set_level(2,0); vTaskDelay((100 - t) / portTICK_PERIOD_MS); if
(!gpio_get_level(14)){ t = t + 1; }
 (!gpio_get_level(14)){ t = t + 1; }

EJERCICIO 3.
Sistema de Menú con LEDs y Botón
Objetivo: Implementar un sistema de menú simple que use un botón para navegar por diferentes
opciones indicadas por LEDs.
Materiales:
ESP32
4 LEDs (cada uno representa una opción de menú diferente)
4 LEDs (cada uno representa una opción de menú diferente)
1 botón
Resistencias de 220 ohmios para los LEDs
Descripción:
Cada presión del botón avanza al siguiente LED (opción de menú).
Al llegar al último LED, la siguiente presión vuelve al primer LED.
Solo un LED debe estar encendido a la vez, indicando la opción de menú actual.

#include <stdio.h> #include "freertos/FreeRTOS.h" #include "freertos/task.h" #include

"driver/gpio.h" void app_main() { int led1 = 14; int s = 0; gpio_set_direction(2,
GPIO_MODE_INPUT); gpio_pullup_en(2); for (int i = 0 ; i < 4 ; i++){
gpio_set_direction(led1 + i, GPIO_MODE_OUTPUT); gpio_set_level(led1 + i,0); } while (1)
{ switch (s){ case 0: gpio_set_level(14,0); gpio_set_level(15,0); gpio_set_level(16,0);
gpio_set_level(17,0); break; case 1: gpio_set_level(14,1); gpio_set_level(15,0);
gpio_set_level(16,0); gpio_set_level(17,0); break; case 2: gpio_set_level(14,0);
gpio_set_level(15,1); gpio_set_level(16,0); gpio_set_level(17,0); break; case 3:
gpio_set_level(14,0); gpio_set_level(15,0); gpio_set_level(16,1); gpio_set_level(17,0);
break; case 4: gpio_set_level(14,0); gpio_set_level(15,0); gpio_set_level(16,0);
gpio_set_level(17,1); break; default : s = 0; break; } if (!gpio_get_level(2)){ s++; }
vTaskDelay((400) / portTICK_PERIOD_MS); } }