LABORATORIO NRO. 2

PROGRAMACION BASICA CON BUCLES DE CONTROL
LAB 2 

Control de flujo I – if, if…else y for

El control de flujo permite variar, en un número ilimitado de ocasiones a lo largo de un programa, el orden “natural” de ejecución del código, omitiendo, ejecutando, o repitiendo sentencias o bloques de sentencias en función de una o varias condiciones. Las instrucciones para el control de flujo son comunes a muchos lenguajes de programación, y son if, if…else, for, while, y do…while. Además, veremos un par de sentencias capaces de variar el comportamiento de estas instrucciones: break y continue.

if

Realiza una comprobación de una condición. En el caso de que esta condición se cumpla, el código escrito entre llaves se ejecuta. Si, por el contrario, la condición entre paréntesis no se cumple, el código entre llaves es ignorado y el programa sigue ejecutándose normalmente.

Estructura básica de una sentencia if

Arduino

1 2 3

if (valorAComparar ?? valorDeReferencia) { instruccionesAEjecutar(); }

Como se puede apreciar en el código anterior, la comparación se realiza con el operador ??, que se ha de sustituir por cualquier operador lógico o cualquier operador de comparación. Hay que tener cuidado con el operador de comparación igual que (==), pues se suele confundir con el operador de asignaciónigual (=). Veámos algunos ejemplos:

Código que se ejecuta si x mayor que 0

Arduino

1 2 3 4 5 6 7

// Condición por la cual queremos que el código se ejecute // si una variable 'x' es mayor que cero if (x > 0) {   digitalWrite(ledPin, HIGH);   delay(1000);   digitalWrite(ledPin, LOW); }

Código que se ejecuta si x igual a 0

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

// Condición por la cual queremos que el código se ejecute // si una variable 'x' es igual a cero // Sentendia mal construida. Lo que se está haciendo es igualar // una variable a cero en lugar de compararlas if (x = 0) {   digitalWrite(ledPin, HIGH);   delay(1000);   digitalWrite(ledPin, LOW); } // Sentencia bien construida if (x == 0) {   digitalWrite(ledPin, HIGH);   delay(1000);   digitalWrite(ledPin, LOW); }

Incluso podemos establecer más de una condición:

Ejecución de código si x mayor que 0 e y menor que 3

1 2 3 4 5 6 7 8

// Condición por la cual queremos que el código se ejecute // si una variable 'x' es mayor que cero, y además otra // variable 'y' es menor que 3. if (x > 0 && y < 3) {   digitalWrite(ledPin, HIGH);   delay(1000);   digitalWrite(ledPin, LOW); }

if…else

Complementa en cierto modo al control de flujo que ofrece la sentencia if, permitiendo ejecutar un bloque de código en el caso de que se cumpla la condición entre paréntesis, y otro bloque de código si la condición no se cumple. Estos dos bloques de código son mutuamente excluyentes, por lo que nunca se podrán ejecutar los dos a la vez.

Estructura de una sentencia if...else

1 2 3 4 5

if (valorAComparar ?? valorDeReferencia) { instruccionesSiCondicionSeCumple; } else { instruccionesSiCondicionNoSeCumple; }

Podemos anidar varias sentencias if…else, siendo todas ellas, a su vez, mutuamente excluyentes:

Anidación de sentencias if...else

1 2 3 4 5 6 7 8 9

if (x <= 0) { delay(100); } else if (x < 100) { delay(250); } else if (x <= 200) { delay(500); } else { delay(1000); }

Analicemos el código anterior, donde tenemos 4 sentencias mutuamente excluyentes que actuarán como control de flujo en función de distintas condiciones:

delay(100);  se ejecutará si:

•  x menor o igual que 0.

delay(250);  se ejecutará si:

• x mayor que 0, derivado de que la anterior condición no se ha cumplido.
• x menor que 100.

delay(500);  se ejecutará si:

• x mayor que 0 y  mayor o igual que 100, derivado de que las anteriores condiciones no se han cumplido.
• x menor o igual que 200.

delay(1000);  se ejecutará si:

• x mayor que 200, ya que ninguna de las anteriores condiciones se han cumplido.

for

Entramos en la parte del control de flujo relativa a la repetición de un bloque de código siempre que se cumpla una condición. Así pues, siempre que nos encontremos con una instrucción for -también llamado bucle for-, el código encerrado entre llaves se repetirá siempre que se cumpla la condición. Con cada repetición del bloque de código, la condición vuelve a ser evaluada.

Estrucutra típica de un bucle for

1 2 3

for (inicialización; condición; expresión) {   codigoAEjecutar(); }

Esta estructura está formada siempre por tres campos separados entre sí por un punto y coma. La inicialización se produce una sola vez y sirve para establecer un estado inicial a partir del cual empezar a evaluar la condición. La condición, como ya hemos dicho, se re-evalúa con cada repetición del bucle. Entonces, puede resultar obvio que siempre que se ejecute el bloque de código hay que variar alguna parte de la condición, evitando entrar en el denominado bucle infinito, donde un bloque de código se repite de forma infinita. Con tal fin, tenemos la expresión del tercer campo, una pieza de código que se va a ejecutar después de que lo haga el bloque de código encerrado entre llaves.

En el siguiente ejemplo vemos un caso muy simple pero práctico para imprimir por el puerto serie los números del 0 al 9:

Imprimir por el puerto serie los enteros de 0 a 9

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

// Para imprimir por consola los números enteros del 0 al 9 // podemos ir por el camino clásico Serial.println(0); Serial.println(1); Serial.println(2); Serial.println(3); Serial.println(4); Serial.println(5); Serial.println(6); Serial.println(7); Serial.println(8); Serial.println(9); // Pero podemos agilizarlo con un bucle for for (int i = 0; i < 10; i++) { Serial.println(i); }

Pero aquí no acaba la cosa. De los 3 campos del bucle for, podemos obviar tantos como queramos, siempre y cuando incluyamos los puntos y coma. Así, podemos hacer la inicialización antes del bucle  (o no hacerla), evaluar la condición dentro del bucle, o modificar la condición dentro del bloque entre llaves.

Bucle for sin los tres campos

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

// Podemos obviar la inicialización int i = 0; for ( ; i < 10; i++) { Serial.println(i); } // Si quitamos la expresión y la inicialización int i = 0; for ( ; i < 10 ; ) { Serial.println(i); i = i + 1; } // Si quitamos los tres campos, tenemos un bonito bucle infinito. // Veremos en la segunda parte como arreglarlo int i = 0; for ( ; ; ) { if (i < 10) { Serial.println(i); } i = i + 1; }

Nos vemos en la segunda parte de la bilogía destinada al control de flujo, donde explicaremos conceptos tan interesantes como los bucles while y do…while, y las sentencias break y continue.

CAPTURAS DEL CURSO VIRTUAL 

Chavez Cheneau David Alonso

Nina Trelles Cristofer

Vídeo de Simulación en clase

Video de Tareas a ser evaluadas

Observaciones:

-Observamos que tenemos que cargar el programa a usar en el comando #include ya que a veces nos puede dar un error y no compilaría el código.

-Existen funcionen que obligatoriamente deben estar incluidas en nuestro comando por ejemplo la función void y la include o int ya que sin estas no estaríamos declarando o dándole la base al programa.

-Observamos que el comando while true se ejecuta para bucles de control ya que gracias a estar el programa puede volver a ejecutarse indefinidamente.

-Nos dimos cuenta de que podemos crear infinidades de programas para diferentes funciones en el ámbito de la electrónica y sus aplicaciones.

-Tuvimos que entender el primer programa para poder crear otro apartir de este ya que los comandos son la parte escensial de esto y deben ser utilizados específicamente.

Conclusiones:

-Utilizamos el microcontrolador en aplicaciones de control electronico.

-Desarrollamos y ejecutamos programas de un microcontrolador PIC.

-Programamos y configuramos interfaces basicas de un microcontrolador.

-Aprendimos a cargar los programas tanto en el entrenador como en la tarjeta real .

-Diferenciamos los dos archivos que nos proporciona el pic compiler cada uno para diferente plataforma.